def __init__(self, parent, name):
QWidget.__init__(self, parent)
self.setStyleSheet(get_stylesheet("ribbonPane"))
horizontal_layout = QHBoxLayout()
horizontal_layout.setSpacing(0)
horizontal_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(horizontal_layout)
vertical_widget = QWidget(self)
horizontal_layout.addWidget(vertical_widget)
horizontal_layout.addWidget(RibbonSeparator(self))
vertical_layout = QVBoxLayout()
vertical_layout.setSpacing(0)
vertical_layout.setContentsMargins(0, 0, 0, 0)
vertical_widget.setLayout(vertical_layout)
label = QLabel(name)
label.setAlignment(Qt.AlignCenter)
label.setStyleSheet("color:#666;")
content_widget = QWidget(self)
vertical_layout.addWidget(content_widget)
vertical_layout.addWidget(label)
content_layout = QHBoxLayout()
content_layout.setAlignment(Qt.AlignLeft)
content_layout.setSpacing(0)
content_layout.setContentsMargins(0, 0, 0, 0)
self.contentLayout = content_layout
content_widget.setLayout(content_layout)
def __init__(self, parent):
super(PercentSlider, self).__init__(parent)
self._slider = QSlider(Qt.Vertical, self)
self._slider.setMinimum(-100)
self._slider.setMaximum(100)
self._slider.setValue(0)
self._slider.setTickInterval(100)
self._slider.setTickPosition(QSlider.TicksBothSides)
self._slider.valueChanged.connect(lambda: self._spinbox.setValue(self._slider.value()))
self._spinbox = QSpinBox(self)
self._spinbox.setMinimum(-100)
self._spinbox.setMaximum(100)
self._spinbox.setValue(0)
self._spinbox.valueChanged.connect(lambda: self._slider.setValue(self._spinbox.value()))
self._zero_button = make_icon_button("hand-stop-o", "Zero setpoint", self, on_clicked=self.zero)
layout = QVBoxLayout(self)
sub_layout = QHBoxLayout(self)
sub_layout.addStretch()
sub_layout.addWidget(self._slider)
sub_layout.addStretch()
layout.addLayout(sub_layout)
layout.addWidget(self._spinbox)
layout.addWidget(self._zero_button)
self.setLayout(layout)
self.setMinimumHeight(400)
def __init__(self, parent=None):
super().__init__(parent)
self.setSubTitle(self.tr("<h2>Select Menu Style</h2>"))
texts = [
self.tr("<p>Application Menu is the default for KaOS because of its \
extremely lightweight (and fast) structure.</p>"),
self.tr("<p>Application Launcher is the standard for KDE. \
Application shortcuts are arranged under a tab structure.</p>"),
self.tr("<p>Application Panel is a full screen menu style. \
Application shortcuts are arranged so that you can access them quickly and easily.</p>")
]
self.menus = [[":/data/images/menu-kicker.png", texts[0]],
[":/data/images/menu-kickoff.png", texts[1]],
[":/data/images/menu-kimpanel.png", texts[2]]]
vlayout = QVBoxLayout(self)
labelLayout = QHBoxLayout()
iconLabel = QLabel()
iconLabel.setMaximumSize(64, 64)
iconLabel.setPixmap(QIcon.fromTheme("kde").pixmap(64, 64))
labelLayout.addWidget(iconLabel)
label = QLabel(self)
label.setText(self.tr("<p>You can also customize your <strong>KDE menu</strong> as you like. \
Please choose one from the following styles.</p>"))
labelLayout.addWidget(label)
vlayout.addLayout(labelLayout)
vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))
self.comboBox = QComboBox(self)
self.comboBox.addItem(self.tr("Application Menu"))
self.comboBox.addItem(self.tr("Application Launcher"))
self.comboBox.addItem(self.tr("Application Dashboard"))
vlayout.addWidget(self.comboBox)
vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))
hlayout = QHBoxLayout(self)
self.labelMenu = QLabel(self)
self.labelMenu.setPixmap(QPixmap(self.menus[0][0]))
self.labelMenu.setMaximumSize(350 ,214)
hlayout.addWidget(self.labelMenu)
self.labelText = QLabel(self)
self.labelText.setWordWrap(True)
self.labelText.setText(self.tr(self.menus[0][1]))
hlayout.addWidget(self.labelText)
vlayout.addLayout(hlayout)
vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))
self.comboBox.currentIndexChanged.connect(self.menuSelect)
self.menuSelected = 0
def show_info_dialog( caption, parent, initial_text ):
dialog = QDialog( parent )
dialog.setWindowTitle( caption )
# Create OK and Cancel buttons in a horizontal box.
ok_button = QPushButton("OK")
ok_button.setDefault(True)
ok_button.clicked.connect(dialog.accept)
cancel_button = QPushButton("Cancel")
cancel_button.setDefault(False)
cancel_button.clicked.connect(dialog.reject)
hbox = QHBoxLayout()
hbox.addWidget(cancel_button,0)
hbox.addStretch()
hbox.addWidget(ok_button,0)
# Lay out a Plain Text Edit above the buttons.
vbox = QVBoxLayout()
pt_editor = QPlainTextEdit()
pt_editor.document().setPlainText( initial_text )
vbox.addWidget(pt_editor,1)
vbox.addLayout(hbox,0)
dialog.setLayout(vbox)
result = dialog.exec_()
if result :
return pt_editor.document().toPlainText()
else :
return None
def __init__(self):
QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("ēØåŗäø»ēŖå£")
self.file_menu = QMenu('&File', self)
self.file_menu.addAction('&Quit', self.fileQuit,
QtCore.Qt.CTRL + QtCore.Qt.Key_Q)
self.menuBar().addMenu(self.file_menu)
self.help_menu = QMenu('&Help', self)
self.menuBar().addSeparator()
self.menuBar().addMenu(self.help_menu)
self.help_menu.addAction('&About', self.about)
self.main_widget = QWidget(self)
l = QVBoxLayout(self.main_widget)
sc = MyStaticMplCanvas(self.main_widget, width=5, height=4, dpi=100)
dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4, dpi=100)
l.addWidget(sc)
l.addWidget(dc)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# ē¶ęę”ę¾ē¤ŗ2ē§
self.statusBar().showMessage("matplotlib äøå²!", 2000)
def add_to_layout(layout, *items):
"""Add items to QVBox and QHBox layouts easily.
Keyword arguments:
layout -- a layout oject (QVBoxLayout or QHBoxLayout) or a string
if "v" or "h" create a QVBox or QHBox respectively
*items -- list with items to be added
"""
if isinstance(layout, str):
if layout == "v":
layout = QVBoxLayout()
elif layout == "h":
layout = QHBoxLayout()
else:
raise TypeError("Invalid layout!")
for item in items:
if isinstance(item, QWidget):
layout.addWidget(item)
elif isinstance(item, QLayout):
layout.addLayout(item)
elif isinstance(item, QSpacerItem):
layout.addItem(item)
elif item is None:
layout.addStretch()
else:
raise TypeError("Argument of wrong type!")
return layout
def createTreeView(self):
dockWidget = QDockWidget()
dockWidget.setAllowedAreas(Qt.LeftDockWidgetArea)
dockWidget.setFeatures(QDockWidget.NoDockWidgetFeatures)
dockWidget.setTitleBarWidget(QWidget())
self.treeView = QTreeView()
self.treeView.clicked.connect(self.treeItemClicked)
self.treeModel = TreeModel()
self.treeView.setModel(self.treeModel)
self.logo = QLabel()
logoPixmap = QPixmap(CMAKE_INSTALL_PREFIX + '/share/jderobot/resources/jderobot.png')
self.logo.setPixmap(logoPixmap)
self.upButton = QPushButton()
self.upButton.setText('Up')
self.upButton.clicked.connect(self.upButtonClicked)
leftContainer = QWidget()
leftLayout = QVBoxLayout()
leftLayout.addWidget(self.treeView)
leftLayout.addWidget(self.upButton)
leftLayout.addWidget(self.logo)
leftContainer.setLayout(leftLayout)
dockWidget.setWidget(leftContainer)
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
def __init__(self, opPixelClassification, parent):
super( QDialog, self ).__init__(parent=parent)
self._op = opPixelClassification
classifier_listwidget = QListWidget(parent=self)
classifier_listwidget.setSelectionMode( QListWidget.SingleSelection )
classifier_factories = self._get_available_classifier_factories()
for name, classifier_factory in list(classifier_factories.items()):
item = QListWidgetItem( name )
item.setData( Qt.UserRole, classifier_factory )
classifier_listwidget.addItem(item)
buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
layout = QVBoxLayout()
layout.addWidget( classifier_listwidget )
layout.addWidget( buttonbox )
self.setLayout(layout)
self.setWindowTitle( "Select Classifier Type" )
# Save members
self._classifier_listwidget = classifier_listwidget
def __init__(self, parent=None):
super(ResultHandler, self).__init__()
self.setWindowTitle('Dash results')
self.control_label = QLabel()
self.rendered_label = QLabel()
self.diff_label = QLabel()
self.mask_label = QLabel()
self.new_mask_label = QLabel()
self.scrollArea = QScrollArea()
self.widget = QWidget()
self.test_name_label = QLabel()
grid = QGridLayout()
grid.addWidget(self.test_name_label, 0, 0)
grid.addWidget(QLabel('Control'), 1, 0)
grid.addWidget(QLabel('Rendered'), 1, 1)
grid.addWidget(QLabel('Difference'), 1, 2)
grid.addWidget(self.control_label, 2, 0)
grid.addWidget(self.rendered_label, 2, 1)
grid.addWidget(self.diff_label, 2, 2)
grid.addWidget(QLabel('Current Mask'), 3, 0)
grid.addWidget(QLabel('New Mask'), 3, 1)
grid.addWidget(self.mask_label, 4, 0)
grid.addWidget(self.new_mask_label, 4, 1)
self.widget.setLayout(grid)
self.scrollArea.setWidget(self.widget)
v_layout = QVBoxLayout()
v_layout.addWidget(self.scrollArea, 1)
next_image_button = QPushButton()
next_image_button.setText('Skip')
next_image_button.pressed.connect(self.load_next)
self.overload_spin = QDoubleSpinBox()
self.overload_spin.setMinimum(1)
self.overload_spin.setMaximum(255)
self.overload_spin.setValue(1)
self.overload_spin.valueChanged.connect(lambda: save_mask_button.setEnabled(False))
preview_mask_button = QPushButton()
preview_mask_button.setText('Preview New Mask')
preview_mask_button.pressed.connect(self.preview_mask)
preview_mask_button.pressed.connect(lambda: save_mask_button.setEnabled(True))
save_mask_button = QPushButton()
save_mask_button.setText('Save New Mask')
save_mask_button.pressed.connect(self.save_mask)
button_layout = QHBoxLayout()
button_layout.addWidget(next_image_button)
button_layout.addWidget(QLabel('Mask diff multiplier:'))
button_layout.addWidget(self.overload_spin)
button_layout.addWidget(preview_mask_button)
button_layout.addWidget(save_mask_button)
button_layout.addStretch()
v_layout.addLayout(button_layout)
self.setLayout(v_layout)
class dailyTab(QWidget):
def __init__(self):
super().__init__()
# ŠŠøŠ“Š¶ŠµŃ Š“Š»Ń Š“ŠµŠ¹Š»ŠŗŠ¾Š²
# Š”Š¾Š“ŠµŃŠ¶ŠøŃ ŃŠ¾Š“ŠµŃŠ¶ŠøŃ Š³Š»Š°Š²Š½ŃŠ¹ ŃŠ°Š± Š²ŠøŠ“Š¶ŠµŃ Š“Š»Ń Š“ŠµŠ¹Š»ŠøŠŗŠ¾Š²
self.tab = QTabWidget()
self.vbox = QVBoxLayout()
self.vbox.addWidget(self.tab)
self.setLayout(self.vbox)
self.threads = []
# ŠŃŠø ŠøŠ½ŠøŃŠµ ŃŠ¾Š·Š“Š°ŃŠ¼ ŃŃŠµŠ“ Š“Š»Ń ŠæŠ¾Š»ŃŃŠµŠ½ŠøŃ Š“ŠµŠ¹Š»ŠøŠŗŠ¾Š²
self.loadDataThread = loadDataThread(r'https://api.guildwars2.com/v2/achievements/daily')
self.loadDataThread.signal.connect(self.getEvent, Qt.QueuedConnection)
self.loadDataThread.start()
def getEvent(self, signal):
signal = json.loads(signal)
for metaEvent in signal.keys():
setattr(self,metaEvent,frame())
self.tab.addTab(getattr(self,metaEvent),metaEvent)
for event in signal[metaEvent]:
if (event['level']['max'] == 80 and metaEvent == 'pve') or metaEvent != 'pve':
getattr(self,metaEvent).getEvent(event)
def addTab(self, event, metaEvent):
getattr(self,'{}Tab'.format(metaEvent)).addEvent(event)
self.resize(self.grid.sizeHint())
class frame(QWidget):
def __init__(self):
super().__init__()
self.vbox = QVBoxLayout()
self.setLayout(self.vbox)
self.threads = []
def getEvent(self, event):
self.threads.append(loadDataThread(r'https://api.guildwars2.com/v2/achievements?id='+str(event['id'])))
self.threads[-1].signal.connect(self.addEvent, Qt.QueuedConnection)
self.threads[-1].start()
def addEvent(self, signal):
signal = json.loads(signal)
print(type(signal))
setattr(self,str(signal['id']),label(signal))
getattr(self,str(signal['id'])).setText(signal['name'])
getattr(self, str(signal['id'])).signal.connect(self.setEventWindow)
self.vbox.addWidget(getattr(self,str(signal['id'])))
# self.resize(self.grid.sizeHint())
def setEventWindow(self, event):
self.eventWindow = eventWindow(event)
self.eventWindow.show()
def __init__(self, parent, cli_iface, iface_name):
super(ControlPanelWindow, self).__init__(parent)
self.setWindowTitle('SLCAN Adapter Control Panel')
self.setAttribute(Qt.WA_DeleteOnClose) # This is required to stop background timers!
self._cli_iface = cli_iface
self._iface_name = iface_name
self._state_widget = StateWidget(self, self._cli_iface)
self._config_widget = ConfigWidget(self, self._cli_iface)
self._cli_widget = CLIWidget(self, self._cli_iface)
self._tab_widget = QTabWidget(self)
self._tab_widget.addTab(self._state_widget, get_icon('dashboard'), 'Adapter State')
self._tab_widget.addTab(self._config_widget, get_icon('wrench'), 'Configuration')
self._tab_widget.addTab(self._cli_widget, get_icon('terminal'), 'Command Line')
self._status_bar = QStatusBar(self)
self._status_bar.setSizeGripEnabled(False)
iface_name_label = QLabel(iface_name.split('/')[-1], self)
iface_name_label.setFont(get_monospace_font())
layout = QVBoxLayout(self)
layout.addWidget(iface_name_label)
layout.addWidget(self._tab_widget)
layout.addWidget(self._status_bar)
left, top, right, bottom = layout.getContentsMargins()
bottom = 0
layout.setContentsMargins(left, top, right, bottom)
self.setLayout(layout)
self.resize(400, 400)
def initMainUi(self):
role_names = self.parentApplet.dataSelectionApplet.topLevelOperator.DatasetRoles.value
self.list_widgets = []
# Create a tab for each role
for role_index, role_name in enumerate(role_names):
select_button = QPushButton("Select " + role_name + " Files...",
clicked=partial(self.select_files, role_index) )
clear_button = QPushButton("Clear " + role_name + " Files",
clicked=partial(self.clear_files, role_index) )
button_layout = QHBoxLayout()
button_layout.addWidget(select_button)
button_layout.addSpacerItem( QSpacerItem(0,0,hPolicy=QSizePolicy.Expanding) )
button_layout.addWidget(clear_button)
button_layout.setContentsMargins(0, 0, 0, 0)
button_layout_widget = QWidget()
button_layout_widget.setLayout(button_layout)
button_layout_widget.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum) )
list_widget = QListWidget(parent=self)
list_widget.setSizePolicy( QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) )
self.list_widgets.append( list_widget )
tab_layout = QVBoxLayout()
tab_layout.setContentsMargins(0, 0, 0, 0)
tab_layout.addWidget( button_layout_widget )
tab_layout.addWidget( list_widget )
layout_widget = QWidget(parent=self)
layout_widget.setLayout(tab_layout)
self.addTab(layout_widget, role_name)
def main(args):
app = QApplication([])
main_frame = QFrame()
layout = QVBoxLayout(main_frame)
number_edit = PyQtExtras.NumberEdit()
number_edit.set_value(10)
print "Current value of 1 is: " + str(number_edit.get_value())
number_edit2 = PyQtExtras.NumberEdit(max_length=2)
number_edit2.set_value(2)
print "Current value of 2 is: " + str(number_edit2.get_value())
number_edit2.set_value(20)
print "Current value of 2 is: " + str(number_edit2.get_value())
number_edit3 = PyQtExtras.NumberEdit(max_length=1)
number_edit3.set_value(2)
print "Current value of 3 is: " + str(number_edit3.get_value())
number_edit3.set_value(50)
print "Current values of 3 is: " + str(number_edit3.get_value())
number_edit3.set_value(25)
print "Current value of 3 is: " + str(number_edit3.get_value())
number_edit3.set_value("text")
print "Current value of 3 is: " + str(number_edit3.get_value())
layout.addWidget(number_edit)
layout.addWidget(number_edit2)
layout.addWidget(number_edit3)
main_frame.show()
app.exec_()
def __init__(self, page, parent=None):
super(HelpForm, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowModality(Qt.WindowModal)
# actions
backAction = QAction(QIcon(":/back.png"), "&Back", self)
backAction.setShortcut(QKeySequence.Back)
homeAction = QAction(QIcon(":/home.png"), "&Home", self)
homeAction.setShortcut("Home")
self.pageLabel = QLabel()
#toolbar
toolBar = QToolBar()
toolBar.addAction(backAction)
toolBar.addAction(homeAction)
toolBar.addWidget(self.pageLabel)
self.textBrowser = QTextBrowser()
# layout
layout = QVBoxLayout()
layout.addWidget(toolBar)
layout.addWidget(self.textBrowser, 1)
self.setLayout(layout)
# signals and slots
backAction.triggered.connect(self.textBrowser.backward)
homeAction.triggered.connect(self.textBrowser.home)
self.textBrowser.sourceChanged.connect(self.updatePageTitle)
self.textBrowser.setSearchPaths([":/help"])
self.textBrowser.setSource(QUrl(page))
self.resize(400, 600)
self.setWindowTitle("{0} Help".format(
QApplication.applicationName()))
class LP_PlaylistsPanel(FFrame):
def __init__(self, app, parent=None):
super().__init__(parent)
self._app = app
self.header = LP_GroupHeader(self._app, 'ęå')
self._layout = QVBoxLayout(self)
self.setObjectName('lp_playlists_panel')
self.set_theme_style()
self.setup_ui()
def set_theme_style(self):
theme = self._app.theme_manager.current_theme
style_str = '''
#{0} {{
background: transparent;
}}
'''.format(self.objectName(),
theme.color5.name())
self.setStyleSheet(style_str)
def add_item(self, item):
self._layout.addWidget(item)
def setup_ui(self):
self._layout.setContentsMargins(0, 0, 0, 0)
self._layout.setSpacing(0)
self._layout.addWidget(self.header)
class LeftPanel(FFrame):
def __init__(self, app, parent=None):
super().__init__(parent)
self._app = app
self.library_panel = LP_LibraryPanel(self._app)
self.playlists_panel = LP_PlaylistsPanel(self._app)
self._layout = QVBoxLayout(self)
self.setLayout(self._layout)
self.setObjectName('c_left_panel')
self.set_theme_style()
self.setup_ui()
def set_theme_style(self):
theme = self._app.theme_manager.current_theme
style_str = '''
#{0} {{
background: transparent;
}}
'''.format(self.objectName(),
theme.color5.name())
self.setStyleSheet(style_str)
def setup_ui(self):
self._layout.setContentsMargins(0, 0, 0, 0)
self._layout.setSpacing(0)
self._layout.addWidget(self.library_panel)
self._layout.addWidget(self.playlists_panel)
self._layout.addStretch(1)
def _createPlotWidget(self):
self._plotWidget = QWidget()
self._plotFigure = Figure()
self._plotCanvas = FigureCanvas(self._plotFigure)
self._plotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._plotCanvas.updateGeometry()
self._plotCanvas.setParent(self._plotWidget)
self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
self._plotFigure.set_canvas(self._plotCanvas)
# Vm and command voltage go in the same subplot
self._vm_axes = self._plotFigure.add_subplot(2,2,1, title='Membrane potential')
self._vm_axes.set_ylim(-20.0, 120.0)
# Channel conductances go to the same subplot
self._g_axes = self._plotFigure.add_subplot(2,2,2, title='Channel conductance')
self._g_axes.set_ylim(0.0, 0.5)
# Injection current for Vclamp/Iclamp go to the same subplot
self._im_axes = self._plotFigure.add_subplot(2,2,3, title='Injection current')
self._im_axes.set_ylim(-0.5, 0.5)
# Channel currents go to the same subplot
self._i_axes = self._plotFigure.add_subplot(2,2,4, title='Channel current')
self._i_axes.set_ylim(-10, 10)
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
layout = QVBoxLayout()
layout.addWidget(self._plotCanvas)
self._plotNavigator = NavigationToolbar(self._plotCanvas, self._plotWidget)
layout.addWidget(self._plotNavigator)
self._plotWidget.setLayout(layout)
def init(self):
vbox = QVBoxLayout()
self.setLayout(vbox)
text = QLineEdit('0.')
text.setReadOnly(True)
vbox.addWidget(text)
grid = QGridLayout()
vbox.addLayout(grid)
names = ['Exit', 'AC', 'DEL', '+/-',
'7', '8', '9', '/',
'4', '5', '6', '*',
'1', '2', '3', '-',
'0', '.', '=', '+']
positions = [(i, j) for i in range(5) for j in range(4)]
for position, name in zip(positions, names):
btn = QPushButton(name)
grid.addWidget(btn, *position)
self.move(300, 200)
self.setWindowTitle('Calculator')
self.show()
class ScrollAreaWidget(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.parent = parent
#Container Widget
widget = QWidget()
#Layout of Container Widget
self.layout = QVBoxLayout(self)
widget.setLayout(self.layout)
#Scroll Area Properties
self.scroll = QScrollArea()
self.scroll.setWidgetResizable(False)
self.scroll.setWidget(widget)
#Scroll Area Layer add
scroll_layout = QVBoxLayout(self)
scroll_layout.addWidget(self.scroll)
self.setLayout(scroll_layout)
def add_widget_item(self, widget_item):
self.layout.addWidget(widget_item)
widget_item.show()
widget = QWidget()
widget.setLayout(self.layout)
self.scroll.setWidget(widget)
def __init__(self, parent):
super(CharacterDialog, self).__init__(parent)
self.setWindowTitle(_("KeepKey Seed Recovery"))
self.character_pos = 0
self.word_pos = 0
self.loop = QEventLoop()
self.word_help = QLabel()
self.char_buttons = []
vbox = QVBoxLayout(self)
vbox.addWidget(WWLabel(CHARACTER_RECOVERY))
hbox = QHBoxLayout()
hbox.addWidget(self.word_help)
for i in range(4):
char_button = CharacterButton('*')
char_button.setMaximumWidth(36)
self.char_buttons.append(char_button)
hbox.addWidget(char_button)
self.accept_button = CharacterButton(_("Accept Word"))
self.accept_button.clicked.connect(partial(self.process_key, 32))
self.rejected.connect(partial(self.loop.exit, 1))
hbox.addWidget(self.accept_button)
hbox.addStretch(1)
vbox.addLayout(hbox)
self.finished_button = QPushButton(_("Seed Entered"))
self.cancel_button = QPushButton(_("Cancel"))
self.finished_button.clicked.connect(partial(self.process_key,
Qt.Key_Return))
self.cancel_button.clicked.connect(self.rejected)
buttons = Buttons(self.finished_button, self.cancel_button)
vbox.addSpacing(40)
vbox.addLayout(buttons)
self.refresh()
self.show()
def message_dialog(self, msg):
self.clear_dialog()
self.dialog = dialog = WindowModalDialog(self.top_level_window(), _("Coldcard Status"))
l = QLabel(msg)
vbox = QVBoxLayout(dialog)
vbox.addWidget(l)
dialog.show()
class Bool(SimpleBlackbox):
author = "DrLuke"
name = "Bool"
modulename = "drluke.builtin.bool"
Category = ["Builtin"]
placeable = True
implementation = BoolImplementation
def __init__(self, *args, **kwargs):
super(Bool, self).__init__(*args, **kwargs)
self.propertiesWidget = QWidget()
self.vlayout = QVBoxLayout()
self.toggle = QCheckBox("Output")
self.toggle.toggled.connect(self.toggleTrueFalse)
self.vlayout.addWidget(self.toggle)
self.vlayout.addItem(QSpacerItem(40, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
self.propertiesWidget.setLayout(self.vlayout)
def toggleTrueFalse(self, bool):
self.sendDataToImplementations(bool)
def getPropertiesWidget(self):
return self.propertiesWidget
def defineIO(self):
self.addOutput(bool, "boolout", "Bool out")
def __init__(self, parent=None):
super(ToolOffsetDialog, self).__init__(parent)
self._color = QColor(0, 0, 0, 150)
self._state = False
self.setWindowModality(Qt.ApplicationModal)
self.setWindowFlags(self.windowFlags() | Qt.Tool |
Qt.Dialog |
Qt.WindowStaysOnTopHint | Qt.WindowSystemMenuHint)
self.setMinimumSize(200, 200)
buttonBox = QDialogButtonBox()
buttonBox.setEnabled(False)
STATUS.connect('not-all-homed', lambda w, axis: buttonBox.setEnabled(False))
STATUS.connect('all-homed', lambda w: buttonBox.setEnabled(True))
STATUS.connect('state-estop', lambda w: buttonBox.setEnabled(False))
STATUS.connect('state-estop-reset', lambda w: buttonBox.setEnabled(STATUS.machine_is_on()
and STATUS.is_all_homed()))
for i in('X', 'Y', 'Z'):
b = 'button_%s' % i
self[b] = QPushButton('Zero %s' % i)
self[b].clicked.connect(self.zeroPress('%s' % i))
buttonBox.addButton(self[b], 3)
v = QVBoxLayout()
h = QHBoxLayout()
self._o = TOOLVIEW_WIDGET()
self._o._hal_init()
self.setLayout(v)
v.addWidget(self._o)
b = QPushButton('OK')
b.clicked.connect(lambda: self.close())
h.addWidget(b)
h.addWidget(buttonBox)
v.addLayout(h)
self.setModal(True)
def widgetImage(self):
"""Create main image display.
"""
imageArea = QHBoxLayout()
scroll = QScrollArea()
scroll.setAlignment(QtCore.Qt.AlignCenter)
self.imageLabel = QLabel(self)
scroll.setWidget(self.imageLabel)
next = QPushButton(self.tr('>'))
next.clicked.connect(self.nextCluster)
prev = QPushButton(self.tr('<'))
prev.clicked.connect(self.prevCluster)
imageArea.addWidget(prev)
imageArea.addWidget(scroll)
imageArea.addWidget(next)
vbox = QVBoxLayout()
self.clusterCountLabel = QLabel(self)
self.clusterCountLabel.setAlignment(QtCore.Qt.AlignCenter)
f = QtGui.QFont('Arial', 14, QtGui.QFont.Bold);
self.clusterCountLabel.setFont(f)
vbox.addWidget(self.clusterCountLabel)
vbox.addLayout(imageArea)
return vbox
def initUI(self):
self.setWindowTitle('Twitter Client')
self.setWindowIcon(QIcon("twitter.svg"))
QIcon.setThemeName("Adwaita")
lay = QVBoxLayout(self)
scr = QScrollArea(self)
scr.setWidgetResizable(True)
scr.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
lay2 = QVBoxLayout()
self.setLayout(lay)
placehold = QWidget()
lay.addWidget(scr)
scr.setWidget(placehold)
placehold.setLayout(lay2)
self.lay = lay2
lay2.setSpacing(0)
lay.setSpacing(0)
lay.setContentsMargins(0, 0, 0, 0)
but = QPushButton("Refresh")
lay.addWidget(but)
but.pressed.connect(self.fetch_tweets)
self.show()
def __init__(self):
super(Dialog, self).__init__()
self.createMenu()
self.widget_register_url()
self.widget_download()
self.thread_download = threading.Thread( group=None, target=self.run_downloader, name=None, args=(), kwargs={}, daemon=True )
self.running = False
bigEditor = QTextEdit()
bigEditor.setPlainText("This widget takes up all the remaining space "
"in the top-level layout.")
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
mainLayout = QVBoxLayout()
mainLayout.setMenuBar(self.menuBar)
mainLayout.addWidget(self.form_register_url)
mainLayout.addWidget(self.form_download_urls)
self.setLayout(mainLayout)
self.setWindowTitle("Bamboodl")
def __init__(self, parent=None):
super(LocatorWidget, self).__init__(
parent, Qt.Dialog | Qt.FramelessWindowHint)
self._parent = parent
self.setModal(True)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setStyleSheet("background:transparent;")
self.setFixedHeight(400)
self.setFixedWidth(500)
view = QQuickWidget()
view.rootContext().setContextProperty("theme", resources.QML_COLORS)
view.setResizeMode(QQuickWidget.SizeRootObjectToView)
view.setSource(ui_tools.get_qml_resource("Locator.qml"))
self._root = view.rootObject()
vbox = QVBoxLayout(self)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(view)
self.locate_symbols = locator.LocateSymbolsThread()
self.locate_symbols.finished.connect(self._cleanup)
# FIXME: invalid signal
# self.locate_symbols.terminated.connect(self._cleanup)
# Hide locator with Escape key
shortEscMisc = QShortcut(QKeySequence(Qt.Key_Escape), self)
shortEscMisc.activated.connect(self.hide)
# Locator things
self.filterPrefix = re.compile(r'(@|<|>|-|!|\.|/|:)')
self.page_items_step = 10
self._colors = {
"@": "#5dade2",
"<": "#4becc9",
">": "#ff555a",
"-": "#66ff99",
".": "#a591c6",
"/": "#f9d170",
":": "#18ffd6",
"!": "#ff884d"}
self._filters_list = [
("@", "Filename"),
("<", "Class"),
(">", "Function"),
("-", "Attribute"),
(".", "Current"),
("/", "Opened"),
(":", "Line"),
("!", "NoPython")
]
self._replace_symbol_type = {"<": "<", ">": ">"}
self.reset_values()
self._filter_actions = {
'.': self._filter_this_file,
'/': self._filter_tabs,
':': self._filter_lines
}
self._root.textChanged['QString'].connect(self.set_prefix)
self._root.open['QString', int].connect(self._open_item)
self._root.fetchMore.connect(self._fetch_more)
class LayerListDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
# add a button box
self.layout = QVBoxLayout()
self.layer_list = LayerListWidget(self)
self.button_box = QDialogButtonBox(self)
self.button_box.setOrientation(Qt.Horizontal)
self.button_box.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
self.layout.addWidget(self.layer_list)
self.layout.addWidget(self.button_box)
self.setLayout(self.layout)
def set_labeling_model(self, model):
self.layer_list.set_model(model)
def exec_(self):
self.layer_list.update_from_layers()
return QDialog.exec_(self)
def accept(self):
# update layers
self.layer_list.update_labeling_from_list()
QDialog.accept(self)
def __init__(self, *args):
super().__init__(BrickletAnalogIn, *args)
self.ai = self.device
# the firmware version of a EEPROM Bricklet can (under common circumstances)
# not change during the lifetime of an EEPROM Bricklet plugin. therefore,
# it's okay to make final decisions based on it here
self.has_range = self.firmware_version >= (2, 0, 1)
self.has_averaging = self.firmware_version >= (2, 0, 3)
self.cbe_voltage = CallbackEmulator(self.ai.get_voltage,
None,
self.cb_voltage,
self.increase_error_count)
self.current_voltage = CurveValueWrapper() # float, V
plots = [('Voltage', Qt.red, self.current_voltage, format_voltage)]
self.plot_widget = PlotWidget('Voltage [V]', plots, y_resolution=0.001)
layout = QVBoxLayout(self)
layout.addWidget(self.plot_widget)
if self.has_range:
self.combo_range = QComboBox()
self.combo_range.addItem('Automatic', BrickletAnalogIn.RANGE_AUTOMATIC)
if self.has_averaging:
self.combo_range.addItem('0 - 3.30 V', BrickletAnalogIn.RANGE_UP_TO_3V)
self.combo_range.addItem('0 - 6.05 V', BrickletAnalogIn.RANGE_UP_TO_6V)
self.combo_range.addItem('0 - 10.32 V', BrickletAnalogIn.RANGE_UP_TO_10V)
self.combo_range.addItem('0 - 36.30 V', BrickletAnalogIn.RANGE_UP_TO_36V)
self.combo_range.addItem('0 - 45.00 V', BrickletAnalogIn.RANGE_UP_TO_45V)
self.combo_range.currentIndexChanged.connect(self.range_changed)
hlayout = QHBoxLayout()
hlayout.addWidget(QLabel('Range:'))
hlayout.addWidget(self.combo_range)
hlayout.addStretch()
if self.has_averaging:
self.spin_average = QSpinBox()
self.spin_average.setMinimum(0)
self.spin_average.setMaximum(255)
self.spin_average.setSingleStep(1)
self.spin_average.setValue(50)
self.spin_average.editingFinished.connect(self.spin_average_finished)
hlayout.addWidget(QLabel('Average Length:'))
hlayout.addWidget(self.spin_average)
line = QFrame()
line.setObjectName("line")
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout.addWidget(line)
layout.addLayout(hlayout)
class PreferencesDialog(QDialog):
fft_check_signal = pyqtSignal()
fft_check_result = 0
def __init__(self, preferences):
super(PreferencesDialog, self).__init__()
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle
self.title = 'Additional Preferences | ' + __appname__ + 'v' + __version__
self.setWindowTitle(self.title)
self.resize(500, 500)
self.outer_layout = QVBoxLayout()
self.outer_layout.setContentsMargins(5, 3, 5, 7)
self.outer_layout.setSpacing(10)
self.pref_widget = QWidget()
self.vlayout = QVBoxLayout()
self.vlayout.setContentsMargins(5, 3, 5, 7)
self.vlayout.setSpacing(10)
self.app_settings_gb = AppSettingsGroupBox(preferences)
self.data_settings_gb = DataSettingsGroupBox(preferences)
self.ref_proc_settings_gb = IterativeProcedureSettingsGroupBox(
preferences)
self.refine_settings_gb = SolverSettingsGroupBox(preferences)
self.global_min_settings_gb = GlobalMinSettingsGroupBox(preferences)
self.gaussian_fit_settings_gb = GaussianFittingSettingsGroupBox(
preferences)
self.vlayout.addWidget(self.app_settings_gb)
self.vlayout.addWidget(self.data_settings_gb)
self.vlayout.addWidget(self.ref_proc_settings_gb)
self.vlayout.addWidget(self.refine_settings_gb)
self.vlayout.addWidget(self.global_min_settings_gb)
self.vlayout.addWidget(self.gaussian_fit_settings_gb)
self.pref_widget.setLayout(self.vlayout)
self.scroll_area = QScrollArea()
self.scroll_area.setFrameShape(QFrame.NoFrame)
self.scroll_area.setWidget(self.pref_widget)
self.scroll_area.setWidgetResizable(True)
self.button_box = QDialogButtonBox()
self.button_box.addButton('&Cancel', QDialogButtonBox.RejectRole)
self.button_box.addButton('&Apply', QDialogButtonBox.AcceptRole)
self.hline = QFrame()
self.hline.setFrameShape(QFrame.HLine)
self.hline.setFrameShadow(QFrame.Sunken)
self.hline.setObjectName('hline')
self.outer_layout.addWidget(self.scroll_area)
self.outer_layout.addWidget(self.hline)
self.outer_layout.addWidget(self.button_box)
self.setLayout(self.outer_layout)
self.button_box.accepted.connect(self.accept_preferences)
self.button_box.rejected.connect(self.rejected)
self.rejected.connect(self.close)
def accept_preferences(self):
# Log mode
if self.app_settings_gb.log_mode_input.currentText() == 'Append':
_append_log_mode = 1
else:
_append_log_mode = 0
try:
_data_units = np.int(
self.data_settings_gb.data_units_input.currentIndex())
_window_length = np.int(
self.data_settings_gb.window_length_input.text())
_poly_order = np.int(self.data_settings_gb.poly_order_input.text())
_rescale_AL = np.int(
self.data_settings_gb.rescale_AL_input.isChecked())
_fft_N = np.int(self.data_settings_gb.fft_N_input.value())
self.fft_check = _fft_N
self.fft_check_signal.emit()
if self.fft_check_result == 1:
raise RuntimeWarning()
_mod_func_mode = np.int(
self.ref_proc_settings_gb.mod_func_mode_input.isChecked())
_op_method = self.refine_settings_gb.op_method_input.currentText()
_disp = np.int(self.refine_settings_gb.disp_check.isChecked())
_maxiter = np.int(self.refine_settings_gb.maxiter_input.text())
_ftol = np.float(self.refine_settings_gb.ftol_input.text())
# Get l_bfgs_b specific options
if _op_method == 'L-BFGS-B':
_maxfun = np.int(self.refine_settings_gb.maxfun_input.text())
_gtol = np.float(self.refine_settings_gb.gtol_input.text())
# Get globam minimisation (basin-hopping) options
_bh_disp = np.int(
self.global_min_settings_gb.disp_check.isChecked())
_bh_niter = np.int(
self.global_min_settings_gb.niter_basin_input.text())
_bh_temp = np.float(
self.global_min_settings_gb.temp_basin_input.text())
_bh_step_size = np.float(
self.global_min_settings_gb.stepsize_basin_input.text())
_bh_interval = np.int(
self.global_min_settings_gb.interval_basin_input.text())
# Get Gaussiant fitting options
_xray_weight_mode = np.int(self.gaussian_fit_settings_gb.
xray_weight_mode_input.isChecked())
# Handle for missing values
except ValueError:
_message = [
'Missing Values!', 'Please ensures all values are set properly'
]
self.error_msg = ErrorMessageBox(_message)
self.error_msg.show()
return
except RuntimeWarning:
_message = [
'\'N\' out of range!', 'Please increase N\nDefault: 12'
]
self.error_msg = ErrorMessageBox(_message)
self.error_msg.show()
return
if not _window_length % 2:
_message = [
'Error!',
'Please ensure window_length is positive odd integer!'
]
self.error_msg = ErrorMessageBox(_message)
self.error_msg.show()
return
if _poly_order >= _window_length:
_message = ['Error!', 'Please ensure poly_order < window_length!']
self.error_msg = ErrorMessageBox(_message)
self.error_msg.show()
return
# Set minimisation options dictionary
_minimisation_options = {
'disp': _disp,
'maxiter': _maxiter,
'ftol': _ftol
}
# Add additional optiosn for l_bfgs_b method
if _op_method == 'L-BFGS-B':
_minimisation_options['maxfun'] = _maxfun
_minimisation_options['gtol'] = _gtol
_global_minimisation = self.global_min_settings_gb.isChecked()
_global_min_options = {
'disp': _bh_disp,
'niter': _bh_niter,
'T': _bh_temp,
'stepsize': _bh_step_size,
'interval': _bh_interval
}
# Set preferences dictionary to return
self._preferences = {
'append_log_mode': _append_log_mode,
'data_units': _data_units,
'window_length': _window_length,
'poly_order': _poly_order,
'rescale_AL': _rescale_AL,
'fft_N': _fft_N,
'mod_func_mode': _mod_func_mode,
'op_method': _op_method,
'minimisation_options': _minimisation_options,
'global_minimisation': _global_minimisation,
'global_min_options': _global_min_options,
'xray_weight_mode': _xray_weight_mode
}
# handle for ValueError if nothing entered
self.done(1)
def get_preferences(self):
return self._preferences
def initUI(self):
backButton = QPushButton('')
backButton.setIcon(QIcon('image/back_2.png'))
backButton.setIconSize(QSize(75, 75))
backButton.clicked.connect(self.back)
tab = QTabWidget()
tab.setTabPosition(QTabWidget.South)
self.city_name = QLineEdit()
cities = QWidget()
form_cities = QFormLayout()
form_cities.setAlignment(Qt.AlignVCenter)
form_cities.addRow(QLabel('ŠŠ°Š·Š²Š°Š½ŠøŠµ Š³Š¾ŃŠ¾Š“Š°'), self.city_name)
cities.setLayout(form_cities)
tab.addTab(cities, 'ŠŠ¾ŃŠ¾Š“Š°')
btn = QPushButton('xii')
btn.clicked.connect(self.search_city)
btn_h = QHBoxLayout()
btn_h.addStretch(3)
btn_h.addWidget(backButton)
hh = QHBoxLayout()
hh.addStretch(1)
hh.addWidget(tab, 3)
hh.addStretch(1)
vv = QVBoxLayout()
vv.addLayout(btn_h)
vv.addStretch(1)
vv.addLayout(hh)
vv.addStretch(1)
vv.addWidget(btn)
self.setLayout(vv)
style = "QTabWidget {background-color: rgb(117, 160, 252); font-size: 30px;}" \
"QLabel {background-color: transparent; font-size: 20px;}" \
"QLineEdit {background-color: white; font-size: 20px; border: 1px solid transparent; margin: 0px;}"
backButton.setStyleSheet(
"background-color: rgba(255, 255, 255, 0.1); padding: 12px;")
self.setStyleSheet(style)
tab.setStyleSheet("background-color: rgb(117, 160, 252);")
p = QPalette()
gradient = QLinearGradient(0, 0, 120, 400)
gradient.setColorAt(0.0, QColor(117, 160, 252))
gradient.setColorAt(1.0, QColor(193, 203, 253))
p.setBrush(QPalette.Window, QBrush(gradient))
self.setPalette(p)
if self.expansion == '1':
self.showFullScreen()
else:
self.setGeometry(0, 30, 800, 600)
self.setFixedSize(800, 600)
self.setWindowTitle('Menubar')
self.show()
class DockContainer(QWidget):
def __init__(self, parent=None):
"""
Class constructor
:param parent: Widget
"""
super(DockContainer, self).__init__(parent=parent, flags=Qt.Widget)
self.vertical_layout = QVBoxLayout() # Create a vertical layout container
# Adding some elements
self.n_stimuli = DockElement("Number of stimuli:")
self.stimuli_duration = DockElement("Stimuli duration:")
self.fs_element = DockElement("FS:")
# Test button
self.test_button = QPushButton("Test button")
self.init_ui()
def init_ui(self) -> None:
"""
initialize ui elements
:return: None
"""
# bind action to button
self.test_button.clicked.connect(self.show_values)
# Add all widgets to the vertical_layout
self.vertical_layout.addWidget(self.n_stimuli)
self.vertical_layout.addWidget(self.stimuli_duration)
self.vertical_layout.addWidget(self.fs_element)
# Set default values
self.n_stimuli.set_text(10)
self.stimuli_duration.set_text(1.024)
self.fs_element.set_text(200)
self.vertical_layout.addWidget(self.test_button, alignment=Qt.AlignCenter)
self.vertical_layout.addStretch() # Keep widgets at the top of the vertical_layout
self.setLayout(self.vertical_layout) # Set self layout as vertical_layout
self.show() # Set self visible
def show_values(self) -> None:
"""
To be deleted
:return: None
"""
wave = AFMWave(self.c_frequency_element.get_value(), self.c_amplitude_element.get_value(), 2048)
wave.setAMFrequency(self.am_frequency_element.get_value())
wave.setAMDepth(self.am_depth_element.get_value())
wave.setFS(self.fs_element.get_value())
frq, yf = Calc.calc_fft(wave.getAMWave(), wave.getBufferSize(), wave.getFS())
fig, ax = plt.subplots(2)
ax[0].plot(frq[:wave.getBufferSize() // 2], abs(yf[:wave.getBufferSize() // 2]))
ax[1].plot(wave.getAMWave())
plt.show()
def make_page(self):
toppage = QFrame()
toplayout = QVBoxLayout()
toppage.setLayout(toplayout)
page = QFrame()
layout = QFormLayout()
page.setLayout(layout)
toplayout.addWidget(page)
self.edit_start_freq = QLineEdit()
self.edit_start_freq.setFixedWidth(350)
self.edit_start_freq.textChanged.connect(self.onChange)
self.edit_end_freq = QLineEdit()
self.edit_end_freq.setFixedWidth(350)
self.edit_end_freq.textChanged.connect(self.onChange)
self.edit_duration = QLineEdit()
self.edit_duration.setFixedWidth(350)
self.edit_duration.textChanged.connect(self.onChange)
self.edit_ampl = QLineEdit()
self.edit_ampl.setFixedWidth(350)
self.edit_ampl.textChanged.connect(self.onChange)
self.edit_inject = QComboBoxNoWheel()
self.edit_inject.setFixedWidth(350)
self.edit_inject.addItem('aileron')
self.edit_inject.addItem('elevator')
self.edit_inject.addItem('rudder')
self.edit_inject.addItem('flaps')
self.edit_inject.addItem('throttle')
self.edit_inject.currentIndexChanged.connect(self.onChange)
layout.addRow("<b>Start Freqency (hz):</b>", self.edit_start_freq)
layout.addRow("<b>End Freqency (hz):</b>", self.edit_end_freq)
layout.addRow("<b>Duration (sec):</b>", self.edit_duration)
layout.addRow("<b>Amplitude (deg):</b>", self.edit_ampl)
layout.addRow("<b>Injection Point:</b>", self.edit_inject)
# 'Parameter' button bar
param_group = QFrame()
toplayout.addWidget(param_group)
param_layout = QHBoxLayout()
param_group.setLayout(param_layout)
param_layout.addWidget(QLabel("<b>Chirp Parameters:</b> "))
update = QPushButton('Update')
update.clicked.connect(self.update)
param_layout.addWidget(update)
revert = QPushButton('Revert')
revert.clicked.connect(self.revert)
param_layout.addWidget(revert)
param_layout.addStretch(1)
# 'Command' button bar
cmd_group = QFrame()
toplayout.addWidget(cmd_group)
cmd_layout = QHBoxLayout()
cmd_group.setLayout(cmd_layout)
cmd_layout.addWidget(
QLabel(
"<b>Task Commands: (set params, then engage with physical switch)</b> "
))
# circle = QPushButton('Circle Here')
# circle.clicked.connect(self.task_circle)
# cmd_layout.addWidget(circle)
# home = QPushButton('Go Home (and Circle)')
# home.clicked.connect(self.task_home)
# cmd_layout.addWidget(home)
# resume = QPushButton('Resume Route')
# resume.clicked.connect(self.task_resume)
# cmd_layout.addWidget(resume)
cmd_layout.addStretch(1)
toplayout.addStretch(1)
# set initial values
self.revert()
return toppage
def add_tx_stats(self, vbox):
hbox_stats = QHBoxLayout()
# left column
vbox_left = QVBoxLayout()
self.tx_desc = TxDetailLabel(word_wrap=True)
vbox_left.addWidget(self.tx_desc)
self.status_label = TxDetailLabel()
vbox_left.addWidget(self.status_label)
self.date_label = TxDetailLabel()
vbox_left.addWidget(self.date_label)
self.amount_label = TxDetailLabel()
vbox_left.addWidget(self.amount_label)
self.ln_amount_label = TxDetailLabel()
vbox_left.addWidget(self.ln_amount_label)
fee_hbox = QHBoxLayout()
self.fee_label = TxDetailLabel()
fee_hbox.addWidget(self.fee_label)
self.fee_warning_icon = QLabel()
pixmap = QPixmap(icon_path("warning"))
pixmap_size = round(2 * char_width_in_lineedit())
pixmap = pixmap.scaled(pixmap_size, pixmap_size, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.fee_warning_icon.setPixmap(pixmap)
self.fee_warning_icon.setVisible(False)
fee_hbox.addWidget(self.fee_warning_icon)
fee_hbox.addStretch(1)
vbox_left.addLayout(fee_hbox)
vbox_left.addStretch(1)
hbox_stats.addLayout(vbox_left, 50)
# vertical line separator
line_separator = QFrame()
line_separator.setFrameShape(QFrame.VLine)
line_separator.setFrameShadow(QFrame.Sunken)
line_separator.setLineWidth(1)
hbox_stats.addWidget(line_separator)
# right column
vbox_right = QVBoxLayout()
self.size_label = TxDetailLabel()
vbox_right.addWidget(self.size_label)
self.rbf_label = TxDetailLabel()
vbox_right.addWidget(self.rbf_label)
self.rbf_cb = QCheckBox(_('Replace by fee'))
self.rbf_cb.setChecked(bool(self.config.get('use_rbf', True)))
vbox_right.addWidget(self.rbf_cb)
self.locktime_final_label = TxDetailLabel()
vbox_right.addWidget(self.locktime_final_label)
locktime_setter_hbox = QHBoxLayout()
locktime_setter_hbox.setContentsMargins(0, 0, 0, 0)
locktime_setter_hbox.setSpacing(0)
locktime_setter_label = TxDetailLabel()
locktime_setter_label.setText("LockTime: ")
self.locktime_e = LockTimeEdit(self)
locktime_setter_hbox.addWidget(locktime_setter_label)
locktime_setter_hbox.addWidget(self.locktime_e)
locktime_setter_hbox.addStretch(1)
self.locktime_setter_widget = QWidget()
self.locktime_setter_widget.setLayout(locktime_setter_hbox)
vbox_right.addWidget(self.locktime_setter_widget)
self.block_height_label = TxDetailLabel()
vbox_right.addWidget(self.block_height_label)
vbox_right.addStretch(1)
hbox_stats.addLayout(vbox_right, 50)
vbox.addLayout(hbox_stats)
# below columns
self.block_hash_label = TxDetailLabel(word_wrap=True)
vbox.addWidget(self.block_hash_label)
# set visibility after parenting can be determined by Qt
self.rbf_label.setVisible(self.finalized)
self.rbf_cb.setVisible(not self.finalized)
self.locktime_final_label.setVisible(self.finalized)
self.locktime_setter_widget.setVisible(not self.finalized)
def __init__(self,
*,
parent: 'ElectrumWindow',
desc,
prompt_if_unsaved,
finalized: bool,
external_keypairs=None):
'''Transactions in the wallet will show their description.
Pass desc to give a description for txs not yet in the wallet.
'''
# We want to be a top-level window
QDialog.__init__(self, parent=None)
self.tx = None # type: Optional[Transaction]
self.external_keypairs = external_keypairs
self.finalized = finalized
self.main_window = parent
self.config = parent.config
self.wallet = parent.wallet
self.prompt_if_unsaved = prompt_if_unsaved
self.saved = False
self.desc = desc
self.setMinimumWidth(640)
self.resize(1200, 600)
self.set_title()
self.psbt_only_widgets = [] # type: List[QWidget]
vbox = QVBoxLayout()
self.setLayout(vbox)
vbox.addWidget(QLabel(_("Transaction ID:")))
self.tx_hash_e = ButtonsLineEdit()
self.tx_hash_e.add_qr_show_button(config=self.config,
title='Transaction ID')
self.tx_hash_e.setReadOnly(True)
vbox.addWidget(self.tx_hash_e)
self.add_tx_stats(vbox)
vbox.addSpacing(10)
self.inputs_header = QLabel()
vbox.addWidget(self.inputs_header)
self.inputs_textedit = QTextEditWithDefaultSize()
vbox.addWidget(self.inputs_textedit)
self.txo_color_recv = TxOutputColoring(
legend=_("Receiving Address"),
color=ColorScheme.GREEN,
tooltip=_("Wallet receive address"))
self.txo_color_change = TxOutputColoring(
legend=_("Change Address"),
color=ColorScheme.YELLOW,
tooltip=_("Wallet change address"))
self.txo_color_2fa = TxOutputColoring(
legend=_("TrustedCoin (2FA) batch fee"),
color=ColorScheme.BLUE,
tooltip=_(
"TrustedCoin (2FA) fee for the next batch of transactions"))
outheader_hbox = QHBoxLayout()
outheader_hbox.setContentsMargins(0, 0, 0, 0)
vbox.addLayout(outheader_hbox)
self.outputs_header = QLabel()
outheader_hbox.addWidget(self.outputs_header)
outheader_hbox.addStretch(2)
outheader_hbox.addWidget(self.txo_color_recv.legend_label)
outheader_hbox.addWidget(self.txo_color_change.legend_label)
outheader_hbox.addWidget(self.txo_color_2fa.legend_label)
self.outputs_textedit = QTextEditWithDefaultSize()
vbox.addWidget(self.outputs_textedit)
self.sign_button = b = QPushButton(_("Sign"))
b.clicked.connect(self.sign)
self.broadcast_button = b = QPushButton(_("Broadcast"))
b.clicked.connect(self.do_broadcast)
self.save_button = b = QPushButton(_("Save"))
b.clicked.connect(self.save)
self.cancel_button = b = QPushButton(_("Close"))
b.clicked.connect(self.close)
b.setDefault(True)
self.export_actions_menu = export_actions_menu = QMenu()
self.add_export_actions_to_menu(export_actions_menu)
export_actions_menu.addSeparator()
export_submenu = export_actions_menu.addMenu(
_("For CoinJoin; strip privates"))
self.add_export_actions_to_menu(export_submenu,
gettx=self._gettx_for_coinjoin)
self.psbt_only_widgets.append(export_submenu)
export_submenu = export_actions_menu.addMenu(
_("For hardware device; include xpubs"))
self.add_export_actions_to_menu(export_submenu,
gettx=self._gettx_for_hardware_device)
self.psbt_only_widgets.append(export_submenu)
self.export_actions_button = QToolButton()
self.export_actions_button.setText(_("Export"))
self.export_actions_button.setMenu(export_actions_menu)
self.export_actions_button.setPopupMode(QToolButton.InstantPopup)
self.finalize_button = QPushButton(_('Finalize'))
self.finalize_button.clicked.connect(self.on_finalize)
partial_tx_actions_menu = QMenu()
ptx_merge_sigs_action = QAction(_("Merge signatures from"), self)
ptx_merge_sigs_action.triggered.connect(self.merge_sigs)
partial_tx_actions_menu.addAction(ptx_merge_sigs_action)
self._ptx_join_txs_action = QAction(_("Join inputs/outputs"), self)
self._ptx_join_txs_action.triggered.connect(self.join_tx_with_another)
partial_tx_actions_menu.addAction(self._ptx_join_txs_action)
self.partial_tx_actions_button = QToolButton()
self.partial_tx_actions_button.setText(_("Combine"))
self.partial_tx_actions_button.setMenu(partial_tx_actions_menu)
self.partial_tx_actions_button.setPopupMode(QToolButton.InstantPopup)
self.psbt_only_widgets.append(self.partial_tx_actions_button)
# Action buttons
self.buttons = [
self.partial_tx_actions_button, self.sign_button,
self.broadcast_button, self.cancel_button
]
# Transaction sharing buttons
self.sharing_buttons = [
self.finalize_button, self.export_actions_button, self.save_button
]
run_hook('transaction_dialog', self)
if not self.finalized:
self.create_fee_controls()
vbox.addWidget(self.feecontrol_fields)
self.hbox = hbox = QHBoxLayout()
hbox.addLayout(Buttons(*self.sharing_buttons))
hbox.addStretch(1)
hbox.addLayout(Buttons(*self.buttons))
vbox.addLayout(hbox)
self.set_buttons_visibility()
dialogs.append(self)
class AboutDialog(QDialog):
def __init__(self):
super(AboutDialog, self).__init__()
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle
self.title = __appname__ + ' v' + __version__
self.setWindowTitle(self.title)
self.resize(595, 630)
self.vlayout = QVBoxLayout()
self.vlayout.setContentsMargins(5, 15, 5, 7)
self.vlayout.setSpacing(10)
self.logo_box = QLabel()
with importlib_resources.path('LiquidDiffract.resources.icons',
'logo.png') as path:
self.logo = QPixmap(str(path))
self.logo_box.setPixmap(self.logo)
self.logo_box.setAlignment(Qt.AlignCenter)
self.text_display = QTextBrowser()
self.text_display.setReadOnly(True)
self.text_display.setFrameStyle(QFrame.NoFrame)
self.text_display.setStyleSheet(
"* { background-color: rgba(0, 0, 0, 0); }")
self.text_display.setOpenExternalLinks(True)
_app_url = 'https://github.com/bjheinen/LiquidDiffract'
_gpl_url = 'https://www.gnu.org/licenses/gpl.html'
_pstr = '<p class="western" align="center">'
_description = ('LiquidDiffract is a graphical application for '
'X-ray total-scattering analysis of liquids and '
'disordered solids.\n'
'It implements procedures to obtain information on '
'macroscopic bulk properties and local atomic-scale '
'structure from total scattering data.\n'
'LiquidDiffract provides tools for background '
'subtraction; calculation, normalisation, and '
'refinement of the reciprocal-space structure factor '
'and real-space correlation functions; '
'and extraction of structural information such as '
'bond lengths, coordination number and bulk density.')
_app_url_str = (f'{_pstr}<a class="western" href="{_app_url}">'
f'<span style="color: #000080;"><span lang="zxx">'
f'<u>{_app_url}</u></span></span></a></p>')
_copyright = 'Copyright © 2018-2021 – Benedict J. Heinen'
_warranty = ('This program comes with absolutely no '
'warranty or guarantee.')
_license = '<u>GNU General Public Licence, version 3 or later</u>'
_l_str = (f'See the </span><a class="western" href="{_gpl_url}">'
f'<span style="color: #000080;"><span style='
f'"font-size: small;"><span lang="zxx">{_license}</span>'
f'</span></span></a><span style="font-size: small;"> '
f'for details.</span></p>')
_text = (
f'{_pstr}<strong>{__appname__}</strong></p>'
f'{_pstr}v{__version__}</p>'
f'{_pstr} </p>'
f'{_pstr}<em>{_description}</em></p>'
f'{_pstr} </p>'
f'{_app_url_str}'
f'{_pstr} </p>'
f'{_pstr}<span style="font-size: small;">{_copyright}</span></p>'
f'{_pstr}<span style="font-size: small;">{_warranty}<br>'
f'{_l_str}')
self.text_display.textCursor().insertHtml(_text)
self.vlayout.addWidget(self.logo_box)
self.vlayout.addWidget(self.text_display)
self.setLayout(self.vlayout)
class SearchMSTitle(QMdiSubWindow):
def __init__(self, main, type):
"""
Search movie or series by title.
:param main: Reference for main windows.
:param type: String if is "movie" then search for movie if not search
by "series".
"""
super(SearchMSTitle, self).__init__()
self.session = DB.get_session()
self.type = type
self.main = main
self.row_select = -1
if self.type == 'movie':
self.obj = self.session.query(Movie).order_by(Movie.name)
name = texts.movie_p
else:
self.obj = self.session.query(Series).order_by(Series.name)
name = texts.series_p
windows_title = texts.search + ' ' + name + ' ' + texts.for_ \
+ ' ' + texts.title_p
self.setWindowTitle(windows_title)
self.width = int(0.9 * main.frameSize().width())
self.height = int(0.9 * main.frameSize().height())
self.setGeometry(0, 0, self.width, self.height)
self.subwindow = QWidget()
p = self.palette()
p.setColor(self.backgroundRole(), QColor(230, 230, 250))
self.setPalette(p)
self.setWidget(self.subwindow)
self.vbox_main = QVBoxLayout(self.subwindow)
self.vbox_main.setContentsMargins(20, 20, 20, 20)
# Title
self.lb_title = QLabel(texts.title_s)
self.lb_title.setMaximumSize(QSize(100, 25))
self.cb_title = cb_create()
self.cb_title.addItem('', 0)
for ms in self.obj:
self.cb_title.addItem(ms.name, ms.id)
# Words
text = texts.or_s + ' ' + texts.with_the_p + ' ' + texts.term_p
self.lb_term = QLabel(text)
self.le_term = le_create(30, texts.with_term_tt)
self.le_term.setPlaceholderText('pressione enter')
#
# HBoxSearch
self.hbox_search = hbox_create(
[self.lb_title, self.cb_title, self.lb_term, self.le_term])
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.hbox_search.addItem(spacer)
self.vbox_main.addLayout(self.hbox_search)
# total
self.lb_total = QLabel(texts.lb_total)
self.le_total = le_create(255)
self.le_total.setMaximumWidth(100)
# Buttons
self.pb_clear = pb_create(texts.pb_clear, 11, 30)
self.pb_clear.setMaximumWidth(100)
self.pb_clear.setShortcut('Ctrl+L')
# self.pb_clear.clicked.connect(self.clear)
self.pb_leave = pb_create(texts.pb_leave, 11, 30)
self.pb_leave.setMaximumWidth(100)
self.pb_leave.setShortcut('Ctrl+Q')
self.pb_leave.clicked.connect(self.close)
# Hbox_result
self.hbox_result = hbox_create(
[self.lb_total, self.le_total, self.pb_clear, self.pb_leave])
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.hbox_result.addItem(spacer)
self.vbox_main.addLayout(self.hbox_result)
# Table
self.table = QTableWidget()
self.table.setObjectName('table-search')
self.rows = 0
self.clear_table()
self.set_table(self.obj)
self.vbox_main.addWidget(self.table)
self.cb_title.currentIndexChanged.connect(self.query_title)
self.le_term.editingFinished.connect(self.query_term)
# Clear Table
def clear_table(self):
"""
Clear all tables values.
"""
self.table.clear()
self.table.setRowCount(0)
self.table.setColumnCount(6)
self.rows = 0
if self.type == 'movie':
headers = [
texts.title_s, texts.original_title_s, texts.lb_time,
texts.media_s, texts.year_s, 'id'
]
else:
headers = [
texts.title_s, texts.original_title_s, texts.season_p,
texts.media_s, texts.year_s, 'id'
]
self.table.setHorizontalHeaderLabels(headers)
col_width = self.width - 70
self.table.setColumnWidth(0, 0.35 * col_width)
self.table.setColumnWidth(1, 0.35 * col_width)
self.table.setColumnWidth(2, 0.10 * col_width)
self.table.setColumnWidth(3, 0.10 * col_width)
self.table.setColumnWidth(4, 0.10 * col_width)
self.table.setColumnWidth(5, 0)
self.table.verticalHeader().setVisible(False)
self.table.setStyleSheet('background-color: #FFFFFF;')
self.table.setSortingEnabled(True)
# Resize Event
def resizeEvent(self, event):
"""
Resize actors and character combobox in table cast if windows resize.
:param event: Window.
"""
self.width = event.size().width()
col_width = self.width - 70
self.table.setColumnWidth(0, 0.35 * col_width)
self.table.setColumnWidth(1, 0.35 * col_width)
self.table.setColumnWidth(2, 0.10 * col_width)
self.table.setColumnWidth(3, 0.10 * col_width)
self.table.setColumnWidth(4, 0.10 * col_width)
self.table.setColumnWidth(5, 0)
# Important don't delete it
QMdiSubWindow.resizeEvent(self, event)
# View Movie
def view_obj(self, row, col):
"""
When clicked a cell table who has title show the html view of movie.
:param row: The number of the row on which the cell was clicked.
:param col: The number of the column on which the cell was clicked.
"""
if self.row_select != row and col == 0:
obj_id = self.table.item(row, 5).text()
if self.type == 'movie':
obj = self.session.query(Movie).get(obj_id)
else:
obj = self.session.query(Series).get(obj_id)
if obj.view:
self.main.view_html(obj.view, obj.name)
self.row_select = row
# Set Table
def set_table(self, objs):
"""
Set table with all movies.
:param query: The movies values.
"""
self.clear_table()
for o in objs:
self.table.insertRow(self.rows)
self.table.setItem(self.rows, 0, QTableWidgetItem(o.name))
font = QFont()
font.setUnderline(True)
self.table.item(self.rows, 0).setForeground(QColor(55, 34, 243))
self.table.item(self.rows, 0).setFont(font)
self.table.setItem(self.rows, 1, QTableWidgetItem(o.original_name))
if self.type == 'movie':
self.table.setItem(self.rows, 2, QTableWidgetItem(o.time))
else:
self.table.setItem(self.rows, 2, QTableWidgetItem(o.seasons))
if o.media_id:
self.table.setItem(self.rows, 3,
QTableWidgetItem(o.media.name))
else:
self.table.setItem(self.rows, 3, QTableWidgetItem(''))
self.table.setItem(self.rows, 4, QTableWidgetItem(o.year))
self.table.setItem(self.rows, 5, QTableWidgetItem(str(o.id)))
for i in range(6):
if self.table.item(self.rows, i):
self.table.item(self.rows, i).setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
self.table.cellDoubleClicked.connect(self.view_obj)
self.rows += 1
self.table.setAlternatingRowColors(True)
self.table.setStyleSheet(
"alternate-background-color: #F0FAE4;; background-color: #FFFFFF;")
self.le_total.setText(str(self.rows))
# Set Query Title
def set_table_title(self, obj):
"""
Set table with movies values search in database.
:param obj: The movies values from a database search.
"""
self.clear_table()
self.table.insertRow(self.rows)
self.table.setItem(self.rows, 0, QTableWidgetItem(obj.name))
font = QFont()
font.setUnderline(True)
self.table.item(self.rows, 0).setForeground(QColor(55, 34, 243))
self.table.item(self.rows, 0).setFont(font)
self.table.setItem(self.rows, 1, QTableWidgetItem(obj.original_name))
if self.type == 'movie':
self.table.setItem(self.rows, 2, QTableWidgetItem(obj.time))
else:
self.table.setItem(self.rows, 2, QTableWidgetItem(obj.seasons))
if obj.media:
self.table.setItem(self.rows, 3, QTableWidgetItem(obj.media.name))
else:
self.table.setItem(self.rows, 3, QTableWidgetItem(''))
self.table.setItem(self.rows, 4, QTableWidgetItem(obj.year))
self.table.setItem(self.rows, 5, QTableWidgetItem(str(obj.id)))
self.table.cellClicked.connect(self.view_obj)
self.rows += 1
self.table.setAlternatingRowColors(True)
self.table.setStyleSheet(
"alternate-background-color: #F0FAE4; background-color: #ffffff;")
self.le_total.setText(str(self.rows))
# Query Title
def query_title(self):
"""
Search movie by selected title in QCombobox.
"""
id, name = get_combobox_info(self.cb_title)
if self.type == 'movie':
query = self.session.query(Movie).get(id)
else:
query = self.session.query(Series).get(id)
self.set_table_title(query)
def query_term(self):
"""
Search movie by words in title.
"""
words = self.le_term.text().split()
queries = []
for word in words:
word = '%{0}%'.format(word)
if self.type == 'movie':
query = self.session.query(Movie)\
.filter(Movie.name.ilike(word)).all()
else:
query = self.session.query(Series) \
.filter(Series.name.ilike(word)).all()
queries += query
self.set_table(queries)
def clear(self):
"""
Clear all values in windows.
"""
self.cb_title.currentIndexChanged.disconnect()
self.cb_title.setCurrentIndex(0)
self.clear_table()
self.set_table(self.obj)
self.cb_title.currentIndexChanged.connect(self.query_title)
# Close Event
def closeEvent(self, event):
self.session.close()
def settings_win(self):
# Define Settings Win
self.settings = QMainWindow(self.main)
self.settings.setWindowTitle('Settings')
# Create StackedWidget and Selection List
self.stacked_settings = QStackedWidget()
self.settings_list = QListWidget()
self.settings_list.setFixedWidth(110)
self.settings_list.addItems(['Main', 'About'])
self.settings_list.clicked.connect(self.actions.select_settings)
# Central Widget
central_widget = QWidget()
hbox = QHBoxLayout()
hbox.addWidget(self.settings_list)
hbox.addWidget(self.stacked_settings)
central_widget.setLayout(hbox)
self.settings.setCentralWidget(central_widget)
'''
Child widget
Behavior Settings
'''
behavior_settings = QWidget()
self.stacked_settings.addWidget(behavior_settings)
# Main Layouts
vbox = QVBoxLayout()
vbox.setAlignment(Qt.AlignTop)
form_layout = QFormLayout()
# Change Directory
dl_directory_label = QLabel('Download directory:')
form_layout.addRow(dl_directory_label)
dl_directory_btn = QPushButton('Select..')
dl_directory_btn.clicked.connect(self.actions.set_dl_directory)
self.dl_directory_input = QLineEdit()
if self.actions.settings is not None:
self.dl_directory_input.setText(self.actions.settings[0])
self.dl_directory_input.setDisabled(True)
form_layout.addRow(dl_directory_btn, self.dl_directory_input)
# Bottom Buttons
save_settings = QPushButton('Save')
save_settings.clicked.connect(self.actions.save_settings)
# Change theme
theme_label = QLabel('Theme:')
form_layout.addRow(theme_label)
self.theme_select = QComboBox()
self.theme_select.addItems(['Light', 'Dark'])
self.theme_select.currentIndexChanged.connect(
self.actions.change_theme)
form_layout.addRow(self.theme_select)
vbox.addLayout(form_layout)
vbox.addStretch()
vbox.addWidget(save_settings)
behavior_settings.setLayout(vbox)
'''
Child widget
About
'''
about_settings = QWidget()
self.stacked_settings.addWidget(about_settings)
about_layout = QGridLayout()
about_layout.setAlignment(Qt.AlignCenter)
logo = QLabel()
logo.setPixmap(QPixmap(absp('res/zap.svg')))
logo.setAlignment(Qt.AlignCenter)
text = QLabel(self.app_name)
text.setStyleSheet('font-weight: bold; color: #4256AD')
github_btn = QPushButton(QIcon(absp('res/github.svg')), '')
github_btn.setFixedWidth(32)
github_btn.clicked.connect(
lambda: webbrowser.open('https://github.com/manuGMG/1fichier-dl'))
about_layout.addWidget(logo, 0, 0, 1, 0)
about_layout.addWidget(github_btn, 1, 0)
about_layout.addWidget(text, 1, 1)
about_settings.setLayout(about_layout)
class WaterfallPlotter(QWidget):
generated_rectangles_signal = QtCore.pyqtSignal(
list) #send list of rects for data display in tree
def __init__(self, parent):
super(WaterfallPlotter, self).__init__(parent)
self.get_settings()
self.settings_update = False
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.btn_plot = QPushButton('Default Plot')
self.btn_plot.clicked.connect(self.plot)
self.layout = QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.btn_plot)
self.setLayout(self.layout)
def on_waterfall_data_signal(self, signal):
self.waterfall_data = signal['waterfall_data'] #pandas dataframe
self.btn_plot.setEnabled(True)
def get_settings(self):
# try:
# with shelve.open('WaterfallSettings') as shelfFile:
# self.keys_and_colors = shelfFile['keys_and_colors']
# shelfFile.close()
# except:
# #set and use default settings
# self.keys_and_colors = {
# 'CR':'#03945D',
# 'PR':'#B1EE97',
# 'PD':'#FF6F69',
# 'SD':'#707070',
# 'a':'r',
# 'b':'g',
# 'c':'b'
# }
# with shelve.open('WaterfallSettings') as shelfFile:
# shelfFile['keys_and_colors'] = self.keys_and_colors
# shelfFile.close()
self.keys_and_colors = {
'CR': '#03945D',
'PR': '#B1EE97',
'PD': '#FF6F69',
'SD': '#707070',
'a': '#FF0000',
'b': '#00FF00',
'c': '#0000FF'
}
def on_general_settings_signal(self, signal):
self.gen_settings = signal
self.settings_update = True
self.plot()
def get_bar_colors(self, responses):
return [self.keys_and_colors[x] for x in responses]
def plot(self):
'''
Plot waterfall data
'''
self.figure.clear()
self.rect_locations = np.arange(
len(self.waterfall_data['Best response percent change']))
self.ax = self.figure.add_subplot(111)
self.patches = []
self.bar_labels = self.waterfall_data['Overall response']
if self.settings_update == False:
self.ax.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom='on', # ticks along the bottom edge are off
top='on', # ticks along the top edge are off
labelbottom='on') # labels along the bottom edge are off
self.ax.axhline(y=20,
linestyle='--',
c='k',
alpha=0.5,
lw=2.0,
label='twenty_percent')
self.ax.axhline(y=-30,
linestyle='--',
c='k',
alpha=0.5,
lw=2.0,
label='thirty_percent')
self.ax.axhline(y=0, c='k', alpha=1, lw=2.0, label='zero_percent')
self.ax.grid(color='k', axis='y', alpha=0.25)
self.bar_colors = self.get_bar_colors(
self.waterfall_data['Overall response'])
self.rects = self.ax.bar(
self.rect_locations,
self.waterfall_data['Best response percent change'],
color=self.bar_colors,
label=self.waterfall_data['Overall response'])
for key in self.keys_and_colors.keys():
self.patches.append(
mpatches.Patch(color=self.keys_and_colors[key], label=key))
self.ax.legend(handles=self.patches)
else:
self.ax.legend([])
#settings were updated, we received them and stored in variable self.gen_settings
self.ax.set_title(self.gen_settings[0])
self.ax.set_xlabel(self.gen_settings[1])
self.ax.set_ylabel(self.gen_settings[2])
if self.gen_settings[3][0]:
self.ax.axhline(y=20,
linestyle='--',
c='k',
alpha=0.5,
lw=2.0,
label='twenty_percent')
if self.gen_settings[3][1]:
self.ax.axhline(y=-30,
linestyle='--',
c='k',
alpha=0.5,
lw=2.0,
label='thirty_percent')
if self.gen_settings[3][2]:
self.ax.axhline(y=0,
c='k',
alpha=1,
lw=2.0,
label='zero_percent')
if self.gen_settings[4][0] and ~self.gen_settings[6]:
#show responses as labels, default color bars
#legend depends on user specified keys
self.rects = self.ax.bar(
self.rect_locations,
self.waterfall_data['Best response percent change'],
label=self.waterfall_data['Overall response'])
self.add_labels(self.ax, self.rects, self.waterfall_data, 1)
elif self.gen_settings[4][1]:
#color bars with response type
self.bar_colors = self.get_bar_colors(
self.waterfall_data['Overall response'])
self.rects = self.ax.bar(
self.rect_locations,
self.waterfall_data['Best response percent change'],
color=self.bar_colors,
label=self.waterfall_data['Overall response'])
for key in self.keys_and_colors.keys():
self.patches.append(
mpatches.Patch(color=self.keys_and_colors[key],
label=key))
self.ax.legend(handles=self.patches)
elif self.gen_settings[4][2]:
#response not shown as color coding, custom color code the bars
self.bar_labels = self.gen_settings[7]
self.bar_colors = self.get_bar_colors(self.gen_settings[7])
used_keys = list(set(self.gen_settings[7]))
self.rects = self.ax.bar(
self.rect_locations,
self.waterfall_data['Best response percent change'],
color=self.bar_colors,
label=self.gen_settings[7])
for key in used_keys:
self.patches.append(
mpatches.Patch(color=self.keys_and_colors[key],
label=key))
self.ax.legend(handles=self.patches)
else:
self.rects = self.ax.bar(
self.rect_locations,
self.waterfall_data['Best response percent change'],
label=self.waterfall_data['Overall response'])
if self.gen_settings[5]:
self.plot_table()
if self.gen_settings[6] and ~self.gen_settings[4][0]:
self.add_labels(self.ax, self.rects, self.waterfall_data, 0)
self.ax.grid(color='k', axis='y', alpha=0.25)
self.canvas.draw()
self.generated_rectangles_signal.emit([self.rects, self.bar_labels])
def plot_table(self):
rows = ['%s' % x for x in self.waterfall_data.keys()]
rows = rows[
4:] #skip first three, they are the 4 standard headers, rest are table rows
columns = self.waterfall_data['Patient number'] #patient numbers
cell_text = []
for row in rows:
cell_text_temp = []
for col in range(len(columns)):
cell_text_temp.append(self.waterfall_data[row][col])
cell_text.append(cell_text_temp)
the_table = self.ax.table(cellText=cell_text,
rowLabels=rows,
colLabels=columns,
loc='bottom',
cellLoc='center',
colLoc='center')
plt.subplots_adjust(bottom=0.15, left=0.5)
self.ax.set_xlim(-0.5, len(columns) - 0.5)
self.ax.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom='off', # ticks along the bottom edge are off
top='off', # ticks along the top edge are off
labelbottom='off') # labels along the bottom edge are off
def add_labels(self, ax, rects, waterfall_data, label_type):
'''
Add labels above/below bars. label_type == 1 --> display responses; == 0 --> display cancer type
'''
i = 0
if label_type:
for rect in rects:
height = rect.get_height()
if height >= 0:
valign = 'bottom'
else:
valign = 'top'
ax.text(rect.get_x() + rect.get_width() / 2.,
height,
'%s' % waterfall_data['Overall response'][i],
ha='center',
va=valign)
i += 1
else:
for rect in rects:
height = rect.get_height()
if height >= 0:
valign = 'top'
hgt = -1
else:
valign = 'bottom'
hgt = 1
ax.text(rect.get_x() + rect.get_width() / 2.,
hgt,
'%s' % waterfall_data['Cancer'][i],
ha='center',
va=valign,
rotation='vertical')
i += 1
def init_ui(self):
layout = QVBoxLayout()
layout.addWidget(self.output_dir)
layout.addWidget(self.preserve_dir)
layout.addWidget(self.preserve_times)
layout.addWidget(self.delete_metadata)
layout.addWidget(self.overwrite_files)
layout.addWidget(self.history)
layout.addWidget(self.sort_by_size)
layout.addWidget(QHLine())
layout.addWidget(self.encoder_editor)
layout.addWidget(QHLine())
layout.addWidget(QLabel("<u>Advanced</u>"))
h_layout = QHBoxLayout()
h_layout.addWidget(
QLabel("Number of files to encode at the same time"))
h_layout.addWidget(self.max_threads)
layout.addLayout(h_layout)
layout.addWidget(self.single_thread_video)
layout.addWidget(QHLine())
layout.addWidget(QLabel("<u>Unsupported files</u>"))
layout.addWidget(
QLabel(
"Copy files with the following extensions to output\n(Separate with ;)"
))
layout.addWidget(self.unsupported_extensions_to_copy)
layout.addWidget(QHLine())
layout.addWidget(QLabel("<u>Appearance</u>"))
layout.addWidget(self.use_system_theme)
layout.addWidget(QHLine())
buttons = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self)
buttons.clicked.connect(self.close)
layout.addWidget(buttons)
self.setLayout(layout)
self.setWindowTitle("Settings")
self.setWindowIcon(TransCoda.theme.ico_app_icon)
def initUI(self):
# set window size and title
self.setGeometry(300, 300, 500, 250)
self.setWindowTitle('Assignment6')
# to send warning to user
self.warning_msg = QMessageBox()
self.warning_msg.setIcon(QMessageBox.Warning)
self.warning_msg.setText("empty DB")
self.warning_msg.setDetailedText("Add Student's Data")
self.warning_msg.setWindowTitle(self.windowTitle())
self.warning_msg.setStandardButtons(QMessageBox.Ok)
# to send is Ok or not
self.ask_msg = QMessageBox()
self.ask_msg.setIcon(QMessageBox.Question)
self.ask_msg.setText("are you sure?")
self.ask_msg.setWindowTitle(self.windowTitle())
self.ask_msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
# first row is user input
name_lbl = QLabel('Name:')
age_lbl = QLabel('Age:')
score_lbl = QLabel('Score:')
self.name_edit = QLineEdit()
self.age_edit = QLineEdit()
self.score_edit = QLineEdit()
vbox = QVBoxLayout()
user_data_hbox = QHBoxLayout()
user_data_hbox.addWidget(name_lbl)
user_data_hbox.addWidget(self.name_edit)
user_data_hbox.addWidget(age_lbl)
user_data_hbox.addWidget(self.age_edit)
user_data_hbox.addWidget(score_lbl)
user_data_hbox.addWidget(self.score_edit)
vbox.addLayout(user_data_hbox)
# end of first row
# second row is key combo and amount
amount_lbl = QLabel('Amount:')
self.amount_edit = QLineEdit()
sort_key_lbl = QLabel('Key')
self.sort_key_combo = QComboBox()
self.sort_key_combo.addItems(ScoreDB.ColumnName)
key_and_amount_hbox = QHBoxLayout()
key_and_amount_hbox.addStretch(1)
key_and_amount_hbox.addWidget(amount_lbl)
key_and_amount_hbox.addWidget(self.amount_edit)
key_and_amount_hbox.addWidget(sort_key_lbl)
key_and_amount_hbox.addWidget(self.sort_key_combo)
vbox.addLayout(key_and_amount_hbox)
# end of second row
# third row is 5 push buttons
# command buttons
self.add_btn = QPushButton('Add')
self.del_btn = QPushButton('Del')
self.find_btn = QPushButton('Find')
self.inc_btn = QPushButton('Inc')
self.show_btn = QPushButton('show')
command_hbox = QHBoxLayout()
command_hbox.addStretch(1)
command_hbox.addWidget(self.add_btn)
command_hbox.addWidget(self.del_btn)
command_hbox.addWidget(self.find_btn)
command_hbox.addWidget(self.inc_btn)
command_hbox.addWidget(self.show_btn)
vbox.addLayout(command_hbox)
# end of third row
# last row is label and text edit
result_lbl = QLabel('Result:')
self.result_txt = QTextEdit()
self.result_txt.setReadOnly(True)
result_hbox = QHBoxLayout()
result_vbox = QVBoxLayout()
result_vbox.addWidget(result_lbl)
result_vbox.addStretch(1)
result_hbox.addLayout(result_vbox)
result_hbox.addWidget(self.result_txt)
vbox.addLayout(result_hbox)
# end of last row
self.setLayout(vbox)
self.is_first_shown = True
self.connect_events()
self.show()
def setup_ui(self):
""" Setup Ui
"""
main_wrap = QVBoxLayout()
main_wrap.setContentsMargins(0, 0, 0, 0)
# updatebar on top
self.update_bar = UpdateBar(self)
self.update_bar.onUpdateNowClicked.connect(self._update_dwarf)
self.update_bar.setVisible(False)
main_wrap.addWidget(self.update_bar)
# main content
h_box = QHBoxLayout()
h_box.setContentsMargins(15, 15, 15, 15)
wrapper = QVBoxLayout()
head = QHBoxLayout()
head.setContentsMargins(50, 10, 0, 10)
# dwarf icon
icon = QLabel()
icon.setPixmap(QPixmap(utils.resource_path('assets/dwarf.svg')))
icon.setAlignment(Qt.AlignCenter)
icon.setMinimumSize(QSize(125, 125))
icon.setMaximumSize(QSize(125, 125))
head.addWidget(icon)
# main title
v_box = QVBoxLayout()
title = QLabel('Dwarf')
title.setContentsMargins(0, 0, 0, 0)
font = QFont('Anton', 100, QFont.Bold)
font.setPixelSize(120)
title.setFont(font)
title.setMaximumHeight(125)
title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
title.setAlignment(Qt.AlignCenter)
head.addWidget(title)
sub_title_text = (self._pick_random_word(0) + ' ' +
self._pick_random_word(1) + ' ' +
self._pick_random_word(2) + ' ' +
self._pick_random_word(3) + ' ' +
self._pick_random_word(4))
sub_title_text = sub_title_text[:1].upper() + sub_title_text[1:]
self._sub_title = QLabel(sub_title_text)
font = QFont('OpenSans', 16, QFont.Bold)
font.setPixelSize(24)
self._sub_title.setFont(font)
font_metric = QFontMetrics(self._sub_title.font())
self._char_width = font_metric.widthChar('#')
self._sub_title.setAlignment(Qt.AlignCenter)
self._sub_title.setContentsMargins(175, 0, 0, 20)
self._sub_title.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Minimum)
v_box.addLayout(head)
v_box.addWidget(self._sub_title)
wrapper.addLayout(v_box)
recent = QLabel('Recent saved Sessions')
font = recent.font()
font.setPixelSize(14)
font.setBold(True)
# font.setPointSize(10)
recent.setFont(font)
wrapper.addWidget(recent)
wrapper.addWidget(self._recent_list)
h_box.addLayout(wrapper, stretch=False)
buttonSpacer = QSpacerItem(15, 100, QSizePolicy.Fixed,
QSizePolicy.Minimum)
h_box.addItem(buttonSpacer)
wrapper = QVBoxLayout()
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/android.svg')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Android Session')
btn.clicked.connect(self._on_android_button)
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/apple.svg')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New iOS Session')
btn.clicked.connect(self._on_ios_button)
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/local.svg')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Local Session')
btn.clicked.connect(self._on_local_button)
wrapper.addWidget(btn)
btn = QPushButton()
ico = QIcon(QPixmap(utils.resource_path('assets/remote.svg')))
btn.setIconSize(QSize(75, 75))
btn.setIcon(ico)
btn.setToolTip('New Remote Session')
btn.clicked.connect(self._on_remote_button)
wrapper.addWidget(btn)
h_box.addLayout(wrapper, stretch=False)
main_wrap.addLayout(h_box)
self.setLayout(main_wrap)
class MainWindow(QMainWindow, mainwindow.Ui_MainWindow):
waterfall_data_signal = QtCore.pyqtSignal(list)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setup_window()
def setup_window(self):
#Dialogs
self.Waterfall_Plot = WaterfallPlotter(self)
self.Waterfall = Waterfall(self)
self.Waterfall_Widget = QWidget()
self.Waterfall_Box = QVBoxLayout()
self.Waterfall_Splitter = QSplitter(QtCore.Qt.Horizontal)
self.Waterfall_Splitter.addWidget(self.Waterfall)
self.Waterfall_Splitter.addWidget(self.Waterfall_Plot)
self.Waterfall_Box.addWidget(self.Waterfall_Splitter)
self.Waterfall_Widget.setLayout(self.Waterfall_Box)
self.Spider_Widget = QWidget()
self.Spider_Box = QVBoxLayout()
self.Spider_Splitter = QSplitter(QtCore.Qt.Horizontal)
self.Spider_Plot = SpiderPlotter(self)
self.Spider = Spider(self)
self.Spider_Splitter.addWidget(self.Spider)
self.Spider_Splitter.addWidget(self.Spider_Plot)
self.Spider_Box.addWidget(self.Spider_Splitter)
self.Spider_Widget.setLayout(self.Spider_Box)
self.Swimmer_Widget = QWidget()
self.Swimmer_Box = QVBoxLayout()
self.Swimmer_Splitter = QSplitter(QtCore.Qt.Horizontal)
self.Swimmer_Plot = SwimmerPlotter(self)
self.Swimmer = Swimmer(self)
self.Swimmer_Splitter.addWidget(self.Swimmer)
self.Swimmer_Splitter.addWidget(self.Swimmer_Plot)
self.Swimmer_Box.addWidget(self.Swimmer_Splitter)
self.Swimmer_Widget.setLayout(self.Swimmer_Box)
self.stackedWidget.addWidget(self.Waterfall_Widget) #0
self.stackedWidget.addWidget(self.Spider_Widget) #1
self.stackedWidget.addWidget(self.Swimmer_Widget) #2
self.stackedWidget.hide()
#Set up toolBar
self.toolBar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
importAction = QAction(
QtGui.QIcon(os.path.join(image_dir, 'images\Download.png')),
'Import date template', self)
importAction.triggered.connect(self.import_data)
importAction.setIconText("Import")
self.toolBar.addAction(importAction)
self.toolBar.addSeparator()
dumpAction = QAction(
QtGui.QIcon(os.path.join(image_dir, 'images\Rubbish.png')),
'Import date template', self)
#dumpAction.triggered.connect(self.dump_data)
dumpAction.setIconText("Dump data")
self.toolBar.addAction(dumpAction)
self.toolBar.addSeparator()
self.waterfallAction = QAction(
QtGui.QIcon(os.path.join(image_dir, 'images\waterfall.png')),
'Waterfall plot', self)
waterfallAction.triggered.connect(self.launch_waterfall)
waterfallAction.setIconText("Waterfall")
waterfallAction.setEnabled(False)
self.toolBar.addAction(waterfallAction)
spiderAction = QAction(
QtGui.QIcon(os.path.join(image_dir, 'images\spider.png')),
'Spider plot', self)
spiderAction.triggered.connect(self.launch_spider)
spiderAction.setIconText("Spider")
spiderAction.setEnabled(False)
self.toolBar.addAction(spiderAction)
swimmerAction = QAction(
QtGui.QIcon(os.path.join(image_dir, 'images\swimmer_stack.png')),
'Swimmer plot', self)
swimmerAction.triggered.connect(self.launch_spider)
swimmerAction.setIconText("Swimmer")
swimmerAction.setEnabled(False)
self.toolBar.addAction(swimmerAction)
self.toolBar.addSeparator()
#Signal interconnections
self.waterfall_data_signal.connect(
self.Waterfall.on_waterfall_data_signal)
self.waterfall_data_signal.connect(
self.Waterfall_Plot.on_waterfall_data_signal)
self.Waterfall.general_settings_signal.connect(
self.Waterfall_Plot.on_general_settings_signal)
#Launch functions
def launch_waterfall(self):
self.stackedWidget.setCurrentIndex(0)
self.stackedWidget.show()
def launch_spider(self):
self.stackedWidget.setCurrentIndex(1)
self.stackedWidget.show()
def launch_swimmer(self):
self.stackedWidget.setCurrentIndex(2)
self.stackedWidget.show()
def import_data(self):
self.file_path = QFileDialog.getOpenFileName(self,
"Select Data Template",
"C:\\")[0]
if self.file_path == '':
pass
else:
self.waterfall_data = import_plot_data(self.file_path)
self.waterfall_data_signal.emit(self.waterfall_data)
waterfallAction.setEnabled(True)
spiderAction.setEnabled(True)
swimmerAction.setEnabled(True)
class tab_widget(QWidget):
def __init__(self):
super().__init__()
self.layout = QVBoxLayout()
self.exeUI()
def exeUI(self):
# tab ģ¤ģ
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.tab4 = QWidget()
# ź° TAB ģ“ė¦ ģ¤ģ ė° ģ¶ź°
self.tabs.addTab(self.tab1, 'Quotation')
self.tabs.addTab(self.tab2, 'Progress')
self.tabs.addTab(self.tab3, 'Result')
self.tabs.addTab(self.tab4, 'Report')
# tab1ģ ģ¤ķ ėŖ
ė ¹ģ“
self.tab1_play = self.tab1_f()
# tab ģ ģ²“ ģģ Æģ ģģ±ģķ¤ė ėŖ
ė ¹ģ“
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
# tab1 ģ¤ķ ķØģ
def tab1_f(self):
# tab1 ģ layout ģ ź·øė¦¬ėė” ģ¤ģ
self.tab1.layout = QGridLayout()
self.tab1_func1 = self.code_c_search()
self.tab1_func2 = self.Quotation()
self.tab1.setLayout(self.tab1.layout)
# tab1 ģ code_c_search
def code_c_search(self):
self.c_code_search = QGroupBox('C-CODE SEARCH')
# GropBox ķ¬źø° ģ”°ģ
self.c_code_search.setMaximumSize(430, 800)
self.tab1.layout.addWidget(self.c_code_search, 0, 0)
self.c_code_label = QLabel('ź² ģ:')
self.c_code_line = QLineEdit()
self.c_code_btn = QPushButton('ķģø')
self.c_code_btn2 = QPushButton('ģ
ė „')
self.c_code_table = QTableWidget(self.c_code_search)
# TableWidget ģ¤ģ
self.c_code_table.resize(300, 700)
# Table ģ§ģė²ģ§ø ģ ė³ķ
self.c_code_table.setAlternatingRowColors(True)
# Table ģ
ģ ģ ķķ ė ģ ģ²“ ķģ ģ ķķėė” ģ¤ģ
self.c_code_table.setSelectionBehavior(QAbstractItemView.SelectRows)
# Tableģ ģģ ķģ§ ėŖ»ķėė” ģ¤ģ
self.c_code_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
# Tableģģ ėėøķ“ė¦ģ ķė©“ ģ¤ķėė źø°ė„
self.c_code_table.doubleClicked.connect(self.move_toQ)
# ė²ķ¼ģ ėė„“ė©“ ģģ
self.c_code_btn.clicked.connect(self.tab1_ccode_btn)
self.c_code_btn2.clicked.connect(self.tab1_ccode_btn2)
self.c_code_line.returnPressed.connect(self.tab1_ccode_btn)
# c_code_search ģ GroupBox ģ ėķ ģ ė ¬ģ½ė
# label ź³¼ line ģ ģģ¹ė„¼ ģ¤ģ
Hbox = QHBoxLayout()
Vbox = QVBoxLayout()
Hbox.addStretch(1)
Hbox.addWidget(self.c_code_label)
Hbox.addWidget(self.c_code_line)
Hbox.addWidget(self.c_code_btn)
Hbox.addStretch(1)
# Vbox.addStretch(0)
Vbox.addLayout(Hbox)
# Vbox.addStretch(20)
Vbox.addWidget(self.c_code_table)
Vbox.addWidget(self.c_code_btn2)
self.c_code_search.setLayout(Vbox)
# c_code ģ ķģø button
def tab1_ccode_btn(self):
df_fun = ef.excel_pd()
df = df_fun.search_ccode()
ccode_text = self.c_code_line.text()
df_search = df['COMPANY'].str.contains(ccode_text)
DF = df[df_search]
if DF.empty:
reply = QMessageBox(self)
reply.question(self, 'Error', 'ź²ģėģ§ ģģµėė¤.', QMessageBox.Yes)
else:
self.numROW = len(DF)
self.numCOL = len(DF.columns)
# ROWģ COLUMN ģ ģ§ģ
self.c_code_table.setRowCount(self.numROW)
self.c_code_table.setColumnCount(self.numCOL)
# COLUMN ģ§ģ
self.c_code_table.setHorizontalHeaderLabels(DF.columns.tolist())
# ģģ ė£źø°
self.v_list = DF.values.tolist()
for m, n in zip(self.v_list, range(self.numROW)):
for a, b in zip(range(self.numCOL), m):
self.c_code_table.setItem(n, a, QTableWidgetItem(b))
# c_code ģ ģ
ė „ button
def tab1_ccode_btn2(self):
tab1_btn2_play = InputDialog()
tab1_btn2_play.exec_()
# ź²ģźø°ė„
def move_toQ(self):
# ėėø ķ“ė¦ė ķģ ė¶ė¬ģģ ź°ź° ģ“ė¦ģ ģ ģøķė¤.
row = self.c_code_table.currentRow()
self.tb_code = self.c_code_table.item(row, 0).text()
self.tb_comp = self.c_code_table.item(row, 1).text()
self.tb_name = self.c_code_table.item(row, 2).text()
# N NUMBER ģ¶ģ¶
mkfunc = ef.excel_pd()
self.Nnumber = mkfunc.MK_DB()
self.Nrow = len(self.Nnumber)
last = self.Nnumber[self.Nnumber.columns[0]][-1:].values.tolist()
# ė§ģ§ė§ N ė²ķø ė¤ģ ė²ķøė„¼ ė¶ģ¼ ė +1 ķ“ģ ģ¬ģ©
self.last = int(last[0][6:])
self.N = str(self.last + 1)
Message1 = 'C-CODE: ' + self.tb_code
Message2 = 'COMPANY: ' + self.tb_comp
Message3 = 'NAME: ' + self.tb_name
Message4 = 'Quotation Number: ' + self.N
self.Quotation_label1.setText(Message1)
self.Quotation_label2.setText(Message2)
self.Quotation_label3.setText(Message3)
self.Quotation_number.setText(Message4)
# tab1ģ Quotation
def Quotation(self):
self.Quotation_1 = QGroupBox('Quotation')
self.Quotation_1.setStyleSheet('border-style: solid;'
'border-width: 2px;'
'border-color: #9E9E9E;'
'border-radius: 3px')
self.Quotation_1.setMaximumSize(700, 100)
self.tab1.layout.addWidget(self.Quotation_1, 0, 1)
self.Quotation_label1 = QLabel('C-CODE: ')
self.Quotation_label2 = QLabel('C-COMP: ')
self.Quotation_label3 = QLabel('C-NAME: ')
self.Quotation_number = QLabel('Quotation Number: ')
layout = QGridLayout()
layout.addWidget(self.Quotation_number, 0, 1)
layout.addWidget(self.Quotation_label1, 1, 0)
layout.addWidget(self.Quotation_label2, 1, 1)
layout.addWidget(self.Quotation_label3, 1, 2)
self.Quotation_1.setLayout(layout)
class AutomaticRL(QWidget):
"""
This class represents a widget for the Q-learning mode.
It consists of play/step buttons, labels for visualization of
Q-values for hovered cell. It uses instance of `logic.gameLogic.GameLogic`
as an environment for RL agent.
"""
made_step_signal = pyqtSignal()
user_interacted = pyqtSignal()
def _init_ui(self):
self._command_layout = QVBoxLayout()
# Text label
self._description_label = QLabel()
self._description_label.setFont(QFont("Pacifico", 14, QFont.Normal))
self._description_label.setAlignment(Qt.AlignCenter)
self._description_label.setText(settings.Q_LEARNING_DESCRIPTION)
self._description_label.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum))
self._description_label.setFixedSize(
settings.AUTO_RL_DESCRIPTION_NAILS)
self._command_layout.addWidget(self._description_label, 0,
Qt.AlignHCenter)
# q-values visualization
self._qlabels = QLabelsVisualization(self._q_learning)
self._command_layout.addWidget(self._qlabels, 0, Qt.AlignHCenter)
# rl buttons
self._buttons = QWidget()
self._buttons_layout = QHBoxLayout()
self._play_button = Button(settings.PLAY_BUTTON_IMAGE)
self._next_step_button = Button(settings.STEP_BUTTON_IMAGE)
self._buttons_layout.addWidget(self._play_button)
self._buttons_layout.addWidget(self._next_step_button)
self._buttons.setLayout(self._buttons_layout)
self._buttons.setFixedWidth(settings.BUTTONS_NAILS_WIDTH)
self._command_layout.addWidget(self._buttons, 0, Qt.AlignHCenter)
self.setLayout(self._command_layout)
def __init__(self, game_screen: GameScreen):
"""
Constructs an AutomaticRL widget.
AutomaticRL widget needs `game_screen` to update
information in cells about Q-values.
Args:
game_screen - GameScreen instance.
"""
super().__init__()
self._game_screen = game_screen
self._params = GameParams(Modes.AUTOMATICRL,
game_height=settings.GAME_HEIGHT,
game_width=settings.GAME_WIDTH,
lava_random=settings.AUTOMATIC_LAVA_RANDOM,
lava_reward=settings.LAVA_REWARD,
lava_is_terminal=True,
green_random=settings.GREEN_RANDOM,
green_reward=settings.GREEN_REWARD,
green_is_terminal=True)
self._logic = GameLogic(self._params)
self._q_learning = QLearning(self._logic)
self._playing = False
self._timer = QTimer()
self._timer.timeout.connect(self._next_step)
self._init_ui()
# connecting player buttons
self._play_button.clicked.connect(self._play)
self._next_step_button.clicked.connect(self._next_step_click)
self.made_step_signal.connect(game_screen.update_screen)
def enter_mode(self):
"""Replaces game screen logic with RL environment and resets cells."""
self._game_screen.change_logic(self._logic)
self.init_cells()
def exit_mode(self):
"""Stops playing. Used when current mode is being changed."""
if self._playing:
self._playing = False
self._timer.stop()
return
def init_cells(self):
"""
Reinitializes self if cells have changed.
Internally does two things:
1. Connects signals to new cells;
2. Resets values for each cell.
#TODO: if graphic scene will be switched without scene reinitialization
(see issue #44), this function will not be required.
"""
# connecting mouse hover from cells to our q-values visualization
for cell in self._game_screen.cells:
cell.enter_signal.connect(self._qlabels.cell_entered)
cell.leave_signal.connect(self._qlabels.cell_left)
# initialize values
for i in range(self._logic.game_size[0]):
for j in range(self._logic.game_size[1]):
self._game_screen.set_cell_value(i, j, 0.)
for pos in self._logic.terminal_cells:
reward = self._logic.game_board.cell_reward(pos)
self._game_screen.set_cell_value(pos[0], pos[1], reward)
def _next_step_click(self):
self.user_interacted.emit()
self._stop_playing()
self._next_step()
def _next_step(self):
if self._logic.done:
self._q_learning.reset()
else:
old_x, old_y = self._logic.scrat_position
# pylint: disable=W0612
reward, done, info = self._q_learning.step()
new_value = max(self._q_learning.get_q_values((old_x, old_y)))
# updating value on the cell in game field
self._game_screen.set_cell_value(old_x, old_y, new_value)
# updating q-visualization
self._qlabels.values_updates(old_x, old_y)
self.made_step_signal.emit()
def _stop_playing(self):
if self._playing:
self._playing = False
self._timer.stop()
self._play_button.updatePic(settings.PLAY_BUTTON_IMAGE)
def reset(self):
"""Reset game state and send signal that state changed"""
self._stop_playing()
self._q_learning.reset()
self.made_step_signal.emit()
def full_reset(self):
"""Reinitialize logic randomly"""
self._stop_playing()
self._logic.full_reset()
self._q_learning.reset_q()
self.init_cells()
self.made_step_signal.emit()
def _play(self):
self.user_interacted.emit()
if self._playing:
self._playing = False
self._timer.stop()
self._play_button.updatePic(settings.PLAY_BUTTON_IMAGE)
return
self._playing = True
self._timer.start(settings.Q_LEARNING_PLAY_SPEED)
self._play_button.updatePic(settings.STOP_BUTTON_IMAGE)
SIMULATE_WINDOWS = True
if SIMULATE_WINDOWS:
import ntpath
os.sep = ntpath.sep
os.path = ntpath
buttons = []
buttons.append(FilePathButton(r"c:\some\long\path\to\the\file.txt", " (Don't abbreviate this suffix)"))
buttons.append(FilePathButton(r"file.txt", " (some suffix)"))
buttons.append(FilePathButton("\\some\\long\\path\\to\\the\\", " (some suffix)"))
else:
buttons = []
buttons.append(FilePathButton("/some/long/path/to/the/file.txt", " (Don't abbreviate this suffix)"))
buttons.append(FilePathButton("file.txt", " (some suffix)"))
buttons.append(FilePathButton("/some/long/path/to/the/", " (some suffix)"))
layout = QVBoxLayout()
for button in buttons:
# Typically, the button chooses a minimum size that is appropriate for its shortest possible text
# But for this little test we force an even smaller minimum size so we can test multiple paths at once...
button.setMinimumWidth(10)
layout.addWidget(button)
widget = QWidget()
widget.setLayout(layout)
widget.show()
app.exec_()
def set_layout(self, file_name_tuple):
file_type, file_usage = file_name_tuple
file_name = '{}_{}.txt'.format(file_type, file_usage)
vertical_box_layout = QVBoxLayout()
vertical_box_layout.setContentsMargins(0, 0, 0, 0)
label = QLabel(' '.join(file_name_tuple))
label.setAlignment(Qt.AlignCenter)
vertical_box_layout.addWidget(label)
if file_type == 'complete':
with open(file_name, 'a+b') as f:
f.seek(0)
achievement_points = calculate_points(parser(f.read()))
self.text_browser = QTextBrowser(maximumHeight=27)
self.text_browser.setAlignment(Qt.AlignCenter)
self.text_browser.setText(
'achievement points: {}'.format(achievement_points))
vertical_box_layout.addWidget(self.text_browser)
self.list_widget = ListWidget(file_name, 'recent')
vertical_box_layout.addWidget(self.list_widget)
button_delete = ButtonDelete(self, file_name)
vertical_box_layout.addWidget(button_delete)
else:
self.list_widget = ListWidget(file_name)
vertical_box_layout.addWidget(self.list_widget)
points_text_edit = None
if file_usage == 'note':
button_delete = ButtonDelete(self, file_name)
vertical_box_layout.addWidget(button_delete)
task_text_edit = QTextEdit(maximumHeight=27)
task_text_edit.setPlaceholderText('note')
vertical_box_layout.addWidget(task_text_edit)
else:
horizontal_box_layout = QHBoxLayout()
horizontal_box_layout.setContentsMargins(0, 0, 0, 0)
button_done = ButtonDone(self, file_name)
horizontal_box_layout.addWidget(button_done)
button_delete = ButtonDelete(self, file_name)
horizontal_box_layout.addWidget(button_delete)
widget = QWidget(maximumHeight=27)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(horizontal_box_layout)
vertical_box_layout.addWidget(widget)
horizontal_box_layout = QHBoxLayout()
horizontal_box_layout.setContentsMargins(0, 0, 0, 0)
task_text_edit = QTextEdit(maximumHeight=27)
task_text_edit.setPlaceholderText('task')
horizontal_box_layout.addWidget(task_text_edit)
points_text_edit = QTextEdit(maximumHeight=27)
points_text_edit.setPlaceholderText('points')
points_text_edit.setText('1')
horizontal_box_layout.addWidget(points_text_edit)
widget = QWidget(maximumHeight=27)
widget.setContentsMargins(0, 0, 0, 0)
widget.setLayout(horizontal_box_layout)
vertical_box_layout.addWidget(widget)
button_add = ButtonAdd(self.list_widget, task_text_edit, file_name,
points_text_edit)
vertical_box_layout.addWidget(button_add)
self.setLayout(vertical_box_layout)
class App(QFrame):
def __init__(self):
super().__init__()
self.setWindowTitle('Navegador Web')
self.CrearApp()
self.setBaseSize(1366, 768)
def CrearApp(self): # CreateApp()
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
#- crear pestaƱas
self.tabbar = QTabBar(movable=True, tabsClosable=True)
self.tabbar.tabCloseRequested.connect(self.CerrarTab)
self.tabbar.tabBarClicked.connect(self.CambiarTab)
self.tabbar.setCurrentIndex(0)
#- seguimiento de pestaƱas
self.cuentaTab = 0 #tabCount
self.tabs = []
#- crear barra de direcciones
self.Toolbar = QWidget()
self.ToolbarLayout = QHBoxLayout()
self.addressbar = BarraDirecciones()
self.Toolbar.setLayout(self.ToolbarLayout)
self.ToolbarLayout.addWidget(self.addressbar)
#- boton nueva pestaƱa
self.botonAgregarTab = QPushButton('+') # AddTabButton
self.addressbar.returnPressed.connect(self.IrA)
self.botonAgregarTab.clicked.connect(self.AgregarTab)
self.ToolbarLayout.addWidget(self.botonAgregarTab)
#- establecer vista principal
self.contenedor = QWidget() # container
self.contenedor.layout = QStackedLayout()
self.contenedor.setLayout(self.contenedor.layout)
self.layout.addWidget(self.tabbar)
self.layout.addWidget(self.Toolbar)
self.layout.addWidget(self.contenedor)
self.setLayout(self.layout)
self.AgregarTab()
self.show()
def CerrarTab(self, i): # CloseTab()
self.tabbar.removeTab(i)
def AgregarTab(self): # AddTab
i = self.cuentaTab
self.tabs.append(QWidget())
self.tabs[i].layout = QVBoxLayout()
self.tabs[i].setObjectName('pestaƱa' + str(i))
#- abrir webview
self.tabs[i].content = QWebEngineView()
self.tabs[i].content.load(QUrl.fromUserInput('http://google.com'))
#- agregar webview al diseƱo de pestaƱas (layout)
self.tabs[i].layout.addWidget(self.tabs[i].content)
#- establecer pestaƱa top de [] al diseƱo (layout)
self.tabs[i].setLayout(self.tabs[i].layout)
#- agregar pestaƱa al top al widget apilado
self.contenedor.layout.addWidget(self.tabs[i])
self.contenedor.layout.setCurrentWidget(self.tabs[i])
#- establecer la pestaƱa al tope de la pantalla
self.tabbar.addTab('Nueva pestaƱa')
self.tabbar.setTabData(i, 'tab' + str(i))
self.tabbar.setCurrentIndex(i)
self.cuentaTab += 1
def CambiarTab(self, i):
tab_dato = self.tabbar.tabData(i)
print('tab:', tab_dato)
tab_contenido = self.findChild(QWidget, tab_dato)
self.contenedor.layout.setCurrentWidget(tab_contenido)
# self.contenedor.layout.setCurrentWidget(self.tabs[i])
def IrA(self):
text = self.addressbar.text()
print(text)
i = self.tabbar.currentIndex()
tab = self.tabbar.tabData(i)
wv = self.findChild(QWidget, tab).content
if 'http' not in text:
if '.' not in text:
url = 'https://google.com/#q=' + text
else:
url = 'http://' + text
else:
url = text
wv.load(QUrl.fromUserInput(url))
class MyGraphWindow(QMainWindow):
ALPHA_OTHER = 0.2 #lassoééøęćć¼ćæć®éęåŗ¦
PICKER = 5 #lineććÆćŖććÆćććØćć«åå¾ć§ććććć®é å
mycolors = MyColors() #memory the color to use for self.plot method.
def __init__(self, fig=None, geo=None, title='temp'):
super().__init__()
#mutablećŖćŖććøć§ćÆććććć©ć«ćć«ęå®ćććØć¾ććć®ć§ćć®ććć«ęøć
if fig == None:
self.fig = Figure(figsize=(6, 6), dpi=100)
else:
self.fig = fig
if geo == None:
self.geo = QRect(30, 30, 500, 500)
else:
self.geo = geo
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.navi_toolbar = NavigationToolbar(self.canvas, self)
self.lassoAction = QAction('lasso', self.canvas)
self.pointerAction = QAction('pointer', self.canvas)
self.lineAction = QAction('line', self.canvas)
self.lassoAction.setCheckable(True)
self.pointerAction.setCheckable(True)
self.lineAction.setCheckable(True)
self.navi_toolbar.addAction(self.lassoAction)
self.navi_toolbar.addAction(self.pointerAction)
self.navi_toolbar.addAction(self.lineAction)
self.lassoAction.triggered.connect(self.lassoTriggered)
self.pointerAction.triggered.connect(self.pointerTriggered)
self.lineAction.triggered.connect(self.lineTriggered)
self.lassoTarget = None #éøęåÆ¾č±” lassoęćÆcilickć§alphaćäøćć
self.selectedLine = None #éøęäøć®ē¹ćself.lassoTargetć®äøć«ćććććć
self.pre_alpha = 1 #alphaćäøććåć®å¤
self.pre_settings = None #markerć®č²ćØćµć¤ćŗselectedLinećplotććęć«ä½æć
#setTargetć§ęå®ććlineć®ē¹ćØććććlassoć§éøć°ććindexćäæå
self.xys = None #numpy.array åę°2ć®č”å
self.selectedIndices = set()
self.unselectedIndices = set()
#ćÆćŖććÆćććlinećčØę¶ćć¦ććć¦getLineć§åē
§ćęø”ć
self.line = None
self.pre_width = 0 #å¤Ŗćććå¾å
ć«ę»ćć®ć«ä½æć
#ē¹ć®åŗ§ęØćč”Øē¤ŗćć
self.pointer = MyPointer()
self.pointer.deactivate()
self.vbl = QVBoxLayout()
self.vbl.addWidget(self.navi_toolbar)
self.vbl.addWidget(self.canvas)
self.vbl.addWidget(self.pointer)
self.frontPanel = QWidget()
self.frontPanel.setLayout(self.vbl)
self.setCentralWidget(self.frontPanel)
self.setGeometry(self.geo)
self.setWindowTitle(title)
self.show()
def __reduce_ex__(self, proto):
#pickleć®ććć®ć”ć½ćć QMainWindowćÆćć®ć¾ć¾pickleć§ććŖćććØć«ę³Øę
return geneMyGraph, (self.fig, self.geometry(), self.windowTitle())
def getSelected(self):
points = self.xys[list(self.selectedIndices)]
return points
def getUnSelected(self):
points = self.xys[list(self.unselectedIndices)]
return points
def getLine(self):
return self.line
def plot(self, *args, **kwargs):
#pickerćÆlineć®éøęć«ä½æćć®ć§åæ
č¦
kwargs = self._addPickerToValue(kwargs)
kwargs = self._addColorToValue(kwargs)
try: #axćęå®ććć¦ććććć®axć«åƾćć¦ęē»ćč”ć axćē”ćć¾ććÆaxćŖććøć§ćÆć仄å¤ćęå®ććć¦ćććØå¼ę°ć«axćē”ćē¶ę
ć§ę¬”
ax = kwargs.pop('ax')
ax.plot(*args, **kwargs)
except: #ē”ććć°self.figć®ęåć®axć«ęē»ćććććŖććć°ę°ćć«axćčæ½å ćć¦ęē»
try:
ax = self.fig.get_axes()[0]
ax.plot(*args, **kwargs)
except:
ax = self.fig.add_subplot(111)
ax.plot(*args, **kwargs)
self.canvas.draw()
def _addPickerToValue(self, kwargs):
#pickerćē”ććØlassoć§éøęć§ććŖćć®ć§ć¦ć¼ć¶ć¼ćå¼ę°ć«pickerćęå®ććŖćć£ćå “åćÆpickerćå ćć
if 'picker' in kwargs.keys():
return kwargs
else:
kwargs['picker'] = self.PICKER
return kwargs
def _addColorToValue(self, kwargs):
#If color is in the kwargs use it. Otherwise get a color from self.mycolors and use it.
if not 'color' in kwargs.keys():
color = self.mycolors.get_color()
kwargs['color'] = color
return kwargs
def lassoTriggered(self):
if self.lassoAction.isChecked() == True: #pointer Off lassoćOn
if self.pointerAction.isChecked() == True:
self.pointerAction.setChecked(False)
self.pointer.deactivate()
if self.lineAction.isChecked() == True:
self.lineAction.setChecked(False)
self.removeLine()
self.setLasso()
else:
self.removeLasso()
def pointerTriggered(self):
if self.pointerAction.isChecked() == True: #pointer on lassoćoff
if self.lassoAction.isChecked() == True:
self.lassoAction.setChecked(False)
self.removeLasso()
if self.lineAction.isChecked() == True:
self.lineAction.setChecked(False)
self.removeLine()
self.pointer.activate(self.canvas)
else:
self.pointer.deactivate()
def lineTriggered(self):
if self.lineAction.isChecked() == True: #ä»ćoff
if self.lassoAction.isChecked() == True:
self.lassoAction.setChecked(False)
self.removeLasso()
if self.pointerAction.isChecked() == True:
self.pointerAction.setChecked(False)
self.pointer.deactivate()
self.setLine()
else:
self.removeLine()
def setLine(self):
self.linepick = self.canvas.mpl_connect('pick_event',
self.highlightLine)
def removeLine(self):
try:
self.canvas.mpl_disconnect(self.linepick)
if not self.line == None: #éøęććć¦ćććć®ćå
ć«ę»ć
self.line.set_linewidth(self.pre_width)
self.canvas.draw()
self.line = None
self.pre_width = 0
except:
print('line is still not sellected')
def highlightLine(self, event):
#éøęäøć®lineć®č¼Ŗéćå¤Ŗććć
if not len(event.ind):
return True
if not self.line == None: #ååć®clickć§ćŖćå “åćÆå
ć«éøęććć¦ćććć®ćå
ć«ę»ć
self.line.set_linewidth(self.pre_width)
#plotć®čØå®ćäæå
self.line = event.artist
self.pre_width = self.line.get_linewidth()
#alphać®čŖæę“ćØselectedLineć®ęē» ć¾ć invisibleććć¼ćæć®åå¾
self.line.set_linewidth(self.pre_width * 5)
self.canvas.draw()
def setLasso(self):
self.pick = self.canvas.mpl_connect('pick_event', self.setTarget)
def removeLasso(self):
try:
self.canvas.mpl_disconnect(self.pick)
del self.lasso
if not self.lassoTarget == None: #å
ć«éøęććć¦ćććć®ćå
ć«ę»ć
self.lassoTarget.set_alpha(self.pre_alpha)
self.selectedLine.remove()
self.canvas.draw()
#å¤ååæ
č¦ćŖććåæµć®ććć«åęå
self.lassoTarget = None
self.selectedLine = None
self.pre_alpha = 1
self.pre_settings = None
self.xys = None
self.selectedIndices = set()
self.unselectedIndices = set()
except:
print('Lasso is still not setted')
def setTarget(self, event):
#lassoć®åÆ¾č±”ćclickććę±ŗå®ćć
if not len(event.ind):
return True
if not self.lassoTarget == None: #ååć®clickć§ćŖćå “åćÆå
ć«éøęććć¦ćććć®ćå
ć«ę»ć
self.lassoTarget.set_alpha(self.pre_alpha)
try: #ćć£ććęé¤ å¤åćć¤ććć
self.selectedLine.remove()
except:
pass
self.selectedIndices = set()
self.unselectedIndices = set()
#plotć®čØå®ćäæå
self.lassoTarget = event.artist
self.pre_alpha = self.lassoTarget.get_alpha()
self.pre_settings = self.getSettings(self.lassoTarget)
#alphać®čŖæę“ćØselectedLineć®ęē» ć¾ć invisibleććć¼ćæć®åå¾
self.lassoTarget.set_alpha(self.ALPHA_OTHER)
self.selectedLine, = self.lassoTarget.axes.plot([], [],
visible=False,
linestyle='None',
**self.pre_settings)
self.lasso = LassoSelector(self.lassoTarget.axes,
onselect=self.onselect)
self.xys = np.array([[x, y] for x, y in zip(
self.lassoTarget.get_xdata(), self.lassoTarget.get_ydata())])
self.canvas.draw()
def getSettings(self, line):
settings = {
'color': line.get_color(),
'marker': line.get_marker(),
'markersize': line.get_markersize()
}
return settings
def onselect(self, verts):
path = Path(verts)
try:
selected_ind = set(
np.nonzero([path.contains_point(xy) for xy in self.xys])[0])
all_ind = set(range(self.xys.shape[0]))
unselected_ind = all_ind - selected_ind
except:
print('canot determin selected points')
#éøęćććåŗ¦ć«selcectedlineć«čæ½å
self.selectedIndices = self.selectedIndices | selected_ind
self.unselectedIndices = self.unselectedIndices | unselected_ind
self.selectedLine.set_visible(True)
points = self.xys[list(self.selectedIndices)]
self.selectedLine.set_data(points[:, 0], points[:, 1])
self.canvas.draw()
def confirm(self, message, title):
label = WWLabel(message)
vbox = QVBoxLayout()
vbox.addWidget(label)
self.exec_layout(vbox, title)
class pca_viewer(QMainWindow):
def __init__(self, pca_data):
super().__init__()
self.init_window()
self.define_widgets()
self.position_widgets()
self.plots_active = True
self.update_data(pca_data)
self.connect_event_handlers()
def init_window(self):
self.setGeometry(500, 500, 1200, 900) #xPos, yPos, width, heigth
self.center() #center function is defined below
self.setWindowTitle('PCA viewer')
self.container0 = QWidget(self)
self.setCentralWidget(self.container0)
self.grid_container = QGridLayout()
self.container0.setLayout(self.grid_container)
def define_widgets(self):
self.select_column_combo = QComboBox()
self.scores_plot = plot_canvas(
plot_title='Scores plot', x_axis_title='PC score')
self.loadings_plot = plot_canvas(
plot_title='Loadings plot', x_axis_title='wavenumber [cm-1]')
self.explained_variance_plot = plot_canvas(
plot_title='Explained variance', x_axis_title='PC number')
self.reconstructed_spectra_plot = plot_canvas(
plot_title='Reconstructed data',
x_axis_title='wavenumber [cm-1]')
self.x_coord_label = QLabel('x')
self.x_coord_combo = QComboBox()
self.y_coord_label = QLabel('y')
self.y_coord_combo = QComboBox()
self.z_coord_label = QLabel('z')
self.z_coord_combo = QComboBox()
self.sample_label = QLabel('Sample')
self.sample_combo = QComboBox()
self.pcs_for_reconstruction_label = QLabel('PCs for reconstruction')
self.pcs_for_reconstruction_combo = QComboBox()
self.first_pc_scores_combo = QComboBox()
self.second_pc_scores_combo = QComboBox()
self.pc_loadings_combo = QComboBox()
def position_widgets(self):
self.pc_selection_scores_layout = QHBoxLayout()
self.pc_selection_scores_layout.addWidget(self.first_pc_scores_combo)
self.pc_selection_scores_layout.addWidget(self.second_pc_scores_combo)
self.coord_combos_layout = QHBoxLayout()
self.coord_combos_layout.addWidget(self.x_coord_label)
self.coord_combos_layout.addWidget(self.x_coord_combo)
self.coord_combos_layout.addWidget(self.y_coord_label)
self.coord_combos_layout.addWidget(self.y_coord_combo)
self.coord_combos_layout.addWidget(self.z_coord_label)
self.coord_combos_layout.addWidget(self.z_coord_combo)
self.coord_combos_layout.addWidget(self.sample_label)
self.coord_combos_layout.addWidget(self.sample_combo)
self.coord_combos_layout.addWidget(self.pcs_for_reconstruction_label)
self.coord_combos_layout.addWidget(self.pcs_for_reconstruction_combo)
self.coord_combos_layout.addStretch(1)
self.reconstructed_spectra_layout = QVBoxLayout()
self.reconstructed_spectra_layout.addWidget(
self.reconstructed_spectra_plot)
self.reconstructed_spectra_layout.addLayout(self.coord_combos_layout)
self.grid_container.addLayout(self.pc_selection_scores_layout,
*(0, 0), 1, 1)
self.grid_container.addWidget(self.pc_loadings_combo, *(0, 1), 1, 1)
self.grid_container.addWidget(self.scores_plot, *(1, 0), 1, 1)
self.grid_container.addWidget(self.loadings_plot, *(1, 1), 1, 1)
self.grid_container.addWidget(self.explained_variance_plot,
*(2, 0), 1, 1)
self.grid_container.addLayout(self.reconstructed_spectra_layout,
*(2, 1), 1, 1)
def connect_event_handlers(self):
self.first_pc_scores_combo.currentIndexChanged.connect(
self.update_plots)
self.second_pc_scores_combo.currentIndexChanged.connect(
self.update_plots)
self.pc_loadings_combo.currentIndexChanged.connect(self.update_plots)
self.x_coord_combo.currentIndexChanged.connect(self.update_plots)
self.y_coord_combo.currentIndexChanged.connect(self.update_plots)
self.z_coord_combo.currentIndexChanged.connect(self.update_plots)
self.sample_combo.currentIndexChanged.connect(self.update_plots)
self.pcs_for_reconstruction_combo.currentIndexChanged.connect(
self.update_plots)
def update_data(self, pca_data):
self.input_datatype = type(pca_data)
self.input_data = pca_data
if type(pca_data) in [spectroscopy_data, raman_image]:
self.pcr_object = self.input_data.pca
else: # is assumed to be instance of principal_component_regression
self.pcr_object = self.input_data
self.init_combo_boxes()
self.update_plots()
def init_combo_boxes(self):
# Disables the update_spectra_plots function.
self.plots_active = False
self.first_pc_scores_combo.clear()
self.first_pc_scores_combo.addItems(
self.pcr_object.pca_scores.columns.to_numpy().astype(str))
self.first_pc_scores_combo.setCurrentIndex(0)
self.second_pc_scores_combo.clear()
self.second_pc_scores_combo.addItems(
self.pcr_object.pca_scores.columns.to_numpy().astype(str))
self.second_pc_scores_combo.setCurrentIndex(1)
self.pc_loadings_combo.clear()
self.pc_loadings_combo.addItems(
self.pcr_object.pca_loadings.columns.to_numpy().astype(str))
self.pc_loadings_combo.setCurrentIndex(0)
self.sample_combo.clear()
self.x_coord_combo.clear()
self.y_coord_combo.clear()
self.z_coord_combo.clear()
if self.input_datatype is raman_image:
self.x_coord_combo.addItems(
np.char.mod('%s',np.around(
self.input_data.get_coord_values(
'real',axis = 'x'),1)))
self.y_coord_combo.addItems(
np.char.mod('%s',np.around(
self.input_data.get_coord_values(
'real',axis = 'y'),1)))
self.z_coord_combo.addItems(
np.char.mod('%s',np.around(
self.input_data.get_coord_values(
'real',axis = 'z'),1)))
if len(self.input_data.get_coord_values('coded',axis = 'x')) > 1:
self.x_coord_combo.setEnabled(True)
else:
self.x_coord_combo.setEnabled(False)
if len(self.input_data.get_coord_values('coded',axis = 'y')) > 1:
self.y_coord_combo.setEnabled(True)
else:
self.y_coord_combo.setEnabled(False)
if len(self.input_data.get_coord_values('coded',axis = 'z')) > 1:
self.z_coord_combo.setEnabled(True)
else:
self.z_coord_combo.setEnabled(False)
self.sample_combo.setEnabled(False)
else:
self.x_coord_combo.setEnabled(False)
self.y_coord_combo.setEnabled(False)
self.z_coord_combo.setEnabled(False)
self.sample_combo.setEnabled(True)
self.sample_combo.addItems(
self.pcr_object.pca_scores.index.values.astype(str))
self.sample_combo.setCurrentIndex(0)
self.pcs_for_reconstruction_combo.clear()
self.pcs_for_reconstruction_combo.addItems(
self.pcr_object.pca_scores.columns.to_numpy().astype(str))
self.pcs_for_reconstruction_combo.setCurrentIndex(0)
# Now the update_spectra_plots function will do something.
self.plots_active = True
def update_plots(self):
if self.plots_active is False:
return
self.scores_plot.axes.clear()
self.loadings_plot.axes.clear()
self.explained_variance_plot.axes.clear()
self.scores_plot.plot(
self.pcr_object.pca_scores[
int(self.first_pc_scores_combo.currentText())],
self.pcr_object.pca_scores[
int(self.second_pc_scores_combo.currentText())],
pen='b', mode='scatter')
# self.scores_plot.axes.axhline(0, ls='dotted')
# self.scores_plot.axes.axvline(0, ls='dotted')
self.loadings_plot.plot(
self.pcr_object.pca_loadings.index,
self.pcr_object.pca_loadings[
int(self.pc_loadings_combo.currentText())],
pen='b', mode='line')
x_explained_variance = np.insert(
self.pcr_object.pca_explained_variance.index.values, 0, 0)
y_explained_variance = np.insert(
self.pcr_object.pca_explained_variance['cum'].values, 0, 0)
for ii, jj in zip(x_explained_variance[1:], y_explained_variance[1:]):
self.explained_variance_plot.axes.annotate(
str(round(jj, 3)), xy=(ii, 0.05))
self.explained_variance_plot.plot(
x_explained_variance, y_explained_variance, pen='b', mode='line')
reconstruction_pca_components = int(
self.pcs_for_reconstruction_combo.currentText())
self.reconstructed_data = self.pcr_object.reconstruct_data(
used_pcs=reconstruction_pca_components)
if self.input_datatype is raman_image:
selected_spectrum_index = (
self.get_coord(
'coded',
coord_value=float(self.x_coord_combo.currentText())),
self.get_coord(
'coded',
coord_value=float(self.y_coord_combo.currentText())),
self.get_coord(
'coded',
coord_value=float(self.z_coord_combo.currentText())))
else:
selected_spectrum_index = self.sample_combo.currentText()
self.reconstructed_spectra_plot.axes.clear()
self.reconstructed_spectra_plot.plot(
self.pcr_object.x.columns,
self.pcr_object.reconstruct_input().loc[
selected_spectrum_index, :],
pen='k')
self.reconstructed_spectra_plot.plot(
self.reconstructed_data.columns,
self.reconstructed_data.loc[
selected_spectrum_index, :],
pen='r')
def center(self): # centers object on screen
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def get_coord(self, value_sort, axis='x', coord_value=None,
mode='raw_data'):
if coord_value is not None:
if value_sort == 'coded':
return_value = round(
coord_value*self.input_data.coord_conversion_factor)
else:
return_value = (coord_value/
self.input_data.coord_conversion_factor)
else:
if mode == 'raw_data':
if axis == 'x':
return_value = float(self.x_coord_combo.currentText())
elif axis == 'y':
return_value = float(self.y_coord_combo.currentText())
elif axis == 'z':
return_value = float(self.z_coord_combo.currentText())
elif mode == 'processed':
if axis == 'x':
return_value = float(
self.x_coord_combo_edited.currentText())
elif axis == 'y':
return_value = float(
self.y_coord_combo_edited.currentText())
elif axis == 'z':
return_value = float(
self.z_coord_combo_edited.currentText())
if value_sort == 'coded':
return_value = round(
return_value*self.input_data.coord_conversion_factor)
return return_value
def __init__(self, config: 'SimpleConfig', exctype, value, tb):
BaseCrashReporter.__init__(self, exctype, value, tb)
self.network = Network.get_instance()
self.config = config
QWidget.__init__(self)
self.setWindowTitle('Electrum - ' + _('An Error Occurred'))
self.setMinimumSize(600, 300)
Logger.__init__(self)
main_box = QVBoxLayout()
heading = QLabel('<h2>' + BaseCrashReporter.CRASH_TITLE + '</h2>')
main_box.addWidget(heading)
main_box.addWidget(QLabel(BaseCrashReporter.CRASH_MESSAGE))
main_box.addWidget(QLabel(BaseCrashReporter.REQUEST_HELP_MESSAGE))
collapse_info = QPushButton(_("Show report contents"))
collapse_info.clicked.connect(
lambda: self.msg_box(QMessageBox.NoIcon,
self,
_("Report contents"),
self.get_report_string(),
rich_text=True))
main_box.addWidget(collapse_info)
main_box.addWidget(QLabel(BaseCrashReporter.DESCRIBE_ERROR_MESSAGE))
self.description_textfield = QTextEdit()
self.description_textfield.setFixedHeight(50)
self.description_textfield.setPlaceholderText(
self.USER_COMMENT_PLACEHOLDER)
main_box.addWidget(self.description_textfield)
main_box.addWidget(QLabel(BaseCrashReporter.ASK_CONFIRM_SEND))
buttons = QHBoxLayout()
report_button = QPushButton(_('Send Bug Report'))
report_button.clicked.connect(self.send_report)
report_button.setIcon(read_QIcon("tab_send.png"))
buttons.addWidget(report_button)
never_button = QPushButton(_('Never'))
never_button.clicked.connect(self.show_never)
buttons.addWidget(never_button)
close_button = QPushButton(_('Not Now'))
close_button.clicked.connect(self.close)
buttons.addWidget(close_button)
main_box.addLayout(buttons)
self.setLayout(main_box)
self.show()
def derivation_and_script_type_gui_specific_dialog(
self,
*,
title: str,
message1: str,
choices: List[Tuple[str, str, str]],
hide_choices: bool = False,
message2: str,
test_text: Callable[[str], int],
run_next,
default_choice_idx: int = 0,
get_account_xpub=None,
) -> Tuple[str, str]:
vbox = QVBoxLayout()
if get_account_xpub:
button = QPushButton(_("Detect Existing Accounts"))
def on_account_select(account):
script_type = account["script_type"]
if script_type == "p2pkh":
script_type = "standard"
button_index = c_values.index(script_type)
button = clayout.group.buttons()[button_index]
button.setChecked(True)
line.setText(account["derivation_path"])
button.clicked.connect(lambda: Bip39RecoveryDialog(
self, get_account_xpub, on_account_select))
vbox.addWidget(button, alignment=Qt.AlignLeft)
vbox.addWidget(QLabel(_("Or")))
c_values = [x[0] for x in choices]
c_titles = [x[1] for x in choices]
c_default_text = [x[2] for x in choices]
def on_choice_click(clayout):
idx = clayout.selected_index()
line.setText(c_default_text[idx])
clayout = ChoicesLayout(message1,
c_titles,
on_choice_click,
checked_index=default_choice_idx)
if not hide_choices:
vbox.addLayout(clayout.layout())
vbox.addWidget(WWLabel(message2))
line = QLineEdit()
def on_text_change(text):
self.next_button.setEnabled(test_text(text))
line.textEdited.connect(on_text_change)
on_choice_click(clayout) # set default text for "line"
vbox.addWidget(line)
self.exec_layout(vbox, title)
choice = c_values[clayout.selected_index()]
return str(line.text()), choice
class WaterfallPlotter(QWidget):
generated_rectangles_signal = QtCore.pyqtSignal(list) #send list of rects for data display in tree
def __init__(self,parent):
super(WaterfallPlotter,self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas,self)
self.btn_plot = QPushButton('Default Plot')
self.btn_plot.clicked.connect(self.default_plot)
self.layout = QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.btn_plot)
self.setLayout(self.layout)
def on_waterfall_data_signal(self,signal):
self.waterfall_data = signal['waterfall_data'] #pandas dataframe
self.btn_plot.setEnabled(True)
def on_general_settings_signal(self,signal):
try:
hasattr(self,'ax')
self.ax.set_title(signal[0])
self.ax.set_xlabel(signal[1])
self.ax.set_ylabel(signal[2])
self.canvas.draw()
except Exception as e:
print(e)
def default_plot(self):
'''
Plot waterfall data
'''
self.figure.clear()
self.rect_locations = np.arange(len(self.waterfall_data['Best response percent change']))
self.ax = self.figure.add_subplot(111)
self.ax.axhline(y=20, linestyle='--', c='k', alpha=0.5, lw=2.0, label='twenty_percent')
self.ax.axhline(y=-30, linestyle='--', c='k', alpha=0.5, lw=2.0, label='thirty_percent')
self.ax.axhline(y=0, c='k', alpha=1, lw=2.0, label='zero_percent')
self.ax.grid(color = 'k', axis = 'y', alpha=0.25)
self.rects = self.ax.bar(self.rect_locations,self.waterfall_data['Best response percent change'])
self.auto_label_responses(self.ax, self.rects, self.waterfall_data)
#self.plot_table()
self.canvas.draw()
self.ax.hold(False) #rewrite the plot when plot() called
self.generated_rectangles_signal.emit([self.rects])
def plot_table(self):
rows = ['%s' % x for x in self.waterfall_data.keys()]
rows = rows[4:] #skip first three, they are the 4 standard headers, rest are table rows
columns = self.waterfall_data['Patient number'] #patient numbers
cell_text = []
for row in rows:
cell_text_temp = []
for col in range(len(columns)):
cell_text_temp.append(self.waterfall_data[row][col])
cell_text.append(cell_text_temp)
the_table = plt.table(cellText=cell_text, rowLabels=rows, colLabels=columns, loc='bottom', cellLoc='center')
plt.subplots_adjust(bottom=0.15,left=0.5)
self.ax.set_xlim(-0.5,len(columns)-0.5)
plt.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom='off', # ticks along the bottom edge are off
top='off', # ticks along the top edge are off
labelbottom='off'
) # labels along the bottom edge are off
def update_plot(self):
'''
TODO
'''
pass
def auto_label_responses(self, ax, rects, waterfall_data):
'''Add labels above/below bars'''
i = 0
for rect in rects:
height = rect.get_height()
if height >= 0:
valign = 'bottom'
else:
valign = 'top'
ax.text(rect.get_x() + rect.get_width()/2., height,
'%s' % waterfall_data['Overall response'][i], ha='center', va=valign)
i+=1
def select_storage(
self, path,
get_wallet_from_daemon) -> Tuple[str, Optional[WalletStorage]]:
vbox = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addWidget(QLabel(_('Wallet') + ':'))
name_e = QLineEdit()
hbox.addWidget(name_e)
button = QPushButton(_('Choose...'))
hbox.addWidget(button)
vbox.addLayout(hbox)
msg_label = WWLabel('')
vbox.addWidget(msg_label)
hbox2 = QHBoxLayout()
pw_e = PasswordLineEdit('', self)
pw_e.setFixedWidth(17 * char_width_in_lineedit())
pw_label = QLabel(_('Password') + ':')
hbox2.addWidget(pw_label)
hbox2.addWidget(pw_e)
hbox2.addStretch()
vbox.addLayout(hbox2)
vbox.addSpacing(50)
vbox_create_new = QVBoxLayout()
vbox_create_new.addWidget(QLabel(_('Alternatively') + ':'),
alignment=Qt.AlignLeft)
button_create_new = QPushButton(_('Create New Wallet'))
button_create_new.setMinimumWidth(120)
vbox_create_new.addWidget(button_create_new, alignment=Qt.AlignLeft)
widget_create_new = QWidget()
widget_create_new.setLayout(vbox_create_new)
vbox_create_new.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(widget_create_new)
self.set_layout(vbox, title=_('Electrum-ECC wallet'))
temp_storage = None # type: Optional[WalletStorage]
wallet_folder = os.path.dirname(path)
def on_choose():
path, __ = QFileDialog.getOpenFileName(self,
"Select your wallet file",
wallet_folder)
if path:
name_e.setText(path)
def on_filename(filename):
# FIXME? "filename" might contain ".." (etc) and hence sketchy path traversals are possible
nonlocal temp_storage
temp_storage = None
msg = None
if filename:
path = os.path.join(wallet_folder, filename)
wallet_from_memory = get_wallet_from_daemon(path)
try:
if wallet_from_memory:
temp_storage = wallet_from_memory.storage # type: Optional[WalletStorage]
else:
temp_storage = WalletStorage(path)
except (StorageReadWriteError, WalletFileException) as e:
msg = _('Cannot read file') + f'\n{repr(e)}'
except Exception as e:
self.logger.exception('')
msg = _('Cannot read file') + f'\n{repr(e)}'
else:
msg = _('')
self.next_button.setEnabled(temp_storage is not None)
user_needs_to_enter_password = False
if temp_storage:
if not temp_storage.file_exists():
msg =_("This file does not exist.") + '\n' \
+ _("Press 'Next' to create this wallet, or choose another file.")
elif not wallet_from_memory:
if temp_storage.is_encrypted_with_user_pw():
msg = _("This file is encrypted with a password.") + '\n' \
+ _('Enter your password or choose another file.')
user_needs_to_enter_password = True
elif temp_storage.is_encrypted_with_hw_device():
msg = _("This file is encrypted using a hardware device.") + '\n' \
+ _("Press 'Next' to choose device to decrypt.")
else:
msg = _("Press 'Next' to open this wallet.")
else:
msg = _("This file is already open in memory.") + "\n" \
+ _("Press 'Next' to create/focus window.")
if msg is None:
msg = _('Cannot read file')
msg_label.setText(msg)
widget_create_new.setVisible(
bool(temp_storage and temp_storage.file_exists()))
if user_needs_to_enter_password:
pw_label.show()
pw_e.show()
pw_e.setFocus()
else:
pw_label.hide()
pw_e.hide()
button.clicked.connect(on_choose)
button_create_new.clicked.connect(
partial(name_e.setText, get_new_wallet_name(wallet_folder)))
name_e.textChanged.connect(on_filename)
name_e.setText(os.path.basename(path))
def run_user_interaction_loop():
while True:
if self.loop.exec_() != 2: # 2 = next
raise UserCancelled()
assert temp_storage
if temp_storage.file_exists(
) and not temp_storage.is_encrypted():
break
if not temp_storage.file_exists():
break
wallet_from_memory = get_wallet_from_daemon(temp_storage.path)
if wallet_from_memory:
raise WalletAlreadyOpenInMemory(wallet_from_memory)
if temp_storage.file_exists() and temp_storage.is_encrypted():
if temp_storage.is_encrypted_with_user_pw():
password = pw_e.text()
try:
temp_storage.decrypt(password)
break
except InvalidPassword as e:
self.show_message(title=_('Error'), msg=str(e))
continue
except BaseException as e:
self.logger.exception('')
self.show_message(title=_('Error'), msg=repr(e))
raise UserCancelled()
elif temp_storage.is_encrypted_with_hw_device():
try:
self.run('choose_hw_device',
HWD_SETUP_DECRYPT_WALLET,
storage=temp_storage)
except InvalidPassword as e:
self.show_message(
title=_('Error'),
msg=
_('Failed to decrypt using this hardware device.'
) + '\n' +
_('If you use a passphrase, make sure it is correct.'
))
self.reset_stack()
return self.select_storage(path,
get_wallet_from_daemon)
except (UserCancelled, GoBack):
raise
except BaseException as e:
self.logger.exception('')
self.show_message(title=_('Error'), msg=repr(e))
raise UserCancelled()
if temp_storage.is_past_initial_decryption():
break
else:
raise UserCancelled()
else:
raise Exception('Unexpected encryption version')
try:
run_user_interaction_loop()
finally:
try:
pw_e.clear()
except RuntimeError: # wrapped C/C++ object has been deleted.
pass # happens when decrypting with hw device
return temp_storage.path, (temp_storage
if temp_storage.file_exists() else None)
class PlotDialog(QDialog):
def __init__(self,
size=(640, 480),
lock_aspect=False,
straxis=None,
par=None):
super(PlotDialog, self).__init__()
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMinMaxButtonsHint)
self.size = size
self.par = par
if straxis is None:
self.axes = Axes(lock_aspect=lock_aspect)
else:
self.axes = Axes(lock_aspect=lock_aspect,
axisItems={'bottom': straxis})
self.opts_dlg = PlotOptions(parent=self)
self.initVar()
self.initUI()
self.sigConnect()
def initVar(self):
self.n_data = 0
self.xlabel = None
self.ylabel = None
self.x_unit = None
self.y_unit = None
def initUI(self):
self.setWindowTitle('Plot')
self.layout = QVBoxLayout()
self.txt = {}
self.inf_line = {
'meanx': None,
'meany': None,
'std1x': None,
'std2x': None,
'std1y': None,
'std2y': None,
}
self.tr_line = False
btns = QDialogButtonBox.Save | QDialogButtonBox.Close
self.buttons = QDialogButtonBox(btns)
self.opts_btn = QPushButton('Options')
# self.test_btn = QPushButton('Test')
self.buttons.button(QDialogButtonBox.Close).setAutoDefault(True)
self.buttons.button(QDialogButtonBox.Close).setDefault(True)
self.buttons.button(QDialogButtonBox.Save).setText('Save Plot')
self.buttons.button(QDialogButtonBox.Save).setAutoDefault(False)
self.buttons.button(QDialogButtonBox.Save).setDefault(False)
self.opts_btn.setAutoDefault(False)
self.opts_btn.setDefault(False)
# self.test_btn.setAutoDefault(False)
# self.test_btn.setDefault(False)
self.actionEnabled(False)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.opts_btn)
# btn_layout.addWidget(self.test_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.buttons)
self.layout.addWidget(self.axes)
self.layout.addLayout(btn_layout)
self.setLayout(self.layout)
self.resize(self.size[0], self.size[1])
# self.crosshair()
# self.axis_line()
def sigConnect(self):
self.buttons.rejected.connect(self.on_close)
self.buttons.accepted.connect(self.on_save)
self.opts_btn.clicked.connect(self.on_opts_dialog)
# self.test_btn.clicked.connect(self.on_test)
[
opt.stateChanged.connect(self.apply_stddev_opts)
for opt in self.opts_dlg.stdv_chks
]
[
opt.stateChanged.connect(self.apply_mean_opts)
for opt in self.opts_dlg.mean_chks
]
self.opts_dlg.trdl_btngrp.buttonClicked[int].connect(
self.apply_trendline_opts)
self.opts_dlg.poly_ordr_spn.valueChanged.connect(
self.on_poly_order_changed)
# self.proxy = pg.SignalProxy(self.axes.linePlot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved)
def on_test(self):
pass
def plot(self, *args, **kwargs):
self.axes.plot(*args, **kwargs)
self.n_data += 1
def scatter(self, *args, **kwargs):
self.axes.scatterPlot.clear()
self.axes.scatter(*args, **kwargs)
self.n_data += 1
def histogram(self, data, bins=20, **kwargs):
y, x = np.histogram(data, bins=bins)
self.plot(x, y, stepMode=True, savedata=False, **kwargs)
self.axes.setXRange(np.min(x), np.max(x))
self.axes.setYRange(np.min(y), np.max(y))
tag = kwargs['name'] if 'name' in kwargs.keys(
) else f'series{self.n_data-1}'
self.axes.data[tag] = np.stack((data, data)).T
def annotate(self, tag, pos=(0, 0), angle=0, *args, **kwargs):
txt = pg.TextItem(*args, **kwargs)
txt.setPos(pos[0], pos[1])
txt.setAngle(angle)
self.txt[tag] = txt
self.axes.addItem(txt)
def clearAnnotation(self, tag):
if self.txt:
self.axes.removeItem(self.txt[tag])
self.txt.pop(tag)
def setLabels(self,
xlabel,
ylabel,
x_unit=None,
y_unit=None,
x_prefix=None,
y_prefix=None):
self.xlabel = xlabel
self.ylabel = ylabel
self.x_unit = x_unit
self.y_unit = y_unit
self.axes.setLabel('bottom', xlabel, x_unit, x_prefix)
self.axes.setLabel('left', ylabel, y_unit, y_prefix)
def setTitle(self, title):
self.setWindowTitle('Graph of ' + title)
self.axes.setTitle(title)
def actionEnabled(self, state):
self.meanActionEnabled(state)
self.stddevActionEnabled(state)
self.trendActionEnabled(state)
def meanActionEnabled(self, state):
[opt.setEnabled(state) for opt in self.opts_dlg.mean_chks]
def trendActionEnabled(self, state):
[opt.setEnabled(state) for opt in self.opts_dlg.trdl_opts]
def stddevActionEnabled(self, state):
[opt.setEnabled(state) for opt in self.opts_dlg.stdv_chks]
def on_avgline(self, axis):
name = "mean"
if self.inf_line[name + axis]:
return
x, y = self.get_data()
if x is None or y is None:
return
mean = x.mean() if axis == 'x' else y.mean()
anchor = (0, 1) #if axis=='x' else (0, 0)
pos = (mean, max(y)) if axis == 'x' else (max(x), mean)
angle = 0 if axis == 'y' else 90
unit = self.x_unit if axis == 'x' else self.y_unit
self.create_inf_line(mean, axis, name, pg.mkPen(color='c', width=2))
self.annotate(name + axis,
anchor=anchor,
pos=pos,
angle=angle,
text=f'mean_{axis}: {mean:#.2f} {unit}')
def get_data(self):
max_size = 0
max_tag = None
for tag, data in self.axes.data.items():
if data.shape[0] > max_size:
max_size = data.shape[0]
max_tag = tag
if max_size == 0 or max_tag is None:
return None, None
return self.axes.data[max_tag].T
def get_plot_data(self):
max_size = 0
max_idx = 0
for idx, curve in enumerate(self.axes.plotItem.curves):
curve_data = curve.getData()
if curve_data[0] is None or curve.name() == 'trendline':
continue
size = curve_data[0].size
if size > max_size:
max_size = size
max_idx = idx
if max_size == 0:
return None, None
return self.axes.plotItem.curves[max_idx].getData()
def on_stddev(self, axis):
name1 = 'std1'
name2 = 'std2'
if self.inf_line[name1 + axis] and self.inf_line[name2 + axis]:
return
x, y = self.get_data()
if x is None or y is None:
return
dep_v = x if axis == 'x' else y
indep_v = y if axis == 'x' else x
mean = dep_v.mean()
std = dep_v.std()
pos1 = (max(x), mean + std) if axis == 'y' else (mean + std, max(y))
pos2 = (max(x), mean - std) if axis == 'y' else (mean - std, max(y))
anchor1 = (0, 1) if axis == 'y' else (0, 1)
anchor2 = (0, 1) if axis == 'y' else (0, 1)
angle = 0 if axis == 'y' else 90
unit = self.x_unit if axis == 'x' else self.y_unit
pen = pg.mkPen(color='m', width=2)
self.create_inf_line(mean + std, axis, name1, pen)
self.create_inf_line(mean - std, axis, name2, pen)
self.annotate(name1 + axis,
anchor=anchor1,
pos=pos1,
angle=angle,
text=f'std_{axis}: +{std:#.2f} {unit}')
self.annotate(name2 + axis,
anchor=anchor2,
pos=pos2,
angle=angle,
text=f'std_{axis}: -{std:#.2f} {unit}')
def on_trendline(self, method):
if self.tr_line:
self.clear_trendline()
x, y = self.get_data()
if x is None or y is None:
return
model = CurveFit(x, y)
if method == 'linear' or method == 'polynomial':
degree = 1 if method == 'linear' else self.opts_dlg.poly_ordr_spn.value(
)
param, r2, predict = model.polyfit(degree)
eq = model.get_poly_eq(param)
elif method == 'exponential':
param, r2, predict = model.expfit()
eq = model.get_exp_eq(param)
elif method == 'logarithmic':
param, r2, predict = model.logfit()
eq = model.get_log_eq(param)
else:
return
pos = ((x[0] + x[-1]) // 2, (y[0] + y[-1]) // 2)
x_trend = np.arange(x[0], x[-1] + 0.01, 0.01)
self.plot(x_trend,
predict(x_trend),
name='trendline',
pen={
'color': "FF0000",
'width': 2.5
})
self.annotate('tr', pos=pos, text=f'y = {eq}\nRĀ² = {r2:#.4f}')
self.tr_line = True
def clear_stddev(self, axis):
if self.inf_line['std1' + axis] and self.inf_line['std2' + axis]:
self.clear_inf_line(axis, 'std1')
self.clear_inf_line(axis, 'std2')
self.clearAnnotation('std1' + axis)
self.clearAnnotation('std2' + axis)
def clear_mean(self, axis):
if self.inf_line['mean' + axis]:
self.clear_inf_line(axis, 'mean')
self.clearAnnotation('mean' + axis)
def clear_trendline(self):
if self.tr_line:
self.tr_line = False
self.axes.clear_graph('trendline')
self.clearAnnotation('tr')
def apply_mean_opts(self):
self.on_avgline('x') if self.opts_dlg.x_mean_chk.isChecked(
) else self.clear_mean('x')
self.on_avgline('y') if self.opts_dlg.y_mean_chk.isChecked(
) else self.clear_mean('y')
def apply_stddev_opts(self):
self.on_stddev('x') if self.opts_dlg.x_stdv_chk.isChecked(
) else self.clear_stddev('x')
self.on_stddev('y') if self.opts_dlg.y_stdv_chk.isChecked(
) else self.clear_stddev('y')
def apply_trendline_opts(self, idx):
button = self.opts_dlg.trdl_btngrp.button(idx)
method = button.text().lower()
self.on_trendline(method)
def on_poly_order_changed(self):
self.on_trendline('polynomial')
def on_opts_dialog(self):
if self.opts_dlg.isVisible():
self.opts_dlg.close()
return
rect = self.frameGeometry()
x, y = rect.topLeft().x(), rect.topLeft().y()
self.opts_dlg.show()
if x - self.opts_dlg.width() < 0:
self.opts_dlg.move(x, y)
else:
self.opts_dlg.move(x - self.opts_dlg.width(), y)
def on_close(self):
self.close()
def on_save(self):
accepted_format = """
PNG (*.png);;
TIFF (*.tif;*.tiff);;
JPEG (*.jpg;*.jpeg;*.jpe;*.jfif);;
Bitmap (*.bmp);;
Scalable Vector Graphics (*.svg);;
Comma-Separated Value (*.csv);;
Microsoft Excel Workbook (*.xlsx)
"""
filename, _ = QFileDialog.getSaveFileName(self,
"Save plot as image...",
self.windowTitle(),
accepted_format)
if not filename:
return
if not filename.lower().endswith(('.csv', '.svg', '.xlsx')):
exporter = pg.exporters.ImageExporter(self.axes.plotItem)
exporter.parameters()['width'] *= 2
elif filename.lower().endswith('.csv'):
exporter = CSVExporter(self.axes.plotItem,
xheader=self.xlabel,
yheader=self.ylabel)
elif filename.lower().endswith('.xlsx'):
exporter = XLSXExporter(self.axes.plotItem,
xheader=self.xlabel,
yheader=self.ylabel)
elif filename.lower().endswith('.svg'):
exporter = pg.exporters.SVGExporter(self.axes.plotItem)
else:
return
exporter.export(filename)
def create_inf_line(self, value, axis, name, pen=None):
if axis == 'x' or axis == 'y':
angle = 90 if axis == 'x' else 0
else:
return
self.inf_line[name + axis] = pg.InfiniteLine(angle=angle,
movable=False,
pen=pen)
self.axes.addItem(self.inf_line[name + axis])
self.inf_line[name + axis].setPos(value)
self.inf_line[name + axis].setZValue(-10)
def bar(self, *args, **kwargs):
self.axes.clearAll()
self.axes.bar(*args, **kwargs)
def clear_inf_line(self, axis, name):
if self.inf_line[name + axis]:
self.axes.removeItem(self.inf_line[name + axis])
self.inf_line[name + axis] = None
def axis_line(self):
self.y_axis = pg.InfiniteLine(angle=90,
movable=False,
pen={
'color': "FFFFFF",
'width': 1.5
})
self.x_axis = pg.InfiniteLine(angle=0,
movable=False,
pen={
'color': "FFFFFF",
'width': 1.5
})
self.y_axis.setZValue(-100)
self.x_axis.setZValue(-100)
self.axes.addItem(self.y_axis, ignoreBounds=True)
self.axes.addItem(self.x_axis, ignoreBounds=True)
def crosshair(self):
self.vLine = pg.InfiniteLine(angle=90,
movable=False,
pen={
'color': "FFFFFF",
'width': 1.5
})
self.hLine = pg.InfiniteLine(angle=0,
movable=False,
pen={
'color': "FFFFFF",
'width': 1.5
})
self.axes.addItem(self.vLine, ignoreBounds=True)
self.axes.addItem(self.hLine, ignoreBounds=True)
def mouseMoved(self, evt):
pos = evt[
0] ## using signal proxy turns original arguments into a tuple
if self.axes.sceneBoundingRect().contains(pos):
mousePoint = self.axes.plotItem.vb.mapSceneToView(pos)
index = int(mousePoint.x())
# if index > 0 and index < len(data1):
self.axes.setTitle(
"<span style='font-size: 12pt'>x=%0.1f, <span style='color: red'>y=%0.1f</span>"
% (mousePoint.x(), mousePoint.y()))
self.vLine.setPos(mousePoint.x())
self.hLine.setPos(mousePoint.y())
def closeEvent(self, event):
if self.opts_dlg.isVisible():
self.opts_dlg.close()
if self.par is not None:
self.par.plot_dialog_closed()
class RenameROIWindow(QDialog):
def __init__(self,
standard_volume_names,
standard_organ_names,
rtss,
roi_id,
roi_name,
rename_signal,
suggested_text="",
*args,
**kwargs):
super(RenameROIWindow, self).__init__(*args, **kwargs)
if platform.system() == 'Darwin':
self.stylesheet_path = "src/res/stylesheet.qss"
else:
self.stylesheet_path = "src/res/stylesheet-win-linux.qss"
stylesheet = open(resource_path(self.stylesheet_path)).read()
self.setStyleSheet(stylesheet)
self.standard_volume_names = standard_volume_names
self.standard_organ_names = standard_organ_names
self.rtss = rtss
self.roi_id = roi_id
self.roi_name = roi_name
self.rename_signal = rename_signal
self.suggested_text = suggested_text
self.setWindowTitle("Rename Region of Interest")
self.setMinimumSize(300, 90)
self.icon = QtGui.QIcon()
self.icon.addPixmap(
QtGui.QPixmap(resource_path("src/res/images/icon.ico")),
QtGui.QIcon.Normal, QtGui.QIcon.Off) # adding icon
self.setWindowIcon(self.icon)
self.explanation_text = QLabel("Enter a new name:")
self.input_field = QLineEdit()
self.input_field.setText(self.suggested_text)
self.input_field.textChanged.connect(self.on_text_edited)
self.feedback_text = QLabel()
self.button_area = QWidget()
self.cancel_button = QPushButton("Cancel")
self.cancel_button.clicked.connect(self.close)
self.rename_button = QPushButton("Rename")
self.rename_button.clicked.connect(self.on_rename_clicked)
self.button_layout = QHBoxLayout()
self.button_layout.addWidget(self.cancel_button)
self.button_layout.addWidget(self.rename_button)
self.button_area.setLayout(self.button_layout)
self.list_label = QLabel()
self.list_label.setText("List of Standard Region of Interests")
# Populating the table of ROIs
self.list_of_ROIs = QListWidget()
self.list_of_ROIs.addItem(
"------------Standard Organ Names------------")
for organ in self.standard_organ_names:
self.list_of_ROIs.addItem(organ)
self.list_of_ROIs.addItem(
"------------Standard Volume Names------------")
for volume in self.standard_volume_names:
self.list_of_ROIs.addItem(volume)
self.list_of_ROIs.clicked.connect(self.on_ROI_clicked)
self.layout = QVBoxLayout()
self.layout.addWidget(self.explanation_text)
self.layout.addWidget(self.input_field)
self.layout.addWidget(self.feedback_text)
self.layout.addWidget(self.button_area)
self.layout.addWidget(self.list_label)
self.layout.addWidget(self.list_of_ROIs)
self.setLayout(self.layout)
def on_text_edited(self, text):
if text in self.standard_volume_names or text in self.standard_organ_names:
self.feedback_text.setStyleSheet("color: green")
self.feedback_text.setText("Entered text is in standard names")
elif text.upper() in self.standard_volume_names or text.upper(
) in self.standard_organ_names:
self.feedback_text.setStyleSheet("color: orange")
self.feedback_text.setText(
"Entered text exists but should be in capitals")
elif text == "":
self.feedback_text.setText("")
else:
self.feedback_text.setStyleSheet("color: red")
self.feedback_text.setText("Entered text is not in standard names")
for item in self.standard_volume_names:
if text.startswith(item):
self.feedback_text.setStyleSheet("color: green")
self.feedback_text.setText("Entered text is in standard names")
else:
upper_text = text.upper()
if upper_text.startswith(item):
self.feedback_text.setStyleSheet("color: orange")
self.feedback_text.setText(
"Entered text exists but should be in capitals")
def on_rename_clicked(self):
self.new_name = self.input_field.text()
progress_window = RenameROIProgressWindow(self,
QtCore.Qt.WindowTitleHint)
progress_window.signal_roi_renamed.connect(self.on_roi_renamed)
progress_window.start_renaming(self.rtss, self.roi_id, self.new_name)
progress_window.show()
def on_roi_renamed(self, new_rtss):
self.rename_signal.emit((new_rtss, {
"rename": [self.roi_name, self.new_name]
}))
QtWidgets.QMessageBox.about(
self, "Saved", "Region of interest successfully renamed!")
self.close()
def on_ROI_clicked(self):
clicked_ROI = self.list_of_ROIs.currentItem()
# Excluding headers from being clicked.
if not str(clicked_ROI.text()).startswith("------------Standard"):
self.input_field.setText(str(clicked_ROI.text()))
def __init__(self):
super(RoadMapWindow, self).__init__()
self.proxy = TableProxy()
self.BeadPlateTable = self.proxy.makeTable('Bead Plate Table', MAX_ROW,
30)
self.bigRoadTable = self.proxy.makeTable('Big Road Table', MAX_ROW, 30)
self.bigEyeRoadTable = self.proxy.makeTable('Big Eye Road Table',
MAX_ROW, 15)
self.smallRoadTable = self.proxy.makeTable('Small Road Table', MAX_ROW,
15)
self.cockroachPigTable = self.proxy.makeTable('Cockroach Pig Table',
MAX_ROW, 15)
self.playerWinButton = QPushButton("Player Win")
palette = self.playerWinButton.palette()
palette.setColor(QPalette.ButtonText, Qt.blue)
self.playerWinButton.setPalette(palette)
self.bankerWinButton = QPushButton("Banker Win")
palette = self.bankerWinButton.palette()
palette.setColor(QPalette.ButtonText, Qt.red)
self.bankerWinButton.setPalette(palette)
self.cleanButton = QPushButton("Clean All")
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(self.playerWinButton,
QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.bankerWinButton,
QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.cleanButton, QDialogButtonBox.ActionRole)
self.playerWinButton.pressed.connect(self.updatePlayerWin)
self.bankerWinButton.pressed.connect(self.updateBankerWin)
self.cleanButton.pressed.connect(self.cleanAllTable)
leftLayout = QVBoxLayout()
leftLayout.addWidget(self.bigEyeRoadTable)
leftLayout.addWidget(self.smallRoadTable)
leftLayout.addWidget(self.cockroachPigTable)
downLayout = QHBoxLayout()
downLayout.addLayout(leftLayout)
downLayout.addWidget(self.BeadPlateTable)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.bigRoadTable)
mainLayout.addLayout(downLayout)
mainLayout.addWidget(self.buttonBox)
mainLayout.setStretchFactor(self.bigRoadTable, 1)
mainLayout.setStretchFactor(downLayout, 1.5)
self.setLayout(mainLayout)
self.setWindowTitle("Baccarat RoadMap")
self.setMinimumSize(960, 640)
self.bigRoadColumn = 0
self.bigRoadRow = 0
self.bigEyeColumn = 0
self.bigEyeRow = 0
def initUI(self):
self.setWindowTitle('Options')
self.x_mean_chk = QCheckBox('x-data')
self.y_mean_chk = QCheckBox('y-data')
self.mean_chks = [self.x_mean_chk, self.y_mean_chk]
mean_grpbox = QGroupBox('Mean')
mean_layout = QVBoxLayout()
mean_layout.addWidget(self.x_mean_chk)
mean_layout.addWidget(self.y_mean_chk)
mean_grpbox.setLayout(mean_layout)
self.x_stdv_chk = QCheckBox('x-data')
self.y_stdv_chk = QCheckBox('y-data')
self.stdv_chks = [self.x_stdv_chk, self.y_stdv_chk]
stdv_grpbox = QGroupBox('Standard Deviation')
stdv_layout = QVBoxLayout()
stdv_layout.addWidget(self.x_stdv_chk)
stdv_layout.addWidget(self.y_stdv_chk)
stdv_grpbox.setLayout(stdv_layout)
self.none_trdl_btn = QRadioButton('None')
self.linr_trdl_btn = QRadioButton('Linear')
self.poly_trdl_btn = QRadioButton('Polynomial')
self.exp_trdl_btn = QRadioButton('Exponential')
self.log_trdl_btn = QRadioButton('Logarithmic')
self.poly_ordr_spn = QSpinBox()
self.trdl_btngrp = QButtonGroup()
self.trdl_opts = [
self.none_trdl_btn, self.linr_trdl_btn, self.poly_trdl_btn,
self.exp_trdl_btn, self.log_trdl_btn
]
self.trdl_btngrp.addButton(self.none_trdl_btn)
self.trdl_btngrp.addButton(self.linr_trdl_btn)
self.trdl_btngrp.addButton(self.poly_trdl_btn)
self.trdl_btngrp.addButton(self.exp_trdl_btn)
self.trdl_btngrp.addButton(self.log_trdl_btn)
self.none_trdl_btn.setChecked(True)
self.poly_ordr_spn.setValue(2)
self.poly_ordr_spn.setMinimum(2)
self.poly_ordr_spn.setMaximumWidth(50)
self.poly_ordr_spn.setEnabled(False)
trdl_grpbox = QGroupBox('Trendline')
trdl_layout = QFormLayout()
trdl_layout.addRow(self.none_trdl_btn, QLabel(''))
trdl_layout.addRow(self.linr_trdl_btn, QLabel(''))
trdl_layout.addRow(self.poly_trdl_btn, self.poly_ordr_spn)
trdl_layout.addRow(self.exp_trdl_btn, QLabel(''))
trdl_layout.addRow(self.log_trdl_btn, QLabel(''))
trdl_grpbox.setLayout(trdl_layout)
self.buttons = QDialogButtonBox(QDialogButtonBox.Close)
layout = QVBoxLayout()
layout.addWidget(mean_grpbox)
layout.addWidget(stdv_grpbox)
layout.addWidget(trdl_grpbox)
layout.addWidget(self.buttons)
self.setLayout(layout)
