def on_new_data(self, data: Dict):
""" Replace existing data views with updated ones drawn from provided
dictionary.
"""
self.clear()
show = self.get_keys()
for ii, (_, keys) in enumerate(show.items()):
current_widget = QWidget()
current_layout = FlowLayout()
for key in keys:
current_layout.addWidget(
CellFeatureView(key,
get_feature(data, *["cell_record", key])))
current_widget.setLayout(current_layout)
self.central_layout.addWidget(current_widget)
if ii < len(show) - 1:
divider = QFrame()
divider.setFrameStyle(QFrame.HLine)
divider.setLineWidth(3)
self.central_layout.addWidget(divider)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.button = QPushButton("Start", self)
self.button.clicked.connect(self.doAnim)
self.button.move(30, 30)
self.frame = QFrame(self)
self.frame.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.frame.setGeometry(150, 30, 100, 100)
self.setGeometry(300, 300, 380, 300)
self.setWindowTitle('Animation')
self.show()
def doAnim(self):
self.anim = QPropertyAnimation(self.frame, b"geometry")
self.anim.setDuration(10000)
self.anim.setStartValue(QRect(150, 30, 100, 100))
self.anim.setEndValue(QRect(150, 30, 200, 200))
self.anim.start()
def create_gui(self):
self.main_window.setWindowTitle("HC Stdout GUI")
self.main_window.setMinimumWidth(500)
top_frame = QFrame()
top_frame.setFrameStyle(QFrame.StyledPanel)
top_layout = QHBoxLayout()
top_layout.addWidget(self.text_input)
button = QPushButton("Send")
# pay attention to "click" vs "clicked" to make this work right
# connect the ENTER key signal to the button.click slot
self.text_input.returnPressed.connect(button.click)
# connect the button.clicked signal to my own slot
button.clicked.connect(self.click_send)
top_layout.addWidget(button)
top_frame.setLayout(top_layout)
main_frame = QFrame()
main_layout = QVBoxLayout()
main_layout.addWidget(top_frame)
main_layout.addWidget(self.console_frame)
main_frame.setLayout(main_layout)
self.main_window.setCentralWidget(main_frame)
self.main_window.show()
class EditColorValue(QWidget):
def __init__(self, value):
super().__init__()
self._val = value
self._rootLayout = QHBoxLayout()
self._colorLineEdit = QLineEdit()
self._colorLineEdit.setAlignment(Qt.AlignRight)
self._colorLineEdit.setReadOnly(True)
self._rootLayout.addWidget(self._colorLineEdit)
self._frame = QFrame()
self._frame.setFrameStyle(QFrame.StyledPanel)
self._frame.setFrameShadow(QFrame.Plain)
self._frameLayout = QHBoxLayout()
self._colorSelectBt = QPushButton()
self._colorSelectBt.setFlat(True)
self._colorSelectBt.clicked.connect(self._signal_colorSelectBt_clicked)
self._frameLayout.setContentsMargins(0, 0, 0, 0)
self._frameLayout.setSpacing(0)
self._frameLayout.addWidget(self._colorSelectBt)
self._frame.setMaximumHeight(
self._colorSelectBt.minimumSizeHint().height() - 2)
self._frame.setLayout(self._frameLayout)
self._rootLayout.addWidget(self._frame)
self._rootLayout.setContentsMargins(1, 1, 1, 1)
self.setLayout(self._rootLayout)
self._pull()
def _updateWith(self, col):
palette = self._colorSelectBt.palette()
palette.setColor(QPalette.Button, col)
self._colorSelectBt.setAutoFillBackground(True)
self._colorSelectBt.setPalette(palette)
self._colorSelectBt.update()
self._colorLineEdit.setText("<{0}, {1}, {2}, {3}>".format(
col.red(), col.green(), col.blue(), col.alpha()))
def _signal_colorSelectBt_clicked(self):
r, g, b, a = self._val.getVal()
resColor = QColorDialog.getColor(QColor(r, g, b,
a), self, "Select Color",
QColorDialog.ShowAlphaChannel)
if not resColor.isValid():
return
self._push(resColor)
SendMessage(MsgOnLogicDataEdited(self._val))
def _push(self, col):
self._val.setVal(col.red(), col.green(), col.blue(), col.alpha())
def _pull(self):
r, g, b, a = self._val.getVal()
self._updateWith(QColor(r, g, b, a))
class MouseTracker(QWidget):
global x, y
x = 0
y = 0
def __init__(self):
super().__init__()
self.initUI()
self.setMouseTracking(True)
def initUI(self):
global x, y
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('Mouse Tracker')
#self.setRotation(60)
self.label = QLabel(self)
self.label.resize(200, 100)
self.ellipse = QGraphicsEllipseItem(10, 20, 100, 60)
self.ellipse.setTransformOriginPoint(QPointF(100 / 2 + 10,
60 / 2 + 20))
self.ellipse.setRotation(-60)
self.scene.addItem(self.ellipse)
self.frame = QFrame(self)
self.frame.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.frame.setGeometry(x, y, 100, 100)
self.show()
def mouseMoveEvent(self, event):
global x, y
x = event.x()
y = event.y()
self.frame.setGeometry(x, y, 100, 100)
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.title = "PyQt5 Animation"
self.top = 100
self.left = 100
self.width = 680
self.height = 500
self.InitWindow()
def InitWindow(self):
self.button = QPushButton("Start", self)
self.button.move(30,30)
self.button.clicked.connect(self.doAnimation)
self.frame = QFrame(self)
self.frame.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.frame.setGeometry(150,30,100,100)
self.setWindowTitle(self.title)
self.setGeometry(self.top, self.left, self.width, self.height)
self.setWindowIcon(QtGui.QIcon('./icon/icon.png'))
self.show()
def doAnimation(self):
self.anim = QPropertyAnimation(self.frame, b"geometry")
self.anim.setDuration(10000)
self.anim.setStartValue(QRect(0,0,100,150))
self.anim.setEndValue(QRect(250,250,100,30))
self.anim.start()
def create_time_graph(self):
self.graph_layout = QVBoxLayout()
graph = OneRMGraphCanvas("Horizontal Press", self.rm_history,
self.current_year, self)
combobox_layout = QHBoxLayout()
self.lifts_combobox = QComboBox(self)
self.lifts_combobox.addItems(list(self.preferred_lifts.values()))
self.lifts_combobox.currentTextChanged.connect(
lambda lift: self.change_exercise_graph(lift))
self.change_year_combobox = QComboBox(self)
self.change_year_combobox.addItems(list(self.rm_history.keys()))
self.change_year_combobox.setCurrentText(self.current_year)
self.change_year_combobox.currentTextChanged.connect(
lambda year: self.change_graph_year(year))
combobox_layout.addWidget(self.change_year_combobox)
combobox_layout.addWidget(self.lifts_combobox)
toolbar = NavigationToolbar(graph, self)
toolbar.setStyleSheet("background-color: white;")
self.graph_layout.addWidget(toolbar)
self.graph_layout.addWidget(graph)
self.graph_layout.addLayout(combobox_layout)
framed_graph = QFrame(self)
framed_graph.setFrameStyle(QFrame.Box)
framed_graph.setLineWidth(3)
framed_graph.setLayout(self.graph_layout)
return framed_graph
def __init__(self, command, meta, value=None, *args, **kwargs):
# print(command, value)
super(CommandMultiSelect, self).__init__(*args, **kwargs)
self.setMinimumWidth(250)
self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
self.inputs = []
vl = VLayout()
hl = HLayout(0)
hl.addWidget(QLabel("<b>{}</b>".format(command)))
hl.addStretch(1)
hl.addWidget(CmdWikiUrl(command, "Wiki"))
vl.addLayout(hl)
desc = QLabel(meta['description'])
desc.setWordWrap(True)
vl.addWidget(desc)
for i, val in enumerate(value):
cb = QComboBox()
for k, v in meta['parameters'].items():
cb.addItem("{}: {} {}".format(k, v['description'], "(default)" if v.get("default") else ""), k)
cb.setCurrentIndex(val)
hl_input = HLayout(0)
hl_input.addWidgets([QLabel("{}: ".format(i+1)), cb])
self.inputs.append(cb)
vl.addLayout(hl_input)
line = QFrame()
line.setFrameStyle(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
vl.addWidget(line)
self.setLayout(vl)
def create_website_form(self, groupbox):
"""Populate the website chooser part of GUI
Arguments:
groupbox {QGroupBox} -- The parent Groupbox having website form
"""
website_chooser_label = QLabel(WEBSITE_CHOOSER_LABEL)
self.website_input = QComboBox(groupbox)
self.website_input, self.website_url_map = self.configuration.populate_website_chooser(
self.website_input)
website_url_label = QLabel(WEBSITE_URL_LABEL)
self.website_url_input = QLineEdit(groupbox)
self.website_url_input.setText(self.website_url_map[str(
self.website_input.currentText())])
self.website_url_input.setDisabled(True)
left_panel = QFrame(groupbox)
left_panel.setFrameStyle(QFrame.StyledPanel)
left_form = QFormLayout()
left_form.setHorizontalSpacing(FORM_HORIZONTAL_SPACING)
left_form.setVerticalSpacing(FORM_VERTICAL_SPACING)
left_form.addRow(website_chooser_label, self.website_input)
left_form.addRow(website_url_label, self.website_url_input)
left_panel.setLayout(left_form)
return left_panel
def create_login_form(self, groupbox):
"""Populate the login form of UI.
Arguments:
groupbox {QGroupBox} -- The parent Groupbox having login form
"""
vbox = QVBoxLayout()
username_label = QLabel(USERNAME_LABEL)
self.username_input = QLineEdit(groupbox)
password_label = QLabel(PASSWORD_LABEL)
self.password_input = QLineEdit(groupbox)
self.password_input.setEchoMode(QLineEdit.Password)
self.login_btn = QPushButton(LOGIN_LABEL, groupbox)
hbox_btn = QHBoxLayout()
hbox_btn.addStretch(1)
hbox_btn.addWidget(self.login_btn)
right_panel = QFrame(groupbox)
right_panel.setFrameStyle(QFrame.StyledPanel)
right_form = QFormLayout()
right_form.setHorizontalSpacing(FORM_HORIZONTAL_SPACING)
right_form.setVerticalSpacing(FORM_VERTICAL_SPACING)
right_form.addRow(username_label, self.username_input)
right_form.addRow(password_label, self.password_input)
vbox.addLayout(right_form)
vbox.addStretch(1)
vbox.addLayout(hbox_btn)
right_panel.setLayout(vbox)
return right_panel
def create_video_tree(self, groupbox):
"""Populate UI part which shows the lectures in a tree format.
Arguments:
groupbox {QGroupBox} -- The parent Groupbox having Course list
"""
vbox = QVBoxLayout()
right_panel = QFrame(groupbox)
right_panel.setFrameStyle(QFrame.StyledPanel)
root_folder_label = QLabel(ROOT_FOLDER_LABEL)
self.root_folder_path_input = QLineEdit()
self.root_folder_path_button = QPushButton(BROWSE_LABEL)
hbox = QHBoxLayout()
hbox.addWidget(root_folder_label)
hbox.addWidget(self.root_folder_path_input)
hbox.addWidget(self.root_folder_path_button)
hbox.setSpacing(50)
title_label = QLabel(COURSE_STRUCTURE_TITLE)
self.course_structure = CourseStructure(self.application_context)
vbox.addLayout(hbox)
vbox.addWidget(title_label)
vbox.addWidget(self.course_structure)
right_panel.setLayout(vbox)
return right_panel
def create_calculator(self):
title_frame = QFrame()
title_layout = QVBoxLayout()
#calculator_label = QLabel("Calculate your body fat", self)
#calculator_label.setFont(QFont("Ariel", 15))
#calculator_label.setFixedHeight(70)
#title_layout.addWidget(calculator_label)
#title_frame.setLayout(title_layout)
calculator_frame = QFrame()
calculator_frame.setObjectName("frameObj")
calculator_frame.setFrameStyle(QFrame.Box)
calculator_frame.setLineWidth(3)
calculator_frame.setStyleSheet("""#frameObj {color: #322d2d;}""")
calculator_frame.setMaximumWidth(600)
calculator_frame.setMaximumHeight(350)
form_layout = self.create_form_metric(
) if self.units == "metric" else self.create_form_imperial()
calculator_frame.setLayout(form_layout)
wrapper_layout = QVBoxLayout()
#wrapper_layout.addWidget(title_frame)
wrapper_layout.addWidget(calculator_frame)
return wrapper_layout
def __init__(self, items: t_.Sequence[str], parent=None):
super().__init__(parent=parent)
# self.setFrameStyle(QFrame.Panel)
self._bGroup = QButtonGroup(self)
l = QHBoxLayout(self)
for i, itemName in enumerate(items):
b = QPushButton(itemName, parent=self)
b.setCheckable(True) # Toggleable
self._bGroup.addButton(b, id=i)
l.addWidget(b)
self._selectedButtonId = self._bGroup.id(self._bGroup.buttons()[0])
self._bGroup.buttons()[0].click(
) # Make sure at least one button is selected.
self._bGroup.buttonClicked.connect(self._buttonSelected)
l.setSpacing(1) # Move buttons close together
l.setContentsMargins(0, 0, 0, 0)
w = QFrame(self)
w.setFrameStyle(QFrame.Box)
w.setLayout(l)
scrollArea = QScrollArea(parent=self)
scrollArea.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
scrollArea.setStyleSheet("""QScrollBar:horizontal {
height:10px;
}""")
scrollArea.setWidget(w)
scrollArea.setFixedHeight(10 + w.height())
ll = QHBoxLayout()
ll.setContentsMargins(0, 0, 0, 0)
ll.addWidget(scrollArea)
self.setLayout(ll)
class MouseTracker(QWidget):
global x, y
x = 0
y = 0
def __init__(self):
super().__init__()
self.initUI()
self.setMouseTracking(True)
def initUI(self):
global x, y
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('Mouse Tracker')
self.label = QLabel(self)
self.label.resize(200, 100)
self.frame = QFrame(self)
self.frame.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.frame.setGeometry(x, y, 100, 100)
self.show()
def mouseMoveEvent(self, event):
global x, y
x = event.x()
y = event.y()
self.frame.setGeometry(x, y, 100, 100)
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.s = self
self.setWindowTitle("Динамический label")
self.setGeometry(0, 0, 400, 300)
self.button = QPushButton("создать label", self)
self.button.clicked.connect(self.run)
self.button.setGeometry(200, 100, 100, 20)
self.panel = QVBoxLayout(self)
#self.panel.addWidget(self.button)
self.frame = QFrame(self)
self.frame.setMinimumSize(200, 300)
self.frame.setFrameStyle(QFrame.Box)
self.frame.setLayout(self.panel)
#self.panel.setGeometry(self.rect())
#self.setLayout(self.panel)
#self.run()
def run(self):
spacerItem = QSpacerItem(20, 55)
self.panel.insertSpacerItem(0, spacerItem)
label = QLabel('This is label')
#label.setGeometry(100, 100, 100, 20)
#self.panel.addWidget(spacerItem)
self.panel.addWidget(label)
#self.panel.insertWidget(1, label)
self.panel.addStretch()
def __init__(self, command, meta, value=None, *args, **kwargs):
super(PulseTime, self).__init__(*args, **kwargs)
self.setMinimumWidth(250)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
self.inputs = []
vl = VLayout()
hl = HLayout(0)
hl.addWidget(QLabel("<b>{}</b>".format(command)))
hl.addStretch(1)
hl.addWidget(CmdWikiUrl(command, "Wiki"))
vl.addLayout(hl)
desc = QLabel(meta['description'])
desc.setWordWrap(True)
vl.addWidget(desc)
vl_groups = VLayout(0)
for k in sorted(list(value.keys())):
sb = SpinBox(minimum=int(meta['parameters']['min']),
maximum=int(meta['parameters']['max']))
sb.setValue(value[k])
hl_group = HLayout(0)
hl_group.addWidgets([QLabel(k), sb])
vl_groups.addLayout(hl_group)
self.inputs.append(sb)
vl.addLayout(vl_groups)
line = QFrame()
line.setFrameStyle(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
vl.addWidget(line)
self.setLayout(vl)
def _init_grid(self):
self.grid = QGridLayout()
self.row = 0
frame = QFrame(self)
frame.setFrameStyle(QFrame.Panel)
frame.setLayout(self.grid)
self.current_layout.addWidget(frame)
def separator(orient='V'):
line = QFrame()
if orient == 'V':
line.setFrameStyle(5)
if orient == 'H':
line.setFrameStyle(4)
return line
def finalise(self): # cette fonction est a appeler une fois tout le contenu ajoute.
line = QFrame(self)#, -1, size=(20,-1), style=wx.LI_HORIZONTAL)
line.setFrameStyle(QFrame.HLine)
self.sizer.addWidget(line)
self.box = QHBoxLayout()
##if wx.Platform != "__WXMSW__":
##btn = wx.ContextHelpButton(self)
##self.box.Add(btn)
btn = QPushButton(" Créer " if self.objet else "Enregistrer", clicked=self.accept)
btn.setWhatsThis("Créer l'objet." if self.objet else "Enregistrer les modifications.")
##btn.SetDefault()
#XXX: Action à ajouter !!
self.box.addWidget(btn)
btn = QPushButton("Annuler", clicked=self.close)
btn.setWhatsThis("Quitter sans rien changer.")
self.box.addWidget(btn)
self.sizer.addLayout(self.box)
self.setLayout(self.sizer)
if self.objet:
self.champs['nom'].setFocus()
class MainWindow(QWidget):
# class constructor
def __init__(self):
# call QWidget constructor
super().__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.frame = QFrame(self)
self.frame.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.frame.setGeometry(150, 30, 100, 100)
# create a timer
self.timer = QTimer()
# set timer timeout callback function
self.timer.timeout.connect(self.viewCam)
# set control_bt callback clicked function
self.ui.control_bt.clicked.connect(self.controlTimer)
self.ui.control_bt.clicked.connect(self.animation)
# view camera
def viewCam(self):
# read image in BGR format
ret, image = self.cap.read()
# convert image to RGB format
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# get image infos
height, width, channel = image.shape
step = channel * width
# create QImage from image
qImg = QImage(image.data, width, height, step, QImage.Format_RGB888)
# show image in img_label
self.ui.image_label.setPixmap(QPixmap.fromImage(qImg))
# start/stop timer
def controlTimer(self):
# if timer is stopped
if not self.timer.isActive():
# create video capture
self.cap = cv2.VideoCapture(0)
# start timer
self.timer.start(20)
# update control_bt text
self.ui.control_bt.setText("Stop")
# if timer is started
else:
# stop timer
self.timer.stop()
# release video capture
self.cap.release()
# update control_bt text
self.ui.control_bt.setText("Start")
def animation(self):
self.anim = QPropertyAnimation(self.frame, b"geometry")
self.anim.setDuration(1000)
self.anim.setStartValue(QRect(0, 0, 100, 30))
self.anim.setEndValue(QRect(250, 250, 100, 30))
self.anim.start()
def __init__(self, parent=None):
super(FindAndReplaceDlg, self).__init__(parent)
findLabel = QLabel("Find &what:")
self.findLineEdit = QLineEdit()
#Remove auto capitalization
self.findLineEdit.setInputMethodHints(Qt.ImhNoAutoUppercase)
findLabel.setBuddy(self.findLineEdit)
replaceLabel = QLabel("Replace w&ith:")
self.replaceLineEdit = QLineEdit()
#Remove auto capitalization
self.replaceLineEdit.setInputMethodHints(Qt.ImhNoAutoUppercase)
replaceLabel.setBuddy(self.replaceLineEdit)
self.caseCheckBox = QCheckBox("&Case sensitive")
self.wholeCheckBox = QCheckBox("Wh&ole words")
moreFrame = QFrame()
moreFrame.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.backwardsCheckBox = QCheckBox("Search &Backwards")
self.regexCheckBox = QCheckBox("Regular E&xpression")
line = QFrame()
line.setFrameStyle(QFrame.VLine | QFrame.Sunken)
self.findButton = QPushButton("&Find")
self.replaceButton = QPushButton("&Replace")
self.replaceAllButton = QPushButton("&ReplaceAll")
self.findButton.setFocusPolicy(Qt.NoFocus)
self.replaceButton.setFocusPolicy(Qt.NoFocus)
self.replaceAllButton.setFocusPolicy(Qt.NoFocus)
gridLayout = QGridLayout()
leftLayout = QVBoxLayout()
gridLayout.addWidget(findLabel, 0, 0)
gridLayout.addWidget(self.findLineEdit, 0, 1)
gridLayout.addWidget(replaceLabel, 1, 0)
gridLayout.addWidget(self.replaceLineEdit, 1, 1)
gridLayout.addWidget(self.caseCheckBox, 2, 0)
gridLayout.addWidget(self.wholeCheckBox, 2, 1)
gridLayout.addWidget(self.backwardsCheckBox, 3, 0)
gridLayout.addWidget(self.regexCheckBox, 3, 1)
leftLayout.addLayout(gridLayout)
buttonLayout = QVBoxLayout()
buttonLayout.addWidget(self.findButton)
buttonLayout.addWidget(self.replaceButton)
buttonLayout.addWidget(self.replaceAllButton)
buttonLayout.addStretch()
mainLayout = QHBoxLayout()
mainLayout.addLayout(leftLayout)
mainLayout.addWidget(line)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
mainLayout.setSizeConstraint(QLayout.SetFixedSize)
self.findLineEdit.textEdited.connect(self.updateUi)
self.findButton.clicked.connect(self.findClicked)
self.replaceButton.clicked.connect(self.replaceClicked)
self.replaceAllButton.clicked.connect(self.replaceAllClicked)
self.updateUi()
self.setWindowTitle("Find and Replace")
def whiteQFrame():
infoFrame = QFrame()
infoFrame.setFrameStyle(QFrame.Box | QFrame.Raised)
infoFrame.setStyleSheet(
'.QFrame {margin-right: 10px; margin-bottom: 10px;background-color: white; border-radius: 5px; border: 1px solid #E1E4E7;}'
)
return infoFrame
def __init__(self, inputDict):
super(OtherDialog, self).__init__()
self.setWindowTitle('Other configurations')
mltpl = inputDict['multiple']
thrshld = inputDict['threshold']
msk = inputDict['mask']
vbox = QVBoxLayout()
self.setLayout(vbox)
label = QLabel("(*) Only meant for image inserted by template")
vbox.addWidget(label)
hline = QFrame()
hline.setFrameStyle(hline.HLine)
hline.setLineWidth(1)
vbox.addWidget(hline)
formLayout = QFormLayout()
vbox.addLayout(formLayout)
self.multiple = QCheckBox()
self.multiple.setChecked(mltpl)
formLayout.addRow("Multiple Match (*):", self.multiple)
self.threshold = QDoubleSpinBox()
self.threshold.setDecimals(1)
self.threshold.setRange(0, 1)
self.threshold.setSingleStep(0.1)
self.threshold.setValue(thrshld)
formLayout.addRow("Threshold (*):", self.threshold)
hbox = QHBoxLayout()
colorBtn = QPushButton("Select")
colorBtn.clicked.connect(self.colorBtn_clicked)
hbox.addWidget(colorBtn)
_, red, _, green, _, blue = msk.split(',')
self.backgroundColor = ("background-color: rgb(" + red + "," + green +
"," + blue + ")")
self.borderColor = "border: 1px solid black"
self.frame = QFrame()
self.frame.setStyleSheet(self.borderColor + ";" + self.backgroundColor)
hbox.addWidget(self.frame)
formLayout.addRow("Image background color:", hbox)
self.btns = QDialogButtonBox()
self.btns.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
vbox.addWidget(self.btns)
self.btns.accepted.connect(self.accept)
self.btns.rejected.connect(self.reject)
def _createStatePlotWidget(self):
self._statePlotWidget = QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(
2, 1, 1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(
2, 1, 2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentText('V')
self._stateplot_xvar_combo.setEditable(False)
self._stateplot_xvar_combo.currentIndexChanged[str].connect(
self._statePlotXSlot)
self._stateplot_yvar_label = QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self._stateplot_yvar_combo.currentIndexChanged[str].connect(
self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas,
self._statePlotWidget)
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout = QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QAction('Close', self)
self._closeStatePlotAction.triggered.connect(
self._statePlotWidget.close)
self._closeStatePlotButton = QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(
False)
def initUI(self):
QToolTip.setFont(QFont('SansSerif', 10))
self.setToolTip('This is a <b>QWidget</b> widget.')
#quitBtn = QPushButton('Quit', self)
#quitBtn.clicked.connect(self.quitBtnEvent())
#quitBtn.clicked.connect(QCoreApplication.instance().quit)
#quitBtn.setToolTip('This is a <b>QPushButton</b> widget.')
#quitBtn.resize(quitBtn.sizeHint())
exitAction = QAction(QIcon('application-exit-4.png'), '&Exit', self)
exitAction.setShortcut('Alt+F4')
exitAction.setStatusTip('Exit Application')
exitAction.triggered.connect(qApp.quit)
menuBar = QMenuBar()
fileMenu = menuBar.addMenu('&File')
fileMenu.addAction(exitAction)
fileMenu.resize(fileMenu.sizeHint())
toolBar = QToolBar(self)
toolBar.addAction(exitAction)
#toolBar.resize(toolBar.sizeHint())
toolBar.setFixedHeight(60)
hozLine = QFrame()
hozLine.setFrameStyle(QFrame.HLine)
#hozLine.setSizePolicy(QSizePolicy.Minimum,QSizePolicy.Expanding)
statusBar = QStatusBar(self)
statusBar.showMessage('Ready')
grid = QGridLayout()
lbl_1 = QLabel('1,1')
lbl_2 = QLabel('1,2')
lbl_3 = QLabel('2,1')
lbl_4 = QLabel('2,2')
grid.addWidget(lbl_1, 1, 1)
grid.addWidget(lbl_2, 1, 2)
grid.addWidget(lbl_3, 2, 1)
grid.addWidget(lbl_4, 2, 2)
vbox = QVBoxLayout()
vbox.addWidget(menuBar)
vbox.addWidget(hozLine)
vbox.addWidget(toolBar)
# vbox.addWidget(hozLine)
vbox.addLayout(grid)
vbox.addStretch(1)
vbox.addWidget(statusBar)
self.setLayout(vbox)
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('Photos')
self.setWindowIcon(QIcon('camera-photo-5.png'))
self.center()
self.show()
def __init__(self, command, meta, value=None, *args, **kwargs):
super(Interlock, self).__init__(*args, **kwargs)
self.setMinimumWidth(250)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
self.input = None
self.groups = []
vl = VLayout()
hl = HLayout(0)
hl.addWidget(QLabel("<b>{}</b>".format(command)))
hl.addStretch(1)
hl.addWidget(CmdWikiUrl(command, "Wiki"))
vl.addLayout(hl)
desc = QLabel(meta['description'])
desc.setWordWrap(True)
vl.addWidget(desc)
self.input = QComboBox()
user_data = ["OFF", "ON"]
for k, v in meta['parameters'].items():
self.input.addItem(
"{} {}".format(v['description'],
"(default)" if v.get("default") else ""),
user_data[int(k)])
if value and value.get("Interlock", "OFF") == "OFF":
self.input.setCurrentIndex(0)
else:
self.input.setCurrentIndex(1)
vl.addWidget(self.input)
vl_groups = VLayout(0)
for i in range(4):
le = QLineEdit()
le.setAlignment(Qt.AlignCenter)
group_value = value.get("Groups", [])
if group_value:
group_value_list = group_value.split(" ")
if i < len(group_value_list):
group_value = group_value_list[i]
le.setText(group_value)
hl_group = HLayout(0)
hl_group.addWidgets([QLabel("Group {}".format(i + 1)), le])
vl_groups.addLayout(hl_group)
self.groups.append(le)
vl.addLayout(vl_groups)
line = QFrame()
line.setFrameStyle(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
vl.addWidget(line)
self.setLayout(vl)
def create_frame_top(self):
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(QLabel(self.txt_top))
frame.setLayout(layout)
return frame
def create_progression(self):
frame = QFrame()
progression_layout = QVBoxLayout()
frame.setLayout(progression_layout)
self.table = QTableWidget(7, 5)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.verticalHeader().setVisible(False)
table_items = {
"table_headers": ["Set", "%", "Weight", "Reps", "Rest"],
"sets": ["1", "2", "3", "4", "5", "6", "7", "8"],
"percentages":
["~30%-50%", "~60%", "~70%", "~80%", "~90%", "~100%", "~102%"],
"weight": [""] * 7,
"number_of_reps": ["8", "5", "3", "1", "1", "1", "1"],
"rest": [
"~2 min", "~2 min", "~3 min", "~3 min", "~5 min", "~5-15 min",
"~5-15 min"
]
}
for key, value in table_items.items():
for i, item in enumerate(value):
if key == "table_headers":
self.table.setHorizontalHeaderItem(i,
QTableWidgetItem(item))
self.table.horizontalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
else:
_item = QTableWidgetItem(item)
_item.setTextAlignment(Qt.AlignCenter)
_item.setFlags(Qt.ItemIsEnabled)
if key == "sets": self.table.setItem(i, 0, _item)
elif key == "percentages": self.table.setItem(i, 1, _item)
elif key == "weight": self.table.setItem(i, 2, _item)
elif key == "number_of_reps":
self.table.setItem(i, 3, _item)
elif key == "rest":
self.table.setItem(i, 4, _item)
for i in range(7):
self.table.verticalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
grid = QGridLayout()
grid_frame = QFrame()
grid_frame.setObjectName("graphObj")
grid_frame.setFrameStyle(QFrame.Box)
grid_frame.setLineWidth(3)
grid_frame.setStyleSheet("""#graphObj {color: #322d2d;}""")
grid.addWidget(self.table, 1, 0, 1, 1)
grid_frame.setLayout(grid)
return grid_frame
class LEDColorWidget(QFrame):
def __init__(self, parent=None, color=QColor("#00FF00"), title=None):
QFrame.__init__(self, parent)
self.color = color
self.title = title
self.icon = None
self.textbox_r = None
self.textbox_g = None
self.textbox_b = None
self.initUI()
def initUI(self):
self.setFrameStyle(QFrame.StyledPanel)
text_frame = QWidget()
#text_frame.setFrameStyle(QFrame.StyledPanel)
text_layout = QGridLayout()
text_layout.addWidget(QLabel(self.title), 0, 0)
self.icon = QFrame()
self.icon.setFrameStyle(QFrame.StyledPanel)
self.icon.setMinimumSize(10, 10)
if self.color is not None:
self.icon.setStyleSheet("background-color: " + self.color.name())
else:
self.icon.setStyleSheet("background-color: #FF0000")
text_layout.addWidget(self.icon, 0, 1)
text_layout.addWidget(QLabel("Red"), 1, 0)
text_layout.addWidget(QLabel("txt"), 1, 1)
text_layout.addWidget(QLabel("Green"), 2, 0)
text_layout.addWidget(QLabel("txt"), 2, 1)
text_layout.addWidget(QLabel("Blue"), 3, 0)
text_layout.addWidget(QLabel("txt"), 3, 1)
text_frame.setLayout(text_layout)
outer_layout = QVBoxLayout()
outer_layout.addWidget(text_frame)
button = QPushButton("Choose Color")
button.clicked.connect(self.button_click)
outer_layout.addWidget(button)
self.setLayout(outer_layout)
def button_click(self):
c = QColorDialog.getColor()
if c is not None and c.isValid():
print("color chosen", c.name())
self.color = c
self.icon.setStyleSheet("background-color: " + c.name())
class Start_Window(QWidget):
def __init__(self):
super().__init__()
self.resize(settings.START_WINDOW_WIDTH,
settings.START_WINDOW_HEIGHT) #Устанавливаем размер окна
self.work_frame = QFrame(self)
self.create_evening_game_button = QPushButton("Создать игровой вечер")
self.date_edit = QDateTimeEdit()
self.ask_date_label = QLabel("Введите дату игрового вечера")
self.customise()
def move_to_center(self):
# Перенесем окошко в центр
form_rectangle = self.frameGeometry()
window_center = QDesktopWidget().availableGeometry().center()
form_rectangle.moveCenter(window_center)
self.move(form_rectangle.topLeft())
def customise(self):
"""Метод настраивает виджеты для работы"""
self.setWindowTitle("Mafia-Driver") #Название программы
self.work_frame.setFrameStyle(QFrame.Box)
self.move_to_center()
#Внесем текущую дату с компьютера
now_date = QDate.currentDate()
now_time = QTime.currentTime()
self.date_edit.setDate(now_date)
self.date_edit.setTime(now_time)
#Перенесем фрейм в центр
form_horizontalLayout = QHBoxLayout(self)
form_horizontalLayout.setContentsMargins(settings.START_WINDOW_SHIFT,
settings.START_WINDOW_SHIFT,
settings.START_WINDOW_SHIFT,
settings.START_WINDOW_SHIFT)
form_horizontalLayout.addWidget(self.work_frame)
#Настроим макет и виджеты внутри фрейма
work_frame_horizontallLayout = QHBoxLayout()
work_frame_veritcallLayout = QVBoxLayout(self.work_frame)
work_frame_horizontallLayout.addWidget(self.date_edit)
work_frame_horizontallLayout.addWidget(self.ask_date_label)
work_frame_veritcallLayout.addLayout(work_frame_horizontallLayout)
work_frame_veritcallLayout.addWidget(self.create_evening_game_button)
def create_frame_central(self):
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
# layout.addStretch(1)
layout.addWidget(SpaceFrame(self.main_window, self.controller))
# layout.addStretch(1)
frame.setLayout(layout)
return frame
def create_frame_right(self):
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(StarListFrame(self.main_window, self.controller))
layout.addWidget(ShipListFrame(self.main_window, self.controller))
layout.addStretch(1)
frame.setLayout(layout)
return frame
def _load_ui(self):
main_layout = QVBoxLayout(self)
main_layout.addWidget(QLabel(translations.TR_SESSIONS_DIALOG_BODY))
main_hbox = QHBoxLayout()
# Session list
session_layout = QVBoxLayout()
self._session_list = QTreeWidget()
self._session_list.setHeaderLabels(["Session", "Last Modified"])
session_layout.addWidget(self._session_list)
# Content frame
content_frame = QFrame()
content_frame.hide()
frame_layout = QVBoxLayout(content_frame)
content_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
session_layout.addWidget(content_frame)
frame_layout.setContentsMargins(0, 0, 0, 0)
self._content_list = QTreeWidget()
self._content_list.setHeaderHidden(True)
frame_layout.addWidget(self._content_list)
# Separator line
line_frame = QFrame()
line_frame.setFrameStyle(QFrame.VLine | QFrame.Sunken)
# Buttons
btn_layout = QVBoxLayout()
btn_create = QPushButton(translations.TR_SESSIONS_BTN_CREATE)
btn_activate = QPushButton(translations.TR_SESSIONS_BTN_ACTIVATE)
btn_update = QPushButton(translations.TR_SESSIONS_BTN_UPDATE)
btn_delete = QPushButton(translations.TR_SESSIONS_BTN_DELETE)
btn_details = QPushButton(translations.TR_SESSIONS_BTN_DETAILS)
btn_details.setCheckable(True)
# Add buttons to layout
btn_layout.addWidget(btn_create)
btn_layout.addWidget(btn_activate)
btn_layout.addWidget(btn_update)
btn_layout.addWidget(btn_delete)
btn_layout.addStretch()
btn_layout.addWidget(btn_details)
# Add widgets and layouts to the main layout
main_layout.addLayout(main_hbox)
main_hbox.addLayout(session_layout)
main_hbox.addWidget(line_frame)
main_hbox.addLayout(btn_layout)
main_hbox.setSizeConstraint(QLayout.SetFixedSize)
btn_details.toggled[bool].connect(content_frame.setVisible)
# Connections
self._session_list.itemSelectionChanged.connect(
self.load_session_content)
btn_activate.clicked.connect(self.open_session)
btn_update.clicked.connect(self.save_session)
btn_create.clicked.connect(self.create_session)
btn_delete.clicked.connect(self.delete_session)
def _createStatePlotWidget(self):
self._statePlotWidget = QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(2,1,1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(2,1,2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentText('V')
self._stateplot_xvar_combo.setEditable(False)
self._stateplot_xvar_combo.currentIndexChanged[str].connect( self._statePlotXSlot )
self._stateplot_yvar_label = QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self._stateplot_yvar_combo.currentIndexChanged[str].connect(self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas, self._statePlotWidget)
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout = QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QAction('Close', self)
self._closeStatePlotAction.triggered.connect(self._statePlotWidget.close)
self._closeStatePlotButton = QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(False)
def _createHelpMessage(self):
if hasattr(self, '_helpWindow'):
return
self._helpWindow = QWidget()
self._helpWindow.setWindowFlags(QtCore.Qt.Window)
layout = QVBoxLayout()
self._helpWindow.setLayout(layout)
self._helpMessageArea = QScrollArea()
self._helpMessageText = QTextBrowser()
self._helpMessageText.setOpenExternalLinks(True)
self._helpMessageArea.setWidget(self._helpMessageText)
layout.addWidget(self._helpMessageText)
self._squidGuiPath = os.path.dirname(os.path.abspath(__file__))
self._helpBaseURL = os.path.join(self._squidGuiPath,'help.html')
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpMessageText.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageArea.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._helpMessageText.setMinimumSize(800, 600)
self._closeHelpAction = QAction('Close', self)
self._closeHelpAction.triggered.connect(self._helpWindow.close)
# Setting the close event so that the ``Help`` button is
# unchecked when the help window is closed
self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(False)
self._helpTOCAction = QAction('Help running demo', self)
self._helpTOCAction.triggered.connect( self._jumpToHelpTOC)
# This panel is for putting two buttons using horizontal
# layout
panel = QFrame()
panel.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout.addWidget(panel)
layout = QHBoxLayout()
panel.setLayout(layout)
self._helpAction = QAction('Help running', self)
self._helpAction.triggered.connect(self._showRunningHelp)
self._helpBiophysicsAction = QAction('Help biophysics', self)
self._helpBiophysicsAction.triggered.connect(self._showBioPhysicsHelp)
self._helpTOCButton = QToolButton()
self._helpTOCButton.setDefaultAction(self._helpTOCAction)
self._helpBiophysicsButton = QToolButton()
self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction)
layout.addWidget(self._helpTOCButton)
layout.addWidget(self._helpBiophysicsButton)
self._closeHelpButton = QToolButton()
self._closeHelpButton.setDefaultAction(self._closeHelpAction)
layout.addWidget(self._closeHelpButton)
def _initialize(self):
"""Delayed initialization of the widget for quicker start of application
"""
# central widget
wdg = QWidget(self)
self.setWidget(wdg)
# vertical layout
vertLayout = QVBoxLayout(wdg)
vertLayout.setContentsMargins(0, 0, 0, 0)
vertLayout.setSpacing(3)
# combo
self._comboBox = ComboBox(self)
vertLayout.addWidget(self._comboBox)
# hline
hline = QFrame(self)
hline.setFrameStyle(QFrame.HLine | QFrame.Sunken)
vertLayout.addWidget(hline)
# files view
self._tree = Tree(self)
vertLayout.addWidget(self._tree)
# cd up button
self._aCdUp = QAction(QIcon(':enkiicons/go-up.png'),
self.tr("Up"),
self)
self.titleBarWidget().addAction(self._aCdUp)
self._aCdUp.triggered.connect(self.moveUp)
# redirirect focus proxy
self.setFocusProxy(self._tree)
self._smartRecents = SmartRecents(self)
self._smartHistory = SmartHistory(self)
self.setCurrentPath(core.project().path() or _getCurDir())
core.actionManager().action('mNavigation/mFileBrowser').setVisible(True)
class ParameterContainer(QWidget, object):
"""Container to hold Parameter Widgets."""
def __init__(
self,
parameters=None,
description_text='',
extra_parameters=None,
parent=None,
vertical=True):
"""Constructor
.. versionadded:: 2.2
:param parameters: List of Parameter Widget
:type parameters: list
:param description_text: Text for description of the parameter
container.
:type description_text: str
"""
super().__init__(parent)
# attributes
if not parameters:
self.parameters = []
else:
self.parameters = parameters
self.description_text = description_text
self.extra_parameters = extra_parameters
self.parent = parent
self.validators = []
self.validators_kwargs = []
# UI
if vertical:
self.vertical_layout = QVBoxLayout()
else:
self.vertical_layout = QHBoxLayout()
self.widget = QWidget()
self.description_label = QLabel()
self.description_label.setWordWrap(True)
self.scroll_area = QScrollArea()
self.group_frame = QFrame()
self.qt5_parameter_factory = Qt5ParameterFactory()
self.main_layout = QGridLayout()
# NOTES(IS) : These functions are commented since the architecture is not
# ready yet.
# def register_widget(self, parameter, parameter_widget):
# """Register new custom widget.
#
# :param parameter:
# :type parameter: GenericParameter
#
# :param parameter_widget:
# :type parameter_widget: GenericParameterWidget
# """
# self.qt5_parameter_factory.register_widget(
# parameter, parameter_widget)
#
# def remove_widget(self, parameter):
# """Register new custom widget.
#
# :param parameter:
# :type parameter: GenericParameter
# """
# if parameter.__name__ in self.dict_widget.keys():
# self.dict_widget.pop(parameter.__name__)
def get_parameters(self, validate=True):
"""Return list of parameters from the current state of widget.
:param validate: If true, run validator, else no.
:type validate: bool
:returns: List of parameter
:rtype: list
"""
if validate:
validation_result = self.validate()
if not validation_result['valid']:
raise InvalidValidationException(validation_result['message'])
parameter_widgets = self.get_parameter_widgets()
parameters = []
for widget_item in parameter_widgets:
parameter_widget = widget_item.widget()
parameter = parameter_widget.get_parameter()
parameters.append(parameter)
# returns based on the object type of self.parameters
if isinstance(self.parameters, list):
return parameters
else:
# just return single parameter
return parameters[0]
def get_parameter_widgets(self):
"""Return list of parameter widgets from the current state of widget.
:returns: List of parameter widget
:rtype: list
"""
parameter_widgets = [self.vertical_layout.itemAt(i) for i in range(
self.vertical_layout.count())]
return parameter_widgets
def setup_ui(self, must_scroll=True):
"""Setup the UI of this parameter container.
"""
# Vertical layout to place the parameter widgets
self.vertical_layout.setContentsMargins(0, 0, 0, 0)
self.vertical_layout.setSpacing(0)
# Widget to hold the vertical layout
self.widget = QWidget()
self.widget.setLayout(self.vertical_layout)
# Label for description
self.description_label.setText(self.description_text)
self.group_frame.setLineWidth(0)
self.group_frame.setFrameStyle(QFrame.NoFrame)
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.setSpacing(0)
self.group_frame.setLayout(vlayout)
if must_scroll:
vlayout.addWidget(self.scroll_area)
self.scroll_area.setWidgetResizable(True)
self.scroll_area.setWidget(self.widget)
else:
vlayout.addWidget(self.widget)
# Main layout of the container
if self.description_text:
self.main_layout.addWidget(self.description_label)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.main_layout)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.MinimumExpanding)
if not isinstance(self.parameters, list):
parameters = [self.parameters]
else:
parameters = self.parameters
if len(parameters) == 0:
self.set_empty_parameters()
return
self.main_layout.addWidget(self.group_frame)
self.qt5_parameter_factory = Qt5ParameterFactory()
if self.extra_parameters is not None:
for extra_parameter in self.extra_parameters:
if (type(extra_parameter) == tuple and
len(extra_parameter) == 2):
self.qt5_parameter_factory.register_widget(
extra_parameter[0], extra_parameter[1])
for parameter in parameters:
parameter_widget = self.qt5_parameter_factory.get_widget(parameter)
parameter_widget.setAutoFillBackground(True)
self.vertical_layout.addWidget(parameter_widget)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def set_description(self, description):
"""Set description of the parameter container.
:param description: A new description fot the parameter container.
:type description: str
"""
self.description_text = description
self.description_label.setText(self.description_text)
def set_empty_parameters(self):
"""Update UI if there is no parameters in the container.
"""
new_description = self.description_text
new_description += '\n'
new_description += 'But, currently there is no parameters available.'
self.description_label.setText(new_description)
def add_validator(self, validator, **kwargs):
"""Add validator for this parameter container.
:param validator: validator function for this parameter container.
:type validator: function
"""
validator.parent = self
self.validators.append(validator)
if kwargs:
self.validators_kwargs.append(kwargs)
else:
self.validators_kwargs.append({})
def validate(self):
"""Validate of all rule for all parameter in this container.
:return: True if all valid, False
:rtype: dict
"""
for i in range(len(self.validators)):
validator = self.validators[i]
validator_kwargs = self.validators_kwargs[i]
validation_result = validator(self, **validator_kwargs)
if not validation_result['valid']:
return validation_result
return {
'valid': True,
'message': ''
}
def get_parameter_by_guid(self, parameter_guid):
"""Return a parameter based on its uuid
:param parameter_guid: The parameter uuid
:type parameter_guid: str
:returns: The parameter or None if not exist
:rtype: GenericParameter, None
"""
parameters = self.get_parameters(validate=False)
for parameter in parameters:
if parameter.guid == parameter_guid:
return parameter
return None
def get_parameter_widget_by_guid(self, parameter_guid):
"""Return a parameter widget based on its uuid
:param parameter_guid: The parameter uuid
:type parameter_guid: str
:returns: The parameter widget or None if not exist
:rtype: GenericParameterWidget, None
"""
parameter_widgets = self.get_parameter_widgets()
for parameter_widget in parameter_widgets:
if (parameter_widget.widget().get_parameter().guid ==
parameter_guid):
return parameter_widget.widget()
return None
def __init__(self, settings):
super(QWidget, self).__init__()
self._layout = QBoxLayout(QBoxLayout.TopToBottom)
self.setLayout(self._layout)
self.settings = settings
self.metrics = QFontMetrics(QApplication.font())
self.characters = self.settings.get_value('characters', None)
if self.characters is None:
self.characters = {}
# select or add new character
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
label = QLabel("Select Character To Edit:")
layout.addWidget(label, 0)
combo = QComboBox()
self._combo_character = combo
self._combo_character.currentIndexChanged.connect(self._combo_changed)
layout.addWidget(combo, 1)
label = QLabel(" or ")
layout.addWidget(label, 0)
button = QPushButton("Add New")
button.clicked.connect(self._new_character_mode_on)
self._add_button = button
layout.addWidget(button, 0)
self._layout.addWidget(widget, 1)
# start of frame
frame = QFrame()
frame.setFrameShadow(QFrame.Sunken)
frame.setFrameStyle(QFrame.Box)
frame_layout = QBoxLayout(QBoxLayout.TopToBottom)
frame.setLayout(frame_layout)
# name and level
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
label = QLabel("Name:")
layout.addWidget(label, 0)
text = QLineEdit()
text.setMaxLength(20)
text.setMinimumWidth(self.metrics.width("8888888888888888888888"))
self._name = text
self._name.textChanged.connect(self._name_changed)
layout.addWidget(text, 1)
label = QLabel("Level:")
layout.addWidget(label, 0)
text = QLineEdit()
text.setMaxLength(3)
text.setMinimumWidth(self.metrics.width("88888"))
self._level = text
self._level.editingFinished.connect(self._level_editing_finished)
layout.addWidget(text, 1)
frame_layout.addWidget(widget, 1)
# logfile
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
label = QLabel("Log File:")
layout.addWidget(label, 0)
text = QLineEdit()
text.setEnabled(False)
self._log_file = text
layout.addWidget(text, 1)
button = QPushButton("Browse...")
self._button_browse = button
self._button_browse.clicked.connect(self._get_log_file)
layout.addWidget(button, 0)
frame_layout.addWidget(widget, 1)
# delete or save buttons
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
button = QPushButton("Save")
button.clicked.connect(self._save_new)
layout.addWidget(button, 0, Qt.AlignRight)
button = QPushButton("Delete")
self._button_delete = button
self._button_delete.clicked.connect(self._button_delete_clicked)
layout.addWidget(button, 0, Qt.AlignRight)
frame_layout.addWidget(widget, 0, Qt.AlignRight)
# end of frame
self._layout.addWidget(frame, 1)
# spacing at bottom of window
widget = QWidget()
self._layout.addWidget(widget, 1)
# setup
self._new_character_mode_off()
self._update_combo_character()
if self.settings.get_value('general', 'eq_directory') is not None:
log_directory = os.path.join(self.settings.get_value('general', 'eq_directory'), 'logs/')
self._log_directory = log_directory
if os.path.exists(log_directory):
self._log_files = [log.lower() for log in os.listdir(log_directory) if 'eqlog' in log[:5]]
def __initUI__(self):
self.setWindowTitle('Weather Stations Browser')
self.setWindowIcon(icons.get_icon('master'))
self.setWindowFlags(Qt.Window)
now = datetime.now()
# ---- Tab Widget Search
# ---- Proximity filter groupbox
label_Lat = QLabel('Latitude :')
label_Lat2 = QLabel('North')
self.lat_spinBox = QDoubleSpinBox()
self.lat_spinBox.setAlignment(Qt.AlignCenter)
self.lat_spinBox.setSingleStep(0.1)
self.lat_spinBox.setValue(0)
self.lat_spinBox.setMinimum(0)
self.lat_spinBox.setMaximum(180)
self.lat_spinBox.setSuffix(u' °')
self.lat_spinBox.valueChanged.connect(self.proximity_grpbox_toggled)
label_Lon = QLabel('Longitude :')
label_Lon2 = QLabel('West')
self.lon_spinBox = QDoubleSpinBox()
self.lon_spinBox.setAlignment(Qt.AlignCenter)
self.lon_spinBox.setSingleStep(0.1)
self.lon_spinBox.setValue(0)
self.lon_spinBox.setMinimum(0)
self.lon_spinBox.setMaximum(180)
self.lon_spinBox.setSuffix(u' °')
self.lon_spinBox.valueChanged.connect(self.proximity_grpbox_toggled)
self.radius_SpinBox = QComboBox()
self.radius_SpinBox.addItems(['25 km', '50 km', '100 km', '200 km'])
self.radius_SpinBox.currentIndexChanged.connect(
self.search_filters_changed)
prox_search_grid = QGridLayout()
row = 0
prox_search_grid.addWidget(label_Lat, row, 1)
prox_search_grid.addWidget(self.lat_spinBox, row, 2)
prox_search_grid.addWidget(label_Lat2, row, 3)
row += 1
prox_search_grid.addWidget(label_Lon, row, 1)
prox_search_grid.addWidget(self.lon_spinBox, row, 2)
prox_search_grid.addWidget(label_Lon2, row, 3)
row += 1
prox_search_grid.addWidget(QLabel('Search Radius :'), row, 1)
prox_search_grid.addWidget(self.radius_SpinBox, row, 2)
prox_search_grid.setColumnStretch(0, 100)
prox_search_grid.setColumnStretch(4, 100)
prox_search_grid.setRowStretch(row+1, 100)
prox_search_grid.setHorizontalSpacing(20)
prox_search_grid.setContentsMargins(10, 10, 10, 10) # (L, T, R, B)
self.prox_grpbox = QGroupBox("Proximity filter :")
self.prox_grpbox.setCheckable(True)
self.prox_grpbox.setChecked(False)
self.prox_grpbox.toggled.connect(self.proximity_grpbox_toggled)
self.prox_grpbox.setLayout(prox_search_grid)
# ---- Province filter
prov_names = ['All']
prov_names.extend(self.PROV_NAME)
self.prov_widg = QComboBox()
self.prov_widg.addItems(prov_names)
self.prov_widg.setCurrentIndex(0)
self.prov_widg.currentIndexChanged.connect(self.search_filters_changed)
layout = QGridLayout()
layout.addWidget(self.prov_widg, 2, 1)
layout.setColumnStretch(2, 100)
layout.setVerticalSpacing(10)
prov_grpbox = QGroupBox("Province filter :")
prov_grpbox.setLayout(layout)
# ---- Data availability filter
# Number of years with data
self.nbrYear = QSpinBox()
self.nbrYear.setAlignment(Qt.AlignCenter)
self.nbrYear.setSingleStep(1)
self.nbrYear.setMinimum(0)
self.nbrYear.setValue(3)
self.nbrYear.valueChanged.connect(self.search_filters_changed)
subgrid1 = QGridLayout()
subgrid1.addWidget(self.nbrYear, 0, 0)
subgrid1.addWidget(QLabel('years of data between'), 0, 1)
subgrid1.setHorizontalSpacing(10)
subgrid1.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
subgrid1.setColumnStretch(2, 100)
# Year range
self.minYear = QSpinBox()
self.minYear.setAlignment(Qt.AlignCenter)
self.minYear.setSingleStep(1)
self.minYear.setMinimum(1840)
self.minYear.setMaximum(now.year)
self.minYear.setValue(1840)
self.minYear.valueChanged.connect(self.minYear_changed)
label_and = QLabel('and')
label_and.setAlignment(Qt.AlignCenter)
self.maxYear = QSpinBox()
self.maxYear.setAlignment(Qt.AlignCenter)
self.maxYear.setSingleStep(1)
self.maxYear.setMinimum(1840)
self.maxYear.setMaximum(now.year)
self.maxYear.setValue(now.year)
self.maxYear.valueChanged.connect(self.maxYear_changed)
subgrid2 = QGridLayout()
subgrid2.addWidget(self.minYear, 0, 0)
subgrid2.addWidget(label_and, 0, 1)
subgrid2.addWidget(self.maxYear, 0, 2)
subgrid2.setHorizontalSpacing(10)
subgrid2.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
subgrid2.setColumnStretch(4, 100)
# Subgridgrid assembly
grid = QGridLayout()
grid.addWidget(QLabel('Search for stations with at least'), 0, 0)
grid.addLayout(subgrid1, 1, 0)
grid.addLayout(subgrid2, 2, 0)
grid.setVerticalSpacing(5)
grid.setRowStretch(0, 100)
# grid.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
self.year_widg = QGroupBox("Data Availability filter :")
self.year_widg.setLayout(grid)
# ---- Toolbar
self.btn_addSta = btn_addSta = QPushButton('Add')
btn_addSta.setIcon(icons.get_icon('add2list'))
btn_addSta.setIconSize(icons.get_iconsize('small'))
btn_addSta.setToolTip('Add selected found weather stations to the '
'current list of weather stations.')
btn_addSta.clicked.connect(self.btn_addSta_isClicked)
btn_save = QPushButton('Save')
btn_save.setIcon(icons.get_icon('save'))
btn_save.setIconSize(icons.get_iconsize('small'))
btn_save.setToolTip('Save current found stations info in a csv file.')
btn_save.clicked.connect(self.btn_save_isClicked)
self.btn_fetch = btn_fetch = QPushButton('Fetch')
btn_fetch.setIcon(icons.get_icon('refresh'))
btn_fetch.setIconSize(icons.get_iconsize('small'))
btn_fetch.setToolTip("Updates the climate station database by"
" fetching it again from the ECCC ftp server.")
btn_fetch.clicked.connect(self.btn_fetch_isClicked)
toolbar_grid = QGridLayout()
toolbar_widg = QWidget()
for col, btn in enumerate([btn_addSta, btn_save, btn_fetch]):
toolbar_grid.addWidget(btn, 0, col+1)
toolbar_grid.setColumnStretch(toolbar_grid.columnCount(), 100)
toolbar_grid.setSpacing(5)
toolbar_grid.setContentsMargins(0, 30, 0, 0) # (L, T, R, B)
toolbar_widg.setLayout(toolbar_grid)
# ---- Left Panel
panel_title = QLabel('<b>Weather Station Search Criteria :</b>')
left_panel = QFrame()
left_panel_grid = QGridLayout()
left_panel_grid.addWidget(panel_title, 0, 0)
left_panel_grid.addWidget(self.prox_grpbox, 1, 0)
left_panel_grid.addWidget(prov_grpbox, 2, 0)
left_panel_grid.addWidget(self.year_widg, 3, 0)
left_panel_grid.setRowStretch(4, 100)
left_panel_grid.addWidget(toolbar_widg, 5, 0)
left_panel_grid.setVerticalSpacing(20)
left_panel_grid.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
left_panel.setLayout(left_panel_grid)
# ----- Main grid
# Widgets
vLine1 = QFrame()
vLine1.setFrameStyle(StyleDB().VLine)
# Grid
main_layout = QGridLayout(self)
main_layout.addWidget(left_panel, 0, 0)
main_layout.addWidget(vLine1, 0, 1)
main_layout.addWidget(self.station_table, 0, 2)
main_layout.addWidget(self.waitspinnerbar, 0, 2)
main_layout.setContentsMargins(10, 10, 10, 10) # (L,T,R,B)
main_layout.setRowStretch(0, 100)
main_layout.setHorizontalSpacing(15)
main_layout.setVerticalSpacing(5)
main_layout.setColumnStretch(col, 100)
def etiquette(self):
select = self.canvas.select
etiquette = select.etiquette if select.etiquette is not None else select
old = {'mode': etiquette.style("mode"), 'texte': etiquette.texte}
# ----------------
# Cas particuliers
# ----------------
if isinstance(select, Champ):
if select.style('choix'):
choix = select.style('choix')
try:
index = choix.index(select.texte)
except ValueError:
index = 0
text, ok = QInputDialog.getItem(self.canvas, "Choisir une valeur",
"Réponse :", choix, index, False)
else:
text, ok = QInputDialog.getText(self.canvas, "Éditer le champ",
"Réponse :", QLineEdit.Normal, select.texte)
if ok:
select.label(text)
return
# -----------
# Cas général
# -----------
dlg = QDialog(self.canvas)
dlg.setWindowTitle("Changer la légende de l'objet (texte quelconque)")
sizer = QVBoxLayout()
sizer.addWidget(QLabel("Note: le code LATEX doit etre entre $$. Ex: $\\alpha$"))
dlg.text = QTextEdit(dlg)
dlg.text.setPlainText(etiquette.texte)
dlg.setMinimumSize(300, 50)
sizer.addWidget(dlg.text)
dlg.cb = QCheckBox("Interpréter la formule", dlg)
dlg.cb.setChecked(select.mode_affichage == 'formule')
sizer.addWidget(dlg.cb)
line = QFrame(self)
line.setFrameStyle(QFrame.HLine)
sizer.addWidget(line)
box = QHBoxLayout()
btn = QPushButton('OK')
btn.clicked.connect(dlg.accept)
box.addWidget(btn)
box.addStretch(1)
btn = QPushButton("Annuler")
btn.clicked.connect(dlg.reject)
box.addWidget(btn)
sizer.addLayout(box)
dlg.setLayout(sizer)
dlg.setWindowModality(Qt.WindowModal)
while True:
ok = dlg.exec_()
if ok:
try:
nom = select.nom
txt = repr(dlg.text.toPlainText())
mode = repr('formule' if dlg.cb.isChecked() else 'texte')
self.executer("%s.label(%s, %s)" %(nom, txt, mode))
except:
# Au cas où une formule incorrecte fasse buguer l'affichage (?)
etiquette.texte = old['texte']
etiquette.style(mode=old['mode'])
print_error()
continue
else:
etiquette.texte = old['texte']
etiquette.style(mode=old['mode'])
break
class SplendorWindow(QWidget):
def __init__(self):
super(SplendorWindow, self).__init__()
self.setWindowTitle("Splendor")
self.resize(950, 670)
self.board = SplendorBoard()
layout = QGridLayout()
self.game_table = SplendorTable()
layout_cards = QGridLayout()
layout_chips = QGridLayout()
layout_lords = QGridLayout()
scoreLcd = QLCDNumber(2)
scoreLcd.setSegmentStyle(QLCDNumber.Filled)
layout.addWidget(self.createLabel("Name: "), 0, 0)
layout.addWidget(self.createLabel("Sandy"), 0, 1)
layout.addWidget(self.createLabel("Score: "), 0, 2)
layout.addWidget(scoreLcd, 0, 3)
self.frame_cards = QFrame()
self.frame_cards.setFrameStyle(QFrame.Box | QFrame.Raised)
self.frame_cards.setLayout(layout_cards)
self.frame_chips = QFrame()
self.frame_chips.setFrameStyle(QFrame.Box | QFrame.Raised)
frame_lords = QFrame()
frame_lords.setFrameStyle(QFrame.Box | QFrame.Raised)
layout.addWidget(self.frame_cards, 2, 0, 4, 5)
layout.addWidget(self.frame_chips, 2, 6, 4, 2)
#layout.addWidget(frame_lords, 2, 10)
self.frame_chips.setLayout(layout_chips)
frame_lords.setLayout(layout_lords)
for r in (0, 4, 8):
row = self.game_table.state[int(r / 4)]
bord_line_cards = []
indent = 0
for i in range(4):
card = row[i]
bord_line_cards.append(self.createCardSelector(card, self.frame_cards))
layout_cards.addWidget(self.createCard(card, self.frame_cards), 0 + r, indent, 3, 2)
layout_cards.addWidget(bord_line_cards[i], 3 + r, indent)
indent += 2
self.setLayout(layout)
rr = 0
for r in (0, 2, 4):
row = self.game_table.state[int(r / 2)]
bord_line_chips = []
indent = 0
for i in range(2):
chip = row[4 + i]
bord_line_chips.append(self.createChipSelector(chip, self.frame_chips))
layout_chips.addWidget(self.createChip(chip, self.frame_chips), 0 + rr, 0, 4, 2)
layout_chips.addWidget(bord_line_chips[i], 2 + rr, 0)
rr += 2
self.setLayout(layout)
def customEvent(self, event):
if event.type() is NotifyParent.idType:
print("NotifyParent")
def mousePressEvent1(self, event):
print("Main Widget Mouse Press")
super(QWidget, self).mousePressEvent(event)
def createLabel(self, text):
lbl = QLabel(text)
lbl.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
lbl.setFrameStyle(QFrame.Box | QFrame.Raised)
return lbl
def createCard(self, card, parent):
btn = ColourLabel(card, parent)
return btn
def createChip(self, chip, parent):
btn = ColourChip(chip, parent)
return btn
def createCardSelector(self, card, parent):
btn = QRadioButton(None, parent)
btn.setChecked(False)
btn.setAutoExclusive(True)
return btn
def createChipSelector(slef, chip, parent):
btn = QCheckBox(parent)
btn.setChecked(False)
return btn
def __init_scalesTabWidget__(self):
class QRowLayout(QGridLayout):
def __init__(self, items, parent=None):
super(QRowLayout, self).__init__(parent)
for col, item in enumerate(items):
self.addWidget(item, 0, col)
self.setContentsMargins(0, 0, 0, 0)
self.setColumnStretch(0, 100)
# ---- Time axis properties
# Generate the widgets :
self.date_start_widget = QDateEdit()
self.date_start_widget.setDisplayFormat('01 / MM / yyyy')
self.date_start_widget.setAlignment(Qt.AlignCenter)
self.date_start_widget.dateChanged.connect(self.layout_changed)
self.date_end_widget = QDateEdit()
self.date_end_widget.setDisplayFormat('01 / MM / yyyy')
self.date_end_widget.setAlignment(Qt.AlignCenter)
self.date_end_widget.dateChanged.connect(self.layout_changed)
self.time_scale_label = QComboBox()
self.time_scale_label.setEditable(False)
self.time_scale_label.setInsertPolicy(QComboBox.NoInsert)
self.time_scale_label.addItems(['Month', 'Year'])
self.time_scale_label.setCurrentIndex(0)
self.time_scale_label.currentIndexChanged.connect(self.layout_changed)
self.dateDispFreq_spinBox = QSpinBox()
self.dateDispFreq_spinBox.setSingleStep(1)
self.dateDispFreq_spinBox.setMinimum(1)
self.dateDispFreq_spinBox.setMaximum(100)
self.dateDispFreq_spinBox.setValue(
self.hydrograph.date_labels_pattern)
self.dateDispFreq_spinBox.setAlignment(Qt.AlignCenter)
self.dateDispFreq_spinBox.setKeyboardTracking(False)
self.dateDispFreq_spinBox.valueChanged.connect(self.layout_changed)
# Setting up the layout :
widget_time_scale = QFrame()
widget_time_scale.setFrameStyle(0)
grid_time_scale = QGridLayout()
GRID = [[QLabel('From :'), self.date_start_widget],
[QLabel('To :'), self.date_end_widget],
[QLabel('Scale :'), self.time_scale_label],
[QLabel('Date Disp. Pattern:'),
self.dateDispFreq_spinBox]]
for i, ROW in enumerate(GRID):
grid_time_scale.addLayout(QRowLayout(ROW), i, 1)
grid_time_scale.setVerticalSpacing(5)
grid_time_scale.setContentsMargins(10, 10, 10, 10)
widget_time_scale.setLayout(grid_time_scale)
# ----- Water level axis properties
# Widget :
self.waterlvl_scale = QDoubleSpinBox()
self.waterlvl_scale.setSingleStep(0.05)
self.waterlvl_scale.setMinimum(0.05)
self.waterlvl_scale.setSuffix(' m')
self.waterlvl_scale.setAlignment(Qt.AlignCenter)
self.waterlvl_scale.setKeyboardTracking(False)
self.waterlvl_scale.valueChanged.connect(self.layout_changed)
self.waterlvl_scale.setFixedWidth(100)
self.waterlvl_max = QDoubleSpinBox()
self.waterlvl_max.setSingleStep(0.1)
self.waterlvl_max.setSuffix(' m')
self.waterlvl_max.setAlignment(Qt.AlignCenter)
self.waterlvl_max.setMinimum(-1000)
self.waterlvl_max.setMaximum(1000)
self.waterlvl_max.setKeyboardTracking(False)
self.waterlvl_max.valueChanged.connect(self.layout_changed)
self.waterlvl_max.setFixedWidth(100)
self.NZGridWL_spinBox = QSpinBox()
self.NZGridWL_spinBox.setSingleStep(1)
self.NZGridWL_spinBox.setMinimum(1)
self.NZGridWL_spinBox.setMaximum(50)
self.NZGridWL_spinBox.setValue(self.hydrograph.NZGrid)
self.NZGridWL_spinBox.setAlignment(Qt.AlignCenter)
self.NZGridWL_spinBox.setKeyboardTracking(False)
self.NZGridWL_spinBox.valueChanged.connect(self.layout_changed)
self.NZGridWL_spinBox.setFixedWidth(100)
self.datum_widget = QComboBox()
self.datum_widget.addItems(['Ground Surface', 'Sea Level'])
self.datum_widget.currentIndexChanged.connect(self.layout_changed)
# Layout :
subgrid_WLScale = QGridLayout()
GRID = [[QLabel('Minimum :'), self.waterlvl_max],
[QLabel('Scale :'), self.waterlvl_scale],
[QLabel('Grid Divisions :'), self.NZGridWL_spinBox],
[QLabel('Datum :'), self.datum_widget]]
for i, ROW in enumerate(GRID):
subgrid_WLScale.addLayout(QRowLayout(ROW), i, 1)
subgrid_WLScale.setVerticalSpacing(5)
subgrid_WLScale.setContentsMargins(10, 10, 10, 10) # (L, T, R, B)
WLScale_widget = QFrame()
WLScale_widget.setFrameStyle(0)
WLScale_widget.setLayout(subgrid_WLScale)
# ---- Weather Axis
# Widgets :
self.Ptot_scale = QSpinBox()
self.Ptot_scale.setSingleStep(5)
self.Ptot_scale.setMinimum(5)
self.Ptot_scale.setMaximum(500)
self.Ptot_scale.setValue(20)
self.Ptot_scale.setSuffix(' mm')
self.Ptot_scale.setAlignment(Qt.AlignCenter)
self.qweather_bin = QComboBox()
self.qweather_bin.setEditable(False)
self.qweather_bin.setInsertPolicy(QComboBox.NoInsert)
self.qweather_bin.addItems(['day', 'week', 'month'])
self.qweather_bin.setCurrentIndex(1)
# Layout :
layout = QGridLayout()
GRID = [[QLabel('Precip. Scale :'), self.Ptot_scale],
[QLabel('Resampling :'), self.qweather_bin]]
for i, row in enumerate(GRID):
layout.addLayout(QRowLayout(row), i, 1)
layout.setVerticalSpacing(5)
layout.setContentsMargins(10, 10, 10, 10) # (L,T,R,B)
layout.setRowStretch(i+1, 100)
widget_weather_scale = QFrame()
widget_weather_scale.setFrameStyle(0)
widget_weather_scale.setLayout(layout)
# ---- ASSEMBLING TABS
tabscales = QTabWidget()
tabscales.addTab(widget_time_scale, 'Time')
tabscales.addTab(WLScale_widget, 'Water Level')
tabscales.addTab(widget_weather_scale, 'Weather')
return tabscales
def __init__(self):
super(SplendorWindow, self).__init__()
self.setWindowTitle("Splendor")
self.resize(950, 670)
self.board = SplendorBoard()
layout = QGridLayout()
self.game_table = SplendorTable()
layout_cards = QGridLayout()
layout_chips = QGridLayout()
layout_lords = QGridLayout()
scoreLcd = QLCDNumber(2)
scoreLcd.setSegmentStyle(QLCDNumber.Filled)
layout.addWidget(self.createLabel("Name: "), 0, 0)
layout.addWidget(self.createLabel("Sandy"), 0, 1)
layout.addWidget(self.createLabel("Score: "), 0, 2)
layout.addWidget(scoreLcd, 0, 3)
self.frame_cards = QFrame()
self.frame_cards.setFrameStyle(QFrame.Box | QFrame.Raised)
self.frame_cards.setLayout(layout_cards)
self.frame_chips = QFrame()
self.frame_chips.setFrameStyle(QFrame.Box | QFrame.Raised)
frame_lords = QFrame()
frame_lords.setFrameStyle(QFrame.Box | QFrame.Raised)
layout.addWidget(self.frame_cards, 2, 0, 4, 5)
layout.addWidget(self.frame_chips, 2, 6, 4, 2)
#layout.addWidget(frame_lords, 2, 10)
self.frame_chips.setLayout(layout_chips)
frame_lords.setLayout(layout_lords)
for r in (0, 4, 8):
row = self.game_table.state[int(r / 4)]
bord_line_cards = []
indent = 0
for i in range(4):
card = row[i]
bord_line_cards.append(self.createCardSelector(card, self.frame_cards))
layout_cards.addWidget(self.createCard(card, self.frame_cards), 0 + r, indent, 3, 2)
layout_cards.addWidget(bord_line_cards[i], 3 + r, indent)
indent += 2
self.setLayout(layout)
rr = 0
for r in (0, 2, 4):
row = self.game_table.state[int(r / 2)]
bord_line_chips = []
indent = 0
for i in range(2):
chip = row[4 + i]
bord_line_chips.append(self.createChipSelector(chip, self.frame_chips))
layout_chips.addWidget(self.createChip(chip, self.frame_chips), 0 + rr, 0, 4, 2)
layout_chips.addWidget(bord_line_chips[i], 2 + rr, 0)
rr += 2
self.setLayout(layout)
def __init__(self, parent):
MyMiniFrame.__init__(self, parent, "Représenter une suite")
##self.SetExtraStyle(wx.WS_EX_BLOCK_EVENTS )
self.parent = parent
self._param_ = self.parent._param_
##p = self.panel = QWidget(self)
self.sizer = sizer = QVBoxLayout()
sizer.addWidget(QLabel("Choisissez le mode de génération de la suite :"))
self.mode = QComboBox()
self.mode.addItems(["u(n+1)=f(u(n))", "u(n)=f(n)"])
self.mode.setCurrentIndex(0)
self.mode.currentIndexChanged.connect(self.EvtChoixMode)
sizer.addWidget(self.mode)
f = QHBoxLayout()
f.addWidget(QLabel("Choisissez la fonction f :"))
self.fonction = QComboBox()
self.fonction.addItems(["Y" + str(i+1) for i in range(self.parent.nombre_courbes)])
self.fonction.setCurrentIndex(0)
self.fonction.currentIndexChanged.connect(self.EvtChoixFonction)
f.addWidget(self.fonction)
sizer.addLayout(f)
start = QHBoxLayout()
start.addWidget(QLabel("Commencer pour n ="))
self.n0 = QSpinBox()
self.n0.setRange(0, 1000000)
self.n0.setValue(0)
start.addWidget(self.n0)
sizer.addLayout(start)
terme = QHBoxLayout()
self.label_init = QLabel("Terme initial :")
terme.addWidget(self.label_init)
self.un0 = QLineEdit("1")
self.un0.setMinimumWidth(100)
terme.addWidget(self.un0)
sizer.addLayout(terme)
ligne = QFrame()
ligne.setFrameStyle(QFrame.HLine|QFrame.Raised)
##sizer.addWidget(wx.StaticLine(p, -1, style=wx.LI_HORIZONTAL), 0, wx.GROW|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
nbr = QHBoxLayout()
nbr.addWidget(QLabel("Construire les"))
self.termes = QSpinBox()
self.termes.setRange(0, 100)
self.termes.setValue(5)
nbr.addWidget(self.termes)
nbr.addWidget(QLabel("premiers termes."))
sizer.addLayout(nbr)
ligne = QFrame()
ligne.setFrameStyle(QFrame.HLine|QFrame.Raised)
sizer.addWidget(ligne)
#p.SetSizer(sizer)
boutons = QHBoxLayout()
fermer = QPushButton("Fermer")
boutons.addWidget(fermer)
lancer = QPushButton("Créer")
boutons.addWidget(lancer)
fermer.clicked.connect(self.close)
lancer.clicked.connect(self.Creer)
sizer.addLayout(boutons)
self.setLayout(sizer)
def __init__(self, compare_frame_controller: CompareFrameController,
generator_tab_controller: GeneratorTabController,
project_manager: ProjectManager, parent):
super().__init__(parent)
self.project_manager = project_manager
self.compare_frame_controller = compare_frame_controller
self.generator_tab_controller = generator_tab_controller
self.proto_analyzer = compare_frame_controller.proto_analyzer
self.simulator_config = SimulatorConfiguration(self.project_manager)
self.sim_expression_parser = SimulatorExpressionParser(self.simulator_config)
SimulatorItem.simulator_config = self.simulator_config
SimulatorItem.expression_parser = self.sim_expression_parser
self.ui = Ui_SimulatorTab()
self.ui.setupUi(self)
util.set_splitter_stylesheet(self.ui.splitter)
util.set_splitter_stylesheet(self.ui.splitterLeftRight)
self.ui.splitter.setSizes([self.width() / 0.7, self.width() / 0.3])
self.ui.treeProtocols.setHeaderHidden(True)
self.tree_model = self.generator_tab_controller.tree_model
self.ui.treeProtocols.setModel(self.tree_model)
self.participant_table_model = ParticipantTableModel(project_manager.participants)
self.ui.tableViewParticipants.setModel(self.participant_table_model)
self.participant_table_model.update()
self.simulator_message_field_model = SimulatorMessageFieldModel(self)
self.ui.tblViewFieldValues.setModel(self.simulator_message_field_model)
self.ui.tblViewFieldValues.setItemDelegateForColumn(1, ComboBoxDelegate(ProtocolLabel.DISPLAY_FORMATS,
parent=self.ui.tblViewFieldValues))
self.ui.tblViewFieldValues.setItemDelegateForColumn(2, ComboBoxDelegate(SimulatorProtocolLabel.VALUE_TYPES,
parent=self.ui.tblViewFieldValues))
self.ui.tblViewFieldValues.setItemDelegateForColumn(3, ProtocolValueDelegate(controller=self,
parent=self.ui.tblViewFieldValues))
self.project_manager.reload_field_types()
self.update_field_name_column()
self.simulator_message_table_model = SimulatorMessageTableModel(self.project_manager, self)
self.ui.tblViewMessage.setModel(self.simulator_message_table_model)
self.ui.ruleCondLineEdit.setValidator(RuleExpressionValidator(self.sim_expression_parser, is_formula=False))
self.completer_model = QStringListModel([])
self.ui.ruleCondLineEdit.setCompleter(QCompleter(self.completer_model, self.ui.ruleCondLineEdit))
self.ui.ruleCondLineEdit.setToolTip(self.sim_expression_parser.rule_condition_help)
self.simulator_scene = SimulatorScene(mode=0, simulator_config=self.simulator_config)
self.simulator_scene.tree_root_item = compare_frame_controller.proto_tree_model.rootItem
self.ui.gvSimulator.setScene(self.simulator_scene)
self.ui.gvSimulator.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.ui.gvSimulator.proto_analyzer = compare_frame_controller.proto_analyzer
self.__active_item = None
self.ui.listViewSimulate.setModel(SimulatorParticipantListModel(self.simulator_config))
self.ui.spinBoxNRepeat.setValue(self.project_manager.simulator_num_repeat)
self.ui.spinBoxTimeout.setValue(self.project_manager.simulator_timeout_ms)
self.ui.spinBoxRetries.setValue(self.project_manager.simulator_retries)
self.ui.comboBoxError.setCurrentIndex(self.project_manager.simulator_error_handling_index)
# place save/load button at corner of tab widget
frame = QFrame(parent=self)
frame.setLayout(QHBoxLayout())
frame.setFrameStyle(frame.NoFrame)
self.ui.btnSave = QToolButton(self.ui.tab)
self.ui.btnSave.setIcon(QIcon.fromTheme("document-save"))
frame.layout().addWidget(self.ui.btnSave)
self.ui.btnLoad = QToolButton(self.ui.tab)
self.ui.btnLoad.setIcon(QIcon.fromTheme("document-open"))
frame.layout().addWidget(self.ui.btnLoad)
frame.layout().setContentsMargins(0, 0, 0, 0)
self.ui.tabWidget.setCornerWidget(frame)
self.ui.splitterLeftRight.setSizes([0.2 * self.width(), 0.8 * self.width()])
self.create_connects()
class TetrisMainWindow(QMainWindow):
""" The main tetris game window.
"""
def __init__(self, parent=None):
super(TetrisMainWindow, self).__init__(parent)
self.setWindowTitle('PyQtris v%s' % pyqtris_version)
self.setWindowIcon(QIcon(get_icon_pixmap()))
self.figurebank = self.make_figure_bank()
self.create_main_frame()
self.create_menu()
self.create_status_bar()
self.timer = QTimer()
self.timer_interval = 1000
self.timer.timeout.connect(self.on_timer)
# self.connect(self.timer, SIGNAL('timeout()'), self.on_timer)
self.timer.start(self.timer_interval)
self.init_highscores()
self.restart_game()
def on_restart(self):
if self.state == GameState.gameover:
self.restart_game()
else:
saved_state = self.state
self.pause_game()
reply = QMessageBox.question(self,
'Restart confirmation',
'Are you sure you want to restart the game?',
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
self.restart_game()
else:
self.set_game_state(saved_state)
def on_pause(self):
if self.state == GameState.paused:
self.resume_game()
elif self.state == GameState.running:
self.pause_game()
def on_about(self):
saved_state = self.state
self.pause_game()
dialog = aboutdialog.AboutDialog(self)
dialog.exec_()
self.set_game_state(saved_state)
def on_highscores(self):
saved_state = self.state
self.pause_game()
self.show_highscores()
self.set_game_state(saved_state)
def set_game_state(self, state):
if state == GameState.paused:
self.pause_game()
elif state == GameState.running:
self.resume_game()
elif state == GameState.gameover:
self.state = GameState.gameover
self.status_text.setText('Game over!')
self.timer.stop()
else:
assert False
def pause_game(self):
self.state = GameState.paused
self.status_text.setText('Paused')
self.pause_button.setText('Resume')
self.timer.stop()
def resume_game(self):
self.state = GameState.running
self.status_text.setText('Playing')
self.pause_button.setText('Pause')
self.timer.start(self.timer_interval)
def game_over(self):
self.state = GameState.gameover
self.status_text.setText('Game over!')
self.timer.stop()
if self.game_score > self.highscores.lowest_score():
text, ok = QInputDialog.getText(self,
"High score!",
'Your name:')
if ok and not text.isEmpty():
self.highscores.add_score(text, self.game_score)
self.save_highscores()
self.show_highscores()
def restart_game(self):
self.game_level = 1
self.game_lines = 0
self.game_score = 0
self.timer_interval = 1000
self.resume_game()
self.update_stats()
self.board_widget.restart(self.figurebank.get_random())
self.preview_figure = self.figurebank.get_random()
self.preview_widget.set_figure(self.preview_figure)
self.timer.start(self.timer_interval)
def on_timer(self):
if self.state == GameState.running:
result = self.board_widget.timer_tick(self.preview_figure)
num_rows = len(result.completed_rows)
if result.state == 'gameover':
self.game_over()
elif result.state == 'newfigure':
old_line_count = self.game_lines
self.game_lines += num_rows
score_bonus = result.drop_height + num_rows ** 2 * 30
score_bonus = int(score_bonus * (1 + 0.1 * (self.game_level - 1)))
self.game_score += score_bonus
self.preview_figure = self.figurebank.get_random()
self.preview_widget.set_figure(self.preview_figure)
if num_rows > 0 and old_line_count % 10 + num_rows >= 10:
self.game_level += 1
self.timer_interval = 1000 - self.game_level * 100
if self.timer_interval < 100:
self.timer_interval = 100
self.timer.stop()
self.timer.start(self.timer_interval)
self.update_stats()
def update_stats(self):
self.level_text.setText(str(self.game_level))
self.lines_text.setText(str(self.game_lines))
self.score_text.setText(str(self.game_score))
def create_main_frame(self):
self.board_widget = MainTetrisWidget(self,
nrows=20,
ncols=10,
blocksize=25,
startfigure=self.figurebank.get_random())
self.board_widget.setFocus()
self.control_panel = QFrame(self)
self.control_panel.setFrameStyle(QFrame.Panel | QFrame.Sunken)
self.control_panel.setFocusPolicy(Qt.NoFocus)
self.populate_control_panel()
main_layout = QHBoxLayout()
main_layout.addWidget(self.board_widget)
main_layout.addWidget(self.control_panel)
main_layout.setSizeConstraint(QLayout.SetFixedSize)
main_frame = QWidget()
main_frame.setLayout(main_layout)
self.setCentralWidget(main_frame)
def populate_control_panel(self):
self.preview_widget = TetrisPreviewWidget(
self.control_panel,
nrows=7,
ncols=7,
blocksize=10)
# preview_group is the group-box for titling the preview
# widget. preview_box is its internal layout.
# finally, preview_layout is used to add stretchers around
# the group box (to keep it slim)
#
preview_group = QGroupBox('Preview')
preview_box = QHBoxLayout()
preview_box.addWidget(self.preview_widget)
preview_group.setLayout(preview_box)
preview_layout = QHBoxLayout()
preview_layout.addStretch()
preview_layout.addWidget(preview_group)
preview_layout.addStretch()
text_layout = QGridLayout()
level_label = StatsLabel('Level')
self.level_text = StatsLabel('1', True)
lines_label = StatsLabel('Lines')
self.lines_text = StatsLabel('0', True)
score_label = StatsLabel('Score')
self.score_text = StatsLabel('0', True)
text_layout.addWidget(level_label, 0, 0)
text_layout.addWidget(self.level_text, 0, 1)
text_layout.addWidget(lines_label, 1, 0)
text_layout.addWidget(self.lines_text, 1, 1)
text_layout.addWidget(score_label, 2, 0)
text_layout.addWidget(self.score_text, 2, 1)
self.pause_button = SizedButton('&Pause', QSize(90, 40))
self.pause_button.setFocusPolicy(Qt.NoFocus)
self.pause_button.clicked.connect(self.on_pause)
#self.connect(self.pause_button, SIGNAL('clicked()'), self.on_pause)
self.restart_button = SizedButton('&New game', QSize(90, 40))
self.restart_button.setFocusPolicy(Qt.NoFocus)
self.restart_button.clicked.connect(self.on_restart)
#self.connect(self.restart_button, SIGNAL('clicked()'), self.on_restart)
button_layout = QHBoxLayout()
button_layout.addWidget(self.pause_button)
button_layout.addSpacing(40)
button_layout.addWidget(self.restart_button)
vbox = QVBoxLayout()
vbox.addSpacing(15)
vbox.addLayout(preview_layout)
vbox.addSpacing(40)
vbox.addLayout(text_layout)
vbox.addSpacing(40)
vbox.addLayout(button_layout)
vbox.addStretch()
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addLayout(vbox)
hbox.addStretch()
self.control_panel.setLayout(hbox)
def create_status_bar(self):
self.status_text = QLabel('Playing')
self.statusBar().addWidget(self.status_text, 1)
def create_menu(self):
self.game_menu = self.menuBar().addMenu("&Game")
self.help_menu = self.menuBar().addMenu("&Help")
new_game_action = self.create_action("&New",
shortcut='Ctrl+N', slot=self.on_restart,
tip='New game')
pause_game_action = self.create_action("&Pause",
shortcut='Ctrl+P', slot=self.on_pause,
tip='Pause game')
highscores_action = self.create_action("&High Scores",
shortcut='Ctrl+H', slot=self.on_highscores,
tip='Pause game')
quit_action = self.create_action("&Quit",
shortcut='Ctrl+Q', slot=self.close,
tip='Quit')
about_action = self.create_action("&About",
shortcut='F1', slot=self.on_about,
tip='About PyQtris')
self.add_actions(self.game_menu,
( new_game_action, pause_game_action, None,
highscores_action, None, quit_action))
self.add_actions(self.help_menu, (about_action,))
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_action(self, text, slot=None, shortcut=None,
icon=None, tip=None, checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
# if slot is not None:
# action.connect(slot)
## self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def make_figure_bank(self):
# The standard 7 Tetris figures, in the orientation
# in which they appear from the top of the screen
#
# oo
# oO
S = Figure([(0,0), (-1,0), (0,-1), (-1,1)], color=QColor(122, 197, 205))
# oo
# Oo
Z = Figure([(0,0), (0,1), (-1,-1), (-1,0)], color=QColor(0, 205, 0))
# oOo
# o
T = Figure([(0,0), (0,1), (0,-1), (1,0)], color=QColor(238, 238, 0))
# oOoo
#
I = Figure([(0,0), (0,-1), (0,1), (0,2)], color=QColor(238, 118, 33))
# oo
# Oo
O = Figure([(0,0), (-1,0), (-1,1), (0,1)], rotatable=False, color=QColor(238, 44, 44))
# oOo
# o
L = Figure([(0,0), (0,-1), (0,1), (1,-1)], color=QColor(0, 0, 225))
# oOo
# o
J = Figure([(0,0), (0,-1), (0,1), (1,1)], color=QColor(148, 0, 211))
return FigureBank([S, Z, T, I, O, L, J])
def keyPressEvent(self, event):
if self.state == GameState.running:
self.board_widget.keyPressEvent(event)
HS_FILENAME = 'pyqtris_highscores'
def init_highscores(self):
self.highscores = HighScores(10)
if os.path.exists(self.HS_FILENAME):
self.highscores.load_from_file(self.HS_FILENAME)
def save_highscores(self):
self.highscores.save_to_file(self.HS_FILENAME)
def show_highscores(self):
dialog = HighscoresDialog(self.highscores.get_list(), self)
dialog.exec_()
class BRFViewer(QWidget):
"""
Window that is used to show all the results produced with for the
currently selected water level dataset.
"""
def __init__(self, wldset=None, parent=None):
super(BRFViewer, self).__init__(parent)
self.__save_ddir = None
self.setWindowTitle('BRF Results Viewer')
self.setWindowIcon(icons.get_icon('master'))
self.setWindowFlags(Qt.Window |
Qt.CustomizeWindowHint |
Qt.WindowMinimizeButtonHint |
Qt.WindowCloseButtonHint)
self.__initGUI__()
self.set_wldset(wldset)
def __initGUI__(self):
# ---- Navigator
self.btn_prev = QToolButtonNormal(icons.get_icon('go_previous'))
self.btn_prev.clicked.connect(self.navigate_brf)
self.btn_next = QToolButtonNormal(icons.get_icon('go_next'))
self.btn_next.clicked.connect(self.navigate_brf)
self.current_brf = QSpinBox()
self.current_brf.setRange(0, 99)
self.current_brf.setAlignment(Qt.AlignCenter)
self.current_brf.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.current_brf.setCorrectionMode(
QAbstractSpinBox.CorrectToNearestValue)
self.current_brf.valueChanged.connect(self.navigate_brf)
self.current_brf.setValue(0)
self.total_brf = QLabel('/ 0')
# ---- Language button
self.btn_language = LangToolButton()
self.btn_language.setToolTip(
"Set the language of the text shown in the graph.")
self.btn_language.sig_lang_changed.connect(self.plot_brf)
self.btn_language.setIconSize(icons.get_iconsize('normal'))
# ---- Toolbar
# Generate the buttons :
self.btn_del = QToolButtonNormal(icons.get_icon('delete_data'))
self.btn_del.setToolTip('Delete current BRF results')
self.btn_del.clicked.connect(self.del_brf)
self.btn_del_all = QToolButtonNormal(icons.get_icon('close_all'))
self.btn_del_all.setToolTip(
'Delete all BRF results for the current water level dataset.')
self.btn_del_all.clicked.connect(self.del_all_brf)
self.btn_save = btn_save = QToolButtonNormal(icons.get_icon('save'))
btn_save.setToolTip('Save current BRF graph as...')
btn_save.clicked.connect(self.select_savefig_path)
self.btn_export = QToolButtonNormal(icons.get_icon('export_data'))
self.btn_export.setToolTip('Export data to file.')
self.btn_export.clicked.connect(self.select_export_brfdata_filepath)
self.btn_copy = QToolButtonNormal('copy_clipboard')
self.btn_copy.setToolTip('Copy figure to clipboard as image.')
self.btn_copy.clicked.connect(self.copyfig_to_clipboard)
self.btn_setp = QToolButtonNormal(icons.get_icon('page_setup'))
self.btn_setp.setToolTip('Show graph layout parameters...')
self.btn_setp.clicked.connect(self.toggle_graphpannel)
# Generate the layout :
self.tbar = myqt.QFrameLayout()
buttons = [btn_save, self.btn_copy, self.btn_export, self.btn_del,
self.btn_del_all, VSep(), self.btn_prev, self.current_brf,
self.total_brf, self.btn_next, VSep(), self.btn_setp,
self.btn_language]
for btn in buttons:
if isinstance(btn, QLayout):
self.tbar.addLayout(btn, 1, self.tbar.columnCount())
else:
self.tbar.addWidget(btn, 1, self.tbar.columnCount())
row = self.tbar.columnCount()
self.tbar.addWidget(HSep(), 0, 0, 1, row+1)
self.tbar.setColumnStretch(row, 100)
self.tbar.setContentsMargins(10, 0, 10, 10) # (l, t, r, b)
# ---- Graph Canvas
self.fig_frame = QFrame()
self.fig_frame.setFrameStyle(StyleDB().frame)
self.fig_frame.setObjectName("figframe")
self.fig_frame.setStyleSheet("#figframe {background-color:white;}")
self.brf_canvas = FigureCanvasQTAgg(BRFFigure())
fflay = QGridLayout(self.fig_frame)
fflay.setContentsMargins(0, 0, 0, 0) # (left, top, right, bottom)
fflay.addWidget(self.tbar, 1, 0)
fflay.addWidget(self.brf_canvas, 0, 0)
# ---- Graph Options Panel
self.graph_opt_panel = BRFOptionsPanel()
self.graph_opt_panel.sig_graphconf_changed.connect(self.plot_brf)
# ---- Main Layout
ml = QGridLayout(self)
ml.addWidget(self.fig_frame, 0, 2)
ml.addWidget(self.graph_opt_panel, 0, 3)
ml.setColumnStretch(1, 100)
@property
def savedir(self):
"""Return a path where figures and files are saved by default."""
if self.__save_ddir is None or not osp.exists(self.__save_ddir):
try:
savedir = self.wldset.dirname
except AttributeError:
savedir = osp.dirname(__rootdir__)
finally:
return savedir
else:
return self.__save_ddir
# ---- Toolbar Handlers
def toggle_graphpannel(self):
if self.graph_opt_panel.isVisible() is True:
# Hide the panel.
self.graph_opt_panel.setVisible(False)
self.btn_setp.setAutoRaise(True)
self.btn_setp.setToolTip('Show graph layout parameters...')
w = self.size().width() - self.graph_opt_panel.size().width()
self.setFixedWidth(w)
else:
# Show the panel.
self.graph_opt_panel.setVisible(True)
self.btn_setp.setAutoRaise(False)
self.btn_setp.setToolTip('Hide graph layout parameters...')
w = self.size().width() + self.graph_opt_panel.size().width()
self.setFixedWidth(w)
def navigate_brf(self):
if self.sender() == self.btn_prev:
cur_num = self.current_brf.value() - 1
elif self.sender() == self.btn_next:
cur_num = self.current_brf.value() + 1
elif self.sender() == self.current_brf:
cur_num = self.current_brf.value()
self.current_brf.setValue(cur_num)
self.update_brfnavigate_state()
def del_brf(self):
"""Delete the graph and data of the currently selected result."""
index = self.current_brf.value()-1
name = self.wldset.get_brfname_at(index)
self.wldset.del_brf(name)
self.update_brfnavigate_state()
def del_all_brf(self):
"""Delete all the graphs and BRF results for the current dataset."""
msg = ("Do you want to delete all BRF results that were evaluated "
"for dataset <i>{}</i>?"
"<br><br>"
"All data will be lost permanently."
).format(self.wldset.name)
btn = QMessageBox.Yes | QMessageBox.No
reply = QMessageBox.question(self, 'Delete all BRF results', msg, btn)
if reply == QMessageBox.Yes:
for name in self.wldset.saved_brf():
self.wldset.del_brf(name)
self.update_brfnavigate_state()
def new_brf_added(self):
self.current_brf.setMaximum(self.wldset.brf_count())
self.current_brf.setValue(self.wldset.brf_count())
self.update_brfnavigate_state()
def update_brfnavigate_state(self):
count = self.wldset.brf_count()
self.total_brf.setText('/ %d' % count)
self.current_brf.setMinimum(min(count, 1))
self.current_brf.setMaximum(count)
curnt = self.current_brf.value()
self.tbar.setEnabled(count > 0)
self.btn_prev.setEnabled(curnt > 1)
self.btn_next.setEnabled(curnt < count)
self.btn_del.setEnabled(count > 0)
self.plot_brf()
def select_savefig_path(self):
"""
Opens a dialog to select a file path where to save the brf figure.
"""
ddir = osp.join(self.savedir, 'brf_%s' % self.wldset['Well'])
dialog = QFileDialog()
fname, ftype = dialog.getSaveFileName(
self, "Save Figure", ddir, '*.pdf;;*.svg')
ftype = ftype.replace('*', '')
if fname:
if not osp.samefile(osp.dirname(ddir), osp.dirname(fname)):
self.__save_ddir = osp.dirname(fname)
if not fname.endswith(ftype):
fname = fname + ftype
self.save_brf_fig(fname)
def save_brf_fig(self, fname):
"""Saves the current BRF figure to fname."""
self.brf_canvas.figure.savefig(fname)
def copyfig_to_clipboard(self):
"""Saves the current BRF figure to the clipboard."""
buf = io.BytesIO()
self.save_brf_fig(buf)
QApplication.clipboard().setImage(QImage.fromData(buf.getvalue()))
buf.close()
def select_export_brfdata_filepath(self):
"""
Open a dialog to select a file path where to save the brf data.
"""
fname = 'brf_' + self.wldset['Well']
if self.wldset['Well ID']:
fname += '_%s' % self.wldset['Well ID']
ddir = osp.join(self.savedir, fname)
dialog = QFileDialog()
fname, ftype = dialog.getSaveFileName(
self, "Export Data", ddir, "*.xlsx;;*.xls;;*.csv")
ftype = ftype.replace('*', '')
if fname:
if not osp.samefile(osp.dirname(ddir), osp.dirname(fname)):
self.__save_ddir = osp.dirname(fname)
if not fname.endswith(ftype):
fname = fname + ftype
self.export_brf_data(fname)
def export_brf_data(self, fname):
"""Export the current BRF data to to file."""
self.wldset.export_brf_to_csv(fname, self.current_brf.value()-1)
# ---- Others
def set_wldset(self, wldset):
self.wldset = wldset
self.setEnabled(wldset is not None)
if wldset is not None:
self.update_brfnavigate_state()
def plot_brf(self):
self.brf_canvas.figure.set_language(self.btn_language.language)
if self.wldset.brf_count() == 0:
self.brf_canvas.figure.empty_BRF()
else:
name = self.wldset.get_brfname_at(self.current_brf.value()-1)
databrf = self.wldset.get_brf(name)
well = self.wldset['Well']
msize = self.graph_opt_panel.markersize
draw_line = self.graph_opt_panel.draw_line
ymin = self.graph_opt_panel.ymin
ymax = self.graph_opt_panel.ymax
yscale = self.graph_opt_panel.yscale
xmin = self.graph_opt_panel.xmin
xmax = self.graph_opt_panel.xmax
xscale = self.graph_opt_panel.xscale
time_units = self.graph_opt_panel.time_units
date0 = databrf.date_start.strftime(format='%d/%m/%y %H:%M')
date1 = databrf.date_end.strftime(format='%d/%m/%y %H:%M')
self.brf_canvas.figure.plot_BRF(
databrf['Lag'].values, databrf['SumA'].values,
databrf['sdA'].values, date0, date1, well, msize, draw_line,
[ymin, ymax], [xmin, xmax], time_units, xscale, yscale)
self.brf_canvas.draw()
def show(self):
super(BRFViewer, self).show()
qr = self.frameGeometry()
if self.parentWidget():
parent = self.parentWidget()
wp = parent.frameGeometry().width()
hp = parent.frameGeometry().height()
cp = parent.mapToGlobal(QPoint(wp/2, hp/2))
else:
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
self.fig_frame.setFixedSize(self.fig_frame.size())
self.setFixedSize(self.size())
self.raise_()
if self.windowState() == Qt.WindowMinimized:
# Window is minimised. Restore it.
self.setWindowState(Qt.WindowNoState)
