def createToolBox(self):
self.buttonGroup = QButtonGroup()
self.buttonGroup.setExclusive(False)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupClicked)
layout = QGridLayout()
layout.addWidget(self.createCellWidget("Diamond", ITGItem.Diamond),
0, 0)
layout.addWidget(self.createCellWidget("Square", ITGItem.Square), 0,
1)
layout.addWidget(self.createCellWidget("Parallelogram", ITGItem.Parallelogram),
1, 0)
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
itemWidget = QWidget()
itemWidget.setLayout(layout)
self.backgroundButtonGroup = QButtonGroup()
self.toolBox = QToolBox()
self.toolBox.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
self.toolBox.setMinimumWidth(itemWidget.sizeHint().width())
self.toolBox.addItem(itemWidget, "Basic Components")
def __init__(self, player, engine, colour=None, parent=None):
super(PochaPlayerInputWidget, self).__init__(parent)
self.player = player
self.engine = engine
self.winner = False
self.pcolour = colour
self.mainLayout = QVBoxLayout(self)
self.mainLayout.setSpacing(0)
self.label = QLabel(self)
self.label.setText(self.player)
self.mainLayout.addWidget(self.label)
self.label.setAutoFillBackground(False)
self.setFrameShape(QFrame.Panel)
self.setFrameShadow(QFrame.Raised)
self.label.setScaledContents(True)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setWordWrap(False)
css = ("QLabel {{ font-size: 24px; font-weight: bold; "
"color:rgb({},{},{});}}")
self.label.setStyleSheet(css.format(self.pcolour.red(),
self.pcolour.green(),
self.pcolour.blue()))
self.expectedGroupBox = QFrame(self)
self.mainLayout.addWidget(self.expectedGroupBox)
self.ebLayout = QHBoxLayout(self.expectedGroupBox)
self.ebLayout.setSpacing(0)
self.ebLayout.setContentsMargins(2, 2, 2, 2)
self.expectedGroup = QButtonGroup(self)
self.expectedGroup.buttonReleased.connect(self.expectedClickedAction)
self.expectedButtons = []
self.wonGroupBox = QFrame(self)
self.mainLayout.addWidget(self.wonGroupBox)
self.wbLayout = QHBoxLayout(self.wonGroupBox)
self.wbLayout.setSpacing(0)
self.wbLayout.setContentsMargins(2, 2, 2, 2)
self.wonGroup = QButtonGroup(self)
self.wonGroup.buttonReleased.connect(self.wonClickedAction)
self.wonButtons = []
for i in range(-1, 9):
button = PochaHandsButton(str(i), self)
self.expectedGroup.addButton(button, i)
self.expectedButtons.append(button)
button.toggled.connect(self.enableWonGroup)
if i < 0:
button.hide()
else:
self.ebLayout.addWidget(button)
button = PochaHandsButton(str(i), self)
self.wonGroup.addButton(button, i)
self.wonButtons.append(button)
if i < 0:
button.hide()
else:
self.wbLayout.addWidget(button)
self.reset()
def intervalButtons(self):
widget = QGroupBox('Interval')
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
def setInterval():
self.interval = group.checkedId()
interval = self.INTERVALS[self.interval][0]
self.updateTitle()
if interval:
self.progress.show()
self.progress.setMaximum(interval)
value = self.timer.seconds()
if value < interval:
self.progress.resume()
else:
self.progress.stop()
self.progress.setValue(min(interval, value))
else:
self.progress.hide()
for i, interval in enumerate(self.INTERVALS):
button = QPushButton(interval[1])
button.setCheckable(True)
button.clicked.connect(setInterval)
group.addButton(button, i)
layout.addWidget(button, 1 if i > 0 else 0)
return widget
class LabelButtonGroup(QWidget):
def __init__(self, label = '', buttons = {'UJ object reference value': 'Name to show'}):
super(LabelButtonGroup, self).__init__()
self.label = QLabel()
self.label.setText(label)
self.button_group = QButtonGroup()
self.buttons = {}
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0,0,0,0)
self.layout.addWidget(self.label)
for button_key in buttons.keys():
self.buttons[button_key] = QRadioButton(buttons[button_key])
self.button_group.addButton(self.buttons[button_key])
self.layout.addWidget(self.buttons[button_key])
def show(self):
for button in self.buttons.values():
button.show()
self.label.show()
def hide(self):
for button in self.buttons.values():
button.hide()
self.label.hide()
def set_text(self, key):
if key != '':
self.buttons[key].setChecked(1)
def text(self):
return self.button_group.checkedButton().text()
def checked(self):
return self.button_group.checkedButton()
class Ui_Widget(object):
""" Klasa definiująca GUI """
def setupUi(self, Widget):
# widgety rysujące kształty, instancje klasy Ksztalt
self.ksztalt1 = Ksztalt(self, Ksztalty.Polygon)
self.ksztalt2 = Ksztalt(self, Ksztalty.Ellipse)
self.ksztaltAktywny = self.ksztalt1
# przyciski CheckBox ###
uklad = QVBoxLayout() # układ pionowy
self.grupaChk = QButtonGroup()
for i, v in enumerate(('Kwadrat', 'Koło', 'Trójkąt', 'Linia')):
self.chk = QCheckBox(v)
self.grupaChk.addButton(self.chk, i)
uklad.addWidget(self.chk)
self.grupaChk.buttons()[self.ksztaltAktywny.ksztalt].setChecked(True)
# CheckBox do wyboru aktywnego kształtu
self.ksztaltChk = QCheckBox('<=')
self.ksztaltChk.setChecked(True)
uklad.addWidget(self.ksztaltChk)
# układ poziomy dla kształtów oraz przycisków CheckBox
ukladH1 = QHBoxLayout()
ukladH1.addWidget(self.ksztalt1)
ukladH1.addLayout(uklad)
ukladH1.addWidget(self.ksztalt2)
# koniec CheckBox ###
self.setLayout(ukladH1) # przypisanie układu do okna głównego
self.setWindowTitle('Widżety')
class GSideToolbar(QWidget):
selectionChanged = pyqtSignal(str)
def __init__(self, buttons):
super().__init__()
self.selectedId = None
self.mainLayout = QVBoxLayout(self)
self.buttonGroup = QButtonGroup()
self.buttons = {}
for button in buttons:
b = QPushButton(button.name)
self.buttonGroup.addButton(b)
self.buttonGroup.setId(b, button.id)
self.buttons[button.id] = b
self.mainLayout.addWidget(b)
self.buttonGroup.buttonClicked.connect(self.buttonClicked)
self.mainLayout.addStretch()
def buttonState(self, state):
pass
def buttonClicked(self, button : QPushButton):
buttonId = self.buttonGroup.id(button)
buttonName = self.buttons[buttonId].text()
self.selectionChanged.emit(buttonName)
@staticmethod
def createButton(text, icon):
pass
def add_radiobuttons(self, tab=False):
from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QVBoxLayout
scrollLayout = QVBoxLayout()
buttonGroup = QButtonGroup()
buttongroup_results = {}
i = 1
if tab:
name = "tab"
i = 2
elif arguments.radiolist:
name = "radiolist"
elif arguments.menu:
name = "menu"
arglen = len(arguments.__dict__[name])
while i < arglen:
if arguments.radiolist:
radiobutton = QRadioButton(arguments.__dict__[name][i+1])
buttongroup_results[radiobutton] = arguments.__dict__[name][i]
if arguments.__dict__[name][i+2].lower() in ["true", "on"]:
radiobutton.setChecked(True)
i += 3
else:
radiobutton = QRadioButton(arguments.__dict__[name][i+1])
buttongroup_results[radiobutton] = arguments.__dict__[name][i]
if i == 1:
radiobutton.setChecked(True)
i += 2
scrollLayout.addWidget(radiobutton)
buttonGroup.addButton(radiobutton)
return scrollLayout, buttonGroup, buttongroup_results
class DyStockSelectAddColumnsDlg(QDialog):
def __init__(self, data, title, parent=None):
super().__init__(parent)
self._data = data
self._initUi(title)
def _initUi(self, title):
self.setWindowTitle('添加{0}列'.format(title))
# 控件
increaseColumnsLable = QLabel('基准日期几日{0}'.format(title))
self._increaseColumnsLineEdit = QLineEdit(','.join(self._data['days']) if self._data else '2,3,4,5,10' )
# 前 & 后
forwardRadioButton = QRadioButton('向前')
backwardRadioButton = QRadioButton('向后'); backwardRadioButton.setChecked(True)
# 添加到QButtonGroup
self._wardButtonGroup = QButtonGroup()
self._wardButtonGroup.addButton(forwardRadioButton, 1);
self._wardButtonGroup.addButton(backwardRadioButton, 2)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(increaseColumnsLable, 0, 0, 1, 2)
grid.addWidget(self._increaseColumnsLineEdit, 1, 0, 1, 2)
grid.addWidget(forwardRadioButton, 2, 0)
grid.addWidget(backwardRadioButton, 2, 1)
grid.addWidget(okPushButton, 3, 1)
grid.addWidget(cancelPushButton, 3, 0)
self.setLayout(grid)
self.setMinimumWidth(QApplication.desktop().size().width()//5)
def _ok(self):
checkedButton = self._wardButtonGroup.checkedButton()
text = checkedButton.text()
self._data['backward'] = True if text == '向后' else False
self._data['days'] = [int(x) for x in self._increaseColumnsLineEdit.text().split(',')]
self.accept()
def _cancel(self):
self.reject()
def initUI(self):
self.widgetLayout = QHBoxLayout(self)
self.playerGroup = QGroupBox(self)
self.widgetLayout.addWidget(self.playerGroup)
self.playerButtonGroup = QButtonGroup(self)
self.playerGroupLayout = QGridLayout(self.playerGroup)
b = QRadioButton("", self.playerGroup)
# self.playerGroupLayout.addWidget(b)
self.playerButtonGroup.addButton(b, 0)
self.playerButtons = [b]
b.hide()
for i, player in enumerate(self.engine.getListPlayers(), 1):
b = QRadioButton(
'{}. {}'.format(i, player), self.playerGroup)
if len(self.engine.getListPlayers()) > 2:
self.playerGroupLayout.addWidget(b, (i-1) % 2, (i-1)/2)
else:
self.playerGroupLayout.addWidget(b, 0, (i-1) % 2)
self.playerButtonGroup.addButton(b, i)
self.playerButtons.append(b)
self.kindGroup = QGroupBox(self)
self.widgetLayout.addWidget(self.kindGroup)
self.kindButtonGroup = QButtonGroup(self)
self.kindGroupLayout = QGridLayout(self.kindGroup)
b = QRadioButton("", self.kindGroup)
# self.kindGroupLayout.addWidget(b)
self.kindButtonGroup.addButton(b, 0)
self.kindButtons = [b]
b.hide()
self.scoreSpinBox = ScoreSpinBox(self)
self.scoreSpinBox.setAlignment(QtCore.Qt.AlignCenter)
self.scoreSpinBox.setMaximumWidth(60)
self.scoreSpinBox.setRange(0, 300)
for i, kind in enumerate(self.engine.getEntryKinds(), 1):
lbl = i18n("CarcassonneInputWidget", kind)
b = QRadioButton('{}. {}'.format(i, lbl), self.kindGroup)
self.kindGroupLayout.addWidget(b, (i-1) % 2, (i-1)/2)
self.kindButtonGroup.addButton(b, i)
b.clicked.connect(self.scoreSpinBox.setFocus)
self.kindButtons.append(b)
self.kindButtons[3].toggled.connect(self.setCloisterPoints)
self.kindButtons[5].toggled.connect(self.setGoodsPoints)
self.kindButtons[6].toggled.connect(self.setFairPoints)
self.scoreGroup = QGroupBox(self)
self.widgetLayout.addWidget(self.scoreGroup)
self.scoreGroupLayout = QHBoxLayout(self.scoreGroup)
self.scoreGroupLayout.addWidget(self.scoreSpinBox)
self.reset()
self.retranslateUI()
def createToolBox(self):
self.buttonGroup = QButtonGroup()
self.buttonGroup.setExclusive(False)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupClicked)
layout = QGridLayout()
layout.addWidget(self.createCellWidget("Conditional", DiagramItem.Conditional),
0, 0)
layout.addWidget(self.createCellWidget("Process", DiagramItem.Step), 0,
1)
layout.addWidget(self.createCellWidget("Input/Output", DiagramItem.Io),
1, 0)
textButton = QToolButton()
textButton.setCheckable(True)
self.buttonGroup.addButton(textButton, self.InsertTextButton)
textButton.setIcon(QIcon(QPixmap(':/images/textpointer.png').scaled(30, 30)))
textButton.setIconSize(QSize(50, 50))
textLayout = QGridLayout()
textLayout.addWidget(textButton, 0, 0, Qt.AlignHCenter)
textLayout.addWidget(QLabel("Text"), 1, 0, Qt.AlignCenter)
textWidget = QWidget()
textWidget.setLayout(textLayout)
layout.addWidget(textWidget, 1, 1)
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
itemWidget = QWidget()
itemWidget.setLayout(layout)
self.backgroundButtonGroup = QButtonGroup()
self.backgroundButtonGroup.buttonClicked.connect(self.backgroundButtonGroupClicked)
backgroundLayout = QGridLayout()
backgroundLayout.addWidget(self.createBackgroundCellWidget("Blue Grid",
':/images/background1.png'), 0, 0)
backgroundLayout.addWidget(self.createBackgroundCellWidget("White Grid",
':/images/background2.png'), 0, 1)
backgroundLayout.addWidget(self.createBackgroundCellWidget("Gray Grid",
':/images/background3.png'), 1, 0)
backgroundLayout.addWidget(self.createBackgroundCellWidget("No Grid",
':/images/background4.png'), 1, 1)
backgroundLayout.setRowStretch(2, 10)
backgroundLayout.setColumnStretch(2, 10)
backgroundWidget = QWidget()
backgroundWidget.setLayout(backgroundLayout)
self.toolBox = QToolBox()
self.toolBox.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
self.toolBox.setMinimumWidth(itemWidget.sizeHint().width())
self.toolBox.addItem(itemWidget, "Basic Flowchart Shapes")
self.toolBox.addItem(backgroundWidget, "Backgrounds")
def create_menu_buttons(self):
# Center on Player Button
button_center_player = QPushButton(
QIcon('maps/graphics/map_menu_center_player.png'),
''
)
button_center_player.setCheckable(True) # Make toggle button
button_center_player.setToolTip('Center on Player')
button_center_player.setObjectName('button_center_player')
# Center on Last Point Button
button_center_point = QPushButton(
QIcon('maps/graphics/map_menu_center_map.png'),
''
)
button_center_point.setCheckable(True) # Make toggle button
button_center_point.setToolTip('Center Normally')
button_center_point.setObjectName('button_center_point')
# Create Button Group for Exclusive Toggling
toggle_group = QButtonGroup(self)
toggle_group.addButton(button_center_player, 1)
toggle_group.addButton(button_center_point, 2)
toggle_group.buttonClicked.connect(self.center_button_toggled)
self.menu.addWidget(button_center_player)
self.menu.addWidget(button_center_point)
# Apply settings for current toggle
if self.settings.get_value('maps', 'center_on') == 'point':
button_center_point.setChecked(True)
else:
button_center_player.setChecked(True)
# Fit to Window Button
button_fit_window = QPushButton(
QIcon('maps/graphics/map_menu_fit_window.png'),
''
)
button_fit_window.setToolTip('Fit Map to Window')
button_fit_window.clicked.connect(self.fit_to_window)
self.menu.addWidget(button_fit_window, 0, Qt.AlignLeft)
# Maps Combo Box
self.combo_load_map = QComboBox(self)
# Need to setView otherwise CSS doesn't work
self.combo_load_map.setView(QListView())
self.combo_load_map.setToolTip('Manually Load Selected Map')
for map_name in sorted(self.map_pairs.keys(), key=str.lower):
self.combo_load_map.addItem(map_name)
self.combo_load_map.currentIndexChanged.connect(
self.load_map_from_combo
)
self.menu.addWidget(self.combo_load_map, 0, Qt.AlignLeft)
def initUI(self):
super().initUI()
self.setWindowTitle("ノイズ付与設定")
self.layout = QGridLayout()
self.radioButton1 = QRadioButton("ごま塩ノイズ")
self.radioButton2 = QRadioButton("gaussianノイズ")
self.soltSlider = HorizontalSlider()
self.soltSlider.setTickPosition(QSlider.TicksBelow)
self.soltSlider.setTickInterval(20)
self.gaussSlider = HorizontalSlider()
self.soltTextLine = TextLine(text=str(self.soltSlider.value()),
width=60, readmode=True)
self.gaussTextLine = TextLine(text=str(self.gaussSlider.value()),
width=60, readmode=True)
self.buttonGroup = QButtonGroup()
self.buttonGroup.addButton(self.radioButton1)
self.buttonGroup.addButton(self.radioButton2)
self.soltSlider.valueChanged[int].connect(self.changedSoltSliderValue)
self.gaussSlider.valueChanged[int].connect(self.changedGaussSliderValue)
self.layout.addWidget(self.radioButton1, 0, 0)
self.layout.addWidget(QLabel("ノイズ割合"), 1, 0)
self.layout.addWidget(self.soltSlider, 1, 1)
self.layout.addWidget(self.soltTextLine, 1, 2)
self.layout.addWidget(self.radioButton2, 2, 0)
self.layout.addWidget(QLabel("分散"), 3, 0)
self.layout.addWidget(self.gaussSlider, 3, 1)
self.layout.addWidget(self.gaussTextLine, 3, 2)
self.layout.addWidget(self.btnBox, 4, 2)
self.setLayout(self.layout)
def __init__(self, *args):
"""
Initialize the Palette.
"""
super().__init__(*args)
self.buttonById = {}
self.buttonGroup = QButtonGroup()
self.buttonGroup.setExclusive(False)
self.buttonClicked = self.buttonGroup.buttonClicked
self.mainLayout = QGridLayout(self)
self.mainLayout.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
self.mainLayout.setContentsMargins(0, Palette.Padding, 0, Palette.Padding)
self.mainLayout.setSpacing(Palette.Spacing)
self.add(ConceptNode, 0, 0)
self.add(RoleNode, 0, 1)
self.add(ValueDomainNode, 0, 2)
self.add(IndividualNode, 1, 0)
self.add(ValueRestrictionNode, 1, 1)
self.add(AttributeNode, 1, 2)
self.add(DomainRestrictionNode, 2, 0)
self.add(RangeRestrictionNode, 2, 1)
self.add(IntersectionNode, 2, 2)
self.add(RoleChainNode, 3, 0)
self.add(DatatypeRestrictionNode, 3, 1)
self.add(RoleInverseNode, 3, 2)
self.add(ComplementNode, 4, 0)
self.add(EnumerationNode, 4, 1)
self.add(UnionNode, 4, 2)
self.add(DisjointUnionNode, 5, 0)
self.add(PropertyAssertionNode, 5, 1)
self.add(InclusionEdge, 5, 2)
self.add(InputEdge, 6, 0)
self.add(InstanceOfEdge, 6, 1)
self.setContentsMargins(0, 0, 0, 0)
self.setFixedSize(216, 394)
def create_tool_box(self):
self.button_group = QButtonGroup()
self.button_group.setExclusive(False)
self.button_group.buttonClicked[int].connect(self.button_group_clicked)
layout = QGridLayout()
layout.addWidget(self.create_cell_widget("Source", "source"), 0, 0)
layout.addWidget(self.create_cell_widget("Channel", "channel"), 0, 1)
layout.addWidget(self.create_cell_widget("Sink", "sink"), 1, 0)
text_button = QToolButton()
text_button.setCheckable(True)
self.button_group.addButton(text_button, self.InsertTextButton)
text_button.setIcon(QIcon(QPixmap(':/images/textpointer.png').scaled(30, 30)))
text_button.setIconSize(QSize(50, 50))
text_layout = QGridLayout()
text_layout.addWidget(text_button, 0, 0, Qt.AlignHCenter)
text_layout.addWidget(QLabel("Text"), 1, 0, Qt.AlignCenter)
text_widget = QWidget()
text_widget.setLayout(text_layout)
layout.addWidget(text_widget, 1, 1)
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
item_widget = QWidget()
item_widget.setLayout(layout)
self.tool_box = QToolBox()
self.tool_box.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
self.tool_box.setMinimumWidth(item_widget.sizeHint().width())
self.tool_box.addItem(item_widget, "Basic Flume Items")
def initUI(self):
self.winnerButtonGroup = QButtonGroup()
self.nobodyWinnerRadioButton = QRadioButton(self)
self.nobodyWinnerRadioButton.hide()
self.nobodyWinnerRadioButton.setChecked(True)
self.winnerButtonGroup.addButton(self.nobodyWinnerRadioButton)
players = self.engine.getListPlayers()
if len(players) >= 4:
players_grid = True
self.widgetLayout = QGridLayout(self)
else:
players_grid = False
self.widgetLayout = QVBoxLayout(self)
# self.widgetLayout.addStretch()
for np, player in enumerate(players):
self.playerInputList[player] = Phase10PlayerWidget(
player, self.engine, self.winnerButtonGroup, self)
self.playerInputList[player].roundWinnerSet.connect(
self.changedWinner)
if players_grid:
self.widgetLayout.addWidget(
self.playerInputList[player], np/2, np % 2)
else:
self.widgetLayout.addWidget(self.playerInputList[player])
def __init__(self):
"""
Constructor
"""
super(HelpViewersPage, self).__init__()
self.setupUi(self)
self.setObjectName("HelpViewersPage")
self.customViewerSelectionButton.setIcon(
UI.PixmapCache.getIcon("open.png"))
self.helpViewerGroup = QButtonGroup()
self.helpViewerGroup.addButton(self.helpBrowserButton)
self.helpViewerGroup.addButton(self.qtAssistantButton)
self.helpViewerGroup.addButton(self.webBrowserButton)
self.helpViewerGroup.addButton(self.customViewerButton)
self.customViewerCompleter = E5FileCompleter(self.customViewerEdit)
# set initial values
hvId = Preferences.getHelp("HelpViewerType")
if hvId == 1:
self.helpBrowserButton.setChecked(True)
elif hvId == 2:
self.qtAssistantButton.setChecked(True)
elif hvId == 3:
self.webBrowserButton.setChecked(True)
else:
self.customViewerButton.setChecked(True)
self.customViewerEdit.setText(
Preferences.getHelp("CustomViewer"))
def _initUi(self, dlgName):
self.setWindowTitle(dlgName)
allRadioButton = QRadioButton('所有'); allRadioButton.setChecked(True)
highlightRadioButton = QRadioButton('高亮')
# 添加到QButtonGroup
self._buttonGroup = QButtonGroup()
self._buttonGroup.addButton(allRadioButton, 1);
self._buttonGroup.addButton(highlightRadioButton, 2)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(allRadioButton, 1, 0)
grid.addWidget(highlightRadioButton, 1, 1)
grid.addWidget(okPushButton, 2, 1)
grid.addWidget(cancelPushButton, 2, 0)
self.setLayout(grid)
self.setMinimumWidth(QApplication.desktop().size().width()//5)
def __init__(self):
"""
Constructor
"""
super(HelpViewersPage, self).__init__()
self.setupUi(self)
self.setObjectName("HelpViewersPage")
self.customViewerPicker.setMode(E5PathPickerModes.OpenFileMode)
self.helpViewerGroup = QButtonGroup()
self.helpViewerGroup.addButton(self.helpBrowserButton)
self.helpViewerGroup.addButton(self.qtAssistantButton)
self.helpViewerGroup.addButton(self.webBrowserButton)
self.helpViewerGroup.addButton(self.customViewerButton)
# set initial values
hvId = Preferences.getHelp("HelpViewerType")
if hvId == 1:
self.helpBrowserButton.setChecked(True)
elif hvId == 2:
self.qtAssistantButton.setChecked(True)
elif hvId == 3:
self.webBrowserButton.setChecked(True)
else:
self.customViewerButton.setChecked(True)
self.customViewerPicker.setText(
Preferences.getHelp("CustomViewer"))
def __init__(self, resource, size):
# Load UI
super(TARWindow, self).__init__()
uic.loadUi(GUI_FOLDER + 'tarCreation.ui', self)
self.resource = cv2.imread(resource)
self.h, self.w = self.resource.shape[:2]
self.tileSize = size
# We'll need a temporal folder
self.tmp_dir = tempfile.mkdtemp()
# In order to get the tiles we'll define the size
self.resourceView.setIconSize(QSize(size, size))
# Defining labels
self.comprLabel.setText('Compression:')
c = self.getTiles(self.resource, self.h, self.w, self.tileSize)
self.columns, self.rows = c
self.refreshdir(self.columns, self.rows, self.tileSize)
# Radio Buttons in a group
self.comprGroup = QButtonGroup()
self.comprGroup.addButton(self.tarRadio)
self.comprGroup.addButton(self.targzRadio)
self.comprGroup.addButton(self.tarbz2Radio)
self.comprGroup.addButton(self.tarxzRadio)
# We'll define a compression by default
self.targzRadio.setChecked(True)
# If we don't define blankTile right now it will return an error
self.blankTile = str()
# Signals
self.blankButton.clicked.connect(self.setBlank)
self.saveBox.accepted.connect(self.saveTilemap)
self.saveBox.rejected.connect(self.cancel)
class DyStockTableSelectDlg(QDialog):
def __init__(self, data, dlgName):
super().__init__()
self._data = data
self._initUi(dlgName)
def _initUi(self, dlgName):
self.setWindowTitle(dlgName)
allRadioButton = QRadioButton('所有'); allRadioButton.setChecked(True)
highlightRadioButton = QRadioButton('高亮')
# 添加到QButtonGroup
self._buttonGroup = QButtonGroup()
self._buttonGroup.addButton(allRadioButton, 1);
self._buttonGroup.addButton(highlightRadioButton, 2)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(allRadioButton, 1, 0)
grid.addWidget(highlightRadioButton, 1, 1)
grid.addWidget(okPushButton, 2, 1)
grid.addWidget(cancelPushButton, 2, 0)
self.setLayout(grid)
self.setMinimumWidth(QApplication.desktop().size().width()//5)
def _ok(self):
checkedButton = self._buttonGroup.checkedButton()
text = checkedButton.text()
self._data['all'] = True if text == '所有' else False
self.accept()
def _cancel(self):
self.reject()
class InputRadioGroup(QWidget):
"""Create an horizontal radio group"""
def __init__(self, parent=None, option_list=None, default_select=0):
super().__init__(parent=parent)
layout = QHBoxLayout(self)
self.group = QButtonGroup()
for idx, op in enumerate(option_list):
self.op = QRadioButton(_(op))
if idx == default_select:
self.op.setChecked(True)
layout.addWidget(self.op)
self.group.addButton(self.op)
self.setLayout(layout)
@pyqtProperty(str)
def currentItemData(self):
return str(abs(int(self.group.checkedId())) - 1)
def contextButtons(self):
widget = QGroupBox('Context')
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
def setContext():
self.context = self.CONTEXTS[group.checkedId()]
self.updateTitle()
for i, context in enumerate(self.CONTEXTS):
button = QPushButton(context.title() if context else 'None')
button.setCheckable(True)
button.clicked.connect(setContext)
group.addButton(button, i)
layout.addWidget(button, 1 if i > 0 else 0)
return widget
def _initUi(self):
self.setWindowTitle('指数均线K线图统计')
# 控件
startDateLable = QLabel('开始日期')
self._startDateLineEdit = QLineEdit(datetime.now().strftime("%Y-%m-%d"))
endDateLable = QLabel('结束日期')
self._endDateLineEdit = QLineEdit(datetime.now().strftime("%Y-%m-%d"))
# 指数和股票代码
shIndexRadioButton = QRadioButton('上证指数'); shIndexRadioButton.setChecked(True)
szIndexRadioButton = QRadioButton('深证成指')
cybIndexRadioButton = QRadioButton('创业板指')
zxbIndexRadioButton = QRadioButton('中小板指')
hs300IndexRadioButton = QRadioButton('沪深300')
zz500IndexRadioButton = QRadioButton('中证500')
# 添加到QButtonGroup
self._stocksButtonGroup = QButtonGroup()
self._stocksButtonGroup.addButton(shIndexRadioButton, 1);
self._stocksButtonGroup.addButton(szIndexRadioButton, 2)
self._stocksButtonGroup.addButton(cybIndexRadioButton, 3)
self._stocksButtonGroup.addButton(zxbIndexRadioButton, 4)
self._stocksButtonGroup.addButton(hs300IndexRadioButton, 4)
self._stocksButtonGroup.addButton(zz500IndexRadioButton, 4)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(startDateLable, 0, 0)
grid.addWidget(self._startDateLineEdit, 1, 0)
grid.addWidget(endDateLable, 0, 1)
grid.addWidget(self._endDateLineEdit, 1, 1)
grid.addWidget(shIndexRadioButton, 2, 0)
grid.addWidget(szIndexRadioButton, 2, 1)
grid.addWidget(cybIndexRadioButton, 3, 0)
grid.addWidget(zxbIndexRadioButton, 3, 1)
grid.addWidget(hs300IndexRadioButton, 4, 0)
grid.addWidget(zz500IndexRadioButton, 4, 1)
grid.addWidget(okPushButton, 5, 1)
grid.addWidget(cancelPushButton, 5, 0)
self.setLayout(grid)
def _setupUi(self):
self.setWindowTitle(tr("Export Options"))
self.mainLayout = QVBoxLayout(self)
self.label1 = QLabel(tr("Which accounts do you want to export?"), self)
self.mainLayout.addWidget(self.label1)
self.exportTypeButtons = QButtonGroup(self)
self.exportAllButton = QRadioButton(tr("All"), self)
self.mainLayout.addWidget(self.exportAllButton)
self.exportTypeButtons.addButton(self.exportAllButton, ExportType.All)
self.exportAllButton.setChecked(True)
self.exportSelectedButton = QRadioButton(tr("Selected"), self)
self.mainLayout.addWidget(self.exportSelectedButton)
self.exportTypeButtons.addButton(self.exportSelectedButton, ExportType.Selected)
self.tableView = QTableView(self)
self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableView.verticalHeader().setVisible(False)
self.tableView.verticalHeader().setDefaultSectionSize(18)
self.mainLayout.addWidget(self.tableView)
self.label2 = QLabel(tr("Export format:"), self)
self.mainLayout.addWidget(self.label2)
self.exportFormatButtons = QButtonGroup(self)
self.exportAsQIFButton = QRadioButton("QIF", self)
self.mainLayout.addWidget(self.exportAsQIFButton)
self.exportFormatButtons.addButton(self.exportAsQIFButton, ExportFormat.QIF)
self.exportAsQIFButton.setChecked(True)
self.exportAsCSVButton = QRadioButton("CSV", self)
self.mainLayout.addWidget(self.exportAsCSVButton)
self.exportFormatButtons.addButton(self.exportAsCSVButton, ExportFormat.CSV)
self.label3 = QLabel(tr("Export scope:"))
self.mainLayout.addWidget(self.label3)
self.dateRangeOnlyCheckbox = QCheckBox(tr("Current date range only"))
self.mainLayout.addWidget(self.dateRangeOnlyCheckbox)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.exportButton = self.buttonBox.addButton(tr("Export"), QDialogButtonBox.ActionRole)
self.mainLayout.addWidget(self.buttonBox)
def __init__(self, parent=None, option_list=None, default_select=0):
super().__init__(parent=parent)
layout = QHBoxLayout(self)
self.group = QButtonGroup()
for idx, op in enumerate(option_list):
self.op = QRadioButton(_(op))
if idx == default_select:
self.op.setChecked(True)
layout.addWidget(self.op)
self.group.addButton(self.op)
self.setLayout(layout)
class CopyConfigDialog(ConfigDialog):
def __init__(self, mode=None):
super().__init__()
self.__initUI()
self.setSelectedCopyMode(mode)
def __initUI(self):
super().initUI()
self.setWindowTitle("画像コピー設定")
self.layout = QGridLayout()
self.radioGroup = QButtonGroup()
self.radioButton1 = QRadioButton("左右反転")
self.radioButton2 = QRadioButton("上下反転")
self.radioButton3 = QRadioButton("左右上下反転")
self.radioGroup.addButton(self.radioButton1)
self.radioGroup.addButton(self.radioButton2)
self.radioGroup.addButton(self.radioButton3)
self.layout.addWidget(self.radioButton1, 0, 0)
self.layout.addWidget(self.radioButton2, 1, 0)
self.layout.addWidget(self.radioButton3, 2, 0)
self.layout.addWidget(self.btnBox, 3, 1)
self.setLayout(self.layout)
"""コピー設定モードUI反映処理"""
def setSelectedCopyMode(self, mode):
if mode == Constant.LR_REVERSAL_MODE or mode is None:
self.radioButton1.setChecked(True)
elif mode == Constant.TB_REVERSAL_MODE:
self.radioButton2.setChecked(True)
else:
self.radioButton3.setChecked(True)
"""コピー設定モード取得処理"""
def getSelectedCopyMode(self):
if self.radioButton1.isChecked():
return Constant.LR_REVERSAL_MODE
elif self.radioButton2.isChecked():
return Constant.TB_REVERSAL_MODE
else:
return Constant.LRTB_REVERSAL_MODE
class RadioGroup(object):
def __init__(self,
value_text_tuples: Iterable[Tuple[str, Any]],
default: Any = None) -> None:
# There's no reason for the caller to care about the internal IDs
# we use. So let's make them up here as positive integers.
self.default_value = default
if not value_text_tuples:
raise ValueError("No values passed to RadioGroup")
if contains_duplicates([x[0] for x in value_text_tuples]):
raise ValueError("Duplicate values passed to RadioGroup")
possible_values = [x[0] for x in value_text_tuples]
if self.default_value not in possible_values:
self.default_value = possible_values[0]
self.bg = QButtonGroup() # exclusive by default
self.buttons = []
self.map_id_to_value = {}
self.map_value_to_button = {}
for i, (value, text) in enumerate(value_text_tuples):
id_ = i + 1 # start with 1
button = QRadioButton(text)
self.bg.addButton(button, id_)
self.buttons.append(button)
self.map_id_to_value[id_] = value
self.map_value_to_button[value] = button
def get_value(self) -> Any:
buttongroup_id = self.bg.checkedId()
if buttongroup_id == NOTHING_SELECTED:
return None
return self.map_id_to_value[buttongroup_id]
def set_value(self, value: Any) -> None:
if value not in self.map_value_to_button:
value = self.default_value
button = self.map_value_to_button[value]
button.setChecked(True)
def add_buttons_to_layout(self, layout: QLayout) -> None:
for button in self.buttons:
layout.addWidget(button)
def __init__(self, result):
QDialog.__init__(self)
self.layout = QVBoxLayout(self)
self.result = result
observation_window = result.observation_window
group = QButtonGroup(self)
use_simu_duration = QRadioButton("Use entire simulation.")
use_simu_duration.setChecked(
observation_window[0] == 0
and observation_window[1] == result.model.duration)
group.addButton(use_simu_duration)
self.layout.addWidget(use_simu_duration)
use_custom = QRadioButton("Use a custom observation window:")
use_custom.setChecked(not use_simu_duration.isChecked())
group.addButton(use_custom)
self.layout.addWidget(use_custom)
self._slider = QxtSpanSliderWidget(
0, result.model.now() // result.model.cycles_per_ms, self)
self._slider.setSpan(
observation_window[0] // result.model.cycles_per_ms,
observation_window[1] // result.model.cycles_per_ms)
self._slider.setEnabled(use_custom.isChecked())
group.buttonClicked.connect(
lambda x: self._slider.setEnabled(x == use_custom))
self.layout.addWidget(self._slider)
buttons = QWidget(self)
buttons_layout = QHBoxLayout()
buttons.setLayout(buttons_layout)
buttons_layout.addStretch()
ok_button = QPushButton("Ok")
cancel_button = QPushButton("Cancel")
ok_button.clicked.connect(self.accept)
cancel_button.clicked.connect(self.reject)
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
self.layout.addWidget(buttons)
def __init__(self, parent):
super().__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
self.lineEdit_loginUsername.setText(app.settings.get("account", "username"))
self.lineEdit_loginPassword.setText(app.settings.get("account", "password"))
self.checkBox_autoLogin.setChecked(app.settings.getbool("account", "autologin"))
self.checkBox_autoStartFrontend.setChecked(self.doesAutoStartFileExists())
self.checkBox_enableDevelopersTools.setChecked(
app.settings.getbool("frontend", "enabledeveloperstools"))
self.checkBox_allowFlash.setChecked(app.settings.getbool("frontend", "allowflash"))
self.checkBox_minimizeToSystray.setChecked(
app.settings.getbool("frontend", "minimizetosystray"))
self.checkBox_closeToMinimize.setChecked(
app.settings.getbool("frontend", "closetominimize"))
self.checkBox_popNotifications.setChecked(
app.settings.getbool("frontend", "popnotifications"))
self.checkBox_notifyBySound.setChecked(
app.settings.getbool("frontend", "notifybysound"))
self.checkBox_showMonitorWindow.setChecked(
app.settings.getbool("frontend", "showmonitorwindow"))
self.spinBox_monitorFullSpeed.setValue(
app.settings.getint("frontend", "monitorfullspeed"))
# clipboard related
self.checkBox_watchClipboard.stateChanged.connect(self.slotWatchClipboardToggled)
self.checkBox_watchClipboard.setChecked(app.settings.getbool("frontend", "watchclipboard"))
self.slotWatchClipboardToggled(self.checkBox_watchClipboard.checkState())
self.plaintext_watchPattern.setPlainText(app.settings.get("frontend", "watchpattern"))
self.btngrp_etmStartWhen = QButtonGroup()
self.btngrp_etmStartWhen.addButton(self.radio_backendStartWhen1, 1)
self.btngrp_etmStartWhen.addButton(self.radio_backendStartWhen2, 2)
self.btngrp_etmStartWhen.addButton(self.radio_backendStartWhen3, 3)
try:
startEtmWhen = callXwaredInterface("getStartEtmWhen")
self.btngrp_etmStartWhen.button(startEtmWhen).setChecked(True)
except SocketDoesntExist:
self.group_etmStartWhen.setEnabled(False)
self.btn_addMount.clicked.connect(self.slotAddMount)
self.btn_removeMount.clicked.connect(self.slotRemoveMount)
self.btn_refreshMount.clicked.connect(self.setupMounts)
# Mounts
self.setupMounts()
# backend setting is a different thing!
self.setupETM()
def controlButtons(self):
widget = QWidget()
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
startButton = QPushButton('Start')
startButton.setCheckable(True)
def onStart():
self.timer.start()
if self.progress.isPaused():
self.progress.resume()
startButton.clicked.connect(lambda: self.timer.start())
group.addButton(startButton)
layout.addWidget(startButton)
stopButton = QPushButton('Stop')
stopButton.setCheckable(True)
def onStop():
self.timer.stop()
self.progress.setPaused(True)
stopButton.clicked.connect(onStop)
group.addButton(stopButton)
layout.addWidget(stopButton)
resetButton = QPushButton('Reset')
def onReset():
self.timer.reset()
self.progress.resume()
resetButton.clicked.connect(onReset)
layout.addWidget(resetButton)
return widget
def createControlGroupBox(self):
self.controlGroupBox = QGroupBox("Controls")
# create and initialize lineEdits
self.LEbitfile = QLineEdit(
'bitfile\\Nov2018_dualprobe_v1_03mmfpc_pll_intclk.bit')
self.LErstcode = QLineEdit('7')
self.LEswitch = QLineEdit('10000000100110000')
self.LEfvco = QLineEdit('960')
self.LEfrep = QLineEdit('10')
self.LEduty = QLineEdit('50')
self.LEphase = QLineEdit('180')
self.LEflen = QLineEdit('1000')
self.LEfignore = QLineEdit('10')
self.LEfnum = QLineEdit('1000')
self.LEinum = QLineEdit('100') # or infinite
self.LEtacq = QLineEdit('?')
self.LEsdir = QLineEdit('rawdata')
self.LEsname = QLineEdit('sample')
self.LEsidx = QLineEdit('1')
# create text labels
Tbitfile = QLabel('Bitfile')
Tbitfile.setBuddy(self.LEbitfile)
Trstcode = QLabel('Rst Code')
Trstcode.setBuddy(self.LErstcode)
Tswitch = QLabel('FPGA Switches')
Tswitch.setBuddy(self.LEswitch)
Tclock = QLabel('Clock')
Tfvco = QLabel('Fvco')
Tfvco.setBuddy(self.LEfvco)
Tfrep = QLabel('Rep Rate')
Tfrep.setBuddy(self.LEfrep)
Tduty = QLabel('Duty Cycle')
Tduty.setBuddy(self.LEduty)
Tphase = QLabel('Phase')
Tphase.setBuddy(self.LEphase)
Tacquire = QLabel('Acquire')
Tflen = QLabel('Frame length')
Tflen.setBuddy(self.LEflen)
Tfignore = QLabel('Pass length')
Tfignore.setBuddy(self.LEfignore)
Tfnum = QLabel('#Frames')
Tfnum.setBuddy(self.LEfnum)
Tinum = QLabel('#Images')
Tinum.setBuddy(self.LEinum)
Ttacq = QLabel('Tacq/Img')
Ttacq.setBuddy(self.LEtacq)
Tsave = QLabel('Save')
Tsdir = QLabel('Dir')
Tsdir.setBuddy(self.LEsdir)
Tsname = QLabel('Name')
Tsname.setBuddy(self.LEsname)
Tsidx = QLabel('Nxt Idx')
Tsidx.setBuddy(self.LEsidx)
# create buttons
self.btnFlash = QPushButton("Flash")
self.btnFlash.setDefault(True)
self.btnReset = QPushButton("Reset")
self.btnReset.setDefault(True)
btngroup1 = QButtonGroup(self.controlGroupBox)
btngroup1.setExclusive(False)
self.tglFlash = QRadioButton("Flash")
self.tglFlash.setChecked(False)
self.tglReset = QRadioButton("Reset")
self.tglReset.setChecked(True)
self.tglReprogPLL = QRadioButton("reprogram PLL")
self.tglReprogPLL.setChecked(False)
self.tglParse = QRadioButton("Parse")
self.tglParse.setChecked(False)
self.tglSave = QRadioButton("Save")
self.tglSave.setChecked(True)
btngroup1.addButton(self.tglFlash)
btngroup1.addButton(self.tglReset)
btngroup1.addButton(self.tglReprogPLL)
btngroup1.addButton(self.tglParse)
btngroup1.addButton(self.tglSave)
self.btnRun = QPushButton("Run")
self.btnRun.setDefault(False)
self.btnStop = QPushButton("Stop")
self.btnStop.setDefault(False)
# create layout
boxlayout = QVBoxLayout()
line = [Tbitfile, self.LEbitfile, self.btnFlash]
size = [1, 100, 1]
self.layoutSingleLine(boxlayout, line, size)
line = [
Trstcode, self.LErstcode, Tswitch, self.LEswitch, self.btnReset
]
size = [1, 1, 1, 80, 1, 1]
self.layoutSingleLine(boxlayout, line, size)
line = [
Tclock, Tfvco, self.LEfvco, Tfrep, self.LEfrep, Tduty, self.LEduty,
Tphase, self.LEphase
]
size = [1, 0, 1, 0, 1, 0, 1, 0, 1]
self.layoutSingleLine(boxlayout, line, size)
line = [
Tacquire, Tflen, self.LEflen, Tfignore, self.LEfignore, Tfnum,
self.LEfnum, Tinum, self.LEinum, Ttacq, self.LEtacq
]
size = [2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
self.layoutSingleLine(boxlayout, line, size)
line = [
Tsave, Tsdir, self.LEsdir, Tsname, self.LEsname, Tsidx, self.LEsidx
]
size = [2, 1, 100, 1, 30, 1, 1]
self.layoutSingleLine(boxlayout, line, size)
line = [
self.tglFlash, self.tglReset, self.tglReprogPLL, self.tglParse,
self.tglSave, self.btnRun, self.btnStop
]
size = [1, 1, 1, 1, 1, 100, 100]
self.layoutSingleLine(boxlayout, line, size)
self.controlGroupBox.setLayout(boxlayout)
class AddAccountDialog(base_class, ui_class):
__metaclass__ = QSingleton
implements(IObserver)
def __init__(self, parent=None):
super(AddAccountDialog, self).__init__(parent)
with Resources.directory:
self.setupUi(self)
self.background_frame.setStyleSheet("")
self.button_group = QButtonGroup(self)
self.button_group.setObjectName("button_group")
self.button_group.addButton(
self.add_account_button,
self.panel_view.indexOf(self.add_account_panel))
self.button_group.addButton(
self.create_account_button,
self.panel_view.indexOf(self.create_account_panel))
default_font_size = self.info_label.fontInfo().pointSizeF()
title_font_size = limit(default_font_size + 3, max=14)
font = self.title_label.font()
font.setPointSizeF(title_font_size)
self.title_label.setFont(font)
font_metrics = self.create_status_label.fontMetrics()
self.create_status_label.setMinimumHeight(
font_metrics.height() + 2 *
(font_metrics.height() + font_metrics.leading())
) # reserve space for 3 lines
font_metrics = self.email_note_label.fontMetrics()
self.email_note_label.setMinimumWidth(
font_metrics.width(
u'The E-mail address is used when sending voicemail')
) # hack to make text justification look nice everywhere
self.add_account_button.setChecked(True)
self.panel_view.setCurrentWidget(self.add_account_panel)
self.new_password_editor.textChanged.connect(
self._SH_PasswordTextChanged)
self.button_group.buttonClicked[int].connect(
self._SH_PanelChangeRequest)
self.accept_button.clicked.connect(self._SH_AcceptButtonClicked)
self.display_name_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.name_editor.statusChanged.connect(self._SH_ValidityStatusChanged)
self.username_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.sip_address_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.new_password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.verify_password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.email_address_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.display_name_editor.regexp = re.compile('^.*$')
self.name_editor.regexp = re.compile('^.+$')
self.username_editor.regexp = re.compile(
'^\w(?<=[^0_])[\w.-]{4,31}(?<=[^_.-])$', re.IGNORECASE
) # in order to enable unicode characters add re.UNICODE to flags
self.sip_address_editor.regexp = re.compile('^[^@\s]+@[^@\s]+$')
self.password_editor.regexp = re.compile('^.*$')
self.new_password_editor.regexp = re.compile('^.{8,}$')
self.verify_password_editor.regexp = re.compile('^$')
self.email_address_editor.regexp = re.compile('^[^@\s]+@[^@\s]+$')
account_manager = AccountManager()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=account_manager)
def _get_display_name(self):
if self.panel_view.currentWidget() is self.add_account_panel:
return self.display_name_editor.text()
else:
return self.name_editor.text()
def _set_display_name(self, value):
self.display_name_editor.setText(value)
self.name_editor.setText(value)
def _get_username(self):
return self.username_editor.text()
def _set_username(self, value):
self.username_editor.setText(value)
def _get_sip_address(self):
return self.sip_address_editor.text()
def _set_sip_address(self, value):
self.sip_address_editor.setText(value)
def _get_password(self):
if self.panel_view.currentWidget() is self.add_account_panel:
return self.password_editor.text()
else:
return self.new_password_editor.text()
def _set_password(self, value):
self.password_editor.setText(value)
self.new_password_editor.setText(value)
def _get_verify_password(self):
return self.verify_password_editor.text()
def _set_verify_password(self, value):
self.verify_password_editor.setText(value)
def _get_email_address(self):
return self.email_address_editor.text()
def _set_email_address(self, value):
self.email_address_editor.setText(value)
display_name = property(_get_display_name, _set_display_name)
username = property(_get_username, _set_username)
sip_address = property(_get_sip_address, _set_sip_address)
password = property(_get_password, _set_password)
verify_password = property(_get_verify_password, _set_verify_password)
email_address = property(_get_email_address, _set_email_address)
del _get_display_name, _set_display_name, _get_username, _set_username
del _get_sip_address, _set_sip_address, _get_email_address, _set_email_address
del _get_password, _set_password, _get_verify_password, _set_verify_password
def _SH_AcceptButtonClicked(self):
if self.panel_view.currentWidget() is self.add_account_panel:
account = Account(self.sip_address)
account.enabled = True
account.display_name = self.display_name or None
account.auth.password = self.password
account.save()
account_manager = AccountManager()
account_manager.default_account = account
self.accept()
else:
self.setEnabled(False)
self.create_status_label.value = Status(
'Creating account on server...')
self._create_sip_account(self.username, self.password,
self.email_address, self.display_name)
def _SH_PanelChangeRequest(self, index):
self.panel_view.setCurrentIndex(index)
if self.panel_view.currentWidget() is self.add_account_panel:
inputs = [
self.display_name_editor, self.sip_address_editor,
self.password_editor
]
else:
inputs = [
self.name_editor, self.username_editor,
self.new_password_editor, self.verify_password_editor,
self.email_address_editor
]
self.accept_button.setEnabled(all(input.text_valid
for input in inputs))
def _SH_PasswordTextChanged(self, text):
self.verify_password_editor.regexp = re.compile(u'^%s$' %
re.escape(text))
def _SH_ValidityStatusChanged(self):
red = '#cc0000'
# validate the add panel
if not self.display_name_editor.text_valid:
self.add_status_label.value = Status(
"Display name cannot be empty", color=red)
elif not self.sip_address_editor.text_correct:
self.add_status_label.value = Status(
"SIP address should be specified as user@domain", color=red)
elif not self.sip_address_editor.text_allowed:
self.add_status_label.value = Status(
"An account with this SIP address was already added",
color=red)
elif not self.password_editor.text_valid:
self.add_status_label.value = Status("Password cannot be empty",
color=red)
else:
self.add_status_label.value = None
# validate the create panel
if not self.name_editor.text_valid:
self.create_status_label.value = Status("Name cannot be empty",
color=red)
elif not self.username_editor.text_correct:
self.create_status_label.value = Status(
"Username should have 5 to 32 characters, start with a letter or non-zero digit, contain only letters, digits or .-_ and end with a letter or digit",
color=red)
elif not self.username_editor.text_allowed:
self.create_status_label.value = Status(
"The username you requested is already taken. Please choose another one and try again.",
color=red)
elif not self.new_password_editor.text_valid:
self.create_status_label.value = Status(
"Password should contain at least 8 characters", color=red)
elif not self.verify_password_editor.text_valid:
self.create_status_label.value = Status("Passwords do not match",
color=red)
elif not self.email_address_editor.text_valid:
self.create_status_label.value = Status(
"E-mail address should be specified as user@domain", color=red)
else:
self.create_status_label.value = None
# enable the accept button if everything is valid in the current panel
if self.panel_view.currentWidget() is self.add_account_panel:
inputs = [
self.display_name_editor, self.sip_address_editor,
self.password_editor
]
else:
inputs = [
self.name_editor, self.username_editor,
self.new_password_editor, self.verify_password_editor,
self.email_address_editor
]
self.accept_button.setEnabled(all(input.text_valid
for input in inputs))
def _initialize(self):
self.display_name = user_info.fullname
self.username = user_info.username.lower().replace(u' ', u'.')
self.sip_address = u''
self.password = u''
self.verify_password = u''
self.email_address = u''
@run_in_thread('network-io')
def _create_sip_account(self,
username,
password,
email_address,
display_name,
timezone=None):
red = '#cc0000'
if timezone is None and sys.platform != 'win32':
try:
timezone = open('/etc/timezone').read().strip()
except (OSError, IOError):
try:
timezone = '/'.join(
os.readlink('/etc/localtime').split('/')[-2:])
except (OSError, IOError):
pass
enrollment_data = dict(username=username.lower().encode('utf-8'),
password=password.encode('utf-8'),
email=email_address.encode('utf-8'),
display_name=display_name.encode('utf-8'),
tzinfo=timezone)
try:
settings = SIPSimpleSettings()
response = urllib2.urlopen(settings.server.enrollment_url,
urllib.urlencode(dict(enrollment_data)))
response_data = cjson.decode(response.read().replace(r'\/', '/'))
response_data = defaultdict(lambda: None, response_data)
if response_data['success']:
try:
passport = response_data['passport']
if passport is not None:
certificate_path = self._save_certificates(
response_data['sip_address'], passport['crt'],
passport['key'], passport['ca'])
else:
certificate_path = None
except (GNUTLSError, IOError, OSError):
certificate_path = None
account_manager = AccountManager()
try:
account = Account(response_data['sip_address'])
except DuplicateIDError:
account = account_manager.get_account(
response_data['sip_address'])
account.enabled = True
account.display_name = display_name or None
account.auth.password = password
account.sip.outbound_proxy = response_data['outbound_proxy']
account.nat_traversal.msrp_relay = response_data['msrp_relay']
account.xcap.xcap_root = response_data['xcap_root']
account.tls.certificate = certificate_path
account.server.conference_server = response_data[
'conference_server']
account.server.settings_url = response_data['settings_url']
account.save()
account_manager.default_account = account
call_in_gui_thread(self.accept)
elif response_data['error'] == 'user_exists':
call_in_gui_thread(self.username_editor.addException, username)
else:
call_in_gui_thread(
setattr, self.create_status_label, 'value',
Status(response_data['error_message'], color=red))
except (cjson.DecodeError, KeyError):
call_in_gui_thread(setattr, self.create_status_label, 'value',
Status('Illegal server response', color=red))
except urllib2.URLError, e:
call_in_gui_thread(
setattr, self.create_status_label, 'value',
Status('Failed to contact server: %s' % e.reason, color=red))
finally:
class MainWindow(QWidget):
def __init__(self, contentProvider):
QWidget.__init__(self)
self.setWindowTitle("Визуализатор содержимого памяти")
#self.setToolTip("Байты, со значением равным 0x00, отображаются белым цветом, остальные -- серым")
QToolTip.setFont(QFont("SansSerif", 8))
self.startaddress = 0x10000000
self.magnifyOffset = 0
self.mode = 0
self.contentProvider = contentProvider
self.memframe = MemFrame()
self.memframe.magnifyPositionChanged.connect(self.onMagnifyPositionChanged)
self.magnify = Magnify()
self.btn1000 = QPushButton("0x10000000")
self.btn2000 = QPushButton("0x20000000")
self.btn2001 = QPushButton("0x20010000")
self.btn2002 = QPushButton("0x20020000")
self.btn1000.clicked.connect(self.on1000)
self.btn2000.clicked.connect(self.on2000)
self.btn2001.clicked.connect(self.on2001)
self.btn2002.clicked.connect(self.on2002)
self.rbColor = QRadioButton("Цветное")
self.rbBw = QRadioButton("Чёрно/белое")
self.rbChanges = QRadioButton("Изменения")
self.rbUsing = QRadioButton("Пользование")
self.rbColor.setChecked(True)
self.rbg = QButtonGroup()
self.rbg.addButton(self.rbColor)
self.rbg.addButton(self.rbBw)
self.rbg.addButton(self.rbChanges)
self.rbg.addButton(self.rbUsing)
self.rbColor.toggled.connect(self.onColor)
self.rbBw.toggled.connect(self.onBw)
self.rbChanges.toggled.connect(self.onChanges)
self.rbUsing.toggled.connect(self.onUsing)
# Размещение виджетов на морде
vbox1 = QVBoxLayout()
vbox1.addWidget(self.memframe)
vbox3 = QVBoxLayout()
vbox3.addSpacing(50)
vbox3.addWidget(self.btn1000)
vbox3.addWidget(self.btn2000)
vbox3.addWidget(self.btn2001)
vbox3.addWidget(self.btn2002)
vbox3.addStretch()
vbox4 = QVBoxLayout()
vbox4.addSpacing(50)
vbox4.addWidget(self.rbColor)
vbox4.addWidget(self.rbBw)
vbox4.addWidget(self.rbChanges)
vbox4.addWidget(self.rbUsing)
vbox4.addStretch()
hbox1 = QHBoxLayout()
hbox1.addLayout(vbox3)
hbox1.addLayout(vbox4)
vbox2 = QVBoxLayout()
vbox2.addLayout(hbox1)
vbox2.addWidget(self.magnify)
vbox2.addStretch()
hbox0 = QHBoxLayout()
hbox0.addLayout(vbox1)
hbox0.addLayout(vbox2)
hbox0.addStretch()
self.setLayout(hbox0)
#hbox0.addSpacing(30)
#hbox0.addLayout(vbox3)
def update(self):
content = self.contentProvider.getContent(self.startaddress, LENGTH)
if content != None:
self.memframe.setContent(content) # Подновим изображение "квадрата"
# Подготовим массив значений из памяти для области увеличения (семь строк по семь значений)
magnifyContent = [[], [], [], [], [], [], []]
for y in range(7):
x1 = self.magnifyOffset + (256 * y)
x2 = x1 + 7
magnifyContent[y] = content[x1:x2]
self.magnify.setContent(magnifyContent)
def onTimer(self):
'''
Периодически опрашивает источник данных провайдера и отображает полученный контент
'''
self.update()
def on1000(self):
self.startaddress = 0x10000000
self.memframe.setStartAddress(self.startaddress)
self.magnify.setStartAddress(self.startaddress)
self.update()
def on2000(self):
self.startaddress = 0x20000000
self.memframe.setStartAddress(self.startaddress)
self.magnify.setStartAddress(self.startaddress)
self.update()
def on2001(self):
self.startaddress = 0x20010000
self.memframe.setStartAddress(self.startaddress)
self.magnify.setStartAddress(self.startaddress)
self.update()
def on2002(self):
self.startaddress = 0x20020000
self.memframe.setStartAddress(self.startaddress)
self.magnify.setStartAddress(self.startaddress)
self.update()
def onColor(self):
if self.sender().isChecked():
#print("Цвет")
self.memframe.setMode(1)
def onBw(self):
if self.sender().isChecked():
#print("Черно-белый")
self.memframe.setMode(2)
def onChanges(self):
if self.sender().isChecked():
#print("Изменения")
self.memframe.setMode(3)
def onUsing(self):
if self.sender().isChecked():
#print("Пользование")
self.memframe.setMode(4)
def onMagnifyPositionChanged(self, pos: QPoint):
'''
Обработчик измение адреса по указателю на "квадрате" памяти
pos -- xy-координаты указателя на "квадрате" памяти
'''
#print(pos)
# Крректируем позицию чтобы не вылезьти за края "квадрата"
x0 = pos.x() - 3 # Смещение на три строки вверх
y0 = pos.y() - 3 # Смещение на три строки влево
if x0 < 0:
x0 = 0
if x0 > 249:
x0 = 249
if y0 < 0:
y0 = 0
if y0 > 249:
y0 = 249
self.magnifyOffset = y0 * 256 + x0 # Начальный адрес области увеличения
addr = self.startaddress + self.magnifyOffset
#print("{:08X}".format(self.magnifyStartAddress))
self.magnify.setStartAddress(addr)
class EasyFitWindow(QDialog):
numGridRows = 3
numButtons = 4
def __init__(self):
super(EasyFitWindow, self).__init__()
self.hbox = QHBoxLayout()
self.nameLabel = QLineEdit()
self.ageLabel = QLineEdit()
self.feetLabel = QLineEdit()
self.inchesLabel = QLineEdit()
self.weightLabel = QLineEdit()
self.gbox = QHBoxLayout()
self.goal1 = QRadioButton("Weight Loss")
self.goal2 = QRadioButton("Maintenance")
self.goal3 = QRadioButton("Strength Gain")
self.r1 = QRadioButton("Male")
self.r2 = QRadioButton("Female")
self.fileLabel = QLineEdit()
self.createFormGroupBox()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.formGroupBox)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("EasyFit")
def createFormGroupBox(self):
self.formGroupBox = QGroupBox()
self.genGroup = QButtonGroup(self.formGroupBox)
self.goalGroup = QButtonGroup(self.formGroupBox)
self.genGroup.addButton(self.r1)
self.genGroup.addButton(self.r2)
self.goalGroup.addButton(self.goal1)
self.goalGroup.addButton(self.goal2)
self.goalGroup.addButton(self.goal3)
layout = QFormLayout()
self.hbox.addWidget(self.r1)
self.hbox.addWidget(self.r2)
self.hbox.addStretch()
self.gbox.addWidget(self.goal1)
self.gbox.addWidget(self.goal2)
self.gbox.addWidget(self.goal3)
self.gbox.addStretch()
layout.addRow(QLabel("Full Name:"), self.nameLabel)
layout.addRow(QLabel("Age:"), self.ageLabel)
layout.addRow(QLabel("Height: (feet)"), self.feetLabel)
layout.addRow(QLabel(" (inches)"), self.inchesLabel)
layout.addRow(QLabel("Weight:"), self.weightLabel)
layout.addRow(QLabel("Workout Goal:"), self.gbox)
layout.addRow(QLabel("Gender:"), self.hbox)
layout.addRow(QLabel("Output File Name:"), self.fileLabel)
layout.addWidget(QLabel("(without file extension)"))
self.formGroupBox.setLayout(layout)
def accept(self):
n = self.nameLabel.text()
a = int(self.ageLabel.text())
h = 12 * int(self.feetLabel.text()) + int(self.inchesLabel.text())
w = int(self.weightLabel.text())
if self.goal1.isChecked():
g = 'C'
elif self.goal2.isChecked():
g = 'M'
else:
g = 'B'
if self.r1.isChecked():
gen = 'M'
else:
gen = 'F'
filename = self.fileLabel.text() + ".txt"
p = person.Person(n, a, h, w, g, gen)
text = None
db = Database.Database()
if db.check(n):
wChange = db.update(n, w)
if wChange >= 0:
text = "Welcome back " + n + "! You have gained " + str(wChange) + " pounds. Here are your updated " \
"diet and workout plans:\n\n "
else:
wChange = str(wChange)
text = "Welcome back " + n + "! You have lost " + wChange[1:] + " pounds. Here are your updated diet " \
"and workout plans:\n\n "
else:
text = "Welcome to EasyFit " + n + "! Here are your first diet and workout plans:\n\n"
db.newUser(n, a, h, w, gen)
db.close()
f = open(filename, 'w')
plan = "\t\tDAILY DIET PLAN FOR " + n.upper() + ":\n\n" + p.diet.print_Diet() + \
"\n\n\n\n\n\t\tWORKOUT PLAN FOR " + n.upper() + ":\n\n" + p.workout.printWorkout()
f.write(text)
f.write(plan)
f.close()
if platform.system() == 'Darwin': # macOS
subprocess.call(('open', filename))
elif platform.system() == 'Windows': # Windows
os.startfile(filename)
else: # linux variants
subprocess.call(('xdg-open', filename))
def update_tests_layout(self):
clear_layout(self.tests_layout)
if self.current_project != '':
folder_path = os.path.join(self.path, self.current_project)
tests = os.listdir(folder_path)
# Добавляем кнопки для всех файлов, лежащих в папке
# Добавляем ScrollArea, чтобы можно было прокручивать вниз, если файлов очень много
if len(tests) == 0:
empty_lbl = QLabel("Нет созданных испытаний")
empty_lbl.setStyleSheet('font-size: 11pt')
self.tests_layout.addWidget(empty_lbl)
else:
test_lbl = QLabel(self.current_project + ':')
test_lbl.setStyleSheet('font-size: 11pt')
self.tests_layout.addWidget(test_lbl)
self.test_buttons = QButtonGroup()
self.test_buttons.buttonClicked[int].connect(self.test_pushed)
box = QGroupBox() # Необходимо для ScrollArea
inner_layout = QVBoxLayout()
for test in range(
len(tests)): # Добавляем каждую внутреннюю директорию
button = QPushButton(tests[test], self)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; '
'font-weight: 100')
# В обработчик нажатия передаём путь, чтобы определять, что нужно открыть
self.test_buttons.addButton(button, test)
inner_layout.addWidget(button)
inner_files = os.listdir(
os.path.join(folder_path, tests[test]))
for file in inner_files: # Добавляем каждый файл из внутренних директорий
button = QPushButton('- ' + file)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: '
'9pt; font-weight: 100; margin-left: 20px')
# В обработчик нажатия передаём путь, чтобы определять, что нужно открыть
button.clicked.connect(
lambda state, file_path=os.path.join(
folder_path, tests[test], file
): self.file_pushed(file_path))
inner_layout.addWidget(button)
if os.path.isdir(
os.path.join(folder_path, tests[test], file)):
data_files = os.listdir(
os.path.join(folder_path, tests[test], file))
for df in data_files:
button = QPushButton('> ' + df)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: '
'7pt; font-weight: 100; margin-left: 40px')
button.clicked.connect(
lambda state, file_path=os.path.join(
folder_path, tests[test], file, df
): self.file_pushed(file_path))
inner_layout.addWidget(button)
box.setLayout(inner_layout)
scroll = QScrollArea()
scroll.setWidget(box)
scroll.setWidgetResizable(True)
self.tests_layout.addWidget(scroll)
class Main(QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.all_sets = {} # Словарь с сетами, где ключ - его название, а в нем находится спиок классов карточек
self.setupUi(self)
self.setWindowTitle("Главная")
self.login = "******"
self.fil_in_sets() # функция заполнения ListView
self.login_button.clicked.connect(self.open_login) # подключаем кнопку входа
self.quet.clicked.connect(self.quete) # подключаем кнопку выхода
self.name = "Неизвестный" # первоначальное имя, если войти без регистрации
self.new_card.clicked.connect(self.add_new_card) # подключает функцию добавления новой карточки
self.show_all.clicked.connect(self.show_all_cards) # Подключает кнопку показа вообще всех карточек у юзера
self.delete_cards.clicked.connect(self.delete_card) # подключает функцию удаления карточек
self.create_new_set.clicked.connect(self.new_set) # подключает функцию создания нового сета
self.edit_set.clicked.connect(self.edit_sets) # подключает редактирование сетов
self.game_with_words.clicked.connect(self.exercises)
def exercises(self):
self.x = ChoiceEx(self)
self.x.show()
def delete_card(self):
self.delete = DeleteCards(self)
self.delete.show()
self.hide()
def open_login(self):
"""Вход"""
reply = QMessageBox.question(self, '',
"Вы хотите выйте из аккаунта?", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.log = Login(parent=self)
self.hide()
self.log.show()
def change_name(self):
self.name_label.setText(self.name)
self.fill_in()
def quete(self):
"""Выход из аккаунта"""
reply = QMessageBox.question(self, '',
"Вы точно хотите выйти из аккаунта?", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.name = "неизвестный"
self.hide()
self.open_login()
def show_main(self):
self.show()
def new_set(self):
"""Создает новый сет в настройках из имеющихся"""
self.sets = CreateNewSet(parent=self)
self.sets.show()
self.hide()
def edit_sets(self):
"""Эта функция будет изменять сет, можно выбрать, что в нем оставить или что в нем удалить"""
self.edit = ChooseSet(self)
self.edit.show()
self.hide()
def show_all_cards(self):
"""Показать вообще все имеющиеся карточки"""
self.hide()
self.show_cards = ShowAllCards(self)
self.show_cards.show()
def add_new_card(self):
CreateNewCard(self)
"""Создает новую карточку с словом"""
def fil_in_sets(self):
"""Заполняем список сетов в виде кнопок, """
self.button_group = QButtonGroup()
self.button_group.buttonClicked.connect(self.are_you_sure) # подключает игру с сетом
self.fill_in()
"""Эти кнопки для того, чтобы начать игру, при нажатии она начинается с выбранным сетом"""
def are_you_sure(self, button):
self.set_name = button.text()
"""Показывает окно, точно ли они хотят играть именно с этим сетом"""
reply = QMessageBox.question(self, '',
f"Хотите заучить набор карточек: {self.set_name}?", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.open_choice()
else:
pass
def open_choice(self):
self.game = ChooseGame(par=self)
self.game.show()
def return_all_sets(self):
"""Достает названия всех сетов пользователя"""
"""подключаем базу данных"""
self.con = sqlite3.connect("quiz.db")
self.cur = self.con.cursor()
all_sets = self.cur.execute("""SELECT title FROM Sets WHERE login = ?""", (str(self.login),)).fetchall()
all_sets2 = []
for i in all_sets:
i = i[0]
if i != 'Все карточки':
all_sets2.append(i)
return all_sets2
def fill_in(self):
"""заполняет ячейки listwidget"""
self.all_sets = self.return_all_sets()
num = 1
if self.all_sets:
self.widget = QWidget()
self.scrollArea.setWidget(self.widget)
self.layout_SArea = QVBoxLayout(self.widget)
"""Заполняем ScrollArea кнопками с топовым дизайном"""
for i in self.all_sets:
self.button = QPushButton(str(i))
self.button.setDisabled(False)
self.button.setObjectName(f"button{num}")
num += 1
self.button.setStyleSheet("""background-color: rgb(0, 0, 0);\ncolor: rgb(255, 250, 255);
\nborder-radius: 20px;\nheight: 40px;\n""")
f = self.button.font()
f.setPointSize(20)
self.button.setFont(f)
self.button_group.addButton(self.button)
self.layout_SArea.addWidget(self.button)
self.layout_SArea.addStretch(1)
else:
self.widget = QWidget()
self.scrollArea.setWidget(self.widget)
self.layout_SArea = QHBoxLayout(self.widget)
self.label = QLabel("Упс, тут пока что пусто \nНо вы можете это исправить")
self.label.setStyleSheet("font: 18pt 'Helvetica';")
self.layout_SArea.addWidget(self.label)
class App(QWidget):
def __init__(self):
super().__init__()
self.algorithm_dict = {'DFS': 'dfs', 'BFS': 'bfs', 'A*': 'astar'}
self.alg_option = 'dfs'
self.title = 'Transport Assistant'
self.initUI()
def initUI(self):
start = QLabel('Start: ', self)
dest = QLabel('Destination: ', self)
self.city_map = QLabel(self)
algorithm_label = QLabel('Algorithm: ', self)
self.pixmap = QPixmap('map.png').scaledToWidth(500)
self.city_map.setPixmap(self.pixmap)
find = QPushButton('Find path', self)
find.clicked.connect(self.find_path)
self.path_label = QTextEdit('', self)
self.path_label.setReadOnly(True)
tram_stops = get_stop_names()
self.combo_start = QComboBox(self)
self.combo_start.addItems(tram_stops)
self.combo_start.setMaxVisibleItems(15)
self.combo_dest = QComboBox(self)
self.combo_dest.addItems(tram_stops)
self.combo_start.setMaxVisibleItems(15)
algorithms = [
QRadioButton('DFS'),
QRadioButton('BFS'),
QRadioButton('A*')
]
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(start, 1, 0)
grid.addWidget(self.combo_start, 1, 1, 1, 5)
grid.addWidget(dest, 2, 0)
grid.addWidget(self.combo_dest, 2, 1, 1, 5)
grid.addWidget(self.city_map, 4, 0, 1, 6)
grid.addWidget(self.path_label, 5, 0, 5, 5)
grid.addWidget(find, 9, 5)
self.buttons = QButtonGroup()
grid.addWidget(algorithm_label, 3, 0)
for i, radio in enumerate(algorithms):
grid.addWidget(radio, 3, i + 1)
self.buttons.addButton(radio, i)
radio.toggled.connect(self.set_algorithm)
self.setLayout(grid)
self.setWindowTitle(self.title)
self.show()
def set_algorithm(self):
self.alg_option = self.algorithm_dict[
self.buttons.checkedButton().text()]
def find_path(self):
path = subprocess.check_output([
'./bin/UrbanTransportApp',
self.combo_start.currentText(),
self.combo_dest.currentText(), self.alg_option
]).decode('utf-8')
self.path_label.setText(path)
subprocess.run(['python3', 'graph_draw.py', 'path.dat'])
self.city_map.setPixmap(QPixmap('path.png').scaledToWidth(500))
def initUI(self):
self.file_handler = File_Handler()
#change Font
load_font(self.file_handler.used_font_path)
self.setFont(QFont("Eurostile LT Std", 18))
heading_font = QFont("Eurostile LT Std", 18, weight=QtGui.QFont.Bold)
#Set name of Window (Starting x, starting y, width, height
self.setGeometry(180, 180, 720, 720)
#Create Grid
self.grid = QGridLayout()
#row pointer
row_position = 0
#Nozzle Size Selection
nozzle_size_selection_label = QLabel(
"With which nozzle name do you want to print?")
nozzle_size_selection_label.setAlignment(QtCore.Qt.AlignCenter)
nozzle_size_selection_label.setFont(heading_font)
self.grid.addWidget(nozzle_size_selection_label, row_position, 0, 1, 2)
row_position += 1
#Nozzle Selection HBox
nozzle_size_selection_hobx = QHBoxLayout()
self.grid.addLayout(nozzle_size_selection_hobx, row_position, 0, 1, 2)
row_position += 1
#Nozzle Selection Buttongroup
nozzle_size_selection_button_group = QButtonGroup(self)
#Nozzle 1.3 Size Button
self.nozzle_1_5_button = QRadioButton("1.5 mm")
#1.5 diameter is the default
self.nozzle_1_5_button.setChecked(True)
self.selected_diameter_path = self.file_handler.diameter_1_5_path
self.nozzle_1_5_button.toggled.connect(
lambda: self.update_diameter_button("1.5"))
nozzle_size_selection_button_group.addButton(self.nozzle_1_5_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_1_5_button,
QtCore.Qt.AlignLeft)
#Nozzle 0.8 Size Button
self.nozzle_0_8_button = QRadioButton("0.8 mm")
self.nozzle_0_8_button.toggled.connect(
lambda: self.update_diameter_button("0.8"))
nozzle_size_selection_button_group.addButton(self.nozzle_0_8_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_0_8_button,
QtCore.Qt.AlignLeft)
#Nozzle 0.6 Size Button
self.nozzle_0_6_button = QRadioButton("0.6 mm")
self.nozzle_0_6_button.toggled.connect(
lambda: self.update_diameter_button("0.6"))
nozzle_size_selection_button_group.addButton(self.nozzle_0_6_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_0_6_button,
QtCore.Qt.AlignLeft)
#File Selection Label
file_selection_label = QLabel("Which file do you want to modify?")
file_selection_label.setAlignment(QtCore.Qt.AlignCenter)
file_selection_label.setFont(heading_font)
self.grid.addWidget(file_selection_label, row_position, 0, 1, 2)
row_position += 1
# File Selection Buttongroup
self.file_selection_button_group = QButtonGroup(self)
# File Selection HBox
self.file_selection_hobx = QHBoxLayout()
self.grid.addLayout(self.file_selection_hobx, row_position, 0, 1, 2)
row_position += 1
self.selected_file_name = None
self.file_button_list = []
self.create_file_buttons()
#Print setting label
print_settings_label = QLabel(
"Which print settings do you want to use?")
print_settings_label.setAlignment(QtCore.Qt.AlignCenter)
print_settings_label.setFont(heading_font)
self.grid.addWidget(print_settings_label, row_position, 0, 1, 2)
row_position += 1
#Print settings grid
self.print_settings_grid = QGridLayout()
self.grid.addLayout(self.print_settings_grid, row_position, 0, 1, 2)
row_position += 1
#Flow Rate Layer 0 Label
flow_rate_layer_0_label = QLabel("Flow rate for the first layer: ")
flow_rate_layer_0_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(flow_rate_layer_0_label, 0, 0)
# Flow Rate Layer 0 Entry
self.flow_rate_layer_0_entry = QLineEdit()
self.flow_rate_layer_0_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_layer_0_entry.setText("100")
self.print_settings_grid.addWidget(self.flow_rate_layer_0_entry, 0, 1)
#Toggle Differentiate between Infill / Outer Walls
self.flow_rate_differentiation_button = QPushButton(
"Different flow rate for outer walls and infill")
self.flow_rate_differentiation_button.clicked.connect(
lambda: self.differentiate_flow_rate(
self.flow_rate_differentiation_button.text()))
self.print_settings_grid.addWidget(
self.flow_rate_differentiation_button, 1, 0, 1, 2)
#Flow Rate Other Layers
self.flow_rate_par_1_label = QLabel("Flow rate for the other layers: ")
self.flow_rate_par_1_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(self.flow_rate_par_1_label, 2, 0)
# Flow Rate Layer 0 Entry
self.flow_rate_par_1_entry = QLineEdit()
self.flow_rate_par_1_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_par_1_entry.setText("100")
self.print_settings_grid.addWidget(self.flow_rate_par_1_entry, 2, 1)
# Temp Label
self.flow_rate_par_2_label = QLabel("Flow rate for the infill: ")
self.flow_rate_par_2_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(self.flow_rate_par_2_label, 3, 0)
self.flow_rate_par_2_label.setHidden(True)
# Temp Entry
self.flow_rate_par_2_entry = QLineEdit()
self.flow_rate_par_2_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_par_2_entry.setText("65")
self.print_settings_grid.addWidget(self.flow_rate_par_2_entry, 3, 1)
self.flow_rate_par_2_entry.setHidden(True)
#Bed Temperature Label
bed_temperature_label = QLabel("Bed Temperature: ")
bed_temperature_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(bed_temperature_label, 0, 2)
#Bed Temperature Entry
self.bed_temperature_entry = QLineEdit()
self.bed_temperature_entry.setAlignment(QtCore.Qt.AlignCenter)
self.bed_temperature_entry.setText("0")
self.print_settings_grid.addWidget(self.bed_temperature_entry, 0, 3)
#Print Speed Label
print_speed_label = QLabel("Print Speed: ")
print_speed_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(print_speed_label, 1, 2)
#Print Speed Entry
self.print_speed_entry = QLineEdit()
self.print_speed_entry.setAlignment(QtCore.Qt.AlignCenter)
self.print_speed_entry.setText("100")
self.print_settings_grid.addWidget(self.print_speed_entry, 1, 3)
#Additional Fan Checkbox
self.fan_checkbox = QCheckBox("Turn on the fan while printing")
self.print_settings_grid.addWidget(self.fan_checkbox, 2, 2)
#Modification label
print_modifications_label = QLabel("What do you want to modify?")
print_modifications_label.setAlignment(QtCore.Qt.AlignCenter)
print_modifications_label.setFont(heading_font)
self.grid.addWidget(print_modifications_label, row_position, 0, 1, 2)
row_position += 1
# Add Information Checkbox
self.add_information_checkbox = QCheckBox(
"Show additional information while printing")
self.grid.addWidget(self.add_information_checkbox, row_position, 0)
# Add Big Syringe Support Checkbox
self.big_syringe_checkbox = QCheckBox("Enable big syringe support")
self.grid.addWidget(self.big_syringe_checkbox, row_position, 1)
row_position += 1
#Pause after each layer checkbox
self.pause_print_retraction_checkbox = QCheckBox(
"Pause print after each layer")
self.pause_print_retraction_checkbox.toggled.connect(
self.pause_print_toggled)
self.grid.addWidget(self.pause_print_retraction_checkbox, row_position,
0)
row_position += 1
#Pause Choices Grid
self.grid_choices_grid = QGridLayout()
self.grid_choices_grid.setColumnMinimumWidth(1, 72)
self.grid_choices_grid.setColumnMinimumWidth(4, 10)
self.grid_choices_grid.setColumnStretch(4, 1)
self.grid.addLayout(self.grid_choices_grid, row_position, 0, 1, 2)
row_position += 1
#Pauser after each layer seconds label
self.pause_print_seconds_label = QLabel("Seconds: ")
# Pauser after each layer seconds entry
self.pause_print_seconds_entry = QLineEdit("10")
self.pause_print_seconds_entry.setAlignment(QtCore.Qt.AlignCenter)
self.pause_print_seconds_entry.setMaximumWidth(64)
# Retract During Pause Label
self.retract_during_pause_checkbox = QCheckBox("Retract during pause")
#Clean the nozzle ever x moves
self.clean_nozzle_checkbox = QCheckBox(
"Clean the nozzle during the print")
self.grid.addWidget(self.clean_nozzle_checkbox, row_position, 0)
self.clean_nozzle_checkbox.toggled.connect(self.clean_nozzle_toggled)
row_position += 1
#Clean Nozzle Grid
self.clean_nozzle_grid = QGridLayout()
self.clean_nozzle_grid.setColumnMinimumWidth(1, 72)
self.clean_nozzle_grid.setColumnMinimumWidth(4, 10)
self.clean_nozzle_grid.setColumnStretch(4, 1)
self.grid.addLayout(self.clean_nozzle_grid, row_position, 0, 1, 2)
row_position += 1
#Pauser after each layer seconds label
self.clean_nozzle_label_1 = QLabel("Every")
# Pauser after each layer seconds entry
self.clean_nozzle_entry = QLineEdit("50")
self.clean_nozzle_entry.setAlignment(QtCore.Qt.AlignCenter)
self.clean_nozzle_entry.setMaximumWidth(64)
#Pauser after each layer seconds label
self.clean_nozzle_label_2 = QLabel("moves")
#Retract syringe at the end of print Checkbox
self.retract_syringe_checkbox = QCheckBox(
"Retract the syringe at the end of print")
self.grid.addWidget(self.retract_syringe_checkbox, row_position, 0)
row_position += 1
#Modification label
storage_label = QLabel("How do you want to store the file?")
storage_label.setAlignment(QtCore.Qt.AlignCenter)
storage_label.setFont(heading_font)
self.grid.addWidget(storage_label, row_position, 0, 1, 2)
row_position += 1
#Storage grid
self.storage_grid = QGridLayout()
self.grid.addLayout(self.storage_grid, row_position, 0, 1, 2)
row_position += 1
# Name of Modified File Label
storage_name_label = QLabel("Name modified file: ")
storage_name_label.setAlignment(QtCore.Qt.AlignLeft)
self.storage_grid.addWidget(storage_name_label, 0, 0)
# Name of Modified File Entry
self.storage_name_entry = QLineEdit()
self.storage_name_entry.setText(self.selected_file_name.split(".")[0])
self.storage_grid.addWidget(self.storage_name_entry, 0, 1)
#Storage Path Label
self.path_label = QLabel("Storage path: ")
self.storage_grid.addWidget(self.path_label, 1, 0)
# Chose Location to store button
self.choose_location_button = QPushButton("Choose location to store")
self.last_directory = ""
self.choose_location_button.clicked.connect(
self.select_storage_location)
self.storage_grid.addWidget(self.choose_location_button, 1, 1)
row_position += 1
self.storage_location_button_row = row_position
#Storage Path Name Label
self.path_name_label = QLabel()
#Modify Button
self.modify_button = QPushButton("Modify!")
self.modify_button.clicked.connect(self.start_modification)
self.grid.addWidget(self.modify_button, row_position, 0, 1, 2)
#Set layout and show mainscreen
self.setLayout(self.grid)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.create_main_window_actions([
QActionProperties(
name=main_window_constants.EXPORT_ACTION_NAME,
icon=QIcon(':/icons/export'),
text='&Export',
shortcut='Ctrl+E',
status_tip='Export to Python code',
triggered=self.export_diagram,
),
QActionProperties(
name=main_window_constants.DELETE_ACTON_NAME,
icon=QIcon(':/icons/delete'),
text='&Delete',
shortcut='Delete',
status_tip='Delete item from diagram',
triggered=self.delete_item,
),
QActionProperties(
name=main_window_constants.TO_FRONT_ACTION_NAME,
icon=QIcon(':/icons/bring_to_front'),
text='Bring to &Front',
shortcut='Ctrl+F',
status_tip='Bring item to front',
triggered=self.bring_to_front,
),
QActionProperties(
name=main_window_constants.TO_BACK_ACTION_NAME,
icon=QIcon(':/icons/send_to_back'),
text='Send to &Back',
shortcut='Ctrl+B',
status_tip='Send item to back',
triggered=self.send_to_back,
),
])
self.create_file_menu()
self.create_edit_menu()
self.create_frameworks_toolbar()
self.create_edit_diagram_toolbar()
self.create_pointer_toolbar()
self.create_diagram_scene_and_view()
self.create_framework_toolbox()
self.layout = QHBoxLayout()
self.layout.addWidget(self.framework_toolbox)
self.layout.addWidget(self.view)
self.widget = QWidget()
self.widget.setLayout(self.layout)
self.setWindowTitle(main_window_constants.MAIN_WINDOW_TITLE)
self.setCentralWidget(self.widget)
# Create methods.
def create_main_window_actions(
self, main_window_actions: List[QActionProperties]):
self.main_window_actions = dict()
for main_window_action in main_window_actions:
self.main_window_actions[main_window_action.name] = QAction(
main_window_action.icon,
main_window_action.text,
self,
shortcut=main_window_action.shortcut,
statusTip=main_window_action.status_tip,
triggered=main_window_action.triggered,
)
def create_file_menu(self):
self.file_menu = self.menuBar().addMenu(
main_window_constants.FILE_MENU_NAME)
self.file_menu.addAction(
self.main_window_actions[main_window_constants.EXPORT_ACTION_NAME])
def create_edit_menu(self):
self.edit_menu = self.menuBar().addMenu(
main_window_constants.EDIT_MENU_NAME)
self.edit_menu.addAction(
self.main_window_actions[main_window_constants.DELETE_ACTON_NAME])
self.edit_menu.addSeparator()
self.edit_menu.addAction(self.main_window_actions[
main_window_constants.TO_FRONT_ACTION_NAME])
self.edit_menu.addAction(self.main_window_actions[
main_window_constants.TO_BACK_ACTION_NAME])
def create_frameworks_toolbar(self):
self.frameworks_label = QLabel(main_window_constants.FRAMEWORKS_LABEL)
self.frameworks_combobox = QComboBox()
self.frameworks_combobox.setEditable(False)
for framework in frameworks_utils.get_sorted_frameworks_list():
self.frameworks_combobox.addItem(framework)
self.frameworks_toolbar = self.addToolBar(
main_window_constants.FRAMEWORKS_TOOLBAR_NAME)
self.frameworks_toolbar.addWidget(self.frameworks_label)
self.frameworks_toolbar.addWidget(self.frameworks_combobox)
def create_edit_diagram_toolbar(self):
self.edit_diagram_toolbar = self.addToolBar(
main_window_constants.DIAGRAM_EDIT_TOOLBAR_NAME)
self.edit_diagram_toolbar.addAction(
self.main_window_actions[main_window_constants.DELETE_ACTON_NAME])
self.edit_diagram_toolbar.addAction(self.main_window_actions[
main_window_constants.TO_FRONT_ACTION_NAME])
self.edit_diagram_toolbar.addAction(self.main_window_actions[
main_window_constants.TO_BACK_ACTION_NAME])
def create_pointer_toolbar(self):
pointer_button = QToolButton()
pointer_button.setCheckable(True)
pointer_button.setChecked(True)
pointer_button.setIcon(QIcon(':/icons/pointer'))
line_pointer_button = QToolButton()
line_pointer_button.setCheckable(True)
line_pointer_button.setIcon(QIcon(':/icons/line_pointer'))
self.pointer_type_group = QButtonGroup()
self.pointer_type_group.addButton(pointer_button,
DiagramScene.move_item)
self.pointer_type_group.addButton(line_pointer_button,
DiagramScene.insert_line)
self.pointer_type_group.buttonClicked[int].connect(
self.pointer_group_clicked)
scene_scale_combo = QComboBox()
scene_scale_combo.addItems(main_window_constants.DIAGRAM_SCENE_SCALES)
scene_scale_combo.setCurrentIndex(
main_window_constants.DIAGRAM_SCENE_SCALES.index(
main_window_constants.DIAGRAM_SCENE_DEFAULT_SCALE))
scene_scale_combo.currentIndexChanged[str].connect(
self.scene_scale_changed)
self.pointer_toolbar = self.addToolBar(
main_window_constants.POINTER_TYPE_TOOLBAR_NAME)
self.pointer_toolbar.addWidget(pointer_button)
self.pointer_toolbar.addWidget(line_pointer_button)
self.pointer_toolbar.addWidget(scene_scale_combo)
def create_diagram_scene_and_view(self):
self.scene = DiagramScene(self.edit_menu)
self.scene.setSceneRect(
QRectF(0, 0, main_window_constants.DIAGRAM_SCENE_SIZE,
main_window_constants.DIAGRAM_SCENE_SIZE))
self.scene.item_inserted.connect(self.item_inserted)
self.view = QGraphicsView(self.scene)
def create_framework_toolbox(self):
framework_layers = frameworks_utils.get_framework_layers(
self.get_selected_framework())
self.framework_layers_button_group = QButtonGroup()
self.framework_layers_button_group.setExclusive(False)
self.framework_layers_button_group.buttonClicked[int].connect(
self.framework_layers_button_group_clicked)
layout = QGridLayout()
for framework_layer in framework_layers:
layout.addWidget(
self.create_framework_layer_widget(framework_layer()))
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
item_widget = QWidget()
item_widget.setLayout(layout)
self.framework_toolbox = QToolBox()
self.framework_toolbox.setSizePolicy(
QSizePolicy(
QSizePolicy.Maximum,
QSizePolicy.Ignored,
), )
self.framework_toolbox.setMinimumWidth(item_widget.sizeHint().width())
self.framework_toolbox.addItem(item_widget,
main_window_constants.LAYERS)
# Callback methods.
def export_diagram(self):
nodes = self.get_nodes_from_scene()
if len(nodes) == 0:
return
edges = self.get_edges_from_scene()
nodes_mapping = self.create_nodes_mapping(nodes)
uni_graph = graph_utils.create_graph_from_qt_elements(
nodes, edges, nodes_mapping)
bi_graph = graph_utils.create_graph_from_qt_elements(
nodes, edges, nodes_mapping, is_bi_directional=True)
is_one_connected_component = graph_utils.is_one_connected_component(
bi_graph)
graph_topological_sort = graph_utils.create_graph_topological_sort(
uni_graph)
root_nodes = graph_utils.get_root_nodes(uni_graph)
is_all_root_nodes_are_input_layers = graph_utils.is_all_root_nodes_are_input_layers(
nodes, root_nodes)
if not is_one_connected_component:
self.show_model_graph_eval_error_msg(
main_window_constants.MODEL_GRAPH_MULTIPLE_COMPONENTS_ERROR_MSG
)
elif graph_topological_sort is None:
self.show_model_graph_eval_error_msg(
main_window_constants.MODEL_GRAPH_CYCLE_ERROR_MSG)
elif not is_all_root_nodes_are_input_layers:
self.show_model_graph_eval_error_msg(
main_window_constants.
MODEL_GRAPH_ROOT_NODE_IS_NOT_INPUT_ERROR_MSG)
else:
input_definitions = self.build_input_definitions(
map(nodes.__getitem__, root_nodes))
layer_definitions = self.build_layer_definitions(
nodes, graph_topological_sort, root_nodes)
model_connections = self.build_model_connections(
nodes, uni_graph, graph_topological_sort, root_nodes)
framework_template = frameworks_utils.get_formatted_framework_template(
self.get_selected_framework(),
input_definitions,
layer_definitions,
model_connections,
)
file_path, _ = QFileDialog.getSaveFileName(
self,
'Export Model As',
'talzeeq.py',
'Python Language (*.py);;'
'All files (*.*)',
)
if file_path:
with open(file_path, 'w') as fp:
fp.write(framework_template)
def delete_item(self):
for item in self.scene.selectedItems():
if isinstance(item, DiagramItem):
item.remove_arrows()
self.scene.removeItem(item)
def bring_to_front(self):
for selected_item in self.scene.selectedItems():
z_value = 0
for item in selected_item.collidingItems():
if item.zValue() >= z_value and isinstance(item, DiagramItem):
z_value = item.zValue() + 0.1
selected_item.setZValue(z_value)
def send_to_back(self):
for selected_item in self.scene.selectedItems():
z_value = 0
for item in selected_item.collidingItems():
if item.zValue() <= z_value and isinstance(item, DiagramItem):
z_value = item.zValue() - 0.1
selected_item.setZValue(z_value)
def pointer_group_clicked(self, index: int):
self.scene.set_mode(self.pointer_type_group.checkedId())
def scene_scale_changed(self, scale: str):
new_scale = int(
scale[:scale.index(main_window_constants.
DIAGRAM_SCENE_SCALE_PERCENT)]) / 100.0
old_transform = self.view.transform()
self.view.resetTransform()
self.view.translate(old_transform.dx(), old_transform.dy())
self.view.scale(new_scale, new_scale)
def item_inserted(self, item: DiagramItem):
self.pointer_type_group.button(DiagramScene.move_item).setChecked(True)
self.scene.set_mode(self.pointer_type_group.checkedId())
layer_index = frameworks_utils.get_framework_layer_index(
self.get_selected_framework(),
item.framework_layer.__class__,
)
self.framework_layers_button_group.button(layer_index).setChecked(
False)
def framework_layers_button_group_clicked(self, id: int):
buttons = self.framework_layers_button_group.buttons()
for button in buttons:
if self.framework_layers_button_group.button(id) != button:
button.setChecked(False)
if self.framework_layers_button_group.button(id).isChecked():
self.scene.set_item_type(id)
self.scene.set_framework_name(self.get_selected_framework())
self.scene.set_mode(DiagramScene.insert_item)
else:
self.scene.set_mode(DiagramScene.move_item)
# Helper methods.
def get_selected_framework(self) -> str:
return str(self.frameworks_combobox.currentText())
def get_nodes_from_scene(self) -> List[DiagramItem]:
return list(
filter(lambda item: isinstance(item, DiagramItem),
self.scene.items()))
def get_edges_from_scene(self) -> List[Arrow]:
return list(
filter(lambda item: isinstance(item, Arrow), self.scene.items()))
def create_nodes_mapping(
self, nodes: List[DiagramItem]) -> Dict[DiagramItem, int]:
return {node: index for index, node in enumerate(nodes)}
def show_model_graph_eval_error_msg(self, message: str):
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText(main_window_constants.MODEL_GRAPH_EVAL_ERROR_MSG_TEXT)
msg.setInformativeText(message)
msg.setWindowTitle(
main_window_constants.MODEL_GRAPH_EVAL_ERROR_MSG_TEXT)
msg.exec_()
def build_input_definitions(self, root_nodes: List[DiagramItem]) -> str:
input_definitions = list()
for node in root_nodes:
input_definitions.append(
node.get_framework_layer().layer_definition())
return ', '.join(input_definitions)
def build_layer_definitions(
self,
nodes: List[DiagramItem],
graph_topological_sort: List[int],
root_nodes: List[int],
) -> str:
layer_definitions = list()
for element in graph_topological_sort:
if element not in root_nodes:
layer_definitions.append(
nodes[element].get_framework_layer().layer_definition())
return '\n'.join(layer_definitions)
def build_model_connections(
self,
nodes: List[DiagramItem],
graph: List[List[int]],
graph_topological_sort: List[int],
root_nodes: List[int],
) -> str:
model_connections = list()
for element in graph_topological_sort:
parents = list()
is_root = list()
for node in range(len(graph)):
if element in graph[node]:
parents.append(nodes[node].get_framework_layer())
is_root.append(node in root_nodes)
layer_connections = nodes[element].get_framework_layer(
).layer_connections(parents, is_root)
if layer_connections:
model_connections.append(layer_connections)
return '\n'.join(model_connections)
def create_framework_layer_widget(
self, framework_layer: LayerInterface) -> QWidget:
button = QToolButton()
button.setText(framework_layer.layer_name())
button.setCheckable(True)
self.framework_layers_button_group.addButton(
button,
frameworks_utils.get_framework_layer_index(
self.get_selected_framework(),
framework_layer.__class__,
),
)
layout = QVBoxLayout()
layout.addWidget(button)
widget = QWidget()
widget.setLayout(layout)
return widget
def loadtable():
tbl = dealui.stocktable
userid = user.getuser()
conn = sqlite3.connect("database.db")
with conn:
cmd = conn.cursor()
cmd.execute('''
select * from stock_live
order by stock_code
''')
d = cmd.fetchall()
conn.close()
n = len(d)
tbl.setRowCount(n + 1)
tbl.setColumnCount(7)
tbl.setItem(0, 0, QtWidgets.QTableWidgetItem("stock code"))
tbl.setItem(0, 1, QtWidgets.QTableWidgetItem("current price"))
tbl.setItem(0, 2, QtWidgets.QTableWidgetItem("abs change"))
tbl.setItem(0, 3, QtWidgets.QTableWidgetItem("per change"))
tbl.setItem(0, 4, QtWidgets.QTableWidgetItem("buy"))
tbl.setItem(0, 5, QtWidgets.QTableWidgetItem("sell"))
tbl.setItem(0, 6, QtWidgets.QTableWidgetItem("own"))
for i in range(0, 7):
tbl.item(0, i).setTextAlignment(QtCore.Qt.AlignCenter)
tbl.item(0, i).setBackground(QtGui.QColor(181, 115, 81))
tbl.item(0, i).setForeground(QtGui.QColor(255, 255, 255))
btn_grp = QButtonGroup()
btn_grp.setExclusive(True)
for i in range(0, n):
for j in range(0, 4):
tbl.setItem(i + 1, j, QtWidgets.QTableWidgetItem(str(d[i][j])))
tbl.item(i + 1, j).setTextAlignment(QtCore.Qt.AlignCenter)
tbl.item(i + 1, j).setBackground(QtGui.QColor(149, 181, 157))
tbl.item(i + 1, 0).setBackground(QtGui.QColor(171, 181, 164))
conn = sqlite3.connect("database.db")
with conn:
cmd = conn.cursor()
cmd.execute(
'''
select * from deal where stock_code=?
''', (d[i][0], ))
option = cmd.fetchall()
conn.close()
buyoption = option[0][1]
selloption = option[0][2]
btn = QPushButton()
btn.setText('buy')
btn.setStyleSheet(
"background-color: rgb(255, 87, 98);font-size:20px;font-variant:small-caps;"
)
btn.setToolTip("buy " + d[i][0])
btn.setCheckable(True)
btn.setChecked(False)
btn.clicked.connect(lambda: getcommand(btn_grp))
if buyoption == 1:
tbl.setCellWidget(i + 1, 4, btn)
else:
tbl.setCellWidget(i + 1, 4, btn)
btn.setDisabled(True)
btn_grp.addButton(btn)
btn = QPushButton()
btn.setText('sell')
btn.setStyleSheet(
"background-color:rgb(90, 181, 70);font-size:20px;font-variant:small-caps;"
)
btn.setToolTip("sell " + d[i][0])
btn.setCheckable(True)
btn.setChecked(False)
btn.clicked.connect(lambda: getcommand(btn_grp))
if selloption == 1:
tbl.setCellWidget(i + 1, 5, btn)
else:
tbl.setCellWidget(i + 1, 5, btn)
btn.setDisabled(True)
btn_grp.addButton(btn)
conn = sqlite3.connect("database.db")
with conn:
cmd = conn.cursor()
cmd.execute(
'''
select count from investment where user_id=? and stock_code=?
''', (userid, d[i][0]))
c = cmd.fetchall()
conn.close()
if len(c) == 0:
scount = 0
else:
scount = c[0][0]
tbl.setItem(i + 1, 6, QtWidgets.QTableWidgetItem(str(scount)))
tbl.item(i + 1, 6).setTextAlignment(QtCore.Qt.AlignCenter)
tbl.item(i + 1, 6).setBackground(QtGui.QColor(253, 174, 95))
class Left_Side(QWidget):
def __init__(self, settings):
super().__init__()
self.initUI()
self.observer = None
self.settings = settings
def initUI(self):
self.file_handler = File_Handler()
#change Font
load_font(self.file_handler.used_font_path)
self.setFont(QFont("Eurostile LT Std", 18))
heading_font = QFont("Eurostile LT Std", 18, weight=QtGui.QFont.Bold)
#Set name of Window (Starting x, starting y, width, height
self.setGeometry(180, 180, 720, 720)
#Create Grid
self.grid = QGridLayout()
#row pointer
row_position = 0
#Nozzle Size Selection
nozzle_size_selection_label = QLabel(
"With which nozzle name do you want to print?")
nozzle_size_selection_label.setAlignment(QtCore.Qt.AlignCenter)
nozzle_size_selection_label.setFont(heading_font)
self.grid.addWidget(nozzle_size_selection_label, row_position, 0, 1, 2)
row_position += 1
#Nozzle Selection HBox
nozzle_size_selection_hobx = QHBoxLayout()
self.grid.addLayout(nozzle_size_selection_hobx, row_position, 0, 1, 2)
row_position += 1
#Nozzle Selection Buttongroup
nozzle_size_selection_button_group = QButtonGroup(self)
#Nozzle 1.3 Size Button
self.nozzle_1_5_button = QRadioButton("1.5 mm")
#1.5 diameter is the default
self.nozzle_1_5_button.setChecked(True)
self.selected_diameter_path = self.file_handler.diameter_1_5_path
self.nozzle_1_5_button.toggled.connect(
lambda: self.update_diameter_button("1.5"))
nozzle_size_selection_button_group.addButton(self.nozzle_1_5_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_1_5_button,
QtCore.Qt.AlignLeft)
#Nozzle 0.8 Size Button
self.nozzle_0_8_button = QRadioButton("0.8 mm")
self.nozzle_0_8_button.toggled.connect(
lambda: self.update_diameter_button("0.8"))
nozzle_size_selection_button_group.addButton(self.nozzle_0_8_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_0_8_button,
QtCore.Qt.AlignLeft)
#Nozzle 0.6 Size Button
self.nozzle_0_6_button = QRadioButton("0.6 mm")
self.nozzle_0_6_button.toggled.connect(
lambda: self.update_diameter_button("0.6"))
nozzle_size_selection_button_group.addButton(self.nozzle_0_6_button)
nozzle_size_selection_hobx.addWidget(self.nozzle_0_6_button,
QtCore.Qt.AlignLeft)
#File Selection Label
file_selection_label = QLabel("Which file do you want to modify?")
file_selection_label.setAlignment(QtCore.Qt.AlignCenter)
file_selection_label.setFont(heading_font)
self.grid.addWidget(file_selection_label, row_position, 0, 1, 2)
row_position += 1
# File Selection Buttongroup
self.file_selection_button_group = QButtonGroup(self)
# File Selection HBox
self.file_selection_hobx = QHBoxLayout()
self.grid.addLayout(self.file_selection_hobx, row_position, 0, 1, 2)
row_position += 1
self.selected_file_name = None
self.file_button_list = []
self.create_file_buttons()
#Print setting label
print_settings_label = QLabel(
"Which print settings do you want to use?")
print_settings_label.setAlignment(QtCore.Qt.AlignCenter)
print_settings_label.setFont(heading_font)
self.grid.addWidget(print_settings_label, row_position, 0, 1, 2)
row_position += 1
#Print settings grid
self.print_settings_grid = QGridLayout()
self.grid.addLayout(self.print_settings_grid, row_position, 0, 1, 2)
row_position += 1
#Flow Rate Layer 0 Label
flow_rate_layer_0_label = QLabel("Flow rate for the first layer: ")
flow_rate_layer_0_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(flow_rate_layer_0_label, 0, 0)
# Flow Rate Layer 0 Entry
self.flow_rate_layer_0_entry = QLineEdit()
self.flow_rate_layer_0_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_layer_0_entry.setText("100")
self.print_settings_grid.addWidget(self.flow_rate_layer_0_entry, 0, 1)
#Toggle Differentiate between Infill / Outer Walls
self.flow_rate_differentiation_button = QPushButton(
"Different flow rate for outer walls and infill")
self.flow_rate_differentiation_button.clicked.connect(
lambda: self.differentiate_flow_rate(
self.flow_rate_differentiation_button.text()))
self.print_settings_grid.addWidget(
self.flow_rate_differentiation_button, 1, 0, 1, 2)
#Flow Rate Other Layers
self.flow_rate_par_1_label = QLabel("Flow rate for the other layers: ")
self.flow_rate_par_1_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(self.flow_rate_par_1_label, 2, 0)
# Flow Rate Layer 0 Entry
self.flow_rate_par_1_entry = QLineEdit()
self.flow_rate_par_1_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_par_1_entry.setText("100")
self.print_settings_grid.addWidget(self.flow_rate_par_1_entry, 2, 1)
# Temp Label
self.flow_rate_par_2_label = QLabel("Flow rate for the infill: ")
self.flow_rate_par_2_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(self.flow_rate_par_2_label, 3, 0)
self.flow_rate_par_2_label.setHidden(True)
# Temp Entry
self.flow_rate_par_2_entry = QLineEdit()
self.flow_rate_par_2_entry.setAlignment(QtCore.Qt.AlignCenter)
self.flow_rate_par_2_entry.setText("65")
self.print_settings_grid.addWidget(self.flow_rate_par_2_entry, 3, 1)
self.flow_rate_par_2_entry.setHidden(True)
#Bed Temperature Label
bed_temperature_label = QLabel("Bed Temperature: ")
bed_temperature_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(bed_temperature_label, 0, 2)
#Bed Temperature Entry
self.bed_temperature_entry = QLineEdit()
self.bed_temperature_entry.setAlignment(QtCore.Qt.AlignCenter)
self.bed_temperature_entry.setText("0")
self.print_settings_grid.addWidget(self.bed_temperature_entry, 0, 3)
#Print Speed Label
print_speed_label = QLabel("Print Speed: ")
print_speed_label.setAlignment(QtCore.Qt.AlignLeft)
self.print_settings_grid.addWidget(print_speed_label, 1, 2)
#Print Speed Entry
self.print_speed_entry = QLineEdit()
self.print_speed_entry.setAlignment(QtCore.Qt.AlignCenter)
self.print_speed_entry.setText("100")
self.print_settings_grid.addWidget(self.print_speed_entry, 1, 3)
#Additional Fan Checkbox
self.fan_checkbox = QCheckBox("Turn on the fan while printing")
self.print_settings_grid.addWidget(self.fan_checkbox, 2, 2)
#Modification label
print_modifications_label = QLabel("What do you want to modify?")
print_modifications_label.setAlignment(QtCore.Qt.AlignCenter)
print_modifications_label.setFont(heading_font)
self.grid.addWidget(print_modifications_label, row_position, 0, 1, 2)
row_position += 1
# Add Information Checkbox
self.add_information_checkbox = QCheckBox(
"Show additional information while printing")
self.grid.addWidget(self.add_information_checkbox, row_position, 0)
# Add Big Syringe Support Checkbox
self.big_syringe_checkbox = QCheckBox("Enable big syringe support")
self.grid.addWidget(self.big_syringe_checkbox, row_position, 1)
row_position += 1
#Pause after each layer checkbox
self.pause_print_retraction_checkbox = QCheckBox(
"Pause print after each layer")
self.pause_print_retraction_checkbox.toggled.connect(
self.pause_print_toggled)
self.grid.addWidget(self.pause_print_retraction_checkbox, row_position,
0)
row_position += 1
#Pause Choices Grid
self.grid_choices_grid = QGridLayout()
self.grid_choices_grid.setColumnMinimumWidth(1, 72)
self.grid_choices_grid.setColumnMinimumWidth(4, 10)
self.grid_choices_grid.setColumnStretch(4, 1)
self.grid.addLayout(self.grid_choices_grid, row_position, 0, 1, 2)
row_position += 1
#Pauser after each layer seconds label
self.pause_print_seconds_label = QLabel("Seconds: ")
# Pauser after each layer seconds entry
self.pause_print_seconds_entry = QLineEdit("10")
self.pause_print_seconds_entry.setAlignment(QtCore.Qt.AlignCenter)
self.pause_print_seconds_entry.setMaximumWidth(64)
# Retract During Pause Label
self.retract_during_pause_checkbox = QCheckBox("Retract during pause")
#Clean the nozzle ever x moves
self.clean_nozzle_checkbox = QCheckBox(
"Clean the nozzle during the print")
self.grid.addWidget(self.clean_nozzle_checkbox, row_position, 0)
self.clean_nozzle_checkbox.toggled.connect(self.clean_nozzle_toggled)
row_position += 1
#Clean Nozzle Grid
self.clean_nozzle_grid = QGridLayout()
self.clean_nozzle_grid.setColumnMinimumWidth(1, 72)
self.clean_nozzle_grid.setColumnMinimumWidth(4, 10)
self.clean_nozzle_grid.setColumnStretch(4, 1)
self.grid.addLayout(self.clean_nozzle_grid, row_position, 0, 1, 2)
row_position += 1
#Pauser after each layer seconds label
self.clean_nozzle_label_1 = QLabel("Every")
# Pauser after each layer seconds entry
self.clean_nozzle_entry = QLineEdit("50")
self.clean_nozzle_entry.setAlignment(QtCore.Qt.AlignCenter)
self.clean_nozzle_entry.setMaximumWidth(64)
#Pauser after each layer seconds label
self.clean_nozzle_label_2 = QLabel("moves")
#Retract syringe at the end of print Checkbox
self.retract_syringe_checkbox = QCheckBox(
"Retract the syringe at the end of print")
self.grid.addWidget(self.retract_syringe_checkbox, row_position, 0)
row_position += 1
#Modification label
storage_label = QLabel("How do you want to store the file?")
storage_label.setAlignment(QtCore.Qt.AlignCenter)
storage_label.setFont(heading_font)
self.grid.addWidget(storage_label, row_position, 0, 1, 2)
row_position += 1
#Storage grid
self.storage_grid = QGridLayout()
self.grid.addLayout(self.storage_grid, row_position, 0, 1, 2)
row_position += 1
# Name of Modified File Label
storage_name_label = QLabel("Name modified file: ")
storage_name_label.setAlignment(QtCore.Qt.AlignLeft)
self.storage_grid.addWidget(storage_name_label, 0, 0)
# Name of Modified File Entry
self.storage_name_entry = QLineEdit()
self.storage_name_entry.setText(self.selected_file_name.split(".")[0])
self.storage_grid.addWidget(self.storage_name_entry, 0, 1)
#Storage Path Label
self.path_label = QLabel("Storage path: ")
self.storage_grid.addWidget(self.path_label, 1, 0)
# Chose Location to store button
self.choose_location_button = QPushButton("Choose location to store")
self.last_directory = ""
self.choose_location_button.clicked.connect(
self.select_storage_location)
self.storage_grid.addWidget(self.choose_location_button, 1, 1)
row_position += 1
self.storage_location_button_row = row_position
#Storage Path Name Label
self.path_name_label = QLabel()
#Modify Button
self.modify_button = QPushButton("Modify!")
self.modify_button.clicked.connect(self.start_modification)
self.grid.addWidget(self.modify_button, row_position, 0, 1, 2)
#Set layout and show mainscreen
self.setLayout(self.grid)
def create_file_buttons(self):
first_time = True
current_index = 0
for widget in self.file_button_list:
self.file_selection_hobx.removeWidget(widget)
self.file_button_list = []
self.file_selection_button_group = QButtonGroup()
for file in os.listdir(self.selected_diameter_path):
if file.endswith(".gcode"):
file_name = Path(file).stem
self.file_button_list.append(QRadioButton(file_name))
self.file_selection_button_group.addButton(
self.file_button_list[current_index])
self.file_selection_hobx.addWidget(
self.file_button_list[current_index], QtCore.Qt.AlignLeft)
if first_time:
self.file_button_list[current_index].setChecked(True)
self.selected_file_name = file_name + ".gcode"
first_time = False
self.file_button_list[current_index].toggled.connect(
self.update_file_name)
current_index += 1
def differentiate_flow_rate(self, current_text):
if current_text == "Different flow rate for outer walls and infill":
self.flow_rate_differentiation_button.setText(
"Same flow rate for infill and outer walls")
self.flow_rate_par_1_label.setText(
"Flow rate for the outer walls: ")
self.flow_rate_par_1_entry.setText("55")
self.flow_rate_par_2_label.setHidden(False)
self.flow_rate_par_2_entry.setHidden(False)
else:
self.flow_rate_differentiation_button.setText(
"Different flow rate for outer walls and infill")
self.flow_rate_par_1_label.setText(
"Flow rate for the other layers: ")
self.flow_rate_par_1_entry.setText("100")
self.flow_rate_par_2_label.setHidden(True)
self.flow_rate_par_2_entry.setHidden(True)
def update_diameter_button(self, size):
sender = self.sender()
if sender.isChecked():
self.update_diameter(size)
def update_diameter(self, size):
if size == "1.5":
self.selected_diameter_path = self.file_handler.diameter_1_5_path
if size == "0.8":
self.selected_diameter_path = self.file_handler.diameter_0_8_path
if size == "0.6":
self.selected_diameter_path = self.file_handler.diameter_0_6_path
self.create_file_buttons()
self.notify_observer()
def update_file_name(self):
checked_button = self.file_selection_button_group.checkedButton()
name = checked_button.text()
self.selected_file_name = name + ".gcode"
self.storage_name_entry.setText(name)
def pause_print_toggled(self):
checkbx = self.sender()
if checkbx.isChecked():
self.grid_choices_grid.addWidget(self.pause_print_seconds_label, 1,
2)
self.grid_choices_grid.addWidget(self.pause_print_seconds_entry, 1,
3)
self.grid_choices_grid.addWidget(
self.retract_during_pause_checkbox, 2, 2)
else:
self.pause_print_seconds_label.setParent(None)
self.pause_print_seconds_entry.setParent(None)
self.retract_during_pause_checkbox.setParent(None)
def clean_nozzle_toggled(self):
checkbx = self.sender()
if checkbx.isChecked():
self.clean_nozzle_grid.addWidget(self.clean_nozzle_label_1, 1, 2)
self.clean_nozzle_grid.addWidget(self.clean_nozzle_entry, 1, 3)
self.clean_nozzle_grid.addWidget(self.clean_nozzle_label_2, 1, 4)
else:
self.clean_nozzle_label_1.setParent(None)
self.clean_nozzle_entry.setParent(None)
self.clean_nozzle_label_2.setParent(None)
def select_storage_location(self):
directory = QFileDialog.getExistingDirectory(self, "Select Directory")
if directory:
if len(directory) == 0 & len(self.last_directory) != 0:
directory = self.self.last_directory
self.path_name_label.setText(directory)
self.last_directory = directory
self.storage_grid.addWidget(self.path_name_label, 1, 1)
#Shift Everything below the new path text one row down
self.choose_location_button.setText("Choose a different location")
self.grid.addWidget(self.choose_location_button,
self.storage_location_button_row, 0, 1, 2)
self.grid.addWidget(self.modify_button,
self.storage_location_button_row + 1, 0, 1, 2)
def start_modification(self):
checked_command = self.sanity_check()
if checked_command != False:
command_executor = Command_Executor(checked_command, self.settings)
result_gcode = command_executor.execute()
finish_modification_message = QMessageBox()
finish_modification_message.setText(
"File has been created successfully!")
finish_modification_message.setWindowTitle(
"File Creation Successful")
finish_modification_message.setIcon(QMessageBox.Information)
open_location_button = QPushButton("Open File Location")
open_location_button.clicked.connect(
lambda: self.open_directory(checked_command.storage_path))
open_notebook_button = QPushButton("Open File in Notebook")
path_to_file = checked_command.storage_path + "\/" + checked_command.file_name + ".gcode"
open_notebook_button.clicked.connect(
lambda: self.open_notebook(path_to_file))
finish_modification_message.addButton(open_location_button,
QMessageBox.AcceptRole)
finish_modification_message.addButton(open_notebook_button,
QMessageBox.AcceptRole)
finish_modification_message.setStandardButtons(QMessageBox.Ok)
finish_modification_message.exec_()
def uncheck_all_nozzle_size_buttons(self):
self.nozzle_1_5_button.setChecked(False)
self.nozzle_0_8_button.setChecked(False)
self.nozzle_0_6_button.setChecked(False)
def uncheck_all_file_buttons(self):
for button in self.file_button_list:
button.setChecked(False)
def check_file_button(self, file_name):
for button in self.file_button_list:
if button.text() == file_name:
button.setChecked(True)
def sanity_check(self):
messages = []
flow_rate_layer_0 = self.flow_rate_layer_0_entry.text()
try:
int_flow_rate_layer_0 = int(flow_rate_layer_0)
if int_flow_rate_layer_0 < 10 or int_flow_rate_layer_0 > 400:
raise Exception
except Exception:
messages.append(
"The flow rate of layer 0 needs to be an integer between 10 and 400."
)
self.flow_rate_layer_0.setText("")
flow_rate_par_1 = self.flow_rate_par_1_entry.text()
try:
int_flow_rate_par_1 = int(flow_rate_par_1)
if int_flow_rate_par_1 < 10 or int_flow_rate_par_1 > 400:
raise Exception
except Exception:
if self.flow_rate_differentiation_button.text(
) == "Different flow rate for outer walls and infill":
messages.append(
"The flow rate of the other layers needs to be an integer between 10 and 400."
)
self.flow_rate_par_1_entry.setText("100")
else:
messages.append(
"The flow rate for the outer walls needs to be an integer between 10 and 400."
)
self.flow_rate_par_1_entry.setText("55")
bed_temperature = self.bed_temperature_entry.text()
try:
int_bed_temperature = int(bed_temperature)
if int_bed_temperature < 0 or int_bed_temperature > 60:
raise Exception
except Exception:
messages.append(
"The bed temperature needs to be an integer between 0 and 60.")
self.bed_temperature_entry.setText("")
print_speed = self.print_speed_entry.text()
try:
float_print_speed = float(print_speed)
if float_print_speed < 0 or float_print_speed > 400:
raise Exception
except Exception:
messages.append(
"The print speed needs to be an integer between 0 and 100.")
self.print_speed_entry.setText("")
storage_location = self.path_name_label.text()
if len(storage_location) == 0:
messages.append("A storage location needs to be specified.")
file_name_checked = self.storage_name_entry.text()
if len(file_name_checked) == 0:
messages.append("A filename needs to be specified.")
flow_rate_differentiate_bol = self.flow_rate_differentiation_button.text(
) == "Same flow rate for infill and outer walls"
if flow_rate_differentiate_bol:
flow_rate_par_2 = self.flow_rate_par_2_entry.text()
try:
int_flow_rate_par_2 = int(flow_rate_par_2)
if int_flow_rate_par_2 < 10 or int_flow_rate_par_2 > 400:
raise Exception
except Exception:
messages.append(
"The flow rate for the infill needs to be an integer between 10 and 400."
)
self.flow_rate_par_2_entry.setText("65")
if self.pause_print_retraction_checkbox.isChecked():
try:
int_duration_pause = int(self.pause_print_seconds_entry.text())
if int_duration_pause < 0 or int_duration_pause > 1800:
raise Exception
except Exception:
messages.append(
"The duration of the pause needs to be an integer between 0 and 1800."
)
self.pause_print_seconds_entry.setText("")
if self.clean_nozzle_checkbox.isChecked():
try:
int_amount_moves = int(self.clean_nozzle_entry.text())
if int_amount_moves < 10 or int_amount_moves > 1000:
raise Exception
except Exception:
messages.append(
"The amount of moves between cleaning needs to be an integer between 10 and 1000."
)
self.clean_nozzle_entry.setText("")
if len(messages) > 0:
error_text = "\n".join(messages)
error_message_box = QMessageBox()
error_message_box.setText(error_text)
error_message_box.setWindowTitle("Input Error")
error_message_box.setIcon(QMessageBox.Warning)
error_message_box.exec_()
return False
else:
file_name_checked = file_name_checked.split(".")[0]
path_to_file = Path.joinpath(self.selected_diameter_path,
self.selected_file_name)
flow_rate_layer_0 = int_flow_rate_layer_0
flow_rate_par_1 = int_flow_rate_par_1
flow_rate_differentiate_bol = flow_rate_differentiate_bol
fan_bol = self.fan_checkbox.isChecked()
additional_information_bol = self.add_information_checkbox.isChecked(
)
pause_each_layer_bol = self.pause_print_retraction_checkbox.isChecked(
)
clean_nozzle_bol = self.clean_nozzle_checkbox.isChecked()
retract_syringe_bol = self.retract_syringe_checkbox.isChecked()
big_syringe_bol = self.big_syringe_checkbox.isChecked()
flow_rate_par_2 = None
pause_each_layer_par_1 = None
pause_each_layer_par_2 = None
clean_nozzle_par_1 = None
if flow_rate_differentiate_bol:
flow_rate_par_2 = int_flow_rate_par_2
if pause_each_layer_bol:
pause_each_layer_par_1 = self.pause_print_seconds_entry.text()
pause_each_layer_par_2 = self.retract_during_pause_checkbox.isChecked(
)
if clean_nozzle_bol:
clean_nozzle_par_1 = self.clean_nozzle_entry.text()
return Command(
path_to_file=path_to_file,
flow_rate_layer_0=flow_rate_layer_0,
flow_rate_par_1=flow_rate_par_1,
flow_rate_differentiate_bol=flow_rate_differentiate_bol,
bed_temperature=int_bed_temperature,
print_speed=float_print_speed,
fan_bol=fan_bol,
additional_information_bol=additional_information_bol,
pause_each_layer_bol=pause_each_layer_bol,
clean_nozzle_bol=clean_nozzle_bol,
retract_syringe_bol=retract_syringe_bol,
big_syringe_bol=big_syringe_bol,
file_name=file_name_checked,
storage_path=storage_location,
flow_rate_par_2=flow_rate_par_2,
pause_each_layer_par_1=pause_each_layer_par_1,
pause_each_layer_par_2=pause_each_layer_par_2,
clean_nozzle_par_1=clean_nozzle_par_1)
def open_directory(self, directory):
os.startfile(directory)
def open_notebook(self, directory):
subprocess.Popen(["notepad.exe", directory])
def notify_observer(self):
self.path_to_file = Path.joinpath(self.selected_diameter_path,
self.selected_file_name)
new_gocde_line_list = self.file_handler.read_gcode_file(
self.path_to_file)
temp_gcode_parser = GCode_Parser(new_gocde_line_list)
new_gcode = temp_gcode_parser.create_gcode()
self.observer.update("left_side", new_gcode)
def __init__(self, parent=None, name="Colormap Dialog"):
QDialog.__init__(self, parent)
self.setWindowTitle(name)
self.title = name
self.colormapList = [
'Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds', 'YlOrBr',
'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu', 'GnBu', 'PuBu', 'YlGnBu',
'PuBuGn', 'BuGn', 'YlGn'
]
# histogramData is tupel(bins, counts)
self.histogramData = None
# default values
self.dataMin = -10
self.dataMax = 10
self.minValue = 0
self.maxValue = 1
self.colormapIndex = 2
self.colormapType = 0
self.autoscale = False
self.autoscale90 = False
# main layout
vlayout = QVBoxLayout(self)
vlayout.setContentsMargins(10, 10, 10, 10)
vlayout.setSpacing(0)
# layout 1 : -combo to choose colormap
# -autoscale button
# -autoscale 90% button
hbox1 = QWidget(self)
hlayout1 = QHBoxLayout(hbox1)
vlayout.addWidget(hbox1)
hlayout1.setContentsMargins(0, 0, 0, 0)
hlayout1.setSpacing(10)
# combo
self.combo = QComboBox(hbox1)
for colormap in self.colormapList:
self.combo.addItem(colormap)
self.combo.activated[int].connect(self.colormapChange)
hlayout1.addWidget(self.combo)
# autoscale
self.autoScaleButton = QPushButton("Autoscale", hbox1)
self.autoScaleButton.setCheckable(True)
self.autoScaleButton.setAutoDefault(False)
self.autoScaleButton.toggled[bool].connect(self.autoscaleChange)
hlayout1.addWidget(self.autoScaleButton)
# autoscale 90%
self.autoScale90Button = QPushButton("Autoscale 90%", hbox1)
self.autoScale90Button.setCheckable(True)
self.autoScale90Button.setAutoDefault(False)
self.autoScale90Button.toggled[bool].connect(self.autoscale90Change)
hlayout1.addWidget(self.autoScale90Button)
# hlayout
hbox0 = QWidget(self)
self.__hbox0 = hbox0
hlayout0 = QHBoxLayout(hbox0)
hlayout0.setContentsMargins(0, 0, 0, 0)
hlayout0.setSpacing(0)
vlayout.addWidget(hbox0)
#hlayout0.addStretch(10)
self.buttonGroup = QButtonGroup()
g1 = QCheckBox(hbox0)
g1.setText("Linear")
g2 = QCheckBox(hbox0)
g2.setText("Logarithmic")
g3 = QCheckBox(hbox0)
g3.setText("Gamma")
self.buttonGroup.addButton(g1, 0)
self.buttonGroup.addButton(g2, 1)
self.buttonGroup.addButton(g3, 2)
self.buttonGroup.setExclusive(True)
if self.colormapType == 1:
self.buttonGroup.button(1).setChecked(True)
elif self.colormapType == 2:
self.buttonGroup.button(2).setChecked(True)
else:
self.buttonGroup.button(0).setChecked(True)
hlayout0.addWidget(g1)
hlayout0.addWidget(g2)
hlayout0.addWidget(g3)
vlayout.addWidget(hbox0)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupChange)
vlayout.addSpacing(20)
hboxlimits = QWidget(self)
hboxlimitslayout = QHBoxLayout(hboxlimits)
hboxlimitslayout.setContentsMargins(0, 0, 0, 0)
hboxlimitslayout.setSpacing(0)
self.slider = None
vlayout.addWidget(hboxlimits)
vboxlimits = QWidget(hboxlimits)
vboxlimitslayout = QVBoxLayout(vboxlimits)
vboxlimitslayout.setContentsMargins(0, 0, 0, 0)
vboxlimitslayout.setSpacing(0)
hboxlimitslayout.addWidget(vboxlimits)
# hlayout 2 : - min label
# - min texte
hbox2 = QWidget(vboxlimits)
self.__hbox2 = hbox2
hlayout2 = QHBoxLayout(hbox2)
hlayout2.setContentsMargins(0, 0, 0, 0)
hlayout2.setSpacing(0)
#vlayout.addWidget(hbox2)
vboxlimitslayout.addWidget(hbox2)
hlayout2.addStretch(10)
self.minLabel = QLabel(hbox2)
self.minLabel.setText("Minimum")
hlayout2.addWidget(self.minLabel)
hlayout2.addSpacing(5)
hlayout2.addStretch(1)
self.minText = MyQLineEdit(hbox2)
self.minText.setFixedWidth(150)
self.minText.setAlignment(QtCore.Qt.AlignRight)
self.minText.returnPressed[()].connect(self.minTextChanged)
hlayout2.addWidget(self.minText)
# hlayout 3 : - min label
# - min text
hbox3 = QWidget(vboxlimits)
self.__hbox3 = hbox3
hlayout3 = QHBoxLayout(hbox3)
hlayout3.setContentsMargins(0, 0, 0, 0)
hlayout3.setSpacing(0)
#vlayout.addWidget(hbox3)
vboxlimitslayout.addWidget(hbox3)
hlayout3.addStretch(10)
self.maxLabel = QLabel(hbox3)
self.maxLabel.setText("Maximum")
hlayout3.addWidget(self.maxLabel)
hlayout3.addSpacing(5)
hlayout3.addStretch(1)
self.maxText = MyQLineEdit(hbox3)
self.maxText.setFixedWidth(150)
self.maxText.setAlignment(QtCore.Qt.AlignRight)
self.maxText.returnPressed[()].connect(self.maxTextChanged)
hlayout3.addWidget(self.maxText)
# Graph widget for color curve...
self.c = PlotWidget(self, backend=None)
self.c.setGraphXLabel("Data Values")
self.c.setInteractiveMode('select')
self.marge = (abs(self.dataMax) + abs(self.dataMin)) / 6.0
self.minmd = self.dataMin - self.marge
self.maxpd = self.dataMax + self.marge
self.c.setGraphXLimits(self.minmd, self.maxpd)
self.c.setGraphYLimits(-11.5, 11.5)
x = [self.minmd, self.dataMin, self.dataMax, self.maxpd]
y = [-10, -10, 10, 10]
self.c.addCurve(x,
y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.markers = []
self.__x = x
self.__y = y
labelList = ["", "Min", "Max", ""]
for i in range(4):
if i in [1, 2]:
draggable = True
color = "blue"
else:
draggable = False
color = "black"
#TODO symbol
legend = "%d" % i
self.c.addXMarker(x[i],
legend=legend,
text=labelList[i],
draggable=draggable,
color=color)
self.markers.append((legend, ""))
self.c.setMinimumSize(QSize(250, 200))
vlayout.addWidget(self.c)
self.c.sigPlotSignal.connect(self.chval)
# colormap window can not be resized
self.setFixedSize(vlayout.minimumSize())
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
vlayout.addWidget(self.buttonBox)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
class ColormapDialog(QDialog):
sigColormapChanged = pyqtSignal(object)
def __init__(self, parent=None, name="Colormap Dialog"):
QDialog.__init__(self, parent)
self.setWindowTitle(name)
self.title = name
self.colormapList = [
'Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds', 'YlOrBr',
'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu', 'GnBu', 'PuBu', 'YlGnBu',
'PuBuGn', 'BuGn', 'YlGn'
]
# histogramData is tupel(bins, counts)
self.histogramData = None
# default values
self.dataMin = -10
self.dataMax = 10
self.minValue = 0
self.maxValue = 1
self.colormapIndex = 2
self.colormapType = 0
self.autoscale = False
self.autoscale90 = False
# main layout
vlayout = QVBoxLayout(self)
vlayout.setContentsMargins(10, 10, 10, 10)
vlayout.setSpacing(0)
# layout 1 : -combo to choose colormap
# -autoscale button
# -autoscale 90% button
hbox1 = QWidget(self)
hlayout1 = QHBoxLayout(hbox1)
vlayout.addWidget(hbox1)
hlayout1.setContentsMargins(0, 0, 0, 0)
hlayout1.setSpacing(10)
# combo
self.combo = QComboBox(hbox1)
for colormap in self.colormapList:
self.combo.addItem(colormap)
self.combo.activated[int].connect(self.colormapChange)
hlayout1.addWidget(self.combo)
# autoscale
self.autoScaleButton = QPushButton("Autoscale", hbox1)
self.autoScaleButton.setCheckable(True)
self.autoScaleButton.setAutoDefault(False)
self.autoScaleButton.toggled[bool].connect(self.autoscaleChange)
hlayout1.addWidget(self.autoScaleButton)
# autoscale 90%
self.autoScale90Button = QPushButton("Autoscale 90%", hbox1)
self.autoScale90Button.setCheckable(True)
self.autoScale90Button.setAutoDefault(False)
self.autoScale90Button.toggled[bool].connect(self.autoscale90Change)
hlayout1.addWidget(self.autoScale90Button)
# hlayout
hbox0 = QWidget(self)
self.__hbox0 = hbox0
hlayout0 = QHBoxLayout(hbox0)
hlayout0.setContentsMargins(0, 0, 0, 0)
hlayout0.setSpacing(0)
vlayout.addWidget(hbox0)
#hlayout0.addStretch(10)
self.buttonGroup = QButtonGroup()
g1 = QCheckBox(hbox0)
g1.setText("Linear")
g2 = QCheckBox(hbox0)
g2.setText("Logarithmic")
g3 = QCheckBox(hbox0)
g3.setText("Gamma")
self.buttonGroup.addButton(g1, 0)
self.buttonGroup.addButton(g2, 1)
self.buttonGroup.addButton(g3, 2)
self.buttonGroup.setExclusive(True)
if self.colormapType == 1:
self.buttonGroup.button(1).setChecked(True)
elif self.colormapType == 2:
self.buttonGroup.button(2).setChecked(True)
else:
self.buttonGroup.button(0).setChecked(True)
hlayout0.addWidget(g1)
hlayout0.addWidget(g2)
hlayout0.addWidget(g3)
vlayout.addWidget(hbox0)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupChange)
vlayout.addSpacing(20)
hboxlimits = QWidget(self)
hboxlimitslayout = QHBoxLayout(hboxlimits)
hboxlimitslayout.setContentsMargins(0, 0, 0, 0)
hboxlimitslayout.setSpacing(0)
self.slider = None
vlayout.addWidget(hboxlimits)
vboxlimits = QWidget(hboxlimits)
vboxlimitslayout = QVBoxLayout(vboxlimits)
vboxlimitslayout.setContentsMargins(0, 0, 0, 0)
vboxlimitslayout.setSpacing(0)
hboxlimitslayout.addWidget(vboxlimits)
# hlayout 2 : - min label
# - min texte
hbox2 = QWidget(vboxlimits)
self.__hbox2 = hbox2
hlayout2 = QHBoxLayout(hbox2)
hlayout2.setContentsMargins(0, 0, 0, 0)
hlayout2.setSpacing(0)
#vlayout.addWidget(hbox2)
vboxlimitslayout.addWidget(hbox2)
hlayout2.addStretch(10)
self.minLabel = QLabel(hbox2)
self.minLabel.setText("Minimum")
hlayout2.addWidget(self.minLabel)
hlayout2.addSpacing(5)
hlayout2.addStretch(1)
self.minText = MyQLineEdit(hbox2)
self.minText.setFixedWidth(150)
self.minText.setAlignment(QtCore.Qt.AlignRight)
self.minText.returnPressed[()].connect(self.minTextChanged)
hlayout2.addWidget(self.minText)
# hlayout 3 : - min label
# - min text
hbox3 = QWidget(vboxlimits)
self.__hbox3 = hbox3
hlayout3 = QHBoxLayout(hbox3)
hlayout3.setContentsMargins(0, 0, 0, 0)
hlayout3.setSpacing(0)
#vlayout.addWidget(hbox3)
vboxlimitslayout.addWidget(hbox3)
hlayout3.addStretch(10)
self.maxLabel = QLabel(hbox3)
self.maxLabel.setText("Maximum")
hlayout3.addWidget(self.maxLabel)
hlayout3.addSpacing(5)
hlayout3.addStretch(1)
self.maxText = MyQLineEdit(hbox3)
self.maxText.setFixedWidth(150)
self.maxText.setAlignment(QtCore.Qt.AlignRight)
self.maxText.returnPressed[()].connect(self.maxTextChanged)
hlayout3.addWidget(self.maxText)
# Graph widget for color curve...
self.c = PlotWidget(self, backend=None)
self.c.setGraphXLabel("Data Values")
self.c.setInteractiveMode('select')
self.marge = (abs(self.dataMax) + abs(self.dataMin)) / 6.0
self.minmd = self.dataMin - self.marge
self.maxpd = self.dataMax + self.marge
self.c.setGraphXLimits(self.minmd, self.maxpd)
self.c.setGraphYLimits(-11.5, 11.5)
x = [self.minmd, self.dataMin, self.dataMax, self.maxpd]
y = [-10, -10, 10, 10]
self.c.addCurve(x,
y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.markers = []
self.__x = x
self.__y = y
labelList = ["", "Min", "Max", ""]
for i in range(4):
if i in [1, 2]:
draggable = True
color = "blue"
else:
draggable = False
color = "black"
#TODO symbol
legend = "%d" % i
self.c.addXMarker(x[i],
legend=legend,
text=labelList[i],
draggable=draggable,
color=color)
self.markers.append((legend, ""))
self.c.setMinimumSize(QSize(250, 200))
vlayout.addWidget(self.c)
self.c.sigPlotSignal.connect(self.chval)
# colormap window can not be resized
self.setFixedSize(vlayout.minimumSize())
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
vlayout.addWidget(self.buttonBox)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def plotHistogram(self, data=None):
if data is not None:
self.histogramData = data
if self.histogramData is None:
return False
bins, counts = self.histogramData
self.c.addCurve(bins,
counts,
"Histogram",
color='darkYellow',
histogram='center',
yaxis='right',
fill=True)
def _update(self):
_logger.debug("colormap _update called")
self.marge = (abs(self.dataMax) + abs(self.dataMin)) / 6.0
self.minmd = self.dataMin - self.marge
self.maxpd = self.dataMax + self.marge
self.c.setGraphXLimits(self.minmd, self.maxpd)
self.c.setGraphYLimits(-11.5, 11.5)
self.__x = [self.minmd, self.dataMin, self.dataMax, self.maxpd]
self.__y = [-10, -10, 10, 10]
self.c.addCurve(self.__x,
self.__y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.c.clearMarkers()
for i in range(4):
if i in [1, 2]:
draggable = True
color = "blue"
else:
draggable = False
color = "black"
key = self.markers[i][0]
label = self.markers[i][1]
self.c.addXMarker(self.__x[i],
legend=key,
text=label,
draggable=draggable,
color=color)
self.sendColormap()
def buttonGroupChange(self, val):
_logger.debug("buttonGroup asking to update colormap")
self.setColormapType(val, update=True)
self._update()
def setColormapType(self, val, update=False):
self.colormapType = val
if self.colormapType == 1:
self.buttonGroup.button(1).setChecked(True)
elif self.colormapType == 2:
self.buttonGroup.button(2).setChecked(True)
else:
self.colormapType = 0
self.buttonGroup.button(0).setChecked(True)
if update:
self._update()
def chval(self, ddict):
_logger.debug("Received %s", ddict)
if ddict['event'] == 'markerMoving':
diam = int(ddict['label'])
x = ddict['x']
if diam == 1:
self.setDisplayedMinValue(x)
elif diam == 2:
self.setDisplayedMaxValue(x)
elif ddict['event'] == 'markerMoved':
diam = int(ddict['label'])
x = ddict['x']
if diam == 1:
self.setMinValue(x)
if diam == 2:
self.setMaxValue(x)
"""
Colormap
"""
def setColormap(self, colormap):
self.colormapIndex = colormap
if QTVERSION < '4.0.0':
self.combo.setCurrentItem(colormap)
else:
self.combo.setCurrentIndex(colormap)
def colormapChange(self, colormap):
self.colormapIndex = colormap
self.sendColormap()
# AUTOSCALE
"""
Autoscale
"""
def autoscaleChange(self, val):
self.autoscale = val
self.setAutoscale(val)
self.sendColormap()
def setAutoscale(self, val):
_logger.debug("setAutoscale called %s", val)
if val:
self.autoScaleButton.setChecked(True)
self.autoScale90Button.setChecked(False)
#self.autoScale90Button.setDown(False)
self.setMinValue(self.dataMin)
self.setMaxValue(self.dataMax)
self.maxText.setEnabled(0)
self.minText.setEnabled(0)
self.c.setEnabled(False)
#self.c.disablemarkermode()
else:
self.autoScaleButton.setChecked(False)
self.autoScale90Button.setChecked(False)
self.minText.setEnabled(1)
self.maxText.setEnabled(1)
self.c.setEnabled(True)
#self.c.enablemarkermode()
"""
set rangeValues to dataMin ; dataMax-10%
"""
def autoscale90Change(self, val):
self.autoscale90 = val
self.setAutoscale90(val)
self.sendColormap()
def setAutoscale90(self, val):
if val:
self.autoScaleButton.setChecked(False)
self.setMinValue(self.dataMin)
self.setMaxValue(self.dataMax - abs(self.dataMax / 10))
self.minText.setEnabled(0)
self.maxText.setEnabled(0)
self.c.setEnabled(False)
else:
self.autoScale90Button.setChecked(False)
self.minText.setEnabled(1)
self.maxText.setEnabled(1)
self.c.setEnabled(True)
self.c.setFocus()
# MINIMUM
"""
change min value and update colormap
"""
def setMinValue(self, val):
v = float(str(val))
self.minValue = v
self.minText.setText("%g" % v)
self.__x[1] = v
key = self.markers[1][0]
label = self.markers[1][1]
self.c.addXMarker(v,
legend=key,
text=label,
color="blue",
draggable=True)
self.c.addCurve(self.__x,
self.__y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.sendColormap()
"""
min value changed by text
"""
def minTextChanged(self):
text = str(self.minText.text())
if not len(text):
return
val = float(text)
self.setMinValue(val)
if self.minText.hasFocus():
self.c.setFocus()
"""
change only the displayed min value
"""
def setDisplayedMinValue(self, val):
val = float(val)
self.minValue = val
self.minText.setText("%g" % val)
self.__x[1] = val
key = self.markers[1][0]
label = self.markers[1][1]
self.c.addXMarker(val,
legend=key,
text=label,
color="blue",
draggable=True)
self.c.addCurve(self.__x,
self.__y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
# MAXIMUM
"""
change max value and update colormap
"""
def setMaxValue(self, val):
v = float(str(val))
self.maxValue = v
self.maxText.setText("%g" % v)
self.__x[2] = v
key = self.markers[2][0]
label = self.markers[2][1]
self.c.addXMarker(v,
legend=key,
text=label,
color="blue",
draggable=True)
self.c.addCurve(self.__x,
self.__y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.sendColormap()
"""
max value changed by text
"""
def maxTextChanged(self):
text = str(self.maxText.text())
if not len(text): return
val = float(text)
self.setMaxValue(val)
if self.maxText.hasFocus():
self.c.setFocus()
"""
change only the displayed max value
"""
def setDisplayedMaxValue(self, val):
val = float(val)
self.maxValue = val
self.maxText.setText("%g" % val)
self.__x[2] = val
key = self.markers[2][0]
label = self.markers[2][1]
self.c.addXMarker(val,
legend=key,
text=label,
color="blue",
draggable=True)
self.c.addCurve(self.__x,
self.__y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
# DATA values
"""
set min/max value of data source
"""
def setDataMinMax(self, minVal, maxVal, update=True):
if minVal is not None:
vmin = float(str(minVal))
self.dataMin = vmin
if maxVal is not None:
vmax = float(str(maxVal))
self.dataMax = vmax
if update:
# are current values in the good range ?
self._update()
def getColormap(self):
if self.minValue > self.maxValue:
vmax = self.minValue
vmin = self.maxValue
else:
vmax = self.maxValue
vmin = self.minValue
cmap = [
self.colormapIndex, self.autoscale, vmin, vmax, self.dataMin,
self.dataMax, self.colormapType
]
return cmap if self.exec_() else None
"""
send 'ColormapChanged' signal
"""
def sendColormap(self):
_logger.debug("sending colormap")
try:
cmap = self.getColormap()
self.sigColormapChanged.emit(cmap)
except:
sys.excepthook(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
def colormapListToDict(colormapList):
"""Convert colormap from this dialog to :class:`PlotBackend`.
:param colormapList: Colormap as returned by :meth:`getColormap`.
:type colormapList: list or tuple
:return: Colormap as used in :class:`PlotBackend`.
:rtype: dict
"""
index, autoscale, vMin, vMax, dataMin, dataMax, cmapType = colormapList
# Warning, gamma cmapType is not supported in plot backend
# Here it is silently replaced by linear as the default colormap
return {
'name': _COLORMAP_NAMES[index],
'autoscale': autoscale,
'vmin': vMin,
'vmax': vMax,
'normalization': 'log' if cmapType == 1 else 'linear',
'colors': 256
}
def getColormap_name(self):
self.getColormap()
return _COLORMAP_NAMES[self.colormapIndex]
def getColor(self):
return _COLOR_NAMES[self.colormapIndex]
def colormapDictToList(colormapDict):
"""Convert colormap from :class:`PlotBackend` to this dialog.
:param dict colormapDict: Colormap as used in :class:`PlotBackend`.
:return: Colormap as returned by :meth:`getColormap`.
:rtype: list
"""
cmapIndex = _COLORMAP_NAMES.index(colormapDict['name'])
cmapType = 1 if colormapDict['normalization'].startswith('log') else 0
return [
cmapIndex,
colormapDict['autoscale'],
colormapDict['vmin'],
colormapDict['vmax'],
0, # dataMin is not defined in PlotBackend colormap
0, # dataMax is not defined in PlotBackend colormap
cmapType
]
def init_ui(self):
self.result_file_title_label = QLabel(self.tr('Result file'))
self.input_file_combobox = QComboBox()
self.select_file_button = QPushButton("...")
self.select_file_button.setToolTip(self.tr("Select file(s)"))
self.select_file_button.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
widget_height = self.input_file_combobox.minimumSizeHint().height()
self.select_file_button.setFixedHeight(widget_height)
self.select_file_button.setFixedWidth(widget_height)
self.select_file_button.clicked.connect(
self.select_file_and_show_informations_dialog)
# selection_layout
self.selection_layout = QHBoxLayout()
self.selection_layout.addWidget(self.input_file_combobox)
self.selection_layout.addWidget(self.select_file_button)
# reach
reach_name_title_label = QLabel(self.tr('Reach name'))
self.reach_name_combobox = QComboBox()
# unit list
unit_title_label = QLabel(self.tr('Unit name'))
self.units_QListWidget = QListWidgetClipboard()
self.units_QListWidget.setSelectionMode(
QAbstractItemView.ExtendedSelection)
# unit type
units_name_title_label = QLabel(self.tr('Type'))
self.units_name_label = QLabel(self.tr('unknown'))
# unit number
units_number_title_label = QLabel(self.tr('Number'))
self.unit_number_label = QLabel(self.tr('unknown'))
# unit_layout
unit_layout = QGridLayout()
unit_layout.addWidget(self.units_QListWidget, 0, 0, 4, 1)
unit_layout.addWidget(units_name_title_label, 0, 1, Qt.AlignBottom)
unit_layout.addWidget(self.units_name_label, 1, 1, Qt.AlignTop)
unit_layout.addWidget(units_number_title_label, 2, 1, Qt.AlignBottom)
unit_layout.addWidget(self.unit_number_label, 3, 1, Qt.AlignTop)
# usefull_mesh_variables
usefull_mesh_variable_label_title = QLabel(self.tr('Mesh data'))
# usefull_mesh_variable_label_title.setFixedHeight(widget_height)
self.usefull_mesh_variable_label = QLabel(self.tr('unknown'))
# usefull_node_variables
usefull_node_variable_label_title = QLabel(self.tr('Node data'))
# usefull_node_variable_label_title.setFixedHeight(widget_height)
self.usefull_node_variable_label = QLabel(self.tr('unknown'))
# LAMMI substrate
sub_radio_group = QButtonGroup(self)
classification_code_title_label = QLabel(
self.tr('Sub classification code'))
classification_code_title_label.setToolTip(
self.tr("LAMMI data substrate classification code"))
self.sub_classification_code_edf_radio = QRadioButton("EDF")
sub_radio_group.addButton(self.sub_classification_code_edf_radio)
self.sub_classification_code_edf_radio.setToolTip(
self.tr("8 EDF classes"))
self.sub_classification_code_cemagref_radio = QRadioButton("Cemagref")
sub_radio_group.addButton(self.sub_classification_code_cemagref_radio)
self.sub_classification_code_cemagref_radio.setToolTip(
self.tr("8 Cemagref classes"))
if user_preferences.data["lammi_sub_classification_code"] == "EDF":
self.sub_classification_code_edf_radio.setChecked(True)
elif user_preferences.data[
"lammi_sub_classification_code"] == "Cemagref":
self.sub_classification_code_cemagref_radio.setChecked(True)
else:
self.send_log.emit(
self.
tr("Warning: lammi_sub_classification_code not recognized in user preferences."
))
print(
"Warning: lammi_sub_classification_code not recognized in user preferences."
)
self.sub_classification_code_cemagref_radio.setChecked(True)
self.sub_classification_code_edf_radio.toggled.connect(
self.lammi_choice_changed)
sub_radio_layout = QHBoxLayout()
sub_radio_layout.addWidget(self.sub_classification_code_edf_radio)
sub_radio_layout.addWidget(self.sub_classification_code_cemagref_radio)
sub_radio_layout.addStretch()
# LAMMI equation
equation_radio_group = QButtonGroup(self)
equation_title_label = QLabel(self.tr('Calculation method'))
equation_title_label.setToolTip(
self.tr("LAMMI hydraulic data calculation method"))
self.equation_fe_radio = QRadioButton(self.tr("Finite Element Method"))
equation_radio_group.addButton(self.equation_fe_radio)
self.equation_fe_radio.setToolTip(
self.tr("Vertical 1D hydraulic profile data set to node."))
self.equation_fv_radio = QRadioButton(self.tr("Finite Volume Method"))
equation_radio_group.addButton(self.equation_fv_radio)
self.equation_fv_radio.setToolTip(
self.tr("Vertical 1D hydraulic profile data set to mesh."))
if user_preferences.data["lammi_calculation_method"] == "FEM":
self.equation_fe_radio.setChecked(True)
elif user_preferences.data["lammi_calculation_method"] == "FVM":
self.equation_fv_radio.setChecked(True)
else:
self.send_log.emit(
self.
tr("Warning: lammi_calculation_method not recognized in user preferences."
))
print(
"Warning: lammi_calculation_method not recognized in user preferences."
)
self.equation_fe_radio.setChecked(True)
self.equation_fe_radio.toggled.connect(self.lammi_choice_changed)
equation_radio_layout = QHBoxLayout()
equation_radio_layout.addWidget(self.equation_fe_radio)
equation_radio_layout.addWidget(self.equation_fv_radio)
equation_radio_layout.addStretch()
# epsg
epsg_title_label = QLabel(self.tr('EPSG code'))
self.epsg_label = QLineEdit(self.tr('unknown'))
self.epsg_label.returnPressed.connect(self.load_hydraulic_create_hdf5)
# hdf5 name
self.hdf5_name_title_label = QLabel(".hyd " + self.tr('file name'))
self.hdf5_name_lineedit = QLineEdit()
self.hdf5_name_lineedit.returnPressed.connect(
self.load_hydraulic_create_hdf5)
# last_hydraulic_file_label
self.last_hydraulic_file_label = QLabel(self.tr('Last file created'))
self.last_hydraulic_file_name_label = QLabel(self.tr('no file'))
# progress_layout
self.progress_layout = ProcessProgLayout(
self.load_hydraulic_create_hdf5,
send_log=self.send_log,
process_type="hyd",
send_refresh_filenames=self.drop_hydro)
# layout
self.hydrau_layout = QGridLayout()
self.hydrau_layout.addWidget(self.result_file_title_label, 0, 0)
self.hydrau_layout.addLayout(self.selection_layout, 0, 1)
self.hydrau_layout.addWidget(reach_name_title_label, 1, 0)
self.hydrau_layout.addWidget(self.reach_name_combobox, 1, 1)
self.hydrau_layout.addWidget(unit_title_label, 3, 0)
self.hydrau_layout.addLayout(unit_layout, 3, 1)
self.hydrau_layout.addWidget(usefull_mesh_variable_label_title, 5, 0)
self.hydrau_layout.addWidget(
self.usefull_mesh_variable_label, 5,
1) # from row, from column, nb row, nb column
self.hydrau_layout.addWidget(usefull_node_variable_label_title, 6, 0)
self.hydrau_layout.addWidget(
self.usefull_node_variable_label, 6,
1) # from row, from column, nb row, nb column
self.hydrau_layout.addWidget(classification_code_title_label, 7, 0)
self.hydrau_layout.addItem(sub_radio_layout, 7, 1)
self.hydrau_layout.addWidget(equation_title_label, 8, 0)
self.hydrau_layout.addItem(equation_radio_layout, 8, 1)
self.hydrau_layout.addWidget(epsg_title_label, 9, 0)
self.hydrau_layout.addWidget(self.epsg_label, 9, 1)
self.hydrau_layout.addWidget(self.hdf5_name_title_label, 10, 0)
self.hydrau_layout.addWidget(self.hdf5_name_lineedit, 10, 1)
self.hydrau_layout.addLayout(self.progress_layout, 11, 0, 1, 2)
self.hydrau_layout.addWidget(self.last_hydraulic_file_label, 12, 0)
self.hydrau_layout.addWidget(self.last_hydraulic_file_name_label, 12,
1)
self.setLayout(self.hydrau_layout)
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
#main image window/widget definition
self.label = QLabel(self)
self.label.mouseDrowingState = False
self.label.setMouseTracking(True)
self.label.lastPos = None
self.label.orginalImage = QPixmap(self.imageName)
#self.label.orginalImage = loadPixmapWithExcludedRegion(self.imageName)
self.label.orginalImageSize = self.label.orginalImage.size()
self.label.orginalImage = self.label.orginalImage.scaledToWidth(
self.width - 100)
self.label.orginalImage = self.label.orginalImage.scaledToHeight(
self.height)
"""self.label.selctedRegionImage = None
head, tail = os.path.split(self.imageName)
if os.path.isfile("{}/ExcludedRegion_{}".format(head,tail)):
self.label.selctedRegionImage = QPixmap("{}/ExcludedRegion_{}".format(head,tail))
self.label.selctedRegionImage = self.label.selctedRegionImage.scaledToWidth(self.width-100)
self.label.selctedRegionImage = self.label.selctedRegionImage.scaledToHeight(self.height)
else:
self.label.selctedRegionImage = QPixmap(self.label.orginalImage.size())"""
self.label.selctedRegionImage = None
head, tail = os.path.split(self.imageName)
if os.path.isfile("{}/ExcludedRegion_{}".format(head, tail)):
self.label.selctedRegionImage = QPixmap(
"{}/ExcludedRegion_{}".format(head, tail))
else:
self.label.selctedRegionImage = QPixmap(
self.label.orginalImage.size())
self.label.selctedRegionImage = self.label.selctedRegionImage.scaledToWidth(
self.width - 100)
self.label.selctedRegionImage = self.label.selctedRegionImage.scaledToHeight(
self.height)
#self.label.orginalImage = cv2.bitwise_and(self.label.orginalImage, self.label.selctedRegionImage, mask = self.label.selctedRegionImage)
self.label.setPixmap(loadPixmapWithExcludedRegion(self.imageName))
self.label.setPixmap(self.label.pixmap().scaledToWidth(self.width -
100))
self.label.setPixmap(self.label.pixmap().scaledToHeight(self.height))
#mouse event interception
self.label.mouseMoveEvent = self.mouseMoveEventOnLabel
self.label.mousePressEvent = self.mousePressEventOnLabel
self.label.mouseReleaseEvent = self.mouseReleaseEventOnLabel
#editing history
self.label.editHistory = []
self.label.editHistory.append(QPixmap(self.label.pixmap()))
#brush size line edit control
brushSizeTextEditLabel = QLabel(self)
brushSizeTextEditLabel.setText("brush size")
brushSizeTextEditLabel.move(self.width - 90, 85)
self.brushSizeTextEdit = QLineEdit(self)
self.brushSizeTextEdit.resize(60, 20)
self.brushSizeTextEdit.move(self.width - 90, 100)
self.label.brushSize = 10
self.brushSizeTextEdit.setText(str(self.label.brushSize))
self.brushSizeTextEdit.textChanged.connect(
self.textChangedBrushSizeLineEdit)
#print mode checkbox (print/erase)
printModeButtonGroup = QButtonGroup(self)
printModeButtonGroup.setExclusive(True)
self.printCheckBoxList = QCheckBox("PRINT", self)
printModeButtonGroup.addButton(self.printCheckBoxList, 1)
self.printCheckBoxList.move(self.width - 90, 200)
self.printCheckBoxList.setCheckState(Qt.Checked)
self.eraseCheckBoxList = QCheckBox("ERASE", self)
printModeButtonGroup.addButton(self.eraseCheckBoxList, 2)
self.eraseCheckBoxList.move(self.width - 90, 230)
self.eraseCheckBoxList.setCheckState(Qt.Unchecked)
#clear all button
self.clearAllButton = QPushButton("CLEAR ALL", self)
self.clearAllButton.mousePressEvent = self.clearAll
self.clearAllButton.resize(60, 20)
self.clearAllButton.move(self.width - 90, 450)
#save selected region button
self.saveSelectedRegionButton = QPushButton("SAVE\nEXCLUDED\nREGIN",
self)
self.saveSelectedRegionButton.mousePressEvent = self.saveSelectedRegion
self.saveSelectedRegionButton.resize(60, 20)
self.saveSelectedRegionButton.move(self.width - 90, 400)
self.show()
def _show_aboutbox(self, title, logo, homepage_url, versions, license_text,
links):
"""
Shows an about dialog box with the specified parameters.
Params:
title (str) Application title
logo (str) Absolute path to application's logo
homepage_url (str) HTTPS link to the project's homepage
versions (list) Table of strings: [["name": "ver"]]
license_text (str) Show this license text.
links (list) List of links: [["label": "url"]]
"""
about = shared.get_ui_widget(self.appdata, "about", QDialog)
_ = self.appdata._
# Logo
about_icon = about.findChild(QLabel, "AppIcon")
shared.set_pixmap_for_label(about_icon, logo, 96)
# App Name
name = about.findChild(QLabel, "AppName")
name.setText(title)
# URL under the application title
url = about.findChild(QLabel, "AppURL")
def _link(a):
webbrowser.open(homepage_url)
url.mousePressEvent = _link
url.setText(homepage_url)
# Set text colour if using Polychromatic Qt theme
if not self.appdata.system_qt_theme:
name.setStyleSheet("QLabel { color: lime }")
url.setStyleSheet("QLabel { color: lime }")
# List versions & dependencies
tree = about.findChild(QTreeWidget, "VersionTree")
column = tree.invisibleRootItem()
for version in versions:
item = QTreeWidgetItem()
item.setText(0, version[0])
item.setText(1, version[1])
column.addChild(item)
# Add application links
links_widget = about.findChild(QWidget, "TabLinks").layout()
button_grp = QButtonGroup()
for button in links:
label = button[0]
href = button[1]
btn = QPushButton(QIcon(common.get_icon("general", "external")),
label)
btn.setToolTip(href)
btn.href = href
button_grp.addButton(btn)
links_widget.addWidget(btn)
def clicked_button_grp(button):
webbrowser.open(button.href)
button_grp.buttonClicked.connect(clicked_button_grp)
# Show license text
license = about.findChild(QTextEdit, "LicenseText")
license.setMarkdown(license_text)
# Set up the about window
close = about.findChild(QPushButton, "Close")
def _close(a):
about.accept()
close.clicked.connect(_close)
if not self.appdata.system_qt_theme:
close.setIcon(self.widgets.get_icon_qt("general", "close"))
window_title = ' '.join(sub[:1].upper() + sub[1:]
for sub in title.split(' '))
about.setWindowTitle(_("About []").replace("[]", window_title))
about.setWindowIcon(QIcon(logo))
about.setWindowFlag(Qt.WindowMinimizeButtonHint, False)
about.setWindowFlag(Qt.WindowMaximizeButtonHint, False)
about.exec()
def fil_in_sets(self):
"""Заполняем список сетов в виде кнопок, """
self.button_group = QButtonGroup()
self.button_group.buttonClicked.connect(self.are_you_sure) # подключает игру с сетом
self.fill_in()
def request_safe_t_init_settings(self, wizard, method, device):
vbox = QVBoxLayout()
next_enabled = True
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
def clean_text(widget):
text = widget.toPlainText().strip()
return ' '.join(text.split())
if method in [TIM_NEW, TIM_RECOVER]:
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg = QButtonGroup()
for i, count in enumerate([12, 18, 24]):
rb = QRadioButton(gb)
rb.setText(_("{:d} words").format(count))
bg.addButton(rb)
bg.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
else:
text = QTextEdit()
text.setMaximumHeight(60)
if method == TIM_MNEMONIC:
msg = _("Enter your BIP39 mnemonic:")
else:
msg = _("Enter the master private key beginning with xprv:")
def set_enabled():
from electrum_exos.bip32 import is_xprv
wizard.next_button.setEnabled(is_xprv(clean_text(text)))
text.textChanged.connect(set_enabled)
next_enabled = False
vbox.addWidget(QLabel(msg))
vbox.addWidget(text)
pin = QLineEdit()
pin.setValidator(QRegExpValidator(QRegExp('[1-9]{0,9}')))
pin.setMaximumWidth(100)
hbox_pin = QHBoxLayout()
hbox_pin.addWidget(QLabel(_("Enter your PIN (digits 1-9):")))
hbox_pin.addWidget(pin)
hbox_pin.addStretch(1)
if method in [TIM_NEW, TIM_RECOVER]:
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
else:
vbox.addLayout(hbox_pin)
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
vbox.addWidget(passphrase_msg)
vbox.addWidget(passphrase_warning)
vbox.addWidget(cb_phrase)
wizard.exec_layout(vbox, next_enabled=next_enabled)
if method in [TIM_NEW, TIM_RECOVER]:
item = bg.checkedId()
pin = cb_pin.isChecked()
else:
item = ' '.join(str(clean_text(text)).split())
pin = str(pin.text())
return (item, name.text(), pin, cb_phrase.isChecked())
class MainTableWidget(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
self.layout.setDirection(QVBoxLayout.Direction.LeftToRight)
# Initialize tab screen
self.tabs = QTabWidget()
self.tab1 = AddFunctionWidget(self)
self.tab2 = FunctionPlotWidget(self)
self.tab3 = SolidRevWidget(self)
self.tab4 = CalculateVolumeWidget(self)
# Array of indices of tabs with plots (for making updates when switching to them)
self.tabsWithPlots = [1,2,3]
# Function whenever a new tab is clicked
self.tabs.currentChanged.connect(self.updatePlot)
# Add tabs
self.tabs.addTab(self.tab1,"Agrega Funciones")
self.tabs.addTab(self.tab2,"Ver Función")
self.tabs.addTab(self.tab3,"Ver Sólido de Revolución")
self.tabs.addTab(self.tab4,"Cálculo de Volumen")
# Add tabs to widget
self.layout.addWidget(self.tabs)
self.tableWidget = None
#self.checkBoxLayout = QVBoxLayout()
self.checkBoxGroup = QButtonGroup()
self.updateListWidget()
# Function to be used for function titles
self.functionTitleFont = QFont()
self.functionTitleFont.setBold(True)
self.functionTitleFont.setPointSize(14)
# Function for updatting math functions widget when new functions are added
def updateListWidget(self, addCheckBox = False):
# Delete existing layouts
if(self.tableWidget != None):
self.layout.removeWidget(self.tableWidget)
listLength = len(GlobalVariables.mathFunctionsList)
# Row added for each function, and row added for each function part
rowAmount = listLength
for mathFunction in GlobalVariables.mathFunctionsList:
rowAmount += len(mathFunction)
self.tableWidget = QTableWidget(rowAmount, 3, self)
header = self.tableWidget.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
rowIndex = 0
for i in range(listLength):
mathFunction = GlobalVariables.mathFunctionsList[i]
rowLabel = QLabel()
self.tableWidget.setSpan(rowIndex, 0, 1, 2) # Mix 2 columns for function title
rowLabel.setText("Función " + str(i+1))
rowLabel.setFont(self.functionTitleFont)
rowLabel.setAlignment(Qt.AlignCenter)
self.tableWidget.setCellWidget(rowIndex, 0, rowLabel) # Add name of this function as a whole
self.tableWidget.setSpan(rowIndex, 2, len(mathFunction) + 1, 1) # Mix rows depending on number of parts of this function
# Add Checkbox for this function
newCheckBox = QCheckBox("F" + str(i+1))
newCheckBox.released.connect(self.selectFunction)
# Set first checkbox to be on
if(listLength==1):
newCheckBox.setChecked(True)
GlobalVariables.selectedIndex = 0
# Set the currently selected Checkbox
if(GlobalVariables.selectedIndex == i):
newCheckBox.setChecked(True)
self.tableWidget.setCellWidget(rowIndex, 2, newCheckBox)
self.checkBoxGroup.addButton(newCheckBox, i)
rowIndex += 1
for j in range(rowIndex, rowIndex + len(mathFunction)):
part = mathFunction[j-rowIndex]
createLatexFormula(r'$f(x) = '+ latex(part.f_expression) +'$', 'equations/function_part_' + str(j), 90)
createLatexFormula(r'$ x \in ('+str(part.x0)+', '+str(part.x1)+')$', 'equations/interval_' + str(j), 90)
partLabel = QLabel()
partLabel.setPixmap(QPixmap('equations/function_part_' + str(j)))
self.tableWidget.setCellWidget(j, 0, partLabel)
partInterval = QLabel()
partInterval.setPixmap(QPixmap('equations/interval_' + str(j)))
self.tableWidget.setCellWidget(j, 1, partInterval)
rowIndex += len(mathFunction)
self.tableWidget.setMaximumWidth(0.4 * GlobalVariables.screenWidth)
self.layout.addWidget(self.tableWidget)
self.setLayout(self.layout)
# Function to set index of the selected function
def selectFunction(self):
GlobalVariables.selectedIndex = self.checkBoxGroup.checkedId()
if(self.tabs.currentIndex() in self.tabsWithPlots):
self.tabs.currentWidget().updatePlot()
# Function to update Plot of the current tab (must have at least one function added)
def updatePlot(self, index):
if(index in self.tabsWithPlots and GlobalVariables.selectedIndex != -1):
self.tabs.widget(index).updatePlot()
def widgets(P, W):
if not P.convSettingsChanged:
#widgets
W.ctLabel = QLabel(_translate('Conversational', 'CUT TYPE'))
W.ctGroup = QButtonGroup(W)
W.cExt = QRadioButton(_translate('Conversational', 'EXTERNAL'))
W.cExt.setChecked(True)
W.ctGroup.addButton(W.cExt)
W.cInt = QRadioButton(_translate('Conversational', 'INTERNAL'))
W.ctGroup.addButton(W.cInt)
W.koLabel = QLabel(_translate('Conversational', 'KERF'))
W.kOffset = QPushButton(_translate('Conversational', 'OFFSET'))
W.kOffset.setCheckable(True)
W.spLabel = QLabel(_translate('Conversational', 'START'))
W.spGroup = QButtonGroup(W)
W.center = QRadioButton(_translate('Conversational', 'CENTER'))
W.spGroup.addButton(W.center)
W.bLeft = QRadioButton(_translate('Conversational', 'BTM LEFT'))
W.spGroup.addButton(W.bLeft)
text = _translate('Conversational', 'ORIGIN')
W.xsLabel = QLabel(_translate('Conversational', 'X {}'.format(text)))
W.xsEntry = QLineEdit(str(P.xSaved), objectName='xsEntry')
W.ysLabel = QLabel(_translate('Conversational', 'Y {}'.format(text)))
W.ysEntry = QLineEdit(str(P.ySaved), objectName='ysEntry')
W.liLabel = QLabel(_translate('Conversational', 'LEAD IN'))
W.liEntry = QLineEdit(str(P.leadIn), objectName='liEntry')
W.loLabel = QLabel(_translate('Conversational', 'LEAD OUT'))
W.loEntry = QLineEdit(str(P.leadOut), objectName='loEntry')
W.wLabel = QLabel(_translate('Conversational', 'WIDTH'))
W.wEntry = QLineEdit(objectName='')
W.hLabel = QLabel(_translate('Conversational', 'HEIGHT'))
W.hEntry = QLineEdit(objectName='')
W.aLabel = QLabel(_translate('Conversational', 'ANGLE'))
W.aEntry = QLineEdit('0', objectName='aEntry')
W.add = QPushButton(_translate('Conversational', 'ADD'))
W.lDesc = QLabel(_translate('Conversational', 'CREATING ELLIPSE'))
W.iLabel = QLabel()
pixmap = QPixmap('{}conv_ellipse_l.png'.format(
P.IMAGES)).scaledToWidth(196)
W.iLabel.setPixmap(pixmap)
#alignment and size
rightAlign = ['ctLabel', 'koLabel', 'spLabel', 'xsLabel', 'xsEntry', 'ysLabel', \
'ysEntry', 'liLabel', 'liEntry', 'loLabel', 'loEntry', 'wLabel', \
'wEntry', 'hLabel', 'hEntry', 'aLabel', 'aEntry']
centerAlign = ['lDesc']
rButton = ['cExt', 'cInt', 'center', 'bLeft']
pButton = ['preview', 'add', 'undo', 'kOffset']
for widget in rightAlign:
W[widget].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
W[widget].setFixedWidth(80)
W[widget].setFixedHeight(24)
for widget in centerAlign:
W[widget].setAlignment(Qt.AlignCenter | Qt.AlignBottom)
W[widget].setFixedWidth(240)
W[widget].setFixedHeight(24)
for widget in rButton:
W[widget].setFixedWidth(80)
W[widget].setFixedHeight(24)
for widget in pButton:
W[widget].setFixedWidth(80)
W[widget].setFixedHeight(24)
#starting parameters
W.add.setEnabled(False)
if P.oSaved:
W.center.setChecked(True)
else:
W.bLeft.setChecked(True)
#connections
W.preview.pressed.disconnect()
W.undo.pressed.disconnect()
W.conv_material.currentTextChanged.connect(lambda: auto_preview(P, W))
W.cExt.toggled.connect(lambda: auto_preview(P, W))
W.kOffset.toggled.connect(lambda: auto_preview(P, W))
W.center.toggled.connect(lambda: auto_preview(P, W))
W.preview.pressed.connect(lambda: preview(P, W))
W.add.pressed.connect(lambda: P.conv_add_shape_to_file())
W.undo.pressed.connect(lambda: P.conv_undo_shape())
entries = [
'xsEntry', 'ysEntry', 'liEntry', 'loEntry', 'wEntry', 'hEntry',
'aEntry'
]
for entry in entries:
W[entry].textChanged.connect(lambda: entry_changed(P, W, W.sender()))
W[entry].returnPressed.connect(lambda: preview(P, W))
#add to layout
if P.landscape:
W.entries.addWidget(W.ctLabel, 0, 0)
W.entries.addWidget(W.cExt, 0, 1)
W.entries.addWidget(W.cInt, 0, 2)
W.entries.addWidget(W.koLabel, 0, 3)
W.entries.addWidget(W.kOffset, 0, 4)
W.entries.addWidget(W.spLabel, 1, 0)
W.entries.addWidget(W.center, 1, 1)
W.entries.addWidget(W.bLeft, 1, 2)
W.entries.addWidget(W.xsLabel, 2, 0)
W.entries.addWidget(W.xsEntry, 2, 1)
W.entries.addWidget(W.ysLabel, 3, 0)
W.entries.addWidget(W.ysEntry, 3, 1)
W.entries.addWidget(W.liLabel, 4, 0)
W.entries.addWidget(W.liEntry, 4, 1)
W.entries.addWidget(W.loLabel, 5, 0)
W.entries.addWidget(W.loEntry, 5, 1)
W.entries.addWidget(W.wLabel, 6, 0)
W.entries.addWidget(W.wEntry, 6, 1)
W.entries.addWidget(W.hLabel, 7, 0)
W.entries.addWidget(W.hEntry, 7, 1)
W.entries.addWidget(W.aLabel, 8, 0)
W.entries.addWidget(W.aEntry, 8, 1)
for r in [9, 10, 11]:
W['s{}'.format(r)] = QLabel('')
W['s{}'.format(r)].setFixedHeight(24)
W.entries.addWidget(W['s{}'.format(r)], r, 0)
W.entries.addWidget(W.preview, 12, 0)
W.entries.addWidget(W.add, 12, 2)
W.entries.addWidget(W.undo, 12, 4)
W.entries.addWidget(W.lDesc, 13, 1, 1, 3)
W.entries.addWidget(W.iLabel, 2, 2, 7, 3)
else:
W.entries.addWidget(W.conv_material, 0, 0, 1, 5)
W.entries.addWidget(W.ctLabel, 1, 0)
W.entries.addWidget(W.cExt, 1, 1)
W.entries.addWidget(W.cInt, 1, 2)
W.entries.addWidget(W.koLabel, 1, 3)
W.entries.addWidget(W.kOffset, 1, 4)
W.entries.addWidget(W.spLabel, 2, 0)
W.entries.addWidget(W.center, 2, 1)
W.entries.addWidget(W.bLeft, 2, 2)
W.entries.addWidget(W.xsLabel, 3, 0)
W.entries.addWidget(W.xsEntry, 3, 1)
W.entries.addWidget(W.ysLabel, 3, 2)
W.entries.addWidget(W.ysEntry, 3, 3)
W.entries.addWidget(W.liLabel, 4, 0)
W.entries.addWidget(W.liEntry, 4, 1)
W.entries.addWidget(W.loLabel, 4, 2)
W.entries.addWidget(W.loEntry, 4, 3)
W.entries.addWidget(W.wLabel, 5, 0)
W.entries.addWidget(W.wEntry, 5, 1)
W.entries.addWidget(W.hLabel, 5, 2)
W.entries.addWidget(W.hEntry, 5, 3)
W.entries.addWidget(W.aLabel, 6, 0)
W.entries.addWidget(W.aEntry, 6, 1)
for r in [7, 8]:
W['s{}'.format(r)] = QLabel('')
W['s{}'.format(r)].setFixedHeight(24)
W.entries.addWidget(W['s{}'.format(r)], r, 0)
W.entries.addWidget(W.preview, 9, 0)
W.entries.addWidget(W.add, 9, 2)
W.entries.addWidget(W.undo, 9, 4)
W.entries.addWidget(W.lDesc, 10, 1, 1, 3)
W.entries.addWidget(W.iLabel, 0, 5, 7, 3)
W.wEntry.setFocus()
P.convSettingsChanged = False
def __init__(self, parent=None):
QWidget.__init__(self, parent=parent)
self.setupUi(self)
self.settings_manager = injector.get_settings_manager()
self.setup_widgets()
self.connect_edit_widgets()
self.selected_objects = []
self.user = User(
id=45,
name='UserName',
)
self.subreddit = Subreddit(id=79, name='SubredditName')
self.post = Post(id=42,
title='Example_Post_Title',
date_posted=datetime.now(),
reddit_id='23sdf9lksdf',
domain='i.imgur.com',
extraction_date=datetime.now(),
author=self.user,
subreddit=self.subreddit,
score=2573)
date_limit_group = QButtonGroup(self)
date_limit_group.addButton(self.absolute_date_limit_radio)
date_limit_group.addButton(self.custom_date_limit_radio)
date_lock_group = QButtonGroup(self)
date_lock_group.addButton(self.update_custom_date_limit_radio)
date_lock_group.addButton(self.do_not_update_custom_date_limit_radio)
def buttton_init(self):
from PyQt5.QtGui import QFont
self.setAttribute(Qt.WA_DeleteOnClose)
self.lineEdit.setFont(QFont("宋体", 14, QFont.Normal))
self.lineEdit_4.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_2.setFont(QFont("宋体", 14, QFont.Normal))
self.lineEdit_3.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_5.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_6.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_7.setFont(QFont("宋体", 14, QFont.Normal))
self.label_10.setText('打开操作脚本路径：工具安装路径/src')
self.label_18.setText('重置后串口\n是否打开')
self.setWindowTitle('开关机压测')
self.setWindowIcon(
QIcon(os.path.join(constant.SRC_ROOT, 'icon', '开关机检测.ico')))
# icon = QIcon(constant.all_icon)
# self.setWindowIcon(icon)
self.lineEdit.setPlaceholderText('未配置，请将广告资源放到U盘根目录下，否则不作广告资源替换.')
# self.lineEdit_4.setPlaceholderText('如勾选，请输入mac地址')
self.lineEdit_4.setHidden(True)
self.label_9.setHidden(True)
self.label_25.setHidden(True)
self.pushButton_2.clicked.connect(
lambda: self.jump_connect(self.pushButton_2.text()))
self.pushButton_3.clicked.connect(
lambda: self.jump_connect(self.pushButton_3.text()))
self.pushButton_4.clicked.connect(
lambda: self.jump_connect(self.pushButton_4.text()))
self.onmode = QButtonGroup()
self.onmode.addButton(self.radioButton, 0)
self.onmode.addButton(self.radioButton_2, 1)
self.onmode.buttonClicked[int].connect(self.set_onmode)
self.farmode = QButtonGroup()
self.farmode.addButton(self.radioButton_5, 0)
self.farmode.addButton(self.radioButton_6, 1)
self.farmode.buttonClicked[int].connect(self.set_farmode)
self.save_app = QButtonGroup()
self.save_app.addButton(self.radioButton_51, 0)
self.save_app.addButton(self.radioButton_61, 1)
self.save_app.buttonClicked[int].connect(self.set_saveapp)
self.open_Serial = QButtonGroup()
self.open_Serial.addButton(self.radioButton_8, 0)
self.open_Serial.addButton(self.radioButton_7, 1)
self.open_Serial.buttonClicked[int].connect(self.set_openSerial)
for clickbox in self.onAndoff_list:
clickbox.stateChanged.connect(
lambda: self.onoff_checkbox(self.sender(),
self.sender().text()))
for clickbox2 in self.recover_list:
clickbox2.stateChanged.connect(
lambda: self.recovery_checkbox(self.sender(),
self.sender().text()))
self.pushButton_8.clicked.connect(
lambda: self.check_onoff_scene(self.pushButton_8.text()))
self.pushButton_7.clicked.connect(
lambda: self.check_onoff_scene(self.pushButton_7.text()))
self.pushButton_13.clicked.connect(
lambda: self.check_scene_boot_enter(self.pushButton_13.text()))
self.pushButton_14.clicked.connect(
lambda: self.check_scene_boot_enter(self.pushButton_14.text()))
self.pushButton_10.clicked.connect(
lambda: self.check_scene_recovery(self.pushButton_10.text()))
self.pushButton_9.clicked.connect(
lambda: self.check_scene_recovery(self.pushButton_9.text()))
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.path = os.path.join(os.getcwd(),
"Projects") # Путь к папке с проектами
self.projects = os.listdir(self.path) # Проекты
self.current_project = "" # Имя проекта
self.current_test = "" # Имя испытания
self.data = pd.DataFrame() # Data from excel
self.x = [] # Data for x
self.x_name = "" # Имя столбца по оси X
self.y = [] # Chosen columns
self.type_flag = False # Необходимо для проверки данных на соответствие типу данных (число)
self.table_ready = False
self.file_path = "" # Отвечает за путь к .xlsx файлу
self.additional_data_flag = False # Флаг, обозначающий, что данные нужно дополнить
self.x_min = 0 # Нижняя граница дополнения
self.x_max = 0 # Верхняя граница дополнения
self.changed_flag = False
self.y_filtered = {} # Фильтрованные данные (y)
self.incorrect_data = {} # Данные с ошибками
self.many_cells = False # Флаг для метода изменения значений в нескольких ячейках
self.is_loading = False # Флаг текущей загрузки
self.setWindowTitle("Excel to data")
self.central_widget = QWidget(self) # Создаём центральный виджет
self.setCentralWidget(self.central_widget)
# Создаём все расположения
main_layout = QHBoxLayout() # Главное
left_layout = QVBoxLayout(
) # Для проектов, испытаний и вывода данных и .data
self.project_layout = QVBoxLayout() # Для проектов
self.tests_layout = QVBoxLayout() # Для испытаний
data_layout = QHBoxLayout() # Для представления данных
graph_layout = QVBoxLayout() # Для графиков
# Часть для окна с данными
self.table = QTableWidget(self) # Пустая таблица
self.table.setMinimumWidth(
int(QApplication.desktop().availableGeometry().width() * 0.3))
self.table.cellChanged.connect(
self.change_cell) # Возможность редактирования данных
# Часть для графиков
pg.setConfigOption('foreground', pg.mkColor("000000"))
# Создаём поле для графика
self.originalGraphWidget = pg.PlotWidget()
self.originalGraphWidget.setBackground('w')
self.originalGraphWidget.setTitle("Исходные данные")
self.originalGraphWidget.setLabel('left', 'Values')
self.originalGraphWidget.setLabel('bottom', 'X')
self.originalGraphWidget.showGrid(x=True, y=True)
self.originalGraphWidget.addLegend() # Описание: цвет - график
# Создаём поле для изменённого графика
self.changedGraphWidget = pg.PlotWidget()
self.changedGraphWidget.setBackground('w')
self.changedGraphWidget.setTitle("Изменённые данные")
self.changedGraphWidget.setLabel('left', 'Values')
self.changedGraphWidget.setLabel('bottom', 'X')
self.changedGraphWidget.showGrid(x=True, y=True)
self.changedGraphWidget.addLegend()
self.original_plt = []
self.changed_plt = []
# Часть для вывода
self.out_text = QTextEdit()
self.out_text.setMaximumHeight(
int(QApplication.desktop().availableGeometry().height() * 0.3))
self.out_text.setReadOnly(True)
# Второй поток
self.threadclass = thread.ThreadClass(self)
self.threadclass.finishSignal.connect(self.finishSignal_process)
data_layout.addLayout(self.project_layout)
data_layout.addLayout(self.tests_layout)
data_layout.addWidget(self.table)
left_layout.addLayout(data_layout)
left_layout.addWidget(self.out_text)
graph_layout.addWidget(self.originalGraphWidget)
graph_layout.addWidget(self.changedGraphWidget)
main_layout.addLayout(left_layout)
main_layout.addLayout(graph_layout)
self.central_widget.setLayout(main_layout)
self.create_menuBar()
self.update_project_layout()
self.update_tests_layout()
def create_menuBar(self):
menuBar = self.menuBar()
file_menu = menuBar.addMenu("Файл")
create_menu = file_menu.addMenu("Создать")
self.project_action = QAction("Проект", self)
self.project_action.triggered.connect(self.create_project)
self.test_action = QAction("Данные испытаний", self)
self.test_action.setEnabled(False)
self.test_action.triggered.connect(self.add_test)
create_menu.addAction(self.project_action)
create_menu.addAction(self.test_action)
delete_menu = file_menu.addMenu("Удалить")
self.delete_prj_action = QAction("Проект", self)
self.delete_prj_action.triggered.connect(self.delete_prj_folder)
self.delete_test_action = QAction("Данные испытаний", self)
self.delete_test_action.triggered.connect(self.delete_test_folder)
delete_menu.addAction(self.delete_prj_action)
delete_menu.addAction(self.delete_test_action)
data_menu = menuBar.addMenu("Данные")
self.conversion_action = QAction("Конвертировать в .data", self)
self.conversion_action.setEnabled(False)
self.conversion_action.triggered.connect(self.convert_data)
self.set_x_action = QAction("Назначить ось абсцисс", self)
self.set_x_action.setEnabled(False)
self.set_x_action.triggered.connect(self.set_x)
self.graph_action = QAction("Построить график", self)
self.graph_action.setEnabled(False)
self.graph_action.triggered.connect(self.get_graph)
self.copy_action = QAction("Копировать данные", self)
self.copy_action.setEnabled(False)
self.copy_action.triggered.connect(self.copy_test)
data_menu.addAction(self.graph_action)
data_menu.addAction(self.conversion_action)
data_menu.addAction(self.set_x_action)
data_menu.addAction(self.copy_action)
change_menu = data_menu.addMenu("Изменить")
self.data_action = QAction("Данные в выбранных ячейках", self)
self.data_action.setEnabled(False)
self.data_action.triggered.connect(self.change_data_in_chosen_cells)
self.column_action = QAction("Порядок столбцов", self)
self.column_action.setEnabled(False)
self.column_action.triggered.connect(self.enumerate_col)
change_menu.addAction(self.data_action)
change_menu.addAction(self.column_action)
self.delete_action = QAction("Удалить столбцы", self)
self.delete_action.setEnabled(False)
self.delete_action.triggered.connect(self.delete_column)
data_menu.addAction(self.delete_action)
graph_menu = menuBar.addMenu("График")
self.filter_action = QAction("Фильтровать", self)
self.filter_action.setEnabled(False)
self.filter_action.triggered.connect(self.filter_data)
self.add_action = QAction("Изменить диапозон Х", self)
self.add_action.setEnabled(False)
self.add_action.triggered.connect(self.add_data)
graph_menu.addAction(self.filter_action)
graph_menu.addAction(self.add_action)
save_menu = graph_menu.addMenu("Сохранить")
self.original_action = QAction("Исходное изображение", self)
self.original_action.setEnabled(False)
self.original_action.triggered.connect(
lambda state, graphWidget=self.originalGraphWidget: self.
save_graph(graphWidget))
self.changed_action = QAction("Изменённое изображение", self)
self.changed_action.setEnabled(False)
self.changed_action.triggered.connect(
lambda state, graphWidget=self.changedGraphWidget: self.save_graph(
graphWidget))
save_menu.addAction(self.original_action)
save_menu.addAction(self.changed_action)
def init_prj_context_menu(self, name):
self.current_project = name
context_menu = QMenu(self)
add_data = QAction("Добавить данные испытаний", self)
add_data.triggered.connect(self.add_test)
delete_project = QAction("Удалить проект", self)
delete_project.triggered.connect(
lambda state: self.delete_prj_folder(name))
context_menu.addAction(add_data)
context_menu.addAction(delete_project)
context_menu.exec_(QCursor.pos())
def init_header_context_menu(self, name):
context_menu = QMenu(self)
set = QAction("Сделать осью абсцисс", self)
#set.triggered.connect(lambda state: self.set_x(name))
context_menu.addAction(set)
context_menu.exec_(QCursor.pos())
def set_x(self):
items = self.data.columns.to_list()
item, ok = QInputDialog().getItem(self, "Назначение оси абсцисс",
"Выберите:", items, 0, False)
if ok and item != '':
self.x_name = item
def loading_data(self):
self.out_text.clear()
self.out_text.setText("Подождите. Идёт загрузка данных...")
def update_project_layout(self):
clear_layout(self.project_layout)
self.projects = os.listdir(self.path)
if len(self.projects) == 0:
empty_lbl = QLabel("Нет созданных проектов")
empty_lbl.setStyleSheet('font-size: 11pt')
self.project_layout.addWidget(empty_lbl)
else:
box = QGroupBox()
inner_layout = QVBoxLayout()
project_lbl = QLabel("Проекты:")
project_lbl.setStyleSheet('font-size: 11pt')
self.project_layout.addWidget(project_lbl)
self.buttons = QButtonGroup()
self.buttons.buttonClicked[int].connect(self.choose_project)
for folder in range(len(self.projects)):
button = QPushButton(self.projects[folder], self)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; '
'font-weight: 100')
button.setContextMenuPolicy(Qt.CustomContextMenu)
button.customContextMenuRequested.connect(
lambda state, name=self.projects[
folder]: self.init_prj_context_menu(name))
self.buttons.addButton(button, folder)
inner_layout.addWidget(button)
inner_layout.addStretch(1)
box.setLayout(inner_layout)
scroll = QScrollArea()
scroll.setWidget(box)
scroll.setWidgetResizable(True)
self.project_layout.addWidget(scroll)
def update_tests_layout(self):
clear_layout(self.tests_layout)
if self.current_project != '':
folder_path = os.path.join(self.path, self.current_project)
tests = os.listdir(folder_path)
# Добавляем кнопки для всех файлов, лежащих в папке
# Добавляем ScrollArea, чтобы можно было прокручивать вниз, если файлов очень много
if len(tests) == 0:
empty_lbl = QLabel("Нет созданных испытаний")
empty_lbl.setStyleSheet('font-size: 11pt')
self.tests_layout.addWidget(empty_lbl)
else:
test_lbl = QLabel(self.current_project + ':')
test_lbl.setStyleSheet('font-size: 11pt')
self.tests_layout.addWidget(test_lbl)
self.test_buttons = QButtonGroup()
self.test_buttons.buttonClicked[int].connect(self.test_pushed)
box = QGroupBox() # Необходимо для ScrollArea
inner_layout = QVBoxLayout()
for test in range(
len(tests)): # Добавляем каждую внутреннюю директорию
button = QPushButton(tests[test], self)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; '
'font-weight: 100')
# В обработчик нажатия передаём путь, чтобы определять, что нужно открыть
self.test_buttons.addButton(button, test)
inner_layout.addWidget(button)
inner_files = os.listdir(
os.path.join(folder_path, tests[test]))
for file in inner_files: # Добавляем каждый файл из внутренних директорий
button = QPushButton('- ' + file)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: '
'9pt; font-weight: 100; margin-left: 20px')
# В обработчик нажатия передаём путь, чтобы определять, что нужно открыть
button.clicked.connect(
lambda state, file_path=os.path.join(
folder_path, tests[test], file
): self.file_pushed(file_path))
inner_layout.addWidget(button)
if os.path.isdir(
os.path.join(folder_path, tests[test], file)):
data_files = os.listdir(
os.path.join(folder_path, tests[test], file))
for df in data_files:
button = QPushButton('> ' + df)
button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: '
'7pt; font-weight: 100; margin-left: 40px')
button.clicked.connect(
lambda state, file_path=os.path.join(
folder_path, tests[test], file, df
): self.file_pushed(file_path))
inner_layout.addWidget(button)
box.setLayout(inner_layout)
scroll = QScrollArea()
scroll.setWidget(box)
scroll.setWidgetResizable(True)
self.tests_layout.addWidget(scroll)
def choose_project(self, id):
for button in self.buttons.buttons():
if self.buttons.id(button) == id:
self.current_project = button.text()
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; font-weight: 700; '
'color: yellow')
else:
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; font-weight: 100;'
)
self.test_action.setEnabled(True)
self.copy_action.setEnabled(False)
self.update_tests_layout()
def test_pushed(self, id):
self.incorrect_data = dict.fromkeys(self.data.columns, 0)
for button in self.test_buttons.buttons():
if self.test_buttons.id(button) == id:
self.current_test = button.text()
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; font-weight: 700; '
'color: yellow')
else:
button.setStyleSheet(
'background: transparent; text-align: left; border: none; font-size: 11pt; font-weight: 100;'
)
self.conversion_action.setEnabled(True)
self.data_action.setEnabled(True)
self.column_action.setEnabled(True)
self.copy_action.setEnabled(True)
self.delete_action.setEnabled(True)
self.set_x_action.setEnabled(True)
# Находим файл с таблицей
xlsx = os.listdir(
os.path.join(self.path, self.current_project, self.current_test))
xlsx = [i for i in xlsx if ('.xlsx' in i) and i != 'out.xlsx']
self.file_path = os.path.join(self.path, self.current_project,
self.current_test, xlsx[0])
self.loading_data()
self.threadclass.start()
def finishSignal_process(self):
self.create_table()
if '.data' in self.file_path:
self.draw_data_graph()
def copy_test(self):
item, ok = QInputDialog.getItem(self, "Выбор проекта", "Проект",
tuple(self.projects), 0, False)
if ok and item:
cur_path = os.path.join(self.path, self.current_project,
self.current_test)
new_path = os.path.join(self.path, item,
self.current_test + "-copy")
try:
os.mkdir(new_path)
paths = [
i for i in os.listdir(
os.path.join(self.path, self.current_project,
self.current_test))
if ('.xlsx' in i) or ('.data' in i)
]
for p in paths:
shutil.copy(os.path.join(cur_path, p), new_path)
except FileExistsError:
QMessageBox.about(self, "Предупреждение",
"Копия уже была создана")
def create_project(self):
name, ok = QInputDialog.getText(self, 'Создание проекта',
'Введите название нового проекта:')
if ok:
if name in self.projects:
QMessageBox.about(self, 'Ошибка',
'Проект с таким именем уже существует.')
else:
pat = "[\w-]+" # Шаблон для названия
if re.sub(pat, "", name, 1) == "":
os.mkdir(os.path.join(self.path, name))
self.projects.append(name)
self.update_project_layout()
else:
QMessageBox.about(
self, 'Ошибка',
'Название проекта может состоять из букв, цифр, а также знаков '
'тире и нижнего подчёркивания.')
def add_test(self):
self.aw = aw.AddWindow(self)
self.aw.show()
def enumerate_col(self):
self.cw = cw.ColumnsWindow(self)
self.cw.show()
def create_table(self):
if self.file_path != "":
self.x_name = self.data.columns[0]
self.x = list(self.data[self.x_name])
self.type_flag = False
self.table_ready = False
headers = self.data.columns.to_list()
self.clear_table()
self.table.setColumnCount(len(headers))
self.table.setRowCount(len(self.data))
self.table.setHorizontalHeaderLabels(headers)
self.incorrect_data = dict.fromkeys(headers, 0)
for i in range(len(headers)):
for j in range(len(self.data)):
self.table.setItem(
j, i, QTableWidgetItem(str(self.data.iloc[j, i])))
self.table_ready = True
self.table.insertRow(0) # Добавляем ряд с checkbox
for i in range(0, len(headers)):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
self.table.setItem(0, i, item)
# делаем ресайз колонок по содержимому
self.table.resizeColumnsToContents()
incorrect_columns = [
key for key, value in self.incorrect_data.items() if value != 0
]
self.paint_headers(incorrect_columns)
if len(incorrect_columns) != 0:
self.conversion_action.setEnabled(False)
self.graph_action.setEnabled(False)
else:
self.conversion_action.setEnabled(True)
self.graph_action.setEnabled(True)
def clear_table(self):
while self.table.rowCount() > 0:
self.table.removeRow(0)
def paint_headers(self, columns):
message = "Некорректные данные в столбцах: \n"
for i in range(len(self.data.columns)):
header = self.table.horizontalHeaderItem(i)
header.setText(header.text().replace('*', ''))
if self.data.columns[i] in columns:
message += header.text() + "\n"
header.setText('*' + header.text())
if message == "Некорректные данные в столбцах: \n":
message = "Все данные в верном формате"
else:
message += "\nДанные могут быть представлены только в числовом формате.\n" \
"Для изменения значений выделите нужные ячейки и нажмите " \
"'Данные' - 'Изменить' - 'Данные в выбранных ячейках'."
self.out_text.clear()
self.out_text.setText(message)
def convert_data(self):
self.get_checked_columns()
text, ok = QInputDialog.getText(self, 'Конвертация данных',
'Введите название файла:')
files = os.listdir(
os.path.join(self.path, self.current_project, self.current_test,
"Изменённые_данные"))
if ok:
pat = "[\w-]+" # Шаблон для названия
if re.sub(pat, "", text, 1) == "":
if not ((text + '.data') in files):
self.data.to_excel(os.path.join(self.path,
self.current_project,
self.current_test,
"Изменённые_данные",
text + '.xlsx'),
columns=self.y,
index=False)
self.data.to_csv(os.path.join(self.path,
self.current_project,
self.current_test,
"Изменённые_данные",
text + '.data'),
sep=' ',
columns=self.y,
header=True,
index=False)
QMessageBox.about(self, "Конвертация",
"Конвертация завершена")
self.update_tests_layout()
else:
QMessageBox.about(
self, "Ошибка",
"Файлы с такими названиями уже существуют")
else:
QMessageBox.about(
self, 'Ошибка',
'Название проекта может состоять из букв, цифр, а также знаков '
'тире и нижнего подчёркивания.')
def get_checked_columns(self):
self.y.clear()
for i in range(0, self.table.columnCount()):
if self.table.item(0, i).checkState() == Qt.Checked:
self.y.append(self.data.columns[i]) # Add labels of columns
def get_graph(self):
self.data = self.data.sort_values(
by=self.x_name) # Сортируем данные по возрастанию x
self.x = list(self.data[self.x_name])
self.filter_action.setEnabled(True)
self.add_action.setEnabled(True)
self.original_action.setEnabled(True)
self.get_checked_columns()
self.draw_graph()
def change_cell(self, row, column):
if self.table_ready:
if row != 0:
t = str(type(self.data.iloc[row - 1, column]))
self.data.iloc[row - 1,
column] = self.table.item(row, column).text()
try:
value = float(self.table.item(row, column).text())
self.data.iloc[row - 1, column] = value
if not ('float' in t) and not ('int' in t):
self.incorrect_data[self.data.columns[column]] -= 1
except (TypeError, ValueError):
if not self.many_cells:
QMessageBox.about(self, "Ошибка",
"Введены некорректные данные")
self.conversion_action.setEnabled(False)
self.graph_action.setEnabled(False)
if 'float' in t or 'int' in t:
self.incorrect_data[self.data.columns[column]] += 1
incorrect_columns = [
key for key, value in self.incorrect_data.items()
if value != 0
]
self.paint_headers(incorrect_columns)
if len(incorrect_columns) != 0:
self.conversion_action.setEnabled(False)
self.graph_action.setEnabled(False)
else:
self.conversion_action.setEnabled(True)
self.graph_action.setEnabled(True)
else:
t = str(type(self.data.iloc[row - 1, column]))
if not ('float' in t) and not ('int' in t):
self.incorrect_data[self.data.columns[column]] += 1
def change_data_in_chosen_cells(self):
cells = self.table.selectedIndexes()
if len(cells) == 0:
QMessageBox.about(self, "Ошибка", "Ни одна ячейка не была выбрана")
else:
text, ok = QInputDialog.getText(self, 'Изменение данных',
'Введите число:')
if ok:
try:
value = float(text)
except (TypeError, ValueError):
QMessageBox.about(self, "Ошибка",
"Введены некорректные данные")
self.many_cells = True
for cell in cells:
row = cell.row()
column = cell.column()
item = QTableWidgetItem()
item.setText(text)
self.table.setItem(row, column, item)
self.many_cells = False
# Метод для сохранения картинок графиков
def save_graph(self, graphWidget):
exporter = pg.exporters.ImageExporter(graphWidget.plotItem)
exporter.params.param('width').setValue(
graphWidget.range.width(), blockSignal=exporter.widthChanged)
exporter.params.param('height').setValue(
graphWidget.range.height(), blockSignal=exporter.heightChanged)
text, ok = QInputDialog.getText(self, 'Сохранение',
'Введите название файла:')
if ok:
# save to file
exporter.export(
os.path.join(self.path, self.current_project,
self.current_test, text + '.png'))
# Метод для отрисовки графиков в первый раз
def draw_graph(self):
self.originalGraphWidget.clear()
self.changedGraphWidget.clear()
self.changed_plt.clear()
self.original_plt.clear()
for col in self.y:
if col != self.x_name:
self.changed_plt.append(
plot([0], [0], col, self.changedGraphWidget))
self.original_plt.append(
plot(self.x, list(self.data[col]), col,
self.originalGraphWidget))
# Метод для отрисовки данных по .data
def draw_data_graph(self):
self.originalGraphWidget.clear()
self.changedGraphWidget.clear()
self.changed_plt.clear()
self.original_plt.clear()
for col in self.data.columns:
if col != self.x_name:
self.original_plt.append(
plot(self.x, list(self.data[col]), col,
self.originalGraphWidget))
self.changed_plt.append(
plot([0], [0], col, self.changedGraphWidget))
# Метод для обновления данных на графиках
def update_graph(self):
# plot data: x, y values
self.changed_flag = False
for col in range(len(self.y)):
if self.y[col] != self.x_name:
flag = False
for fc in self.y_filtered.keys():
if fc == self.y[col]:
flag = True
break
if flag: # Если эти данные были отфильтрованы
values = list(self.y_filtered.get(self.y[col]))
self.changed_flag = True
else:
values = list(self.data[self.y[col]])
if self.additional_data_flag: # Если есть дополнения к графику
self.changed_flag = True
x = list(enumerate(self.x, 0))
min_value = min(x, key=lambda j: j[1])
max_value = max(x, key=lambda j: j[1])
new_x = []
new_y = []
for i in range(len(self.x)):
if self.x_min <= self.x[i] <= self.x_max:
new_x.append(self.x[i])
new_y.append(values[i])
if min_value[1] > self.x_min:
new_x.insert(0, self.x_min)
new_y.insert(0, values[min_value[0]])
if max_value[1] < self.x_max:
new_x.insert(len(new_x), self.x_max)
new_y.insert(len(new_x), values[max_value[0]])
self.changed_plt[col].setData(new_x, new_y)
elif self.changed_flag:
self.changed_plt[col].setData(self.x, values)
self.original_plt[col].setData(self.x,
list(self.data[self.y[col]]))
# Дополнения к графику
def add_data(self):
begin, ok = QInputDialog.getText(self, 'Начальное значение',
'Введите начальное значение:')
if ok:
try:
self.x_min = int(begin)
end, ok = QInputDialog.getText(self, 'Конечное значение',
'Введите конечное значение:')
if ok:
try:
self.x_max = int(end)
self.additional_data_flag = True
self.changed_action.setEnabled(True)
self.update_graph()
except ValueError:
QMessageBox.about(self, "Ошибка",
"Введены некорректные данные")
except ValueError:
QMessageBox.about(self, "Ошибка",
"Введены некорректные данные")
def filter_data(self):
self.filter_win = fw.FilterWindow(self)
self.filter_win.show()
def file_pushed(self, file_path):
if '.txt' in file_path:
f = open(file_path)
self.out_text.setText(f.read())
elif '.data' in file_path:
self.file_path = file_path
self.conversion_action.setEnabled(True)
self.data_action.setEnabled(True)
self.column_action.setEnabled(True)
self.copy_action.setEnabled(True)
self.delete_action.setEnabled(True)
self.set_x_action.setEnabled(True)
f = open(file_path)
self.out_text.setText(f.read())
self.loading_data()
self.threadclass.start()
elif '.' in file_path:
subprocess.run(file_path, shell=True)
def delete_column(self):
self.get_checked_columns()
self.data = self.data.drop(columns=self.y)
self.create_table()
def delete_prj_folder(self, name=""):
self.current_project = ""
if name == "":
path = os.path.normpath(os.path.join(os.getcwd(), "Projects"))
prj = QFileDialog.getExistingDirectory(self, "Выберите проект",
path,
QFileDialog.ShowDirsOnly)
if prj != "" and (path in os.path.normpath(prj)):
shutil.rmtree(prj, ignore_errors=True)
self.update_project_layout()
self.update_tests_layout()
else:
shutil.rmtree(os.path.join(self.path, name), ignore_errors=True)
self.update_project_layout()
self.update_tests_layout()
def delete_test_folder(self):
path = os.path.normpath(os.path.join(os.getcwd(), "Projects"))
prj = QFileDialog.getExistingDirectory(self, "Выберите испытание",
path, QFileDialog.ShowDirsOnly)
if prj != "":
h, t = os.path.split(os.path.normpath(prj))
h, t = os.path.split(h)
if path == h:
os.rmdir(prj)
class model_on_and_off(Ui_MainWindow, QMainWindow):
off_open_list = pyqtSignal()
def __init__(self):
super(Ui_MainWindow, self).__init__()
self.setupUi(self)
self.setWindowFlags(Qt.WindowCloseButtonHint)
self.setFixedSize(self.width(), self.height())
self.mode = None
self.far = None
self.is_open_Serial = None
self.is_save_app = None
self.attribute_init()
# 定义属性
self.onAndoff_list = [
self.checkBox, self.checkBox_2, self.checkBox_3, self.checkBox_4,
self.checkBox_7, self.checkBox_15, self.checkBox_16,
self.checkBox_17, self.checkBox_18, self.checkBox_20,
self.checkBox_21, self.checkBox_19, self.checkBox_22,
self.checkBox_23
]
self.onAndoff_list_dict = [
"音量+-", "频道+-", "五维键", "语音键", "网络是否回连成功", "近场唤醒是否成功",
"移动存储设备挂载是否成功,U盘个数：", "遥控器是否回连成功", "远场唤醒是否成功", "蓝牙音箱是否回连成功",
"HDMI出图是否成功", "内置应用", "第三方应用", "信源"
]
self.onAndoff_dict = {
"音量+-": False,
"频道+-": False,
"五维键": False,
"语音键": False,
"网络是否回连成功": False,
"近场唤醒是否成功": False,
"移动存储设备挂载是否成功,U盘个数：": False,
"遥控器是否回连成功": False,
"远场唤醒是否成功": False,
"蓝牙音箱是否回连成功": False,
"HDMI出图是否成功": False,
"内置应用": False,
"第三方应用": False,
"信源": False
}
self.recover_list = [
self.checkBox_24, self.checkBox_27, self.checkBox_25,
self.checkBox_28, self.checkBox_26, self.checkBox_29,
self.checkBox_30
]
self.recover_dict = {
"检测第三方应用是否存在": False,
"launcher进入正常": False,
"摄像头驱动是否正常，是否能升降": False,
"WiFi驱动是否正常": False,
"移动存储设备是否能够成功挂载,U盘个数：": False,
"远场语音是否能唤醒": False,
"批量安装APK（APK路径：xxx）": False
}
self.buttton_init()
def buttton_init(self):
from PyQt5.QtGui import QFont
self.setAttribute(Qt.WA_DeleteOnClose)
self.lineEdit.setFont(QFont("宋体", 14, QFont.Normal))
self.lineEdit_4.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_2.setFont(QFont("宋体", 14, QFont.Normal))
self.lineEdit_3.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_5.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_6.setFont(QFont("宋体", 12, QFont.Normal))
self.lineEdit_7.setFont(QFont("宋体", 14, QFont.Normal))
self.label_10.setText('打开操作脚本路径：工具安装路径/src')
self.label_18.setText('重置后串口\n是否打开')
self.setWindowTitle('开关机压测')
self.setWindowIcon(
QIcon(os.path.join(constant.SRC_ROOT, 'icon', '开关机检测.ico')))
# icon = QIcon(constant.all_icon)
# self.setWindowIcon(icon)
self.lineEdit.setPlaceholderText('未配置，请将广告资源放到U盘根目录下，否则不作广告资源替换.')
# self.lineEdit_4.setPlaceholderText('如勾选，请输入mac地址')
self.lineEdit_4.setHidden(True)
self.label_9.setHidden(True)
self.label_25.setHidden(True)
self.pushButton_2.clicked.connect(
lambda: self.jump_connect(self.pushButton_2.text()))
self.pushButton_3.clicked.connect(
lambda: self.jump_connect(self.pushButton_3.text()))
self.pushButton_4.clicked.connect(
lambda: self.jump_connect(self.pushButton_4.text()))
self.onmode = QButtonGroup()
self.onmode.addButton(self.radioButton, 0)
self.onmode.addButton(self.radioButton_2, 1)
self.onmode.buttonClicked[int].connect(self.set_onmode)
self.farmode = QButtonGroup()
self.farmode.addButton(self.radioButton_5, 0)
self.farmode.addButton(self.radioButton_6, 1)
self.farmode.buttonClicked[int].connect(self.set_farmode)
self.save_app = QButtonGroup()
self.save_app.addButton(self.radioButton_51, 0)
self.save_app.addButton(self.radioButton_61, 1)
self.save_app.buttonClicked[int].connect(self.set_saveapp)
self.open_Serial = QButtonGroup()
self.open_Serial.addButton(self.radioButton_8, 0)
self.open_Serial.addButton(self.radioButton_7, 1)
self.open_Serial.buttonClicked[int].connect(self.set_openSerial)
for clickbox in self.onAndoff_list:
clickbox.stateChanged.connect(
lambda: self.onoff_checkbox(self.sender(),
self.sender().text()))
for clickbox2 in self.recover_list:
clickbox2.stateChanged.connect(
lambda: self.recovery_checkbox(self.sender(),
self.sender().text()))
self.pushButton_8.clicked.connect(
lambda: self.check_onoff_scene(self.pushButton_8.text()))
self.pushButton_7.clicked.connect(
lambda: self.check_onoff_scene(self.pushButton_7.text()))
self.pushButton_13.clicked.connect(
lambda: self.check_scene_boot_enter(self.pushButton_13.text()))
self.pushButton_14.clicked.connect(
lambda: self.check_scene_boot_enter(self.pushButton_14.text()))
self.pushButton_10.clicked.connect(
lambda: self.check_scene_recovery(self.pushButton_10.text()))
self.pushButton_9.clicked.connect(
lambda: self.check_scene_recovery(self.pushButton_9.text()))
def attribute_init(self):
self.waittime = None
self.boottime = None
self.usb_count = 1
self.a2dp_mac = None
self.ad_root = ''
self.apk_root = None
self.device_choice_ui = None
self.create_scene_view = None
def onoff_checkbox(self, checkbox, text):
if checkbox.isChecked():
self.onAndoff_dict[text] = True
else:
self.onAndoff_dict[text] = False
def recovery_checkbox(self, checkbox, text):
if checkbox.isChecked():
self.recover_dict[text] = True
else:
self.recover_dict[text] = False
def message(self, title, text):
newMessagebox = QMessageBox(self)
# icon = QIcon(constant.all_icon)
# newMessagebox.setWindowIcon(icon)
newMessagebox.setText('\r\r\r' + text + '\r\r\r')
newMessagebox.setWindowTitle(title)
newMessagebox.setIcon(1)
newMessagebox.setStyleSheet(
'QMessageBox{background-color:rgb(240,240,240)}')
newMessagebox.setStandardButtons(QMessageBox.Yes)
newMessagebox.exec()
return newMessagebox.clickedButton()
def check_onoff_scene(self, value):
if self.mode == None:
if self.message('提示', '请勾选带*号的必选项：开机模式') != QMessageBox.No:
return
if self.lineEdit_2.text() == "":
if self.message('提示', '请填写带*号的必选项：待机等待时间') != QMessageBox.No:
return
if self.lineEdit_7.text() == "":
if self.message('提示', '请填写带*号的必选项：开机等待时间') != QMessageBox.No:
return
else:
if self.lineEdit_2.text().isdigit():
self.waittime = int(self.lineEdit_2.text())
else:
self.lineEdit_2.clear()
self.label_9.setHidden(False)
return
if self.lineEdit_7.text().isdigit():
self.boottime = int(self.lineEdit_7.text())
else:
self.lineEdit_7.clear()
self.label_25.setHidden(False)
return
self.ad_root = self.lineEdit.text() if self.lineEdit.text() else ''
if self.onAndoff_dict["移动存储设备挂载是否成功,U盘个数："]:
if not self.lineEdit_3.text().isdigit():
if self.message('提示', 'U盘个数：请输入数字！') != QMessageBox.No:
return
else:
self.usb_count = int(self.lineEdit_3.text())
if value == "一键调试":
if self.view_close(self.device_choice_ui):
return
self.device_choice_ui = device_chooose_connect(self)
self.device_choice_ui.device_list_signal.connect(
self.create_onoff_scene)
self.device_choice_ui.show()
else:
if self.view_close(self.create_scene_view):
return
self.create_scene_view = create_scene_view('count', parent=self)
self.create_scene_view.scene_information.connect(
self.create_onoff_scene)
self.create_scene_view.show()
def view_close(self, view):
try:
if view != None:
if view.isVisible():
return True
else:
view.close()
return False
except:
return False
def check_scene_boot_enter(self, button_text):
if self.onAndoff_dict["内置应用"] == False and self.onAndoff_dict[
"第三方应用"] == False and self.onAndoff_dict["信源"] == False:
if self.message('提示', '请勾选一个开机直达应用') != QMessageBox.No:
return
if button_text == "一键调试":
if self.view_close(self.device_choice_ui):
return
self.device_choice_ui = device_chooose_connect(self)
self.device_choice_ui.device_list_signal.connect(
self.create_scene_boot_enter)
self.device_choice_ui.show()
else:
if self.view_close(self.create_scene_view):
return
self.create_scene_view = create_scene_view('count', parent=self)
self.create_scene_view.scene_information.connect(
self.create_scene_boot_enter)
self.create_scene_view.show()
def check_scene_recovery(self, button_text):
if self.save_app.checkedId() == -1:
if self.message('提示', '请勾选是否保留应用') != QMessageBox.No:
return
if self.recover_dict["批量安装APK（APK路径：xxx）"]:
if self.lineEdit_6.text() == '':
if self.message('提示', '请输入APK所在路径') != QMessageBox.No:
return
else:
self.apk_root = self.lineEdit_6.text()
if self.recover_dict["移动存储设备是否能够成功挂载,U盘个数："]:
if not self.lineEdit_5.text().isdigit():
if self.message('提示', 'U盘个数：请输入数字！') != QMessageBox.No:
return
else:
self.usb_count = int(self.lineEdit_5.text())
if button_text == "一键调试":
if self.view_close(self.device_choice_ui):
return
self.device_choice_ui = device_chooose_connect(self)
self.device_choice_ui.device_list_signal.connect(
self.create_recovery_scene)
self.device_choice_ui.show()
else:
if self.view_close(self.create_scene_view):
return
self.create_scene_view = create_scene_view('count', parent=self)
self.create_scene_view.scene_information.connect(
self.create_recovery_scene)
self.create_scene_view.show()
def open_scene_list(self):
self.off_open_list.emit()
self.close()
def create_scene_boot_enter(self, devices_list, scene_name, exec_times):
this_checker = ck.Checker()
if len(devices_list) == 0:
self.scene_boot_enter = scene_boot_enter.SceneBootEnter(
name=scene_name,
exec_time=exec_times,
by=sc.BY_COUNT,
checker=this_checker,
inner=self.onAndoff_dict["内置应用"],
third=self.onAndoff_dict["第三方应用"],
tv=self.onAndoff_dict["信源"])
self.scene_boot_enter.save()
self.attribute_init()
self.creat_success_toast = toast(parent=self, text='开机直达场景\n创建成功！')
self.creat_success_toast.move(
QPoint(self.geometry().left() + self.width() * 0.3,
self.geometry().top() + self.height() * 0.3))
self.creat_success_toast.ocl_signal.connect(self.open_scene_list)
self.creat_success_toast.exec()
else:
self.scene_boot_enter = scene_boot_enter.SceneBootEnter(
name="开机直达",
exec_time=1,
checker=this_checker,
inner=self.onAndoff_dict["内置应用"],
third=self.onAndoff_dict["第三方应用"],
tv=self.onAndoff_dict["信源"])
self.attribute_init()
self.scene_boot_enter.device = dv.Device(devices_list[0][0],
devices_list[0][1])
self.checkscene = sceneOneCheck(self.scene_boot_enter)
self.checkscene.reflash_sig.connect(self.showlog)
self.checkscene.dependent_check_sig.connect(self.check_message)
self.checkscene.start()
def create_onoff_scene(self, devices_list, scene_name, exec_times):
this_checker = ck.Checker(
net=self.onAndoff_dict["网络是否回连成功"],
usb=self.onAndoff_dict["移动存储设备挂载是否成功,U盘个数："],
hdmi=self.onAndoff_dict["HDMI出图是否成功"],
blue_controller=self.onAndoff_dict["遥控器是否回连成功"],
blue_speaker=self.onAndoff_dict["蓝牙音箱是否回连成功"],
near=self.onAndoff_dict["近场唤醒是否成功"],
far=self.onAndoff_dict["远场唤醒是否成功"],
usb_count=self.usb_count,
# a2dp_mac=self.a2dp_mac
)
if len(devices_list) == 0:
self.scene_onoff = scene_on_and_off.SceneOnAndOff(
name=scene_name,
exec_time=exec_times,
by=sc.BY_COUNT,
checker=this_checker,
mode=self.mode,
key_set=dict(volume=self.onAndoff_dict["音量+-"],
channel=self.onAndoff_dict["频道+-"],
pad=self.onAndoff_dict["五维键"],
voice=self.onAndoff_dict['语音键']),
dc_off_interval=self.waittime,
on2check_interval=self.boottime,
ad_root=self.ad_root,
far=self.far)
self.scene_onoff.save()
self.attribute_init()
self.creat_success_toast = toast(parent=self, text='开关机场景\n创建成功！')
self.creat_success_toast.move(
QPoint(self.geometry().left() + self.width() * 0.3,
self.geometry().top() + self.height() * 0.3))
self.creat_success_toast.ocl_signal.connect(self.open_scene_list)
self.creat_success_toast.exec()
else:
self.scene_onoff = scene_on_and_off.SceneOnAndOff(
name="开机压测",
exec_time=1,
checker=this_checker,
mode=self.mode,
key_set=dict(volume=self.onAndoff_dict["音量+-"],
channel=self.onAndoff_dict["频道+-"],
pad=self.onAndoff_dict["五维键"],
voice=self.onAndoff_dict['语音键']),
dc_off_interval=self.waittime,
on2check_interval=self.boottime,
ad_root=self.ad_root,
far=self.far)
self.attribute_init()
self.scene_onoff.device = dv.Device(devices_list[0][0],
devices_list[0][1])
self.checkscene = sceneOneCheck(self.scene_onoff)
self.checkscene.reflash_sig.connect(self.showlog)
self.checkscene.dependent_check_sig.connect(self.check_message)
self.checkscene.start()
def inform_text(self, string):
if string == 'begin':
self.loading = loading(self)
self.loading.label_2.setText('调试中，请等待')
self.loading.move(self.width() * 0.45, self.height() * 0.45)
self.loading.exec()
if string == 'FAIL':
self.loading.label_2.setText('执行失败')
self.loading.close()
QMessageBox.information(self, '提示', '执行失败', QMessageBox.Yes)
return
if string == 'FINISH':
self.loading.label_2.setText('执行成功')
self.loading.close()
QMessageBox.information(self, '提示', '执行完成', QMessageBox.Yes)
return
def create_recovery_scene(self, devices_list, scene_name, exec_times):
this_checker = ck.Checker(
launcher=self.recover_dict["launcher进入正常"],
camera=self.recover_dict["摄像头驱动是否正常，是否能升降"],
usb=self.recover_dict["移动存储设备是否能够成功挂载,U盘个数："],
wifi_driver=self.recover_dict["WiFi驱动是否正常"],
far=self.recover_dict["远场语音是否能唤醒"],
check_apk=self.recover_dict["检测第三方应用是否存在"],
install_apk=self.recover_dict["批量安装APK（APK路径：xxx）"],
usb_count=self.usb_count,
apk_root=self.apk_root)
if len(devices_list) == 0:
self.recovery_scene = scene_recovery.SceneRecovery(
name=scene_name,
exec_time=exec_times,
by=sc.BY_COUNT,
checker=this_checker,
retain_app=self.is_save_app,
serial_open=self.is_open_Serial)
self.recovery_scene.save()
self.attribute_init()
self.creat_success_toast = toast(parent=self, text='系统重置场景\n创建成功！')
self.creat_success_toast.move(
QPoint(self.geometry().left() + self.width() * 0.3,
self.geometry().top() + self.height() * 0.3))
self.creat_success_toast.ocl_signal.connect(self.open_scene_list)
self.creat_success_toast.exec()
else:
self.recovery_scene = scene_recovery.SceneRecovery(
name="恢复出厂设置",
exec_time=1,
checker=this_checker,
retain_app=self.is_save_app,
serial_open=self.is_open_Serial)
self.attribute_init()
self.recovery_scene.device = dv.Device(devices_list[0][0],
devices_list[0][1])
self.checkscene = sceneOneCheck(self.recovery_scene)
self.checkscene.reflash_sig.connect(self.showlog)
self.checkscene.dependent_check_sig.connect(self.check_message)
self.checkscene.start()
def showlog(self):
self.debug_tootip = debug_tootip(self)
self.debug_tootip.move(self.width() * 0.3, self.height() * 0.3)
self.debug_tootip.exec()
def check_message(self, check):
self.message('依赖检查', check)
def set_farmode(self, int):
if int == 0:
self.far = True
else:
self.far = False
def set_saveapp(self, int):
if int == 0:
self.is_save_app = True
else:
self.is_save_app = False
def set_openSerial(self, int):
if int == 0:
self.is_open_Serial = True
else:
self.is_open_Serial = False
def set_onmode(self, int):
if int == 0:
self.mode = sw.MODE_AC
else:
self.mode = sw.MODE_DC
def jump_connect(self, str):
if str.strip() == "开关机流程检测":
self.tabWidget.setCurrentIndex(0)
self.pushButton_2.setStyleSheet('background: #1890FF;')
self.pushButton_3.setStyleSheet('background: #000C17;')
self.pushButton_4.setStyleSheet('background: #000C17;')
elif str == "开机直达轮询":
self.tabWidget.setCurrentIndex(1)
self.pushButton_3.setStyleSheet('background: #1890FF;')
self.pushButton_4.setStyleSheet('background: #000C17;')
self.pushButton_2.setStyleSheet('background: #000C17;')
elif str == "恢复出厂设置":
self.tabWidget.setCurrentIndex(2)
self.pushButton_4.setStyleSheet('background: #1890FF;')
self.pushButton_2.setStyleSheet('background: #000C17;')
self.pushButton_3.setStyleSheet('background: #000C17;')
else:
pass
def __init__(self, parent=None):
super(AddAccountDialog, self).__init__(parent)
with Resources.directory:
self.setupUi(self)
self.background_frame.setStyleSheet("")
self.button_group = QButtonGroup(self)
self.button_group.setObjectName("button_group")
self.button_group.addButton(
self.add_account_button,
self.panel_view.indexOf(self.add_account_panel))
self.button_group.addButton(
self.create_account_button,
self.panel_view.indexOf(self.create_account_panel))
default_font_size = self.info_label.fontInfo().pointSizeF()
title_font_size = limit(default_font_size + 3, max=14)
font = self.title_label.font()
font.setPointSizeF(title_font_size)
self.title_label.setFont(font)
font_metrics = self.create_status_label.fontMetrics()
self.create_status_label.setMinimumHeight(
font_metrics.height() + 2 *
(font_metrics.height() + font_metrics.leading())
) # reserve space for 3 lines
font_metrics = self.email_note_label.fontMetrics()
self.email_note_label.setMinimumWidth(
font_metrics.width(
u'The E-mail address is used when sending voicemail')
) # hack to make text justification look nice everywhere
self.add_account_button.setChecked(True)
self.panel_view.setCurrentWidget(self.add_account_panel)
self.new_password_editor.textChanged.connect(
self._SH_PasswordTextChanged)
self.button_group.buttonClicked[int].connect(
self._SH_PanelChangeRequest)
self.accept_button.clicked.connect(self._SH_AcceptButtonClicked)
self.display_name_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.name_editor.statusChanged.connect(self._SH_ValidityStatusChanged)
self.username_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.sip_address_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.new_password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.verify_password_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.email_address_editor.statusChanged.connect(
self._SH_ValidityStatusChanged)
self.display_name_editor.regexp = re.compile('^.*$')
self.name_editor.regexp = re.compile('^.+$')
self.username_editor.regexp = re.compile(
'^\w(?<=[^0_])[\w.-]{4,31}(?<=[^_.-])$', re.IGNORECASE
) # in order to enable unicode characters add re.UNICODE to flags
self.sip_address_editor.regexp = re.compile('^[^@\s]+@[^@\s]+$')
self.password_editor.regexp = re.compile('^.*$')
self.new_password_editor.regexp = re.compile('^.{8,}$')
self.verify_password_editor.regexp = re.compile('^$')
self.email_address_editor.regexp = re.compile('^[^@\s]+@[^@\s]+$')
account_manager = AccountManager()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=account_manager)
def open_apply_to_all(self):
"""
Show options for setting options that apply to all connected devices, where
the option is supported.
"""
self.set_cursor_busy()
layout = self.Contents.layout()
shared.clear_layout(layout)
bulk = common.get_bulk_apply_options(self._,
self.middleman.get_device_all())
effects = bulk["effects"]
brightnesses = bulk["brightness"]
# For creating controls
self.btn_grps["all"] = QButtonGroup()
def _create_button(label,
icon_path,
option_id,
option_data,
option_colours=0,
colour=None):
# Same button as effects
button = QToolButton()
button.setText(label)
button.setIconSize(QSize(30, 30))
button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
button.setIcon(QIcon(icon_path))
button.setMinimumHeight(40)
button.setMinimumWidth(130)
button.option_id = option_id
button.option_data = option_data
button.required_colours = option_colours
button.colour = colour
self.btn_grps["all"].addButton(button)
return button
def add_to_page(label, widgets):
group = self.widgets.create_group_widget(label)
group.layout().setAlignment(Qt.AlignTop)
group.layout().setContentsMargins(QMargins(30, 5, 30, 5))
row = 0
col = 0
for position, widget in enumerate(widgets):
group.layout().addWidget(widget, row, col)
col += 1
if col >= 5:
col = 0
row += 1
layout.addWidget(group)
def _apply_button_clicked(button):
self.set_cursor_busy()
if button.option_id:
# Setting effect/brightness
self.middleman.set_bulk_option(button.option_id,
button.option_data,
button.required_colours)
else:
# Setting colour
self.middleman.set_bulk_colour(button.colour)
self.set_cursor_normal()
self.btn_grps["all"].buttonClicked.connect(_apply_button_clicked)
# Brightness
if len(brightnesses) > 0:
widgets = []
for brightness in brightnesses:
option_id = brightness["id"]
option_data = brightness["data"]
label = brightness["label"]
icon = common.get_icon("options", str(option_data))
widgets.append(
_create_button(label, icon, option_id, option_data))
add_to_page(self._("Brightness"), widgets)
# Options
if len(effects) > 0:
widgets = []
for option in effects:
option_id = option["id"]
option_data = option["data"]
required_colours = option["required_colours"]
label = option["label"]
icon = common.get_icon("options", str(option_id))
widgets.append(
_create_button(label,
icon,
option_id,
option_data,
option_colours=required_colours))
add_to_page(self._("Effects"), widgets)
# Colours
if len(effects) > 0:
widgets = []
for colour in pref.load_file(self.paths.colours):
label = colour["name"]
data = colour["hex"]
icon = common.generate_colour_bitmap(self.dbg, data, "40x40")
widgets.append(
_create_button(label, icon, None, None, colour=data))
add_to_page(self._("Colours"), widgets)
layout.addStretch()
self.set_cursor_normal()
def __init__(self, contentProvider):
QWidget.__init__(self)
self.setWindowTitle("Визуализатор содержимого памяти")
#self.setToolTip("Байты, со значением равным 0x00, отображаются белым цветом, остальные -- серым")
QToolTip.setFont(QFont("SansSerif", 8))
self.startaddress = 0x10000000
self.magnifyOffset = 0
self.mode = 0
self.contentProvider = contentProvider
self.memframe = MemFrame()
self.memframe.magnifyPositionChanged.connect(self.onMagnifyPositionChanged)
self.magnify = Magnify()
self.btn1000 = QPushButton("0x10000000")
self.btn2000 = QPushButton("0x20000000")
self.btn2001 = QPushButton("0x20010000")
self.btn2002 = QPushButton("0x20020000")
self.btn1000.clicked.connect(self.on1000)
self.btn2000.clicked.connect(self.on2000)
self.btn2001.clicked.connect(self.on2001)
self.btn2002.clicked.connect(self.on2002)
self.rbColor = QRadioButton("Цветное")
self.rbBw = QRadioButton("Чёрно/белое")
self.rbChanges = QRadioButton("Изменения")
self.rbUsing = QRadioButton("Пользование")
self.rbColor.setChecked(True)
self.rbg = QButtonGroup()
self.rbg.addButton(self.rbColor)
self.rbg.addButton(self.rbBw)
self.rbg.addButton(self.rbChanges)
self.rbg.addButton(self.rbUsing)
self.rbColor.toggled.connect(self.onColor)
self.rbBw.toggled.connect(self.onBw)
self.rbChanges.toggled.connect(self.onChanges)
self.rbUsing.toggled.connect(self.onUsing)
# Размещение виджетов на морде
vbox1 = QVBoxLayout()
vbox1.addWidget(self.memframe)
vbox3 = QVBoxLayout()
vbox3.addSpacing(50)
vbox3.addWidget(self.btn1000)
vbox3.addWidget(self.btn2000)
vbox3.addWidget(self.btn2001)
vbox3.addWidget(self.btn2002)
vbox3.addStretch()
vbox4 = QVBoxLayout()
vbox4.addSpacing(50)
vbox4.addWidget(self.rbColor)
vbox4.addWidget(self.rbBw)
vbox4.addWidget(self.rbChanges)
vbox4.addWidget(self.rbUsing)
vbox4.addStretch()
hbox1 = QHBoxLayout()
hbox1.addLayout(vbox3)
hbox1.addLayout(vbox4)
vbox2 = QVBoxLayout()
vbox2.addLayout(hbox1)
vbox2.addWidget(self.magnify)
vbox2.addStretch()
hbox0 = QHBoxLayout()
hbox0.addLayout(vbox1)
hbox0.addLayout(vbox2)
hbox0.addStretch()
self.setLayout(hbox0)
def _create_effect_controls(self, zone, effect_options):
"""
Groups all options with the "effect" type and present them as larger buttons.
"""
widgets = []
self.btn_grps[zone] = QButtonGroup()
for effect in effect_options:
fx_id = effect["id"]
fx_params = effect["parameters"]
fx_string = effect["label"]
fx_active = effect["active"]
fx_colours = effect["colours"]
button = QToolButton()
button.setText(fx_string)
button.setCheckable(True)
button.setIconSize(QSize(40, 40))
button.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
button.setIcon(QIcon(common.get_icon("options", fx_id)))
button.setMinimumHeight(70)
button.setMinimumWidth(70)
button.effect = effect
button.zone = zone
self.btn_grps[zone].addButton(button)
if fx_active:
button.setChecked(True)
widgets.append(button)
def _clicked_effect_button(button):
effect = button.effect
zone = button.zone
param_count = len(effect["parameters"])
option_id = effect["id"]
option_data = None
colour_hex = []
# Use saved colour, if available for this effect
if len(effect["parameters"]) == 0:
colour_hex = effect["colours"]
# For effects with parameters, the second one will be used as the first may be 'random' or 'off'.
if param_count > 0:
if param_count == 1:
param = effect["parameters"][0]
elif param_count >= 2:
param = effect["parameters"][1]
option_data = param["data"]
colour_hex = param["colours"]
self.dbg.stdout(
"Setting effect {0} (data: {1}) on {2} device {3} (zone: {4}, colours: {5})"
.format(option_id, str(option_data),
self.current_backend, self.current_uid, zone,
str(colour_hex)), self.dbg.action, 1)
response = self.middleman.set_device_state(self.current_backend,
self.current_uid,
self.current_serial,
zone, option_id,
option_data, colour_hex)
self._event_check_response(response)
self.reload_device()
self.btn_grps[zone].buttonClicked.connect(_clicked_effect_button)
if not widgets:
return None
return self.widgets.create_row_widget(self._("Effect"),
widgets,
wrap=True)
class logTab(QWidget):
def __init__(self):
super().__init__()
self.logJSONFile = {"access": "", "error": "", "loglevel": "warning"}
self.translate = QCoreApplication.translate
def createLogTab(self):
labelAccess = QLabel(self.translate("logTab", "Access File: "))
labelError = QLabel(self.translate("logTab", "Error File: "))
self.lineEditAccess = QLineEdit()
self.lineEditError = QLineEdit()
btnSaveAccess = QPushButton(self.translate("logTab", "&Save"), self)
btnSaveError = QPushButton(self.translate("logTab", "S&ave"), self)
labelLogLevel = QLabel(self.translate("logTab", "Log Level: "), self)
self.comboxLogLevel = QComboBox()
self.comboxLogLevel.addItems(
("warning", "debug", "info", "error", "none"))
self.buttonGroupSave = QButtonGroup()
self.buttonGroupSave.addButton(btnSaveAccess)
self.buttonGroupSave.addButton(btnSaveError)
hboxAccess = QHBoxLayout()
hboxAccess.addWidget(labelAccess)
hboxAccess.addWidget(self.lineEditAccess)
hboxAccess.addWidget(btnSaveAccess)
hboxError = QHBoxLayout()
hboxError.addWidget(labelError)
hboxError.addWidget(self.lineEditError)
hboxError.addWidget(btnSaveError)
hboxLogLevel = QHBoxLayout()
hboxLogLevel.addWidget(labelLogLevel)
hboxLogLevel.addWidget(self.comboxLogLevel)
hboxLogLevel.addStretch()
vboxLogPanel = QVBoxLayout()
vboxLogPanel.addLayout(hboxAccess)
vboxLogPanel.addLayout(hboxError)
vboxLogPanel.addLayout(hboxLogLevel)
vboxLogPanel.addStretch()
self.setLayout(vboxLogPanel)
groupBoxLogTAB = QGroupBox("", self)
groupBoxLogTAB.setLayout(vboxLogPanel)
self.createLogTabSignals()
if (v2rayshellDebug):
self.__debugBtn = QPushButton("__debugTest", self)
vboxLogPanel.addWidget(self.__debugBtn)
self.__debugBtn.clicked.connect(self.__debugTest)
self.settingLogTabFromJSONFile(self.logJSONFile, True)
return groupBoxLogTAB
def createLogTabSignals(self):
self.buttonGroupSave.buttonClicked.connect(self.onbuttonGroupSave)
def onbuttonGroupSave(self, e):
options = QFileDialog.Options()
if (e.text() == self.translate("logTab", "&Save")):
fileName, _ = QFileDialog.getSaveFileName(
self,
self.translate("logTab", "Save V2ray Access log file"),
"_access",
"Log Files (*.log)",
options=options)
self.lineEditAccess.setText(fileName)
if (e.text() == self.translate("logTab", "S&ave")):
fileName, _ = QFileDialog.getSaveFileName(
self,
self.translate("logTab", "Save V2ray Error log file"),
"_error",
"Log Files (*.log)",
options=options)
self.lineEditError.setText(fileName)
def settingLogTabFromJSONFile(self,
logJSONFile={},
openFromJSONFile=False):
logTagslog = logBook(openFromJSONFile)
if (not logJSONFile): logJSONFile = {}
try:
logJSONFile["access"]
except KeyError as e:
logTagslog.writeLog("LogTAB", "KeyError", e)
logJSONFile["access"] = ""
try:
logJSONFile["error"]
except KeyError as e:
logTagslog.writeLog("LogTAB", "KeyError", e)
logJSONFile["error"] = ""
try:
logJSONFile["loglevel"]
except KeyError as e:
logTagslog.writeLog("LogTAB", "KeyError", e)
logJSONFile["loglevel"] = "warning"
self.lineEditAccess.setText(str(logJSONFile["access"]))
self.lineEditError.setText(str(logJSONFile["error"]))
try:
self.comboxLogLevel.setCurrentText(str(logJSONFile["loglevel"]))
except (ValueError, TypeError) as e:
logTagslog.writeLog("LogTAB", "ValueError or TypeError", e)
def createLogJSONFile(self):
logJSONFile = {}
logJSONFile["access"] = self.lineEditAccess.text()
logJSONFile["error"] = self.lineEditError.text()
logJSONFile["loglevel"] = self.comboxLogLevel.currentText()
return logJSONFile
def __debugTest(self):
print(json.dumps(self.createLogJSONFile(), indent=4, sort_keys=False))
def request_trezor_init_settings(self, wizard, method, device_id):
vbox = QVBoxLayout()
next_enabled = True
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
if not client:
raise Exception(_("The device was disconnected."))
model = client.get_trezor_model()
fw_version = client.client.version
# label
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
# word count
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg_numwords = QButtonGroup()
word_counts = (12, 18, 24)
for i, count in enumerate(word_counts):
rb = QRadioButton(gb)
rb.setText(_("{:d} words").format(count))
bg_numwords.addButton(rb)
bg_numwords.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
# PIN
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
# "expert settings" button
expert_vbox = QVBoxLayout()
expert_widget = QWidget()
expert_widget.setLayout(expert_vbox)
expert_widget.setVisible(False)
expert_button = QPushButton(_("Show expert settings"))
def show_expert_settings():
expert_button.setVisible(False)
expert_widget.setVisible(True)
expert_button.clicked.connect(show_expert_settings)
vbox.addWidget(expert_button)
# passphrase
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
expert_vbox.addWidget(passphrase_msg)
expert_vbox.addWidget(passphrase_warning)
expert_vbox.addWidget(cb_phrase)
# ask for recovery type (random word order OR matrix)
bg_rectype = None
if method == TIM_RECOVER and not model == 'T':
gb_rectype = QGroupBox()
hbox_rectype = QHBoxLayout()
gb_rectype.setLayout(hbox_rectype)
expert_vbox.addWidget(gb_rectype)
gb_rectype.setTitle(_("Select recovery type:"))
bg_rectype = QButtonGroup()
rb1 = QRadioButton(gb_rectype)
rb1.setText(_('Scrambled words'))
bg_rectype.addButton(rb1)
bg_rectype.setId(rb1, RECOVERY_TYPE_SCRAMBLED_WORDS)
hbox_rectype.addWidget(rb1)
rb1.setChecked(True)
rb2 = QRadioButton(gb_rectype)
rb2.setText(_('Matrix'))
bg_rectype.addButton(rb2)
bg_rectype.setId(rb2, RECOVERY_TYPE_MATRIX)
hbox_rectype.addWidget(rb2)
# no backup
cb_no_backup = None
if method == TIM_NEW:
cb_no_backup = QCheckBox(f'''{_('Enable seedless mode')}''')
cb_no_backup.setChecked(False)
if (model == '1' and fw_version >= (1, 7, 1)
or model == 'T' and fw_version >= (2, 0, 9)):
cb_no_backup.setToolTip(SEEDLESS_MODE_WARNING)
else:
cb_no_backup.setEnabled(False)
cb_no_backup.setToolTip(_('Firmware version too old.'))
expert_vbox.addWidget(cb_no_backup)
vbox.addWidget(expert_widget)
wizard.exec_layout(vbox, next_enabled=next_enabled)
return TrezorInitSettings(
word_count=word_counts[bg_numwords.checkedId()],
label=name.text(),
pin_enabled=cb_pin.isChecked(),
passphrase_enabled=cb_phrase.isChecked(),
recovery_type=bg_rectype.checkedId() if bg_rectype else None,
no_backup=cb_no_backup.isChecked() if cb_no_backup else False,
)
