class collapsibleGroupBox2(QWidget):
def __init__(self, parent=None, title=None):
QWidget.__init__(self, parent)
self.frame = QFrame(self)
self.button = QPushButton("Toggle", self)
self.button.setCheckable(True)
self.button.setChecked(True)
self.switched = False
self.vPolicy = None
self.button.setStyleSheet(style.collapsibleGroupBoxButton())
if title:
self.setTitle(title)
def resizeEvent(self, event):
if not self.switched:
self.switchLayout()
return QWidget.resizeEvent(self, event)
def switchLayout(self):
self.frame.setLayout(self.layout())
self.wLayout = QVBoxLayout(self)
self.wLayout.setContentsMargins(0, 0, 0, 0)
self.wLayout.setSpacing(0)
self.wLayout.addWidget(self.button)
self.wLayout.addWidget(self.frame)
self.button.toggled.connect(self.setExpanded)
self.frame.layout().setContentsMargins(0, 0, 0, 4)
self.frame.layout().setSpacing(0)
self.switched = True
self.vPolicy = self.sizePolicy().verticalPolicy()
self.parent().layout().setAlignment(Qt.AlignTop)
self.setExpanded(self.button.isChecked())
def setFlat(self, val):
if val:
self.frame.setFrameShape(QFrame.NoFrame)
def setCheckable(self, val):
pass
def setTitle(self, title):
self.button.setText(title)
def setExpanded(self, val):
self.frame.setVisible(val)
if val:
self.setSizePolicy(QSizePolicy.Preferred, self.vPolicy)
else:
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
def saveState(self):
return self.button.isChecked()
def restoreState(self, val):
self.button.setChecked(val)
class HydroprintGUI(myqt.DialogWindow):
ConsoleSignal = QSignal(str)
def __init__(self, datamanager, parent=None):
super(HydroprintGUI, self).__init__(parent, maximize=True)
self.__updateUI = True
# Child widgets:
self.dmngr = datamanager
self.dmngr.wldsetChanged.connect(self.wldset_changed)
self.dmngr.wxdsetChanged.connect(self.wxdset_changed)
self.page_setup_win = PageSetupWin(self)
self.page_setup_win.newPageSetupSent.connect(self.layout_changed)
self.color_palette_win = ColorsSetupWin(self)
self.color_palette_win.newColorSetupSent.connect(self.update_colors)
# Memory path variable:
self.save_fig_dir = self.workdir
# Generate UI:
self.__initUI__()
def __initUI__(self):
# ---- Toolbar
self.btn_save = btn_save = QToolButtonNormal(icons.get_icon('save'))
btn_save.setToolTip('Save the well hydrograph')
# btn_draw is usefull for debugging purposes
btn_draw = QToolButtonNormal(icons.get_icon('refresh'))
btn_draw.setToolTip('Force a refresh of the well hydrograph')
btn_draw.hide()
self.btn_load_layout = QToolButtonNormal(
icons.get_icon('load_graph_config'))
self.btn_load_layout.setToolTip(
"<p>Load graph layout for the current water level "
" datafile if it exists</p>")
self.btn_load_layout.clicked.connect(self.load_layout_isClicked)
self.btn_save_layout = QToolButtonNormal(
icons.get_icon('save_graph_config'))
self.btn_save_layout.setToolTip('Save current graph layout')
self.btn_save_layout.clicked.connect(self.save_layout_isClicked)
btn_bestfit_waterlvl = QToolButtonNormal(icons.get_icon('fit_y'))
btn_bestfit_waterlvl.setToolTip('Best fit the water level scale')
btn_bestfit_time = QToolButtonNormal(icons.get_icon('fit_x'))
btn_bestfit_time.setToolTip('Best fit the time scale')
self.btn_page_setup = QToolButtonNormal(icons.get_icon('page_setup'))
self.btn_page_setup.setToolTip('Show the page setup window')
self.btn_page_setup.clicked.connect(self.page_setup_win.show)
btn_color_pick = QToolButtonNormal(icons.get_icon('color_picker'))
btn_color_pick.setToolTip('<p>Show a window to setup the color palette'
' used to draw the hydrograph</p.')
btn_color_pick.clicked.connect(self.color_palette_win.show)
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.layout_changed)
self.btn_language.setIconSize(icons.get_iconsize('normal'))
# ---- Zoom Panel
btn_zoom_out = QToolButtonSmall(icons.get_icon('zoom_out'))
btn_zoom_out.setToolTip('Zoom out (ctrl + mouse-wheel-down)')
btn_zoom_out.clicked.connect(self.zoom_out)
btn_zoom_in = QToolButtonSmall(icons.get_icon('zoom_in'))
btn_zoom_in.setToolTip('Zoom in (ctrl + mouse-wheel-up)')
btn_zoom_in.clicked.connect(self.zoom_in)
self.zoom_disp = QSpinBox()
self.zoom_disp.setAlignment(Qt.AlignCenter)
self.zoom_disp.setButtonSymbols(QAbstractSpinBox.NoButtons)
self.zoom_disp.setReadOnly(True)
self.zoom_disp.setSuffix(' %')
self.zoom_disp.setRange(0, 9999)
self.zoom_disp.setValue(100)
zoom_pan = myqt.QFrameLayout()
zoom_pan.setSpacing(3)
zoom_pan.addWidget(btn_zoom_out, 0, 0)
zoom_pan.addWidget(btn_zoom_in, 0, 1)
zoom_pan.addWidget(self.zoom_disp, 0, 2)
# LAYOUT :
btn_list = [btn_save, btn_draw,
self.btn_load_layout, self.btn_save_layout, VSep(),
btn_bestfit_waterlvl, btn_bestfit_time, VSep(),
self.btn_page_setup, btn_color_pick, self.btn_language,
VSep(), zoom_pan]
subgrid_toolbar = QGridLayout()
toolbar_widget = QWidget()
row = 0
for col, btn in enumerate(btn_list):
subgrid_toolbar.addWidget(btn, row, col)
subgrid_toolbar.setSpacing(5)
subgrid_toolbar.setContentsMargins(0, 0, 0, 0)
subgrid_toolbar.setColumnStretch(col + 1, 100)
toolbar_widget.setLayout(subgrid_toolbar)
# ---- LEFT PANEL
# SubGrid Hydrograph Frame :
self.hydrograph = hydrograph.Hydrograph()
self.hydrograph_scrollarea = mplFigViewer.ImageViewer()
self.hydrograph_scrollarea.zoomChanged.connect(self.zoom_disp.setValue)
grid_hydrograph = QGridLayout()
grid_hydrograph.addWidget(self.hydrograph_scrollarea, 0, 0)
grid_hydrograph.setRowStretch(0, 500)
grid_hydrograph.setColumnStretch(0, 500)
grid_hydrograph.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
# ASSEMBLING SubGrids :
grid_layout = QGridLayout()
self.grid_layout_widget = QFrame()
row = 0
grid_layout.addWidget(toolbar_widget, row, 0)
row += 1
grid_layout.addLayout(grid_hydrograph, row, 0)
grid_layout.setContentsMargins(0, 0, 0, 0) # (L, T, R, B)
grid_layout.setSpacing(5)
grid_layout.setColumnStretch(0, 500)
grid_layout.setRowStretch(1, 500)
self.grid_layout_widget.setLayout(grid_layout)
# ---- Right Panel
self.tabscales = self.__init_scalesTabWidget__()
self.right_panel = myqt.QFrameLayout()
self.right_panel.addWidget(self.dmngr, 0, 0)
self.right_panel.addWidget(self.tabscales, 1, 0)
self.right_panel.setRowStretch(2, 100)
self.right_panel.setSpacing(15)
# ---- MAIN GRID
mainGrid = QGridLayout()
mainGrid.addWidget(self.grid_layout_widget, 0, 0)
mainGrid.addWidget(VSep(), 0, 1)
mainGrid.addWidget(self.right_panel, 0, 2)
mainGrid.setContentsMargins(10, 10, 10, 10) # (L, T, R, B)
mainGrid.setSpacing(15)
mainGrid.setColumnStretch(0, 500)
mainGrid.setColumnMinimumWidth(2, 250)
self.setLayout(mainGrid)
# ---- EVENTS
# Toolbox Layout :
btn_bestfit_waterlvl.clicked.connect(self.best_fit_waterlvl)
btn_bestfit_time.clicked.connect(self.best_fit_time)
btn_draw.clicked.connect(self.draw_hydrograph)
btn_save.clicked.connect(self.select_save_path)
# Hydrograph Layout :
self.Ptot_scale.valueChanged.connect(self.layout_changed)
self.qweather_bin.currentIndexChanged.connect(self.layout_changed)
# ---- Init Image
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
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
@property
def workdir(self):
return self.dmngr.workdir
# ---- Utilities
def zoom_in(self):
self.hydrograph_scrollarea.zoomIn()
def zoom_out(self):
self.hydrograph_scrollarea.zoomOut()
def update_colors(self):
self.hydrograph.update_colors()
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
# ---- Datasets Handlers
@property
def wldset(self):
return self.dmngr.get_current_wldset()
@property
def wxdset(self):
return self.dmngr.get_current_wxdset()
def wldset_changed(self):
"""Handle when the water level dataset of the datamanager changes."""
if self.wldset is None:
self.clear_hydrograph()
return
else:
self.hydrograph.set_wldset(self.wldset)
self.hydrograph.gluedf = self.wldset.get_glue_at(-1)
# Load the manual measurements.
fname = os.path.join(
self.workdir, "Water Levels", 'waterlvl_manual_measurements')
tmeas, wlmeas = load_waterlvl_measures(fname, self.wldset['Well'])
self.wldset.set_wlmeas(tmeas, wlmeas)
# Setup the layout of the hydrograph.
layout = self.wldset.get_layout()
if layout is not None:
msg = ("Loading existing graph layout for well %s." %
self.wldset['Well'])
print(msg)
self.ConsoleSignal.emit('<font color=black>%s</font>' % msg)
self.load_graph_layout(layout)
else:
print('No graph layout exists for well %s.' % self.wldset['Well'])
# Fit Water Level in Layout :
self.__updateUI = False
self.best_fit_waterlvl()
self.best_fit_time()
if self.dmngr.set_closest_wxdset() is None:
self.draw_hydrograph()
self.__updateUI = True
def wxdset_changed(self):
"""Handle when the weather dataset of the datamanager changes."""
if self.wldset is None:
self.clear_hydrograph()
else:
self.hydrograph.set_wxdset(self.wxdset)
QCoreApplication.processEvents()
self.draw_hydrograph()
# ---- Draw Hydrograph Handlers
def best_fit_waterlvl(self):
wldset = self.dmngr.get_current_wldset()
if wldset is not None:
WLscale, WLmin = self.hydrograph.best_fit_waterlvl()
self.waterlvl_scale.setValue(WLscale)
self.waterlvl_max.setValue(WLmin)
def best_fit_time(self):
wldset = self.dmngr.get_current_wldset()
if wldset is not None:
date0, date1 = self.hydrograph.best_fit_time(wldset.xldates)
self.date_start_widget.setDate(QDate(date0[0], date0[1], date0[2]))
self.date_end_widget.setDate(QDate(date1[0], date1[1], date1[2]))
@QSlot()
def mrc_wl_changed(self):
"""
Force a redraw of the MRC water levels after the results have
changed for the dataset.
"""
self.hydrograph.draw_mrc_wl()
self.hydrograph.setup_legend()
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
@QSlot(GLUEDataFrameBase)
def glue_wl_changed(self, gluedf):
"""
Force a redraw of the GLUE water levels after the results have
changed for the dataset.
"""
self.hydrograph.set_gluedf(gluedf)
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
def layout_changed(self):
"""
When an element of the graph layout is changed in the UI.
"""
if self.__updateUI is False:
return
self.update_graph_layout_parameter()
if self.hydrograph.isHydrographExists is False:
return
sender = self.sender()
if sender == self.btn_language:
self.hydrograph.draw_ylabels()
self.hydrograph.setup_xticklabels()
self.hydrograph.setup_legend()
elif sender in [self.waterlvl_max, self.waterlvl_scale]:
self.hydrograph.setup_waterlvl_scale()
self.hydrograph.draw_ylabels()
elif sender == self.NZGridWL_spinBox:
self.hydrograph.setup_waterlvl_scale()
self.hydrograph.update_precip_scale()
self.hydrograph.draw_ylabels()
elif sender == self.Ptot_scale:
self.hydrograph.update_precip_scale()
self.hydrograph.draw_ylabels()
elif sender == self.datum_widget:
yoffset = int(self.wldset['Elevation']/self.hydrograph.WLscale)
yoffset *= self.hydrograph.WLscale
self.hydrograph.WLmin = (yoffset - self.hydrograph.WLmin)
self.waterlvl_max.blockSignals(True)
self.waterlvl_max.setValue(self.hydrograph.WLmin)
self.waterlvl_max.blockSignals(False)
# This is calculated so that trailing zeros in the altitude of the
# well is not carried to the y axis labels, so that they remain a
# int multiple of *WLscale*.
self.hydrograph.setup_waterlvl_scale()
self.hydrograph.draw_waterlvl()
self.hydrograph.draw_ylabels()
elif sender in [self.date_start_widget, self.date_end_widget]:
self.hydrograph.set_time_scale()
self.hydrograph.draw_weather()
self.hydrograph.draw_figure_title()
elif sender == self.dateDispFreq_spinBox:
self.hydrograph.set_time_scale()
self.hydrograph.setup_xticklabels()
elif sender == self.page_setup_win:
self.hydrograph.update_fig_size()
# Implicitly call : set_margins()
# draw_ylabels()
# set_time_scale()
# draw_figure_title
self.hydrograph.draw_waterlvl()
self.hydrograph.setup_legend()
elif sender == self.qweather_bin:
self.hydrograph.resample_bin()
self.hydrograph.draw_weather()
self.hydrograph.draw_ylabels()
elif sender == self.time_scale_label:
self.hydrograph.set_time_scale()
self.hydrograph.draw_weather()
else:
print('No action for this widget yet.')
# !!!! temporary fix until I can find a better solution !!!!
# sender.blockSignals(True)
if type(sender) in [QDoubleSpinBox, QSpinBox]:
sender.setReadOnly(True)
for i in range(10):
QCoreApplication.processEvents()
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
for i in range(10):
QCoreApplication.processEvents()
if type(sender) in [QDoubleSpinBox, QSpinBox]:
sender.setReadOnly(False)
# sender.blockSignals(False)
def update_graph_layout_parameter(self):
# language :
self.hydrograph.language = self.btn_language.language
# Scales :
self.hydrograph.WLmin = self.waterlvl_max.value()
self.hydrograph.WLscale = self.waterlvl_scale.value()
self.hydrograph.RAINscale = self.Ptot_scale.value()
self.hydrograph.NZGrid = self.NZGridWL_spinBox.value()
# WL Datum :
self.hydrograph.WLdatum = self.datum_widget.currentIndex()
# Dates :
self.hydrograph.datemode = self.time_scale_label.currentText()
year = self.date_start_widget.date().year()
month = self.date_start_widget.date().month()
self.hydrograph.TIMEmin = xldate_from_date_tuple((year, month, 1), 0)
year = self.date_end_widget.date().year()
month = self.date_end_widget.date().month()
self.hydrograph.TIMEmax = xldate_from_date_tuple((year, month, 1), 0)
self.hydrograph.date_labels_pattern = self.dateDispFreq_spinBox.value()
# Page Setup :
self.hydrograph.fwidth = self.page_setup_win.pageSize[0]
self.hydrograph.fheight = self.page_setup_win.pageSize[1]
self.hydrograph.va_ratio = self.page_setup_win.va_ratio
self.hydrograph.trend_line = self.page_setup_win.isTrendLine
self.hydrograph.isLegend = self.page_setup_win.isLegend
self.hydrograph.isGraphTitle = self.page_setup_win.isGraphTitle
self.hydrograph.set_meteo_on(self.page_setup_win.is_meteo_on)
self.hydrograph.set_glue_wl_on(self.page_setup_win.is_glue_wl_on)
self.hydrograph.set_mrc_wl_on(self.page_setup_win.is_mrc_wl_on)
self.hydrograph.set_figframe_lw(self.page_setup_win.figframe_lw)
# Weather bins :
self.hydrograph.bwidth_indx = self.qweather_bin.currentIndex()
def clear_hydrograph(self):
"""Clear the hydrograph figure to show only a blank canvas."""
self.hydrograph.clf()
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
def draw_hydrograph(self):
if self.dmngr.wldataset_count() == 0:
msg = 'Please import a valid water level data file first.'
self.ConsoleSignal.emit('<font color=red>%s</font>' % msg)
self.emit_warning(msg)
return
self.update_graph_layout_parameter()
# Generate and Display Graph :
for i in range(5):
QCoreApplication.processEvents()
QApplication.setOverrideCursor(Qt.WaitCursor)
self.hydrograph.set_wldset(self.dmngr.get_current_wldset())
self.hydrograph.set_wxdset(self.dmngr.get_current_wxdset())
self.hydrograph.generate_hydrograph()
self.hydrograph_scrollarea.load_mpl_figure(self.hydrograph)
QApplication.restoreOverrideCursor()
def select_save_path(self):
"""
Open a dialog where the user can select a file name to save the
hydrograph.
"""
if self.wldset is None:
return
ffmat = "*.pdf;;*.svg;;*.png"
fname = find_unique_filename(osp.join(
self.save_fig_dir, 'hydrograph_%s.pdf' % self.wldset['Well']))
fname, ftype = QFileDialog.getSaveFileName(
self, "Save Figure", fname, ffmat)
if fname:
ftype = ftype.replace('*', '')
fname = fname if fname.endswith(ftype) else fname + ftype
self.save_fig_dir = os.path.dirname(fname)
try:
self.save_figure(fname)
except PermissionError:
msg = "The file is in use by another application or user."
QMessageBox.warning(self, 'Warning', msg, QMessageBox.Ok)
self.select_save_path()
def save_figure(self, fname):
"""Save the hydrograph figure in a file."""
self.hydrograph.generate_hydrograph()
self.hydrograph.savefig(fname)
# ---- Graph Layout Handlers
def load_layout_isClicked(self):
"""Handle when the button to load the graph layout is clicked."""
if self.wldset is None:
self.emit_warning(
"Please import a valid water level data file first.")
return
layout = self.wldset.get_layout()
if layout is None:
self.emit_warning(
"No graph layout exists for well %s." % self.wldset['Well'])
else:
self.load_graph_layout(layout)
def load_graph_layout(self, layout):
"""Load the graph layout into the GUI."""
self.__updateUI = False
# Scales :
date = layout['TIMEmin']
date = xldate_as_tuple(date, 0)
self.date_start_widget.setDate(QDate(date[0], date[1], date[2]))
date = layout['TIMEmax']
date = xldate_as_tuple(date, 0)
self.date_end_widget.setDate(QDate(date[0], date[1], date[2]))
self.dateDispFreq_spinBox.setValue(layout['date_labels_pattern'])
self.waterlvl_scale.setValue(layout['WLscale'])
self.waterlvl_max.setValue(layout['WLmin'])
self.NZGridWL_spinBox.setValue(layout['NZGrid'])
self.Ptot_scale.setValue(layout['RAINscale'])
x = ['mbgs', 'masl'].index(layout['WLdatum'])
self.datum_widget.setCurrentIndex(x)
self.qweather_bin.setCurrentIndex(layout['bwidth_indx'])
self.time_scale_label.setCurrentIndex(
self.time_scale_label.findText(layout['datemode']))
# ---- Language and colors
self.btn_language.set_language(layout['language'])
self.color_palette_win.load_colors()
# ---- Page Setup
self.page_setup_win.pageSize = (layout['fwidth'], layout['fheight'])
self.page_setup_win.va_ratio = layout['va_ratio']
self.page_setup_win.isLegend = layout['legend_on']
self.page_setup_win.isGraphTitle = layout['title_on']
self.page_setup_win.isTrendLine = layout['trend_line']
self.page_setup_win.is_meteo_on = layout['meteo_on']
self.page_setup_win.is_glue_wl_on = layout['glue_wl_on']
self.page_setup_win.is_mrc_wl_on = layout['mrc_wl_on']
self.page_setup_win.figframe_lw = layout['figframe_lw']
self.page_setup_win.legend_on.set_value(layout['legend_on'])
self.page_setup_win.title_on.set_value(layout['title_on'])
self.page_setup_win.wltrend_on.set_value(layout['trend_line'])
self.page_setup_win.meteo_on.set_value(layout['meteo_on'])
self.page_setup_win.glue_wl_on.set_value(layout['glue_wl_on'])
self.page_setup_win.mrc_wl_on.set_value(layout['mrc_wl_on'])
self.page_setup_win.fframe_lw_widg.setValue(layout['figframe_lw'])
self.page_setup_win.fwidth.setValue(layout['fwidth'])
self.page_setup_win.fheight.setValue(layout['fheight'])
self.page_setup_win.va_ratio_spinBox.setValue(layout['va_ratio'])
# Check if Weather Dataset :
if layout['wxdset'] in self.dmngr.wxdsets:
self.dmngr.set_current_wxdset(layout['wxdset'])
else:
if self.dmngr.set_closest_wxdset() is None:
self.draw_hydrograph()
self.__updateUI = True
def save_layout_isClicked(self):
wldset = self.wldset
if wldset is None:
self.emit_warning(
"Please import a valid water level data file first.")
return
layout = wldset.get_layout()
if layout is not None:
msg = ('A graph layout already exists for well %s.Do you want to'
' you want to replace it?') % wldset['Well']
reply = QMessageBox.question(self, 'Save Graph Layout', msg,
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
self.save_graph_layout()
elif reply == QMessageBox.No:
msg = "Graph layout not saved for well %s." % wldset['Well']
self.ConsoleSignal.emit('<font color=black>%s' % msg)
else:
self.save_graph_layout()
def save_graph_layout(self):
"""Save the graph layout in the project hdf5 file."""
print("Saving the graph layout for well %s..." % self.wldset['Well'],
end=" ")
layout = {'WLmin': self.waterlvl_max.value(),
'WLscale': self.waterlvl_scale.value(),
'RAINscale': self.Ptot_scale.value(),
'fwidth': self.page_setup_win.pageSize[0],
'fheight': self.page_setup_win.pageSize[1],
'va_ratio': self.page_setup_win.va_ratio,
'NZGrid': self.NZGridWL_spinBox.value(),
'bwidth_indx': self.qweather_bin.currentIndex(),
'date_labels_pattern': self.dateDispFreq_spinBox.value(),
'datemode': self.time_scale_label.currentText()}
layout['wxdset'] = None if self.wxdset is None else self.wxdset.name
year = self.date_start_widget.date().year()
month = self.date_start_widget.date().month()
layout['TIMEmin'] = xldate_from_date_tuple((year, month, 1), 0)
year = self.date_end_widget.date().year()
month = self.date_end_widget.date().month()
layout['TIMEmax'] = xldate_from_date_tuple((year, month, 1), 0)
if self.datum_widget.currentIndex() == 0:
layout['WLdatum'] = 'mbgs'
else:
layout['WLdatum'] = 'masl'
# ---- Page Setup
layout['title_on'] = bool(self.page_setup_win.isGraphTitle)
layout['legend_on'] = bool(self.page_setup_win.isLegend)
layout['language'] = self.btn_language.language
layout['trend_line'] = bool(self.page_setup_win.isTrendLine)
layout['meteo_on'] = bool(self.page_setup_win.is_meteo_on)
layout['glue_wl_on'] = bool(self.page_setup_win.is_glue_wl_on)
layout['mrc_wl_on'] = bool(self.page_setup_win.is_mrc_wl_on)
layout['figframe_lw'] = self.page_setup_win.figframe_lw
# Save the colors :
cdb = ColorsReader()
cdb.load_colors_db()
layout['colors'] = cdb.RGB
# Save the layout :
self.wldset.save_layout(layout)
msg = 'Layout saved successfully for well %s.' % self.wldset['Well']
self.ConsoleSignal.emit('<font color=black>%s</font>' % msg)
print("done")
def __init__(self, settings):
super(QWidget, self).__init__()
self._layout = QBoxLayout(QBoxLayout.TopToBottom)
self.setLayout(self._layout)
self.settings = settings
# eq directory
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
label = QLabel("Everquest Directory: ")
layout.addWidget(label)
text = QLineEdit()
text.setText(self.settings.get_value("general", "eq_directory"))
text.setToolTip(self.settings.get_value("general", "eq_directory"))
text.setDisabled(True)
self._text_eq_directory = text
layout.addWidget(text, 1)
button = QPushButton("Browse...")
button.clicked.connect(self._get_eq_directory)
layout.addWidget(button)
self._layout.addWidget(widget, 0, Qt.AlignTop)
# eq directory info
frame = QFrame()
frame.setFrameShadow(QFrame.Sunken)
frame.setFrameShape(QFrame.Box)
frame_layout = QBoxLayout(QBoxLayout.LeftToRight)
frame.setLayout(frame_layout)
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
self._label_eq_directory = QLabel()
layout.addWidget(self._label_eq_directory, 1)
frame_layout.addWidget(widget, 1, Qt.AlignCenter)
self._layout.addWidget(frame, 1)
# parse interval
widget = QWidget()
layout = QBoxLayout(QBoxLayout.LeftToRight)
widget.setLayout(layout)
label = QLabel("Seconds between parse checks: ")
layout.addWidget(label, 0, Qt.AlignLeft)
text = QLineEdit()
text.setText(str(self.settings.get_value("general", "parse_interval")))
text.editingFinished.connect(self._parse_interval_editing_finished)
text.setMaxLength(3)
self._text_parse_interval = text
metrics = QFontMetrics(QApplication.font())
text.setFixedWidth(metrics.width("888888"))
layout.addWidget(text, 0, Qt.AlignLeft)
self._layout.addWidget(widget, 0, Qt.AlignTop | Qt.AlignLeft)
# spacing at bottom of window
widget = QWidget()
self._layout.addWidget(widget, 1)
# setup
if settings.get_value("general", "eq_directory") is not None:
self._check_directory_stats()
def initUI(self, haveAuto):
vbox = QVBoxLayout(self)
top = QFrame(self)
top.setFrameShape(QFrame.StyledPanel)
bottom = QFrame(self)
bottom.setFrameShape(QFrame.StyledPanel)
grid1 = QGridLayout()
grid1.setSpacing(10)
self.lineLabel = []
self.lineEdit = []
for i in range(len(self.label)):
self.lineLabel.append(QLabel(self.label[i]))
self.lineEdit.append(QLineEdit('%s' % self.value[i]))
grid1.addWidget(self.lineLabel[i], i, 0)
grid1.addWidget(self.lineEdit[i], i, 1)
top.setLayout(grid1)
grid2 = QGridLayout()
grid2.setSpacing(5)
autoButton = QPushButton(self.tr("Auto"))
okButton = QPushButton(self.tr("OK"))
cancelButton = QPushButton(self.tr("Cancel"))
autoButton.clicked.connect(self.cbAuto)
okButton.clicked.connect(self.cbOK)
cancelButton.clicked.connect(self.cbCancel)
if haveAuto:
grid2.addWidget(autoButton, 0, 0)
grid2.addWidget(okButton, 0, 1)
grid2.addWidget(cancelButton, 0, 2)
bottom.setLayout(grid2)
vbox.addWidget(top)
vbox.addWidget(bottom)
self.setLayout(vbox)
self.resize(50, 50)
self.setWindowFlags(self.windowFlags() & ~QtCore.Qt.WindowContextHelpButtonHint)
self.setWindowTitle(self.title)
iconWT = QIcon()
iconWT.addPixmap(QPixmap(":images/DXF2GCODE-001.ico"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(QIcon(iconWT))
self.exec_()
def define_section2(self):
"""defining section 2: Specify allele details
"""
mywidget = QWidget(self)
layout = QGridLayout()
mywidget.setLayout(layout)
a1_new = False
self.allele1_sec = AlleleSection("Allele 1:", self)
layout.addWidget(self.allele1_sec,0,0)
a2_new = False
self.allele2_sec = AlleleSection("Allele 2:", self)
layout.addWidget(self.allele2_sec,0,1)
#ToDo: add closest alleles!
button_widget = QFrame(self) # contains both-checkbox & proceed-button
layout2 = QFormLayout()
button_widget.setLayout(layout2)
# self.both_cbx = QCheckBox(self)
# self.both_cbx.clicked.connect(self.select_both)
# self.both_lbl = QLabel("Both alleles?")
# self.both_lbl.setStyleSheet(general.label_style_main)
# layout2.addRow(self.both_lbl, self.both_cbx)
# self.msg = QLabel("When selecting this option, please ensure\nyou have entered details for both alleles.")
# self.msg.setStyleSheet(general.label_style_normal)
# layout2.addRow(self.msg)
layout2.addRow(QLabel("\n\n"))
if a1_new:
self.allele1_sec.checkbox.setChecked(True)
if a2_new:
self.allele2_sec.checkbox.setChecked(True)
elif a2_new:
self.allele2_sec.checkbox.setChecked(True)
# self.allele1_sec.checkbox.clicked.connect(self.unselect_both_cbx)
self.allele1_sec.checkbox.clicked.connect(self.unselect_other_box)
self.allele2_sec.checkbox.clicked.connect(self.unselect_other_box)
# self.allele2_sec.checkbox.clicked.connect(self.unselect_both_cbx)
self.ok_btn = ProceedButton("Proceed", [self.allele1_sec.checkbox, self.allele2_sec.checkbox], self.log,
only1 = True)
self.ok_btn.check_ready()
self.ok_btn.clicked.connect(self.make_ENA_file)
self.allele1_sec.selection_changed.connect(self.ok_btn.check_ready)
self.allele2_sec.selection_changed.connect(self.ok_btn.check_ready)
layout2.addRow(self.ok_btn)
layout.addWidget(button_widget, 0 ,3)
layout.setColumnStretch(0,1)
layout.setColumnStretch(1,1)
layout.setColumnStretch(2,0)
self.sections.append(("(2) Specify allele details:", mywidget))
def make_page(self):
# make the edit line
page = QFrame()
layout = QVBoxLayout()
page.setLayout( layout )
line1 = QFrame()
layout1 = QHBoxLayout()
line1.setLayout( layout1 )
layout.addWidget( line1 )
layout1.addWidget( QLabel("<b>W x H:</b> ") )
self.edit_width = QLineEdit()
self.edit_width.setFixedWidth(50)
self.edit_width.textChanged.connect(self.onChange)
layout1.addWidget( self.edit_width )
self.edit_height = QLineEdit()
self.edit_height.setFixedWidth(50)
self.edit_height.textChanged.connect(self.onChange)
layout1.addWidget( self.edit_height )
self.edit_shape = QComboBoxNoWheel()
self.edit_shape.addItem("Flat Triangle")
self.edit_shape.addItem("Symmetrical")
self.edit_shape.addItem("Bottom Sheet")
self.edit_shape.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_shape)
self.edit_start = QComboBoxNoWheel()
self.edit_start.addItem("-")
self.edit_start.addItem("1")
self.edit_start.addItem("2")
self.edit_start.addItem("3")
self.edit_start.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_start)
self.edit_end = QComboBoxNoWheel()
self.edit_end.addItem("-")
self.edit_end.addItem("1")
self.edit_end.addItem("2")
self.edit_end.addItem("3")
self.edit_end.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_end)
layout1.addStretch(1)
delete = QPushButton('Delete ')
delete.clicked.connect(self.delete_self)
layout1.addWidget(delete)
return page
def QFramedVTK(**kw):
"""
Wrap the VTK widget in a tight fitting frame.
This ensures that the widget has a parent, and allows for retina handling.
"""
frame = QFrame()
widget = QVTKRenderWindowInteractor(frame, **kw)
vl = QHBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(widget)
frame.setLayout(vl)
return frame, widget
def totalBox(self):
lblTest = QLabel("test")
lblSomething = QLabel("something else")
totBox = QVBoxLayout()
totBox.addWidget(lblTest)
totBox.addWidget(lblSomething)
totBox.addStretch()
tFrame = QFrame()
tFrame.setLayout(totBox)
tFrame.setMinimumWidth(350)
return tFrame
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 make_page(self):
# make the full edit widget
page = QFrame()
layout = QFormLayout()
page.setLayout( layout )
self.edit_name = QLineEdit()
self.edit_name.setFixedWidth(250)
self.edit_name.textChanged.connect(self.onChange)
self.edit_desc = QTextEdit()
self.edit_desc.setFixedWidth(250)
self.edit_desc.textChanged.connect(self.onChange)
self.edit_author = QLineEdit()
self.edit_author.setFixedWidth(250)
self.edit_author.textChanged.connect(self.onChange)
self.edit_email = QLineEdit()
self.edit_email.setFixedWidth(250)
self.edit_email.textChanged.connect(self.onChange)
self.edit_units = QComboBoxNoWheel()
self.edit_units.setFixedWidth(250)
self.edit_units.addItem("in")
self.edit_units.addItem("cm")
self.edit_units.addItem("mm")
self.edit_units.currentIndexChanged.connect(self.onChange)
self.edit_sheet_w = QLineEdit()
self.edit_sheet_w.setFixedWidth(250)
self.edit_sheet_w.textChanged.connect(self.onChange)
self.edit_sheet_h = QLineEdit()
self.edit_sheet_h.setFixedWidth(250)
self.edit_sheet_h.textChanged.connect(self.onChange)
self.edit_plans_w = QLineEdit()
self.edit_plans_w.setFixedWidth(250)
self.edit_plans_w.textChanged.connect(self.onChange)
self.edit_plans_h = QLineEdit()
self.edit_plans_h.setFixedWidth(250)
self.edit_plans_h.textChanged.connect(self.onChange)
layout.addRow( "<b>Design Name:</b>", self.edit_name )
layout.addRow( "<b>Description:</b>", self.edit_desc )
layout.addRow( "<b>Author:</b>", self.edit_author )
layout.addRow( "<b>Email:</b>", self.edit_email )
layout.addRow( "<b>Units:</b>", self.edit_units )
layout.addRow( "<b>Mat. Sheet Width:</b>", self.edit_sheet_w )
layout.addRow( "<b>Mat. Sheet Height:</b>", self.edit_sheet_h )
layout.addRow( "<b>Plans Width:</b>", self.edit_plans_w )
layout.addRow( "<b>Plans Height:</b>", self.edit_plans_h )
return page
def Homepage(self):
self.win = QMainWindow()
frame = QFrame()
self.win.setCentralWidget(frame)
Layout = QGridLayout()
frame.setLayout(Layout)
Francais = QPushButton("FR", self)
Francais.clicked.connect(self.RecetteFR)
Anglais = QPushButton("AN", self)
#Anglais.clicked.connect(self.RecetteAN)
Layout.addWidget(Francais, 0, 0, 1, 2)
Layout.addWidget(Anglais, 0, 2, 1, 2)
self.win.show()
def initCtrPane(self):
# main control set up
mainCtr = QFrame(self.ctrPane)
mainCtr.setFrameShape(QFrame.StyledPanel)
mainCtr.setFrameShadow(QFrame.Sunken)
# buttons and controls
backSubButton = QPushButton('Background Subtraction', mainCtr)
backSubButton.clicked.connect(self.backSub)
plotButton = QPushButton('Plot', mainCtr)
plotButton.clicked.connect(self.updatePlot1)
newTabButton = QPushButton('New tab', mainCtr)
newTabButton.clicked.connect(self.addTab)
self.plotPeak = QCheckBox('Plot fitted peak', mainCtr)
holdPlot = QCheckBox('Hold plot', mainCtr)
holdPlot.stateChanged.connect(self.canvas.toggleHold)
# layout
mainLayout = QGridLayout(mainCtr)
mainLayout.addWidget(backSubButton, 0, 0)
mainLayout.addWidget(plotButton, 0, 1)
mainLayout.addWidget(newTabButton, 1, 0)
mainLayout.addWidget(self.plotPeak, 2, 0)
mainLayout.addWidget(holdPlot, 2, 1)
mainCtr.setLayout(mainLayout)
self.ctrPane.addTab(mainCtr, 'Main Control')
# NMF control set up
NMFCtr = QFrame(self.ctrPane)
NMFCtr.setFrameShape(QFrame.StyledPanel)
NMFCtr.setFrameShadow(QFrame.Sunken)
# input & buttons
self.alphaBox = MyDoubleBox(NMFCtr)
self.l1RatioBox = MyDoubleBox(NMFCtr)
self.loadSettings()
NMFButton = QPushButton('NMF', NMFCtr)
NMFButton.clicked.connect(self.NMF)
# layout
NMFLayout = QGridLayout(NMFCtr)
NMFLayout.addWidget(QLabel('α'), 0, 0)
NMFLayout.addWidget(QLabel('l1 ratio'), 1, 0)
NMFLayout.addWidget(self.alphaBox, 0, 1)
NMFLayout.addWidget(self.l1RatioBox, 1, 1)
NMFLayout.addWidget(NMFButton, 2, 0, 1, 2)
NMFCtr.setLayout(NMFLayout)
self.ctrPane.addTab(NMFCtr, 'NMF Control')
class StockSourceDisplayPanel:
def __init__(self,parent,world):
self.parent = parent
self.world = world
self.scrollable_display = 0
self.button_display = 0
self.button_list = []
self.initUI()
def initUI(self):
self.scrollable_display = QScrollArea(self.parent)
self.button_display = QFrame(self.scrollable_display)
self.scrollable_display.setWidget(self.button_display)
self.populate_button_list()
self.scrollable_display.show()
self.button_display.show()
def populate_button_list(self):
stock_list = self.world.get_stock_source_list()
vbox = QVBoxLayout()
button_list = []
i = 0
for entry in stock_list:
entry_button = QPushButton(entry.get_name())
button_list.append(entry_button)
vbox.addWidget(entry_button)
entry_button.clicked.connect(functools.partial(self.parent.stockUI,i,stock_target=entry.get_stock()))
i += 1
vbox.addStretch(1)
self.button_display.setLayout(vbox)
self.resize()
def destroy(self):
self.scrollable_display.hide()
self.button_display.hide()
self.parent.resize(self.parent.size())
self.button_display.destroy(False, False)
self.scrollable_display.destroy(False, False)
def resize(self):
self.scrollable_display.resize(self.parent.size())
frameWidth = self.scrollable_display.lineWidth()
self.button_display.resize(self.scrollable_display.size().width()-(frameWidth*2),self.scrollable_display.size().height()-(frameWidth*2))
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 __init__(self, gallery, parent=None):
super().__init__(parent)
self.setWindowFlags(Qt.Window)
self.current_chapters = len(gallery.chapters)
self.added_chaps = 0
layout = QFormLayout()
self.setLayout(layout)
lbl = QLabel('{} by {}'.format(gallery.title, gallery.artist))
layout.addRow('Gallery:', lbl)
layout.addRow('Current chapters:', QLabel('{}'.format(self.current_chapters)))
new_btn = QPushButton('New')
new_btn.clicked.connect(self.add_new_chapter)
new_btn.adjustSize()
add_btn = QPushButton('Finish')
add_btn.clicked.connect(self.finish)
add_btn.adjustSize()
new_l = QHBoxLayout()
new_l.addWidget(add_btn, alignment=Qt.AlignLeft)
new_l.addWidget(new_btn, alignment=Qt.AlignRight)
layout.addRow(new_l)
frame = QFrame()
frame.setFrameShape(frame.StyledPanel)
layout.addRow(frame)
self.chapter_l = QVBoxLayout()
frame.setLayout(self.chapter_l)
new_btn.click()
self.setMaximumHeight(550)
self.setFixedWidth(500)
if parent:
self.move(parent.window().frameGeometry().topLeft() +
parent.window().rect().center() -
self.rect().center())
else:
frect = self.frameGeometry()
frect.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(frect.topLeft())
self.setWindowTitle('Add Chapters')
def make_page(self):
# make the edit line
page = QFrame()
layout = QVBoxLayout()
page.setLayout( layout )
line1 = QFrame()
layout1 = QHBoxLayout()
line1.setLayout( layout1 )
layout.addWidget( line1 )
layout1.addWidget( QLabel("<b>Size:</b> ") )
self.edit_size = QLineEdit()
self.edit_size.setFixedWidth(50)
self.edit_size.textChanged.connect(self.onChange)
layout1.addWidget( self.edit_size )
self.edit_start = QComboBoxNoWheel()
self.edit_start.addItem("-")
self.edit_start.addItem("1")
self.edit_start.addItem("2")
self.edit_start.addItem("3")
self.edit_start.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_start)
self.edit_end = QComboBoxNoWheel()
self.edit_end.addItem("-")
self.edit_end.addItem("1")
self.edit_end.addItem("2")
self.edit_end.addItem("3")
self.edit_end.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_end)
layout1.addStretch(1)
delete = QPushButton('Delete ')
delete.clicked.connect(self.delete_self)
layout1.addWidget(delete)
return page
class AvailableSizes(QDialog):
def __init__(self):
super(AvailableSizes, self).__init__()
self.createCombos()
self.createHeader()
#self.createMenuBar()
self.printOut = QTextEdit()
self.printOut.setFont(QFont('Helvetica', 11, QFont.Bold))
self.printOut.setReadOnly(True)
mainLayout = QVBoxLayout()
#mainLayout.setMenuBar(self.menuBar)
mainLayout.addWidget(self.frmHeader)
mainLayout.addWidget(self.grpBox)
mainLayout.addWidget(self.printOut)
#mainLayout.setAlignment(self.frmHeader, Qt.AlignRight)
self.setLayout(mainLayout)
#self.setWindowTitle("Available Sizes")
self.setWindowFlags(Qt.FramelessWindowHint)
bgColor = QPalette()
bgColor.setColor(self.backgroundRole(), Qt.gray)
self.setPalette(bgColor)
self.setWindowIcon(QIcon('icon/PS_Icon.png'))
self.cbSku.setFocus()
def createHeader(self):
blk = QPalette()
blk.setColor(blk.Foreground, Qt.white)
lblTitle = QLabel("Availability Checker")
lblTitle.setFont(QFont("Times", 12, QFont.Bold ))
lblTitle.setPalette(blk)
btnClose = QToolButton()
btnClose.setIcon(QIcon("icon\size_exit.png"))
btnClose.setAutoRaise(True)
btnClose.setIconSize(QSize(25,25))
btnClose.clicked.connect(lambda: self.close())
hbHeader = QHBoxLayout()
hbHeader.addWidget(lblTitle)
hbHeader.addWidget(btnClose)
hbHeader.setContentsMargins(0, 0, 0, 0)
self.frmHeader = QFrame()
self.frmHeader.setLayout(hbHeader)
def createCombos(self):
cbFont = QFont("Times", 8, QFont.Bold)
designs = self.getDesigns()
self.grpBox = QGroupBox()
self.grpBox.setFont(QFont('Times', 10, QFont.Bold))
layout = QFormLayout()
self.cbSku = QComboBox()
self.cbSku.addItem("Designs")
self.cbSku.addItems(designs)
self.cbSku.setFont(cbFont)
self.cbSku.currentIndexChanged.connect(self.skuChanged)
self.cbStyle = QComboBox()
self.cbStyle.addItem("Styles")
self.cbStyle.setFont(cbFont)
self.cbStyle.currentIndexChanged.connect(self.styleChanged)
layout.addRow(QLabel("Design:"), self.cbSku)
layout.addRow(QLabel("Style:"), self.cbStyle)
self.grpBox.setLayout(layout)
def skuChanged(self):
if self.cbStyle.count() > 0:
self.cbStyle.clear()
self.cbStyle.addItem("Style")
self.cbStyle.setCurrentIndex(0)
styles = self.getStyles(self.cbSku.currentText())
else:
styles = self.getStyles(self.cbSku.currentText())
self.cbStyle.addItems(styles)
def styleChanged(self):
self.printOut.clear()
sizes = self.getSizes(self.cbSku.currentText(), self.cbStyle.currentText())
if self.cbStyle.currentText() != "Styles":
for i in sizes:
self.printOut.insertPlainText(i + '\n')
def createMenuBar(self):
self.menuBar = QMenuBar()
self.fileMenu = QMenu("&File", self)
self.exitAction = self.fileMenu.addAction("E&xit")
self.menuBar.addMenu(self.fileMenu)
self.exitAction.triggered.connect(self.accept)
def getDesigns(self):
sd = mysql_db.mysql_connect(self)
sd.execute("""SELECT
DISTINCT CONCAT(d.sku_code, " - ", d.name) design
FROM
designs d
JOIN packages p on p.design_id = d.id
ORDER BY RIGHT(d.sku_code, 3), LEFT(d.sku_code,1)""")
ds = sd.fetchall()
lsDesigns = []
for i in ds:
lsDesigns.append(i[0])
return lsDesigns
def getStyles(self, sku):
sd = mysql_db.mysql_connect(self)
sd.execute("""SELECT
DISTINCT g.name
FROM
garment_styles_ages g
JOIN packages p ON p.garment_styles_age_id = g.id
JOIN designs d ON d.id = p.design_id
WHERE d.sku_code = '""" + sku[:4] + """'
ORDER BY g.name""")
ds = sd.fetchall()
lsStyles = []
for i in ds:
lsStyles.append(i[0])
return lsStyles
def getSizes(self, sku, style):
style = style.replace("'", "\\'")
sd = mysql_db.mysql_connect(self)
sd.execute("""
SELECT
DISTINCT CONCAT(s.name, ' - ', c.name) size
FROM
sizes s
JOIN packages p ON p.size_id = s.id
JOIN designs d ON d.id = p.design_id
JOIN colors c ON c.id = p.color_id
JOIN garment_styles_ages g ON g.id = p.garment_styles_age_id
WHERE
d.sku_code = '""" + sku[:4] + """'
AND
g.name = '""" + style + """'""")
ds = sd.fetchall()
lsSizes = []
for i in ds:
lsSizes.append(i[0])
return lsSizes
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.leftClick = True
self.offset = event.pos()
def mouseMoveEvent(self, event):
if self.leftClick == True:
x=event.globalX()
y=event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x-x_w, y-y_w)
def mouseReleaseEvent(self, event):
self.leftClick = False
def __init__(self, engine):
super().__init__()
self.setupUi(self)
self._engine = engine
machines = {
plugin.name: _(plugin.name)
for plugin in registry.list_plugins('machine')
}
mappings = (
(_('Interface'), (
ConfigOption(_('Start minimized:'), 'start_minimized', BooleanOption,
_('Minimize the main window to systray on startup.')),
ConfigOption(_('Show paper tape:'), 'show_stroke_display', BooleanOption,
_('Open the paper tape on startup.')),
ConfigOption(_('Show suggestions:'), 'show_suggestions_display', BooleanOption,
_('Open the suggestions dialog on startup.')),
ConfigOption(_('Add translation dialog opacity:'), 'translation_frame_opacity',
partial(IntOption, maximum=100, minimum=0),
_('Set the translation dialog opacity:\n'
'- 0 makes the dialog invisible\n'
'- 100 is fully opaque')),
ConfigOption(_('Dictionaries display order:'), 'classic_dictionaries_display_order',
partial(BooleanAsDualChoiceOption,
_('top-down'), _('bottom-up')),
_('Set the display order for dictionaries:\n'
'- top-down: match the search order; highest priority first\n'
'- bottom-up: reverse search order; lowest priority first\n')),
)),
(_('Logging'), (
ConfigOption(_('Log file:'), 'log_file_name',
partial(FileOption,
_('Select a log file'),
_('Log files') + ' (*.log)'),
_('File to use for logging strokes/translations.')),
ConfigOption(_('Log strokes:'), 'enable_stroke_logging', BooleanOption,
_('Save strokes to the logfile.')),
ConfigOption(_('Log translations:'), 'enable_translation_logging', BooleanOption,
_('Save translations to the logfile.')),
)),
(_('Machine'), (
ConfigOption(_('Machine:'), 'machine_type', partial(ChoiceOption, choices=machines),
dependents=(
('machine_specific_options', self._update_machine_options),
('system_keymap', lambda v: self._update_keymap(machine_type=v)),
)),
ConfigOption(_('Options:'), 'machine_specific_options', self._machine_option),
ConfigOption(_('Keymap:'), 'system_keymap', KeymapOption),
)),
(_('Output'), (
ConfigOption(_('Enable at start:'), 'auto_start', BooleanOption,
_('Enable output on startup.')),
ConfigOption(_('Start attached:'), 'start_attached', BooleanOption,
_('Disable preceding space on first output.\n'
'\n'
'This option is only applicable when spaces are placed before.')),
ConfigOption(_('Start capitalized:'), 'start_capitalized', BooleanOption,
_('Capitalize the first word.')),
ConfigOption(_('Space placement:'), 'space_placement',
partial(ChoiceOption, choices={
'Before Output': _('Before Output'),
'After Output': _('After Output'),
}),
_('Set automatic space placement: before or after each word.')),
ConfigOption(_('Undo levels:'), 'undo_levels',
partial(IntOption,
maximum=10000,
minimum=MINIMUM_UNDO_LEVELS),
_('Set how many preceding strokes can be undone.\n'
'\n'
'Note: the effective value will take into account the\n'
'dictionaries entry with the maximum number of strokes.')),
)),
(_('Plugins'), (
ConfigOption(_('Extension:'), 'enabled_extensions',
partial(MultipleChoicesOption, choices={
plugin.name: plugin.name
for plugin in registry.list_plugins('extension')
}, labels=(_('Name'), _('Enabled'))),
_('Configure enabled plugin extensions.')),
)),
(_('System'), (
ConfigOption(_('System:'), 'system_name',
partial(ChoiceOption, choices={
plugin.name: plugin.name
for plugin in registry.list_plugins('system')
}),
dependents=(
('system_keymap', lambda v: self._update_keymap(system_name=v)),
)),
)),
)
# Only keep supported options, to avoid messing with things like
# dictionaries, that are handled by another (possibly concurrent)
# dialog.
self._supported_options = set()
for section, option_list in mappings:
self._supported_options.update(option.option_name for option in option_list)
self._update_config()
# Create and fill tabs.
options = {}
for section, option_list in mappings:
layout = QFormLayout()
for option in option_list:
widget = self._create_option_widget(option)
options[option.option_name] = option
option.tab_index = self.tabs.count()
option.layout = layout
option.widget = widget
label = QLabel(option.display_name)
label.setToolTip(option.help_text)
layout.addRow(label, widget)
frame = QFrame()
frame.setLayout(layout)
scroll_area = QScrollArea()
scroll_area.setWidgetResizable(True)
scroll_area.setWidget(frame)
self.tabs.addTab(scroll_area, section)
# Update dependents.
for option in options.values():
option.dependents = [
(options[option_name], update_fn)
for option_name, update_fn in option.dependents
]
buttons = self.findChild(QWidget, 'buttons')
buttons.button(QDialogButtonBox.Ok).clicked.connect(self.on_apply)
buttons.button(QDialogButtonBox.Apply).clicked.connect(self.on_apply)
self.restore_state()
self.finished.connect(self.save_state)
class Builder(QWidget):
def __init__(self, app):
super().__init__()
self.app = app
self.build()
def build(self):
self.setGeometry(375, 300, 435, 316)
self.setWindowTitle('Cast list')
self.grid = QGridLayout()
#List of voice types
self.voiceBox = QFrame()
self.voiceGrid = QGridLayout() # in a grid layout
vs = VoiceButton("Soprano", 0)
vs.setChecked(True) # first one is checked
va = VoiceButton("Alto", 1)
vt = VoiceButton("Tenor", 2)
vb = VoiceButton("Bass", 3)
self.voiceGrid.addWidget(vs, 0, 0)
self.voiceGrid.addWidget(va, 1, 0)
self.voiceGrid.addWidget(vt, 2, 0)
self.voiceGrid.addWidget(vb, 3, 0)
self.voiceBox.setLayout(self.voiceGrid)
self.grid.addWidget(self.voiceBox, 0, 0)
# List of part names
self.partBox = QFrame()
self.partGrid = QGridLayout()
rp = RoleButton("Principal", 0)
rp.setChecked(True) # first one is checked
rm = RoleButton("Minor lead", 1)
rc = RoleButton("Chorus", 2)
self.partGrid.addWidget(rp, 0, 0)
self.partGrid.addWidget(rm, 1, 0)
self.partGrid.addWidget(rc, 2, 0)
self.partBox.setLayout(self.partGrid)
self.grid.addWidget(self.partBox, 0, 1)
# create listbox
self.nameList = QListWidget()
self.grid.addWidget(self.nameList, 0, 2)
self.grid.setColumnMinimumWidth(2, 275)
# create Label and entry field
self.lbl = QLabel("Name: ")
self.nameField = QLineEdit()
self.hbox1 = QHBoxLayout()
self.hbox1.addWidget(self.lbl)
self.hbox1.addWidget(self.nameField)
self.grid.addLayout(self.hbox1, 1, 0, 1, 2)
# create Add and Clear buttons
self.addButton = QPushButton("Add")
self.clearButton = QPushButton("Clear")
self.hbox2 = QHBoxLayout()
self.hbox2.addStretch(1)
self.hbox2.addWidget(self.addButton)
self.hbox2.addWidget(self.clearButton)
self.hbox2.addStretch(1)
self.grid.addLayout(self.hbox2, 2, 0, 1, 3)
self.med = Mediator(self.nameField, self.nameList)
self.addButton.clicked.connect(self.med.addClick)
self.clearButton.clicked.connect(self.med.clearClick)
self.setLayout(self.grid)
self.show()
class AudioVideoTab(QWidget):
def __init__(self, parent):
super(AudioVideoTab, self).__init__(parent)
self.parent = parent
self.name = 'AudioVideo'
self.defaultStr = self.tr('Default')
self.DisableStream = self.tr('Disable')
self.formats = config.video_formats
frequency_values = [self.defaultStr] + config.video_frequency_values
bitrate_values = [self.defaultStr] + config.video_bitrate_values
rotation_options = [
self.tr('None'),
'90 ' + self.tr('clockwise'),
'90 ' + self.tr('clockwise') + ' + ' + self.tr('vertical flip'),
'90 ' + self.tr('counter clockwise'),
'90 ' + self.tr('counter clockwise') +
' + ' + self.tr('vertical flip'),
'180',
self.tr('horizontal flip'),
self.tr('vertical flip')
]
digits_validator = QRegExpValidator(QRegExp(r'[1-9]\d*'), self)
digits_validator_wzero = QRegExpValidator(QRegExp(r'\d*'), self)
digits_validator_minus = QRegExpValidator(QRegExp(r'(-1|[1-9]\d*)'), self)
time_validator = QRegExpValidator(
QRegExp(r'\d{1,2}:\d{1,2}:\d{1,2}\.\d+'), self)
converttoQL = QLabel(self.tr('Convert to:'))
self.extQCB = QComboBox()
self.extQCB.setMinimumWidth(100)
vidcodecQL = QLabel('Video codec:')
self.vidcodecQCB = QComboBox()
self.vidcodecQCB.setMinimumWidth(110)
audcodecQL = QLabel('Audio codec:')
self.audcodecQCB = QComboBox()
self.audcodecQCB.setMinimumWidth(110)
hlayout1 = utils.add_to_layout(
'h', converttoQL, self.extQCB, QSpacerItem(180, 20),
vidcodecQL, self.vidcodecQCB, audcodecQL, self.audcodecQCB)
commandQL = QLabel(self.tr('Command:'))
self.commandQLE = QLineEdit()
self.presetQPB = QPushButton(self.tr('Preset'))
self.defaultQPB = QPushButton(self.defaultStr)
hlayout2 = utils.add_to_layout(
'h', commandQL, self.commandQLE, self.presetQPB,
self.defaultQPB)
sizeQL = QLabel(self.tr('Video Size:'))
aspectQL = QLabel(self.tr('Aspect:'))
frameQL = QLabel(self.tr('Frame Rate (fps):'))
bitrateQL = QLabel(self.tr('Video Bitrate (kbps):'))
self.widthQLE = utils.create_LineEdit(
(70, 16777215), digits_validator_minus, 4)
self.heightQLE = utils.create_LineEdit(
(70, 16777215), digits_validator_minus, 4)
label = QLabel('<html><p align="center">x</p></html>')
layout1 = utils.add_to_layout('h', self.widthQLE, label,self.heightQLE)
self.aspect1QLE = utils.create_LineEdit(
(50, 16777215), digits_validator, 2)
self.aspect2QLE = utils.create_LineEdit(
(50, 16777215), digits_validator, 2)
label = QLabel('<html><p align="center">:</p></html>')
layout2 = utils.add_to_layout(
'h', self.aspect1QLE, label, self.aspect2QLE)
self.frameQLE = utils.create_LineEdit(
(120, 16777215), digits_validator, 4)
self.bitrateQLE = utils.create_LineEdit(
(130, 16777215), digits_validator, 6)
labels = [sizeQL, aspectQL, frameQL, bitrateQL]
widgets = [layout1, layout2, self.frameQLE, self.bitrateQLE]
self.preserveaspectQChB = QCheckBox(self.tr("Preserve aspect ratio"))
self.preservesizeQChB = QCheckBox(self.tr("Preserve video size"))
preserve_layout = utils.add_to_layout(
'v', self.preserveaspectQChB, self.preservesizeQChB)
videosettings_layout = QHBoxLayout()
for a, b in zip(labels, widgets):
a.setText('<html><p align="center">{0}</p></html>'.format(a.text()))
layout = utils.add_to_layout('v', a, b)
videosettings_layout.addLayout(layout)
if a == aspectQL:
# add vidaspectCB in layout after aspectQL
videosettings_layout.addLayout(preserve_layout)
freqQL = QLabel(self.tr('Frequency (Hz):'))
chanQL = QLabel(self.tr('Audio Channels:'))
bitrateQL = QLabel(self.tr('Audio Bitrate (kbps):'))
threadsQL = QLabel(self.tr('Threads:'))
self.freqQCB = QComboBox()
self.freqQCB.addItems(frequency_values)
self.chan1QRB = QRadioButton('1')
self.chan1QRB.setMaximumSize(QSize(51, 16777215))
self.chan2QRB = QRadioButton('2')
self.chan2QRB.setMaximumSize(QSize(51, 16777215))
self.group = QButtonGroup()
self.group.addButton(self.chan1QRB)
self.group.addButton(self.chan2QRB)
spcr1 = QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Minimum)
spcr2 = QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Minimum)
chanlayout = utils.add_to_layout(
'h', spcr1, self.chan1QRB, self.chan2QRB, spcr2)
self.audbitrateQCB = QComboBox()
self.audbitrateQCB.addItems(bitrate_values)
self.threadsQLE = utils.create_LineEdit(
(50, 16777215), digits_validator_wzero, 1)
labels = [freqQL, bitrateQL, chanQL, threadsQL]
widgets = [self.freqQCB, self.audbitrateQCB, chanlayout,self.threadsQLE]
audiosettings_layout = QHBoxLayout()
for a, b in zip(labels, widgets):
a.setText('<html><p align="center">{0}</p></html>'.format(a.text()))
layout = utils.add_to_layout('v', a, b)
audiosettings_layout.addLayout(layout)
time_format = " (hh:mm:ss):"
beginQL = QLabel(self.tr("Split file. Begin time") + time_format)
self.beginQLE = utils.create_LineEdit(None, time_validator, None)
durationQL = QLabel(self.tr("Duration") + time_format)
self.durationQLE = utils.create_LineEdit(None, time_validator, None)
hlayout4 = utils.add_to_layout(
'h', beginQL, self.beginQLE, durationQL, self.durationQLE)
embedQL = QLabel(self.tr("Embed subtitle:"))
self.embedQLE = QLineEdit()
self.embedQTB = QToolButton()
self.embedQTB.setText("...")
rotateQL = QLabel(self.tr("Rotate:"))
self.rotateQCB = QComboBox()
self.rotateQCB.addItems(rotation_options)
hlayout5 = utils.add_to_layout(
'h', rotateQL, self.rotateQCB, embedQL, self.embedQLE,
self.embedQTB)
hidden_layout = utils.add_to_layout(
'v', videosettings_layout, audiosettings_layout,
hlayout4, hlayout5)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.moreQPB = QPushButton(QApplication.translate('Tab', 'More'))
self.moreQPB.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.moreQPB.setCheckable(True)
hlayout3 = utils.add_to_layout('h', line, self.moreQPB)
self.frame = QFrame()
self.frame.setLayout(hidden_layout)
self.frame.hide()
final_layout = utils.add_to_layout(
'v', hlayout1, hlayout2, hlayout3, self.frame)
self.setLayout(final_layout)
self.presetQPB.clicked.connect(self.choose_preset)
self.defaultQPB.clicked.connect(self.set_default_command)
self.embedQTB.clicked.connect(self.open_subtitle_file)
self.moreQPB.toggled.connect(self.frame.setVisible)
self.moreQPB.toggled.connect(
lambda: QTimer.singleShot(100, self.resize_parent))
self.widthQLE.textChanged.connect(self.command_update_size)
self.heightQLE.textChanged.connect(self.command_update_size)
self.aspect1QLE.textChanged.connect(self.command_update_aspect)
self.aspect2QLE.textChanged.connect(self.command_update_aspect)
self.frameQLE.textChanged.connect(self.command_update_frames)
self.bitrateQLE.textChanged.connect(self.command_update_vidbitrate)
self.threadsQLE.textChanged.connect(self.command_update_threads)
self.beginQLE.textChanged.connect(self.command_update_begin_time)
self.durationQLE.textChanged.connect(self.command_update_duration)
self.embedQLE.textChanged.connect(self.command_update_subtitles)
self.vidcodecQCB.currentIndexChanged.connect(self.command_update_vcodec)
self.audcodecQCB.currentIndexChanged.connect(self.command_update_acodec)
self.freqQCB.currentIndexChanged.connect(self.command_update_frequency)
self.rotateQCB.currentIndexChanged.connect(self.command_update_rotation)
self.audbitrateQCB.currentIndexChanged.connect(
self.command_update_audbitrate)
self.chan1QRB.clicked.connect(
lambda: self.command_update_channels('1'))
self.chan2QRB.clicked.connect(
lambda: self.command_update_channels('2'))
self.preserveaspectQChB.toggled.connect(
self.command_update_preserve_aspect)
self.preservesizeQChB.toggled.connect(
self.command_update_preserve_size)
def resize_parent(self):
"""Give MainWindow its default size."""
self.parent.setMinimumSize(self.parent.sizeHint())
self.parent.resize(self.parent.sizeHint())
def clear(self):
"""Clear all values of graphical widgets."""
lines = [
self.commandQLE, self.widthQLE, self.heightQLE,
self.aspect1QLE, self.aspect2QLE, self.frameQLE,
self.bitrateQLE, self.threadsQLE, self.beginQLE,
self.embedQLE, self.durationQLE
]
for i in lines:
i.clear()
self.vidcodecQCB.setCurrentIndex(0)
self.audcodecQCB.setCurrentIndex(0)
self.freqQCB.setCurrentIndex(0)
self.audbitrateQCB.setCurrentIndex(0)
self.rotateQCB.setCurrentIndex(0)
self.preserveaspectQChB.setChecked(False)
self.preservesizeQChB.setChecked(False)
self.group.setExclusive(False)
self.chan1QRB.setChecked(False)
self.chan2QRB.setChecked(False)
self.group.setExclusive(True)
# setExclusive(False) in order to be able to uncheck checkboxes and
# then setExclusive(True) so only one radio button can be set
def fill_video_comboboxes(self, vcodecs, acodecs, extraformats):
self.vidcodecQCB.currentIndexChanged.disconnect()
self.audcodecQCB.currentIndexChanged.disconnect()
self.vidcodecQCB.clear()
self.audcodecQCB.clear()
self.extQCB.clear()
self.vidcodecQCB.addItems([self.defaultStr, self.DisableStream] + vcodecs)
self.audcodecQCB.addItems([self.defaultStr, self.DisableStream] + acodecs)
self.extQCB.addItems(sorted(self.formats + extraformats))
self.vidcodecQCB.currentIndexChanged.connect(self.command_update_vcodec)
self.audcodecQCB.currentIndexChanged.connect(self.command_update_acodec)
def ok_to_continue(self):
"""
Check if everything is ok with audiovideotab to continue conversion.
Returns boolean.
"""
if not self.parent.ffmpeg_path:
QMessageBox.warning(self, 'FF Multi Converter - ' + self.tr(
'Error!'), self.tr('FFmpeg is not installed!'))
return False
return True
def open_subtitle_file(self):
fname = QFileDialog.getOpenFileName(
self, 'FF Multi Converter - ' + self.tr('Choose File'),
config.home, 'Subtitles (*.srt *.sub *.ssa *.ass)'
)[0]
if fname:
self.embedQLE.setText(fname)
def set_default_command(self):
"""Set the default value to self.commandQLE."""
self.clear()
self.commandQLE.setText(self.parent.default_command)
def choose_preset(self):
"""
Open the presets dialog and update self.commandQLE,
and self.extQCB and with the appropriate values.
"""
dialog = presets_dlgs.ShowPresets(choose=True)
if dialog.exec_() and dialog.the_command is not None:
self.clear()
self.commandQLE.setText(dialog.the_command)
self.commandQLE.home(False)
find = self.extQCB.findText(dialog.the_extension)
if find >= 0:
self.extQCB.setCurrentIndex(find)
def command_update_size(self):
command = self.commandQLE.text()
text1 = self.widthQLE.text()
text2 = self.heightQLE.text()
if not (text1 == '-1' or text2 == '-1'):
self.preserveaspectQChB.setChecked(False)
if (text1 or text2) and not (text1 and text2) or (text1 == '-' or
text2 == '-'):
return
regex = r'(\s+|^)-s(:v){0,1}\s+\d+x\d+(\s+|$)'
if re.search(regex, command):
command = re.sub(regex, '', command)
regex = r'(,*\s*){0,1}(scale=-?\d+:-?\d+)(\s*,*\s*){0,1}'
_filter = "scale={0}:{1}".format(text1, text2) if text1 and text2 else ''
self.commandQLE.setText(utils.update_cmdline_text(
command, _filter, regex, bool(text1 and text2), 0, 2))
def command_update_preserve_size(self):
checked = self.preservesizeQChB.isChecked()
self.widthQLE.setEnabled(not checked)
self.heightQLE.setEnabled(not checked)
if checked:
self.widthQLE.clear()
self.heightQLE.clear()
# command_update_size() is triggered here
command = self.commandQLE.text()
regex = r'(\s+|^)-s\s+\d+x\d+(\s+|$)'
command = re.sub(' +', ' ', re.sub(regex, ' ', command)).strip()
self.commandQLE.setText(command)
def command_update_aspect(self):
command = self.commandQLE.text()
text1 = self.aspect1QLE.text()
text2 = self.aspect2QLE.text()
if (text1 or text2) and not (text1 and text2):
return
regex = r'(\s+|^)-aspect\s+\d+:\d+(\s+|$)'
s = ' -aspect {0}:{1} '.format(text1, text2) if text1 and text2 else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_preserve_aspect(self):
command = self.commandQLE.text()
checked = self.preserveaspectQChB.isChecked()
self.aspect1QLE.setEnabled(not checked)
self.aspect2QLE.setEnabled(not checked)
if checked:
self.aspect1QLE.clear()
self.aspect2QLE.clear()
# self.command_update_aspect() is triggered here
regex = r'(,*\s*){0,1}(scale=(-?\d+):(-?\d+))(\s*,*\s*){0,1}'
search = re.search(regex, command)
if search:
width = search.groups()[2]
height = search.groups()[3]
if not (width == '-1' or height == '-1'):
s = "scale=-1:{0}".format(height)
command = re.sub(regex, r'\1{0}\5'.format(s), command)
self.widthQLE.setText('-1')
self.heightQLE.setText(height)
regex = r'(\s+|^)-aspect\s+\d+:\d+(\s+|$)'
command = re.sub(' +', ' ', re.sub(regex, ' ', command)).strip()
self.commandQLE.setText(command)
def command_update_frames(self):
command = self.commandQLE.text()
text = self.frameQLE.text()
regex = r'(\s+|^)-r\s+\d+(\s+|$)'
s = ' -r {0} '.format(text) if text else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_vidbitrate(self):
command = self.commandQLE.text()
text = self.bitrateQLE.text()
regex = r'(\s+|^)-b(:v){0,1}\s+\d+[kKmM](\s+|$)'
s = ' -b:v {0}k '.format(text) if text else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub('-sameq', '', command)
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_frequency(self):
command = self.commandQLE.text()
text = self.freqQCB.currentText()
regex = r'(\s+|^)-ar\s+\d+(\s+|$)'
s = ' -ar {0} '.format(text) if self.freqQCB.currentIndex() != 0 else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_audbitrate(self):
command = self.commandQLE.text()
text = self.audbitrateQCB.currentText()
regex = r'(\s+|^)-(ab|b:a)\s+\d+[kKmM](\s+|$)'
if self.audbitrateQCB.currentIndex() != 0:
s = ' -b:a {0}k '.format(text)
else:
s = ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_channels(self, channel):
command = self.commandQLE.text()
regex = r'(\s+|^)-ac\s+\d+(\s+|$)'
s = ' -ac {0} '.format(channel)
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_threads(self):
command = self.commandQLE.text()
text = self.threadsQLE.text()
regex = r'(\s+|^)-threads\s+\d+(\s+|$)'
s = ' -threads {0} '.format(text) if text else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_begin_time(self):
command = self.commandQLE.text()
text = self.beginQLE.text()
regex = r'(\s+|^)-ss\s+\S+(\s+|$)'
s = ' -ss {0} '.format(text) if text else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_duration(self):
command = self.commandQLE.text()
text = self.durationQLE.text()
regex = r'(\s+|^)-t\s+\S+(\s+|$)'
s = ' -t {0} '.format(text) if text else ' '
if re.search(regex, command):
command = re.sub(regex, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_vcodec(self):
command = self.commandQLE.text()
text = self.vidcodecQCB.currentText()
regex = r'(\s+|^)-(vcodec|c:v)\s+\S+(\s+|$)'
regex_vn = r'(\s+|^)-vn(\s+|$)'
if self.vidcodecQCB.currentIndex() == 1:
s = ' -vn '.format(text)
elif self.vidcodecQCB.currentIndex() == 0:
s = ' '
else:
s = ' -vcodec {0} '.format(text)
if re.search(regex, command):
command = re.sub(regex, s, command)
elif re.search(regex_vn, command):
command = re.sub(regex_vn, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_acodec(self):
command = self.commandQLE.text()
text = self.audcodecQCB.currentText()
regex = r'(\s+|^)-(acodec|c:a)\s+\S+(\s+|$)'
regex_an = r'(\s+|^)-an(\s+|$)'
if self.audcodecQCB.currentIndex() == 1:
s = ' -an '.format(text)
elif self.audcodecQCB.currentIndex() == 0:
s = ' '
else:
s = ' -acodec {0} '.format(text)
if re.search(regex, command):
command = re.sub(regex, s, command)
elif re.search(regex_an, command):
command = re.sub(regex_an, s, command)
else:
command += s
command = re.sub(' +', ' ', command).strip()
self.commandQLE.setText(command)
def command_update_subtitles(self):
command = self.commandQLE.text()
regex = r'(,*\s*){0,1}(subtitles=\'.*\')(\s*,*\s*){0,1}'
text = self.embedQLE.text()
_filter = "subtitles='{0}'".format(text) if text else ''
self.commandQLE.setText(utils.update_cmdline_text(
command, _filter, regex, bool(text), 0, 2))
def command_update_rotation(self):
command = self.commandQLE.text()
regex = r'(,*\s*){0,1}(transpose=\d(,\s*transpose=\d)*|vflip|hflip)(\s*,*\s*){0,1}'
rotate = self.rotateQCB.currentIndex()
if rotate == 0: # none
_filter = ''
elif rotate == 1: # 90 clockwise
_filter = 'transpose=1'
elif rotate == 2: # 90 clockwise + vertical flip
_filter = 'transpose=3'
elif rotate == 3: # 90 counter clockwise
_filter = 'transpose=2'
elif rotate == 4: # 90 counter clockwise + vertical flip
_filter = 'transpose=0'
elif rotate == 5: # 180
_filter = 'transpose=2,transpose=2'
elif rotate == 6: # horizontal flip
_filter = 'hflip'
elif rotate == 7: # vertical flip
_filter = 'vflip'
self.commandQLE.setText(utils.update_cmdline_text(
command, _filter, regex, bool(rotate != 0), 0, 3))
class UserInterface(QMainWindow):
def __init__(self, parent):
super().__init__(parent)
self._gameBoard = GameBoard()
self._parent = parent
self._gameover = False
self._isTowerSelected = False
self._isTowerHovered = False
self._towerBeingHovered = None
self._selectedTower = None
self._waveFinishTime = 0
self._gameSpeed = self._parent.speed
self._timePassed = 0
self.timer = QBasicTimer()
self._gameBoard.readMapData(os.path.join('./Maps/', self._parent.map))
self.timer.start(self._gameSpeed, self)
self.initUI()
def initUI(self):
centralWidget = QWidget()
self.setCentralWidget(centralWidget)
self.setWindowTitle(self._gameBoard.name)
self.setWindowIcon(QIcon(os.path.join('./Pictures/', 'berserker_icon.png'))) #Apparently this doens't work the same way on a mac.
self.statusBar().showMessage('Ready!')
vbox = QVBoxLayout()
centralWidget.setLayout(vbox)
self.gameStats = GameStats(self)
self.mapView = MapView(self)
self.bottomButtons = BottomButtons(self)
vbox.addWidget(self.gameStats)
vbox.addWidget(self.mapView)
vbox.addWidget(self.bottomButtons)
screen = QDesktopWidget().screenGeometry()
self.setGeometry((screen.width() - (self.gameboard.width - 1) * 20) / 2, (screen.height() - self.gameboard.height * 20 - 200) / 2, 500, 400)
self.show()
def getGameboard(self):
return self._gameBoard
def getIsTowerSelected(self):
return self._isTowerSelected
def setIsTowerSelected(self, boolean):
self._isTowerSelected = boolean
def getSelectedTower(self):
return self._selectedTower
def setSelectedTower(self, towerType):
self._selectedTower = towerType
def getIsTowerBeingHovered(self):
return self._isTowerHovered
def setIsTowerBeingHovered(self, boolean, tower):
self._isTowerHovered = boolean
self._towerBeingHovered = tower
def getTowerBeingHovered(self):
return self._towerBeingHovered
def getGameStats(self):
return self.gameStats
def getTimePassed(self):
return self._timePassed
def setWaveFinishTime(self, value):
self._waveFinishTime = value
def getGameOver(self):
return self._gameover
def timerEvent(self, event):
# The time passed attribute helps with setting the enemy appearance interval and tower firerate.
self._timePassed += 1
self.mapView.summonEnemy()
self.mapView.moveEnemies()
self.mapView.checkShooting()
self.mapView.moveProjectiles()
self.mapView.update()
def loseGame(self):
self.bottomButtons.clockTimer.stop()
self.timer.stop()
self.statusBar().showMessage('Game has ended. You lost.')
self._gameover = True
self.popUp = QFrame()
self.popUp.setGeometry(500, 500, 100, 100)
vbox = QVBoxLayout()
youLost = QLabel()
youLost.setPixmap(QPixmap(os.path.join('./Pictures/', "game_over.png")))
vbox.addWidget(youLost)
done = QPushButton("Done")
vbox.addWidget(done)
self.popUp.setLayout(vbox)
self.popUp.move(self.mapToGlobal(QPoint(0,0)).x() + self.gameboard.width*blockSize / 2 - 130, self.mapToGlobal(QPoint(0,0)).y() + self.gameboard.height*blockSize / 2)
self.popUp.show()
done.clicked.connect(self.backToMainMenu)
def winGame(self):
self.bottomButtons.clockTimer.stop()
self.timer.stop()
self.statusBar().showMessage('Game has ended. You won.')
self._gameover = True
self.popUp = QFrame()
self.popUp.setGeometry(500, 500, 100, 100)
vbox = QVBoxLayout()
youLost = QLabel()
youLost.setPixmap(QPixmap(os.path.join('./Pictures/', "victory.png")))
vbox.addWidget(youLost)
done = QPushButton("Done")
vbox.addWidget(done)
self.popUp.setLayout(vbox)
self.popUp.move(self.mapToGlobal(QPoint(0,0)).x() + self.gameboard.width*blockSize / 2 - 130, self.mapToGlobal(QPoint(0,0)).y() + self.gameboard.height*blockSize / 2)
self.popUp.show()
done.clicked.connect(self.backToMainMenu)
def backToMainMenu(self):
self._parent.show()
self.popUp.deleteLater()
self.deleteLater()
def getGameSpeed(self):
return self._gameSpeed
def setGameSpeed(self, value):
self._gameSpeed = value
def getWaveFinishTime(self):
return self._waveFinishTime
def getTimer(self):
return self.timer
isTowerSelected = property(getIsTowerSelected, setIsTowerSelected)
selectedTower = property(getSelectedTower, setSelectedTower)
isTowerHovered = property(getIsTowerBeingHovered)
towerBeingHovered = property(getTowerBeingHovered)
gamestats = property(getGameStats)
gameboard = property(getGameboard)
timePassed = property(getTimePassed)
gameover = property(getGameOver)
gameSpeed = property(getGameSpeed, setGameSpeed)
waveFinishTime = property(getWaveFinishTime, setWaveFinishTime)
class Tabs(QTabWidget):
filter_files = "Text files (*.txt);;All files (*.*)"
file_formats = [filter_files.split(';;')]
ff = file_formats[0][0]
ff = ff[ff.rindex('*') + 1:-1]
print('format are :', ff)
quantity = 15
tabs = [["File" + str(i), None] for i in range(0, quantity)]
def __init__(self, center_widget, *args, **kwargs):
super().__init__(*args, **kwargs)
#self.default_processor = default_processor
print('self.default_processor in tabs: ', self.default_processor)
self.colored_tabbar = coloredTabBar()
self.setTabBar(self.colored_tabbar)
self.setTabsClosable(True)
self.setMovable(True)
self.center_widget = center_widget
self.little_widget = QFrame()
little_layout = QHBoxLayout()
self.little_widget.setLayout(little_layout)
self.setCornerWidget(self.little_widget)
self.new_tab_button = My_Button("NEW")
little_layout.addWidget(self.new_tab_button)
self.new_tab_button.setStyleSheet("background-color: {}".format(color1))
self.new_tab_button.clicked.connect(self.new_tab)
self.save_tab_button = My_Button("SAVE")
little_layout.addWidget(self.save_tab_button )
self.save_tab_button.setStyleSheet("background-color: {}".format(color1))
self.cornerWidget().setMinimumSize(20, 40)
self.tabCloseRequested.connect(self.delete_tab)
#todo унаследовать нормально
stylesheet = """
QTabBar::tab:selected {background: rgb(145,191,204)}
QTabWidget>QWidget>QWidget{background: gray;}
"""
self.setStyleSheet(stylesheet)
@property
def default_processor(self):
from Settings.settings import default_processor
return default_processor
@property
def default_machine(self):
from Settings.settings import default_machine
return default_machine
def delete_tab(self, n):
name = self.widget(n).editor.existing
if not name:
name = self.tabText(n)
print('tab delete:', name)
if self.widget(n).editor.changed:
if 'Cancel' != simple_2_dialog(self.save_file, lambda: self.close_only(n), "Save changes in {}?".format(self.tabText(n))):
self.removeTab(n)
remove_new_name(name)
else:
print('tab delete CANCEL')
else:
print('111111111')
self.close_only(n)
print('222222222222')
self.removeTab(n)
if name:
remove_new_name(name)
print('333333333333333333')
def close_only(self, n):
#time.sleep(8)
if self.widget(n).editor.existing is False:
for i in range(1, self.quantity - 1):
if self.tabs[i][0] == self.tabText(n):
self.tabs[i][1] = None
break
def new_tab(self):
print('tab create')
i = 1
while (i < self.quantity-1) & (self.tabs[i][1] is not None):
i += 1
if self.tabs[i][1] is None:
self.tabs[i][1] = True
print('new tab0')
self.insertTab(self.currentIndex() + 1, redactor.ParentOfMyEdit(None, existing=False, tab_=self), self.tabs[i][0])
#gbplf
#print('self.currentWidget().main_g_cod_pool', self.currentWidget().main_g_cod_pool)
#self.currentWidget().editor.set_syntax()
self.setCurrentIndex(self.currentIndex()+1)
self.currentWidget().np_box.main_g_cod_pool = np.insert(self.currentWidget().np_box.main_g_cod_pool, 0,
self.currentWidget().np_box.main_g_cod_pool, axis=0)
self.center_widget.left.update_visible_np_left()
add_new_name(self.tabs[i][0])
self.currentWidget().np_box.add_line_in_new_tab()
print('new tab1')
else:
simple_warning('warning', "Притормози \n ¯\_(ツ)_/¯")
def close_all(self):
i = -1 #we don't want endless close cycle, aren't we?
while self.currentIndex() != -1 and self.currentIndex() != i:
i = self.currentIndex()
self.close_current()
def close_current(self):
self.tabCloseRequested.emit(self.currentIndex())
#self.delete_tab(self.currentIndex())
def open_file(self):
#options = QFileDialog.Options()
#options |= QFileDialog.DontUseNativeDialog
print('QFileDialog.DontUseNativeDialog')
path, _ = QFileDialog.getOpenFileName(None, "Open file", g_programs_folder, self.filter_files)
print(path)
if path:
self.make_open_DRY(path)
directory_to_remember = path[: path.rindex('/')]
names = [['g_programs_folder ', " '{}'".format(directory_to_remember)]]
change_setting.change_settins(names)
def save_file_as(self):
if self.currentIndex() == -1:
return
print('saving as')
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
name = g_programs_folder + '\\' + self.tabText(self.currentIndex())
if self.currentWidget().editor.existing is False:
name += str(self.ff)
path, _ = QFileDialog.getSaveFileName(None, "Save As", name,
self.filter_files, options=options)
if path in current_files:
simple_warning('Nope, not recommended!', 'File name already \ntaking part in session')
return
if path:
text = self.currentWidget().editor.toPlainText()
with open(path, 'w') as file:
file.write(text)
self.currentWidget().editor.changed = False
self.currentWidget().editor.existing = path
#self.currentWidget().editor.set_syntax()
try:
name_open_file = path[path.rindex('/') + 1:]
except ValueError:
name_open_file = path
self.setTabText(self.currentIndex(), name_open_file)
self.window().setWindowTitle(path)
add_new_name(name)
directory_to_remember = path[: path.rindex('/')]
names = [['g_programs_folder ', " '{}'".format(directory_to_remember)]]
change_setting.change_settins(names)
def save_file(self):
print(self.currentWidget().editor.existing)
if self.currentWidget().editor.existing is False:
print('is false')
self.save_file_as()
return
print('saving file')
path = self.currentWidget().editor.existing
if path:
text = self.currentWidget().editor.toPlainText()
with open(path, 'w') as file:
file.write(text)
self.currentWidget().editor.changed = False
print(path)
def make_open_DRY(self, path):
if path in current_files:
simple_warning('Nope, not recommended!', 'File name already taking part in session')
return
try:
text = open(path).read()
try:
name_open_file = path[path.rindex('/') + 1:]
except ValueError:
name_open_file = path
self.insertTab(self.currentIndex() + 1, redactor.ParentOfMyEdit(text, tab_=self, existing=path), name_open_file)
#self.currentWidget().editor.set_syntax()
self.setCurrentIndex(self.currentIndex()+1)
self.currentWidget().editor.existing = path
add_new_name(path)
except BaseException:
simple_warning('warning', "У файла формат не тот \n ¯\_(ツ)_/¯ ")
class Gui(QMainWindow):
def __init__(self):
super().__init__()
self.title = ' Allium Wallet'
self.left = 100
self.top = 100
self.width = 800
self.height = 400
self.initUI()
self.show()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setFixedSize(self.width, self.height)
#set up fonts to be used
self.bigFont = QFont("Arial", 16,QFont.Bold)
self.normalFont = QFont("Arial", 12)
# Sets the background image of the page to qbetdark.png
self.setBackgroundImage()
# Initializes the file bar
self.initFileBar()
# Initializes the mine button
self.initMineButton()
# Initializes the transaction button
self.initTxButton()
# Initializes the wallet label
self.initWalletFrame()
# Initializes the IP label
self.initIPFrame()
# Initializes the transaction dialog
self.initTxDialog()
#set up a GridLayout
gridLayout = QGridLayout()
#gridlayout.addWidget(widget, startRow, endRow, startCol, endCol)
# Places the Mine Button in the top left corner of the screen
gridLayout.addWidget(self.mineButton, 0, 0)
# Places the Transaction Button in the top left corner of the screen
gridLayout.addWidget(self.txButton, 0, 2)
# Places Wallet label between mine and transaction button
gridLayout.addWidget(self.walletFrame, 0, 1)
# Places the IP label below the mine label
gridLayout.addWidget(self.IPFrame, 1, 0)
#create a QWidget and set it as a central widget
#we need the QWidget because you cannot set a QLayout directly on QMainWindow
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
centralWidget.setLayout(gridLayout)
def setBackgroundImage(self):
# Creates a QImage Object with the image file
oImage = QImage(sys.path[0] + "/qbertdark.png")
# Scales the image to the size of the window
sImage = oImage.scaled(QtCore.QSize(self.width, self.height))
# Creates a palette, sets the brush to a brush with the scaled image
palette = QPalette()
palette.setBrush(10, QBrush(sImage))
# Sets window palette to this palette
self.setPalette(palette)
def initFileBar(self):
# Creates a menubar
self.mainMenu = self.menuBar()
# Sets the background of filebar to grey and text to white
self.mainMenu.setStyleSheet("""
QWidget{
background-color: rgb(20, 20, 20);
color: rgb(200, 200, 200)
}""")
# FILE TAB ========================================================
self.fileMenu = self.mainMenu.addMenu('File')
# VIEW TAB ========================================================
self.viewMenu = self.mainMenu.addMenu('View')
# TOOLS TAB =======================================================
self.toolsMenu = self.mainMenu.addMenu('Settings')
def initMineButton(self):
# Creates a mine button, sets its text, font and style
self.mineButton = QPushButton("Mine", self)
self.mineButton.setFont(self.bigFont)
self.mineButton.setStyleSheet("""
QWidget{
background-color: rgb(20, 20, 20);
color: rgb(200, 200, 200)
}""")
#self.mineButton.clicked.connect("""MINE FUNCTION""")
# Sets fixed size for mine button
self.mineButton.setFixedWidth(200)
self.mineButton.setFixedHeight(50)
def initTxButton(self):
# Creates a transaction button, sets its text, font and style
self.txButton = QPushButton("Transaction", self)
self.txButton.setFont(self.bigFont)
self.txButton.setStyleSheet("""
QWidget{
background-color: rgb(20, 20, 20);
color: rgb(200, 200, 200)
}""")
self.txButton.clicked.connect(self.showTxDialog)
# Sets fixed size for transaction button
self.txButton.setFixedWidth(200)
self.txButton.setFixedHeight(50)
def initWalletFrame(self):
self.walletContent = QLabel('₩ 0.00', self)
self.walletContent.setAlignment(QtCore.Qt.AlignCenter)
self.walletContent.setFont(self.bigFont)
walletLayout = QHBoxLayout()
walletLayout.addWidget(self.walletContent)
self.walletFrame = QFrame(self)
#Set up the style of the main Label
self.walletFrame.setStyleSheet("""
QFrame {
background-color: rgb(20, 20, 20);
color: rgb(200, 200, 200);
border-radius: 12px;
padding: 6px
}""")
self.walletFrame.setLayout(walletLayout)
def initIPFrame(self):
self.IPAddress = QLabel("Offline", self)
self.IPAddress.setAlignment(QtCore.Qt.AlignCenter)
self.IPAddress.setFont(self.bigFont)
IPLayout = QHBoxLayout()
IPLayout.addWidget(self.IPAddress)
self.IPFrame = QFrame(self)
#Set up the style of the main Label
self.IPFrame.setStyleSheet("""
QFrame {
background-color: rgb(20, 20, 20);
color: rgb(200, 200, 200);
border-radius: 12px;
padding: 6px
}""")
self.IPFrame.setLayout(IPLayout)
self.IPFrame.setFixedWidth(200)
self.IPFrame.setFixedHeight(60)
def initTxDialog(self):
self.txDialog = QDialog()
self.txDialog.setWindowTitle("Transaction")
self.txDialog.setFixedSize(600, 250)
# Creates a QImage Object with the image file
oImage = QImage(sys.path[0] + "/qbertdark.png")
# Creates a palette, sets the brush to a brush with the original image
palette = QPalette()
palette.setBrush(10, QBrush(oImage))
# Sets window palette to this palette
self.txDialog.setPalette(palette)
# def resetTxDialog(self):
# This should reset all text boxes, buttons, and labels in this window
def showTxDialog(self):
self.txDialog.exec()
class MainWindow_Ui(QMainWindow):
def __init__(self, persepolis_setting):
super().__init__()
# MainWindow
self.persepolis_setting = persepolis_setting
# add support for other languages
locale = str(self.persepolis_setting.value('settings/locale'))
QLocale.setDefault(QLocale(locale))
self.translator = QTranslator()
if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
QCoreApplication.installTranslator(self.translator)
# set ui direction
ui_direction = self.persepolis_setting.value('ui_direction')
if ui_direction == 'rtl':
self.setLayoutDirection(Qt.RightToLeft)
elif ui_direction in 'ltr':
self.setLayoutDirection(Qt.LeftToRight)
icons = ':/' + \
str(self.persepolis_setting.value('settings/icons')) + '/'
self.setWindowTitle(
QCoreApplication.translate("mainwindow_ui_tr",
"Persepolis Download Manager"))
self.setWindowIcon(
QIcon.fromTheme('persepolis', QIcon(':/persepolis.svg')))
self.centralwidget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.centralwidget)
# enable drag and drop
self.setAcceptDrops(True)
# frame
self.frame = QFrame(self.centralwidget)
# download_table_horizontalLayout
download_table_horizontalLayout = QHBoxLayout()
tabels_splitter = QSplitter(Qt.Horizontal)
# category_tree
self.category_tree_qwidget = QWidget(self)
category_tree_verticalLayout = QVBoxLayout()
self.category_tree = CategoryTreeView(self)
category_tree_verticalLayout.addWidget(self.category_tree)
self.category_tree_model = QStandardItemModel()
self.category_tree.setModel(self.category_tree_model)
category_table_header = [
QCoreApplication.translate("mainwindow_ui_tr", 'Category')
]
self.category_tree_model.setHorizontalHeaderLabels(
category_table_header)
self.category_tree.header().setStretchLastSection(True)
self.category_tree.header().setDefaultAlignment(Qt.AlignCenter)
# queue_panel
self.queue_panel_widget = QWidget(self)
queue_panel_verticalLayout_main = QVBoxLayout(self.queue_panel_widget)
# queue_panel_show_button
self.queue_panel_show_button = QPushButton(self)
queue_panel_verticalLayout_main.addWidget(self.queue_panel_show_button)
# queue_panel_widget_frame
self.queue_panel_widget_frame = QFrame(self)
self.queue_panel_widget_frame.setFrameShape(QFrame.StyledPanel)
self.queue_panel_widget_frame.setFrameShadow(QFrame.Raised)
queue_panel_verticalLayout_main.addWidget(
self.queue_panel_widget_frame)
queue_panel_verticalLayout = QVBoxLayout(self.queue_panel_widget_frame)
queue_panel_verticalLayout_main.setContentsMargins(50, -1, 50, -1)
# start_end_frame
self.start_end_frame = QFrame(self)
# start time
start_verticalLayout = QVBoxLayout(self.start_end_frame)
self.start_checkBox = QCheckBox(self)
start_verticalLayout.addWidget(self.start_checkBox)
self.start_frame = QFrame(self)
self.start_frame.setFrameShape(QFrame.StyledPanel)
self.start_frame.setFrameShadow(QFrame.Raised)
start_frame_verticalLayout = QVBoxLayout(self.start_frame)
self.start_time_qDataTimeEdit = QDateTimeEdit(self.start_frame)
self.start_time_qDataTimeEdit.setDisplayFormat('H:mm')
start_frame_verticalLayout.addWidget(self.start_time_qDataTimeEdit)
start_verticalLayout.addWidget(self.start_frame)
# end time
self.end_checkBox = QCheckBox(self)
start_verticalLayout.addWidget(self.end_checkBox)
self.end_frame = QFrame(self)
self.end_frame.setFrameShape(QFrame.StyledPanel)
self.end_frame.setFrameShadow(QFrame.Raised)
end_frame_verticalLayout = QVBoxLayout(self.end_frame)
self.end_time_qDateTimeEdit = QDateTimeEdit(self.end_frame)
self.end_time_qDateTimeEdit.setDisplayFormat('H:mm')
end_frame_verticalLayout.addWidget(self.end_time_qDateTimeEdit)
start_verticalLayout.addWidget(self.end_frame)
self.reverse_checkBox = QCheckBox(self)
start_verticalLayout.addWidget(self.reverse_checkBox)
queue_panel_verticalLayout.addWidget(self.start_end_frame)
# limit_after_frame
self.limit_after_frame = QFrame(self)
# limit_checkBox
limit_verticalLayout = QVBoxLayout(self.limit_after_frame)
self.limit_checkBox = QCheckBox(self)
limit_verticalLayout.addWidget(self.limit_checkBox)
# limit_frame
self.limit_frame = QFrame(self)
self.limit_frame.setFrameShape(QFrame.StyledPanel)
self.limit_frame.setFrameShadow(QFrame.Raised)
limit_verticalLayout.addWidget(self.limit_frame)
limit_frame_verticalLayout = QVBoxLayout(self.limit_frame)
# limit_spinBox
limit_frame_horizontalLayout = QHBoxLayout()
self.limit_spinBox = QDoubleSpinBox(self)
self.limit_spinBox.setMinimum(1)
self.limit_spinBox.setMaximum(1023)
limit_frame_horizontalLayout.addWidget(self.limit_spinBox)
# limit_comboBox
self.limit_comboBox = QComboBox(self)
self.limit_comboBox.addItem("")
self.limit_comboBox.addItem("")
limit_frame_horizontalLayout.addWidget(self.limit_comboBox)
limit_frame_verticalLayout.addLayout(limit_frame_horizontalLayout)
# limit_pushButton
self.limit_pushButton = QPushButton(self)
limit_frame_verticalLayout.addWidget(self.limit_pushButton)
# after_checkBox
self.after_checkBox = QtWidgets.QCheckBox(self)
limit_verticalLayout.addWidget(self.after_checkBox)
# after_frame
self.after_frame = QtWidgets.QFrame(self)
self.after_frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.after_frame.setFrameShadow(QtWidgets.QFrame.Raised)
limit_verticalLayout.addWidget(self.after_frame)
after_frame_verticalLayout = QVBoxLayout(self.after_frame)
# after_comboBox
self.after_comboBox = QComboBox(self)
self.after_comboBox.addItem("")
after_frame_verticalLayout.addWidget(self.after_comboBox)
# after_pushButton
self.after_pushButton = QPushButton(self)
after_frame_verticalLayout.addWidget(self.after_pushButton)
queue_panel_verticalLayout.addWidget(self.limit_after_frame)
category_tree_verticalLayout.addWidget(self.queue_panel_widget)
# keep_awake_checkBox
self.keep_awake_checkBox = QCheckBox(self)
queue_panel_verticalLayout.addWidget(self.keep_awake_checkBox)
self.category_tree_qwidget.setLayout(category_tree_verticalLayout)
tabels_splitter.addWidget(self.category_tree_qwidget)
# download table widget
self.download_table_content_widget = QWidget(self)
download_table_content_widget_verticalLayout = QVBoxLayout(
self.download_table_content_widget)
self.download_table = DownloadTableWidget(self)
download_table_content_widget_verticalLayout.addWidget(
self.download_table)
tabels_splitter.addWidget(self.download_table_content_widget)
self.download_table.setColumnCount(13)
self.download_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.download_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.download_table.verticalHeader().hide()
# hide gid and download dictioanry section
self.download_table.setColumnHidden(8, True)
self.download_table.setColumnHidden(9, True)
download_table_header = [
QCoreApplication.translate("mainwindow_ui_tr", 'File Name'),
QCoreApplication.translate("mainwindow_ui_tr", 'Status'),
QCoreApplication.translate("mainwindow_ui_tr", 'Size'),
QCoreApplication.translate("mainwindow_ui_tr", 'Downloaded'),
QCoreApplication.translate("mainwindow_ui_tr", 'Percentage'),
QCoreApplication.translate("mainwindow_ui_tr", 'Connections'),
QCoreApplication.translate("mainwindow_ui_tr", 'Transfer rate'),
QCoreApplication.translate("mainwindow_ui_tr",
'Estimated time left'), 'Gid',
QCoreApplication.translate("mainwindow_ui_tr", 'Link'),
QCoreApplication.translate("mainwindow_ui_tr", 'First try date'),
QCoreApplication.translate("mainwindow_ui_tr", 'Last try date'),
QCoreApplication.translate("mainwindow_ui_tr", 'Category')
]
self.download_table.setHorizontalHeaderLabels(download_table_header)
# fixing the size of download_table when window is Maximized!
self.download_table.horizontalHeader().setSectionResizeMode(0)
self.download_table.horizontalHeader().setStretchLastSection(True)
tabels_splitter.setStretchFactor(0, 3) # category_tree width
tabels_splitter.setStretchFactor(1, 10) # ratio of tables's width
download_table_horizontalLayout.addWidget(tabels_splitter)
self.frame.setLayout(download_table_horizontalLayout)
self.verticalLayout.addWidget(self.frame)
self.setCentralWidget(self.centralwidget)
# menubar
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 600, 24))
self.setMenuBar(self.menubar)
fileMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&File'))
editMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&Edit'))
viewMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&View'))
downloadMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&Download'))
queueMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&Queue'))
videoFinderMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", 'V&ideo Finder'))
helpMenu = self.menubar.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", '&Help'))
# viewMenu submenus
sortMenu = viewMenu.addMenu(
QCoreApplication.translate("mainwindow_ui_tr", 'Sort by'))
# statusbar
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
self.statusbar.showMessage(
QCoreApplication.translate("mainwindow_ui_tr",
"Persepolis Download Manager"))
# toolBar
self.toolBar2 = QToolBar(self)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar2)
self.toolBar2.setWindowTitle(
QCoreApplication.translate("mainwindow_ui_tr", 'Menu'))
self.toolBar2.setFloatable(False)
self.toolBar2.setMovable(False)
self.toolBar = QToolBar(self)
self.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar)
self.toolBar.setWindowTitle(
QCoreApplication.translate("mainwindow_ui_tr", 'Toolbar'))
self.toolBar.setFloatable(False)
self.toolBar.setMovable(False)
#toolBar and menubar and actions
self.persepolis_setting.beginGroup('settings/shortcuts')
# videoFinderAddLinkAction
self.videoFinderAddLinkAction = QAction(
QIcon(icons + 'video_finder'),
QCoreApplication.translate("mainwindow_ui_tr", 'Find Video Links'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'Download video or audio from Youtube, Vimeo, etc...'),
triggered=self.showVideoFinderAddLinkWindow)
self.videoFinderAddLinkAction_shortcut = QShortcut(
self.persepolis_setting.value('video_finder_shortcut'), self,
self.showVideoFinderAddLinkWindow)
videoFinderMenu.addAction(self.videoFinderAddLinkAction)
# stopAllAction
self.stopAllAction = QAction(QIcon(icons + 'stop_all'),
QCoreApplication.translate(
"mainwindow_ui_tr",
'Stop all active downloads'),
self,
statusTip='Stop all active downloads',
triggered=self.stopAllDownloads)
downloadMenu.addAction(self.stopAllAction)
# sort_file_name_Action
self.sort_file_name_Action = QAction(QCoreApplication.translate(
"mainwindow_ui_tr", 'File name'),
self,
triggered=self.sortByName)
sortMenu.addAction(self.sort_file_name_Action)
# sort_file_size_Action
self.sort_file_size_Action = QAction(QCoreApplication.translate(
"mainwindow_ui_tr", 'File size'),
self,
triggered=self.sortBySize)
sortMenu.addAction(self.sort_file_size_Action)
# sort_first_try_date_Action
self.sort_first_try_date_Action = QAction(
QCoreApplication.translate("mainwindow_ui_tr", 'First try date'),
self,
triggered=self.sortByFirstTry)
sortMenu.addAction(self.sort_first_try_date_Action)
# sort_last_try_date_Action
self.sort_last_try_date_Action = QAction(QCoreApplication.translate(
"mainwindow_ui_tr", 'Last try date'),
self,
triggered=self.sortByLastTry)
sortMenu.addAction(self.sort_last_try_date_Action)
# sort_download_status_Action
self.sort_download_status_Action = QAction(QCoreApplication.translate(
"mainwindow_ui_tr", 'Download status'),
self,
triggered=self.sortByStatus)
sortMenu.addAction(self.sort_download_status_Action)
# trayAction
self.trayAction = QAction(
QCoreApplication.translate("mainwindow_ui_tr",
'Show system tray icon'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Show/Hide system tray icon"),
triggered=self.showTray)
self.trayAction.setCheckable(True)
viewMenu.addAction(self.trayAction)
# showMenuBarAction
self.showMenuBarAction = QAction(
QCoreApplication.translate("mainwindow_ui_tr", 'Show menubar'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Show menubar'),
triggered=self.showMenuBar)
self.showMenuBarAction.setCheckable(True)
viewMenu.addAction(self.showMenuBarAction)
# showSidePanelAction
self.showSidePanelAction = QAction(
QCoreApplication.translate("mainwindow_ui_tr", 'Show side panel'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Show side panel'),
triggered=self.showSidePanel)
self.showSidePanelAction.setCheckable(True)
viewMenu.addAction(self.showSidePanelAction)
# minimizeAction
self.minimizeAction = QAction(
QIcon(icons + 'minimize'),
QCoreApplication.translate("mainwindow_ui_tr",
'Minimize to system tray'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Minimize to system tray"),
triggered=self.minMaxTray)
self.minimizeAction_shortcut = QShortcut(
self.persepolis_setting.value('hide_window_shortcut'), self,
self.minMaxTray)
viewMenu.addAction(self.minimizeAction)
# addlinkAction
self.addlinkAction = QAction(
QIcon(icons + 'add'),
QCoreApplication.translate("mainwindow_ui_tr",
'Add New Download Link'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Add New Download Link"),
triggered=self.addLinkButtonPressed)
self.addlinkAction_shortcut = QShortcut(
self.persepolis_setting.value('add_new_download_shortcut'), self,
self.addLinkButtonPressed)
fileMenu.addAction(self.addlinkAction)
# importText
self.addtextfileAction = QAction(
QIcon(icons + 'file'),
QCoreApplication.translate("mainwindow_ui_tr",
'Import links from text file'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'Create a Text file and put links in it.line by line!'),
triggered=self.importText)
self.addtextfileAction_shortcut = QShortcut(
self.persepolis_setting.value('import_text_shortcut'), self,
self.importText)
fileMenu.addAction(self.addtextfileAction)
# resumeAction
self.resumeAction = QAction(
QIcon(icons + 'play'),
QCoreApplication.translate("mainwindow_ui_tr", 'Resume Download'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Resume Download"),
triggered=self.resumeButtonPressed)
downloadMenu.addAction(self.resumeAction)
# pauseAction
self.pauseAction = QAction(
QIcon(icons + 'pause'),
QCoreApplication.translate("mainwindow_ui_tr", 'Pause Download'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Pause Download"),
triggered=self.pauseButtonPressed)
downloadMenu.addAction(self.pauseAction)
# stopAction
self.stopAction = QAction(
QIcon(icons + 'stop'),
QCoreApplication.translate("mainwindow_ui_tr", 'Stop Download'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Stop/Cancel Download"),
triggered=self.stopButtonPressed)
downloadMenu.addAction(self.stopAction)
# propertiesAction
self.propertiesAction = QAction(
QIcon(icons + 'setting'),
QCoreApplication.translate("mainwindow_ui_tr", 'Properties'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Properties"),
triggered=self.propertiesButtonPressed)
downloadMenu.addAction(self.propertiesAction)
# progressAction
self.progressAction = QAction(
QIcon(icons + 'window'),
QCoreApplication.translate("mainwindow_ui_tr", 'Progress'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
"Progress"),
triggered=self.progressButtonPressed)
downloadMenu.addAction(self.progressAction)
# openFileAction
self.openFileAction = QAction(
QIcon(icons + 'file'),
QCoreApplication.translate("mainwindow_ui_tr", 'Open file'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Open file'),
triggered=self.openFile)
fileMenu.addAction(self.openFileAction)
# openDownloadFolderAction
self.openDownloadFolderAction = QAction(
QIcon(icons + 'folder'),
QCoreApplication.translate("mainwindow_ui_tr",
'Open download folder'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Open download folder'),
triggered=self.openDownloadFolder)
fileMenu.addAction(self.openDownloadFolderAction)
# openDefaultDownloadFolderAction
self.openDefaultDownloadFolderAction = QAction(
QIcon(icons + 'folder'),
QCoreApplication.translate("mainwindow_ui_tr",
'Open default download folder'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr", 'Open default download folder'),
triggered=self.openDefaultDownloadFolder)
fileMenu.addAction(self.openDefaultDownloadFolderAction)
# exitAction
self.exitAction = QAction(
QIcon(icons + 'exit'),
QCoreApplication.translate("mainwindow_ui_tr", 'Exit'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr", "Exit"),
triggered=self.closeAction)
self.exitAction_shortcut = QShortcut(
self.persepolis_setting.value('quit_shortcut'), self,
self.closeAction)
fileMenu.addAction(self.exitAction)
# clearAction
self.clearAction = QAction(QIcon(icons + 'multi_remove'),
QCoreApplication.translate(
"mainwindow_ui_tr",
'Clear download list'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'Clear all items in download list'),
triggered=self.clearDownloadList)
editMenu.addAction(self.clearAction)
# removeSelectedAction
self.removeSelectedAction = QAction(
QIcon(icons + 'remove'),
QCoreApplication.translate("mainwindow_ui_tr",
'Remove selected downloads from list'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr", 'Remove selected downloads form list'),
triggered=self.removeSelected)
self.removeSelectedAction_shortcut = QShortcut(
self.persepolis_setting.value('remove_shortcut'), self,
self.removeSelected)
editMenu.addAction(self.removeSelectedAction)
self.removeSelectedAction.setEnabled(False)
# deleteSelectedAction
self.deleteSelectedAction = QAction(
QIcon(icons + 'trash'),
QCoreApplication.translate("mainwindow_ui_tr",
'Delete selected download files'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr", 'Delete selected download files'),
triggered=self.deleteSelected)
self.deleteSelectedAction_shortcut = QShortcut(
self.persepolis_setting.value('delete_shortcut'), self,
self.deleteSelected)
editMenu.addAction(self.deleteSelectedAction)
self.deleteSelectedAction.setEnabled(False)
# moveSelectedDownloadsAction
self.moveSelectedDownloadsAction = QAction(
QIcon(icons + 'folder'),
QCoreApplication.translate(
"mainwindow_ui_tr",
'move selected download files to another destination'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'move selected download files to another destination'),
triggered=self.moveSelectedDownloads)
editMenu.addAction(self.moveSelectedDownloadsAction)
self.moveSelectedDownloadsAction.setEnabled(False)
# createQueueAction
self.createQueueAction = QAction(
QIcon(icons + 'add_queue'),
QCoreApplication.translate("mainwindow_ui_tr", 'Create new queue'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Create new download queue'),
triggered=self.createQueue)
queueMenu.addAction(self.createQueueAction)
# removeQueueAction
self.removeQueueAction = QAction(
QIcon(icons + 'remove_queue'),
QCoreApplication.translate("mainwindow_ui_tr",
'Remove this queue'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Remove this queue'),
triggered=self.removeQueue)
queueMenu.addAction(self.removeQueueAction)
# startQueueAction
self.startQueueAction = QAction(
QIcon(icons + 'start_queue'),
QCoreApplication.translate("mainwindow_ui_tr", 'Start this queue'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Start this queue'),
triggered=self.startQueue)
queueMenu.addAction(self.startQueueAction)
# stopQueueAction
self.stopQueueAction = QAction(
QIcon(icons + 'stop_queue'),
QCoreApplication.translate("mainwindow_ui_tr", 'Stop this queue'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Stop this queue'),
triggered=self.stopQueue)
queueMenu.addAction(self.stopQueueAction)
# moveUpSelectedAction
self.moveUpSelectedAction = QAction(
QIcon(icons + 'multi_up'),
QCoreApplication.translate("mainwindow_ui_tr",
'Move up selected items'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'Move currently selected items up by one row'),
triggered=self.moveUpSelected)
self.moveUpSelectedAction_shortcut = QShortcut(
self.persepolis_setting.value('move_up_selection_shortcut'), self,
self.moveUpSelected)
queueMenu.addAction(self.moveUpSelectedAction)
# moveDownSelectedAction
self.moveDownSelectedAction = QAction(
QIcon(icons + 'multi_down'),
QCoreApplication.translate("mainwindow_ui_tr",
'Move down selected items'),
self,
statusTip=QCoreApplication.translate(
"mainwindow_ui_tr",
'Move currently selected items down by one row'),
triggered=self.moveDownSelected)
self.moveDownSelectedAction_shortcut = QShortcut(
self.persepolis_setting.value('move_down_selection_shortcut'),
self, self.moveDownSelected)
queueMenu.addAction(self.moveDownSelectedAction)
# preferencesAction
self.preferencesAction = QAction(
QIcon(icons + 'preferences'),
QCoreApplication.translate("mainwindow_ui_tr", 'Preferences'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Preferences'),
triggered=self.openPreferences,
menuRole=5)
editMenu.addAction(self.preferencesAction)
# aboutAction
self.aboutAction = QAction(
QIcon(icons + 'about'),
QCoreApplication.translate("mainwindow_ui_tr", 'About'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr", 'About'),
triggered=self.openAbout,
menuRole=4)
helpMenu.addAction(self.aboutAction)
# issueAction
self.issueAction = QAction(
QIcon(icons + 'about'),
QCoreApplication.translate("mainwindow_ui_tr", 'Report an issue'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Report an issue'),
triggered=self.reportIssue)
helpMenu.addAction(self.issueAction)
# updateAction
self.updateAction = QAction(
QIcon(icons + 'about'),
QCoreApplication.translate("mainwindow_ui_tr",
'Check for newer version'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr",
'Check for newer release'),
triggered=self.newUpdate)
helpMenu.addAction(self.updateAction)
# logAction
self.logAction = QAction(
QIcon(icons + 'about'),
QCoreApplication.translate("mainwindow_ui_tr", 'Show log file'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr", 'Help'),
triggered=self.showLog)
helpMenu.addAction(self.logAction)
# helpAction
self.helpAction = QAction(
QIcon(icons + 'about'),
QCoreApplication.translate("mainwindow_ui_tr", 'Help'),
self,
statusTip=QCoreApplication.translate("mainwindow_ui_tr", 'Help'),
triggered=self.persepolisHelp)
helpMenu.addAction(self.helpAction)
self.persepolis_setting.endGroup()
self.qmenu = MenuWidget(self)
self.toolBar2.addWidget(self.qmenu)
# labels
self.queue_panel_show_button.setText(
QCoreApplication.translate("mainwindow_ui_tr", "Hide options"))
self.start_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr", "Start Time"))
self.end_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr", "End Time"))
self.reverse_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr",
"Download bottom of\n the list first"))
self.limit_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr", "Limit Speed"))
self.limit_comboBox.setItemText(0, "KiB/s")
self.limit_comboBox.setItemText(1, "MiB/s")
self.limit_pushButton.setText(
QCoreApplication.translate("mainwindow_ui_tr", "Apply"))
self.after_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr", "After download"))
self.after_comboBox.setItemText(
0, QCoreApplication.translate("mainwindow_ui_tr", "Shut Down"))
self.keep_awake_checkBox.setText(
QCoreApplication.translate("mainwindow_ui_tr",
"Keep system awake!"))
self.keep_awake_checkBox.setToolTip(
QCoreApplication.translate(
"mainwindow_ui_tr",
"<html><head/><body><p>This option is preventing system from going to sleep.\
This is necessary if your power manager is suspending system automatically. </p></body></html>"
))
self.after_pushButton.setText(
QCoreApplication.translate("mainwindow_ui_tr", "Apply"))
def changeIcon(self, icons):
icons = ':/' + str(icons) + '/'
action_icon_dict = {
self.stopAllAction: 'stop_all',
self.minimizeAction: 'minimize',
self.addlinkAction: 'add',
self.addtextfileAction: 'file',
self.resumeAction: 'play',
self.pauseAction: 'pause',
self.stopAction: 'stop',
self.propertiesAction: 'setting',
self.progressAction: 'window',
self.openFileAction: 'file',
self.openDownloadFolderAction: 'folder',
self.openDefaultDownloadFolderAction: 'folder',
self.exitAction: 'exit',
self.removeSelectedAction: 'multi_remove',
self.deleteSelectedAction: 'multi_trash',
self.createQueueAction: 'add_queue',
self.removeQueueAction: 'remove_queue',
self.startQueueAction: 'start_queue',
self.stopQueueAction: 'stop_queue',
self.preferencesAction: 'preferences',
self.aboutAction: 'about',
self.issueAction: 'about',
self.updateAction: 'about',
self.videoFinderAddLinkAction: 'video_finder',
self.qmenu: 'menu'
}
for key in action_icon_dict.keys():
key.setIcon(QIcon(icons + str(action_icon_dict[key])))
class ZhuangGeiFX(QDialog):
def __init__(self,data,chess,job,race,equip):
super().__init__()
self.data=data
self.chess=chess
self.job = job
self.race = race
self.equip = equip
self.initshow()
def initshow(self):
self.setMinimumWidth(504)
self.setObjectName('ZhuangbeiFX')
self.spTitle=QLabel('装备分析')
self.spTitle.setObjectName('Title')
self.spDoc = QLabel(self.data['equipment_info'].replace('&nbsp;',''))
self.spDoc.setObjectName('Doc')
self.spDoc.setWordWrap(True)
self.vbox=QVBoxLayout()
self.vbox.addWidget(self.spTitle)
self.vbox.addWidget(self.spDoc)
#装备推荐框架
self.zbTJFrame=QFrame()
self.zbTJVbox=QVBoxLayout()
#遍历站位数据,看有没有装备,有装备的就加入zbTJHbox
self.zbtj_YLH=[]
self.xjzb_Vbox=[]
#初始化羁绊和职业容器
job_list=[]
race_list=[]
txData =None
for item in self.data['hero_location']:
# 将羁绊和职业数据存进容器
try:
chessData = chessId_get_data(self.chess, item['hero_id'])
if chessData==None:
continue
except:
continue
try:
for job_item in chessData['jobIds'].split(','):
job_list.append(job_item)
except:
pass
try:
for race_item in chessData['raceIds'].split(','):
race_list.append(race_item)
except:
pass
zwpath = Path_chess + chessData['name']
if item['equipment_id']!='':
#英雄头像
self.zbtj_YLH.append(QHBoxLayout())
self.zbTJVbox.addLayout(self.zbtj_YLH[-1])
if chessData["price"] == '1':
color = '#989898'
elif chessData["price"] == '2':
color = '#58B137'
elif chessData["price"] == '3':
color = '#3678C8'
elif chessData["price"] == '4':
color = '#C81FC8'
else:
color = '#FDBC03'
tp_yx = QLabel()
# 让图像适应标签
tp_yx.setScaledContents(True)
tp_yx.setPixmap(QPixmap(zwpath))
tp_yx.setMaximumSize(50, 50)
tp_yx.setMinimumSize(50, 50)
tp_yx.setObjectName('tp_yx')
tp_yx.setStyleSheet('''#tp_yx{border: 1px solid %s;border-radius: 10px; }
''' % color)
tp_yx.setToolTip(tanChudataForm(chessData, self.job, self.race))
self.zbtj_YLH[-1].addWidget(tp_yx)
jtbt=QLabel('>')
jtbt.setObjectName('Title')
self.zbtj_YLH[-1].addWidget(jtbt)
for equi in item['equipment_id'].split(','):
djzb=equipId_get_data(self.equip,equi)
# 将羁绊和职业数据存进容器
try:
if djzb['jobId']!='0' and djzb['jobId']!=None:
job_list.append(djzb['jobId'])
except:
pass
try:
if djzb['raceId'] != '0' and djzb['raceId']!=None:
race_list.append(djzb['raceId'])
except:
pass
zbpath = Path_equip+djzb['imagePath'].split('/')[-1]
#print('大装备', zbpath)
tp_djzb=QLabel()
# 让图像适应标签
tp_djzb.setScaledContents(True)
tp_djzb.setPixmap(QPixmap(zbpath))
tp_djzb.setMaximumSize(40, 40)
tp_djzb.setMinimumSize(40, 40)
self.zbtj_YLH[-1].addWidget(tp_djzb)
#取小装备的id
self.xjzb_Vbox.append(QVBoxLayout())
self.xjzb_Vbox[-1].addStretch()
self.zbtj_YLH[-1].addLayout(self.xjzb_Vbox[-1])
for itemXJ in djzb['formula'].split(','):
xjzb = equipId_get_data(self.equip, itemXJ)
xjzbpath = Path_equip+xjzb['imagePath'].split('/')[-1]
#print('小装备', zbpath)
tp_xjzb = QLabel()
# 让图像适应标签
tp_xjzb.setScaledContents(True)
tp_xjzb.setPixmap(QPixmap(xjzbpath))
tp_xjzb.setMaximumSize(20, 20)
tp_xjzb.setMinimumSize(20, 20)
self.xjzb_Vbox[-1].addWidget(tp_xjzb)
#一个弹簧..用来控制位置的
self.xjzb_Vbox[-1].addStretch()
self.zbtj_YLH[-1].addStretch()
# 天选羁绊和职业存入
if 'isChosenHero' in item:
if item['isChosenHero'] != None:
txData = item['isChosenHero']
# 天选羁绊id
sss = ''
for key in txData.keys():
sss = key
if sss == 'race':
race_list.append(txData['race'])
else:
job_list.append(txData['job'])
else:
pass
#职业分析组件---------------------------------------------
self.from_job =QFrame()
self.from_jobHBox=QHBoxLayout()
#统计总职业数,并且将底图和图标获取
jb_ss={}.fromkeys(job_list ).keys()
for ss in jb_ss:
num=job_list.count(ss)
if txData != None:
if sss == 'job' and txData['job']==ss :
test_job=job_get_background_sf(self.job,ss,num,True)
else:
test_job=job_get_background_sf(self.job, ss, num, False)
else:
test_job=job_get_background_sf(self.job, ss, num, False)
if test_job != None:
#将每一个小组件渲染
tp_hbox=QHBoxLayout()
#羁绊背景
tp_jb_bj=QLabel()
tp_jb_bj.setScaledContents(True)
tp_jb_bj.setPixmap(QPixmap(test_job[0]))
tp_jb_bj.setMaximumSize(30, 34)
tp_jb_bj.setMinimumSize(30, 34)
tp_jb_bj.setToolTip(
f'''<b style='color:#FFFFFF;'>{test_job[2]['introduce']}<br>{str(test_job[2]['level']).replace('{', '').replace('}', '').replace(',', '<br>')}</b>''')
#tp_jb_bj上方显示图标
tp_jb = QLabel(tp_jb_bj)
tp_jb.move(5,7)
tp_jb.setScaledContents(True)
tp_jb.setPixmap(QPixmap(test_job[1]))
tp_jb.setMaximumSize(20, 20)
tp_jb.setMinimumSize(20, 20)
#羁绊名 文字
tp_text=QLabel(tp_jb_bj)
tp_text.setObjectName('JB')
tp_text.setText(f"{num} "+test_job[2]['name'])
#将数据加入到每一列的布局中
tp_hbox.addWidget(tp_jb_bj)
tp_hbox.addWidget(tp_text)
self.from_jobHBox.addLayout(tp_hbox)
self.from_jobHBox.addStretch()
# 羁绊分析组件---------------------------------------------
self.from_race = QFrame()
self.from_raceHBox = QHBoxLayout()
# 统计总羁绊数,并且将底图和图标获取
race_ss = {}.fromkeys(race_list).keys()
for ss in race_ss:
num = race_list.count(ss)
if txData != None:
if sss == 'race' and txData['race']==ss :
test_race = race_get_background_sf(self.race, ss, num, True)
else:
test_race = race_get_background_sf(self.race, ss, num, False)
else:
test_race = race_get_background_sf(self.race, ss, num, False)
if test_race!=None:
# 将每一个小组件渲染
tp_hbox = QHBoxLayout()
# 羁绊背景
tp_jb_bj = QLabel()
tp_jb_bj.setScaledContents(True)
tp_jb_bj.setPixmap(QPixmap(test_race[0]))
tp_jb_bj.setMaximumSize(30, 34)
tp_jb_bj.setMinimumSize(30, 34)
tp_jb_bj.setToolTip(
f'''<b style='color:#FFFFFF;'>{test_race[2]['introduce']}<br>{str(test_race[2]['level']).replace('{', '').replace('}', '').replace(',', '<br>')}</b>''')
# tp_jb_bj上方显示图标
tp_jb = QLabel(tp_jb_bj)
tp_jb.move(5,7)
tp_jb.setScaledContents(True)
tp_jb.setPixmap(QPixmap(test_race[1]))
tp_jb.setMaximumSize(20, 20)
tp_jb.setMinimumSize(20, 20)
# 羁绊名 文字
tp_text = QLabel(tp_jb_bj)
tp_text.setObjectName('JB')
tp_text.setText(f"{num} "+test_race[2]['name'])
# 将数据加入到每一列的布局中
tp_hbox.addWidget(tp_jb_bj)
tp_hbox.addWidget(tp_text)
self.from_raceHBox.addLayout(tp_hbox)
self.from_raceHBox.addStretch()
self.zbTJFrame.setLayout(self.zbTJVbox)
self.from_job.setLayout(self.from_jobHBox)
self.from_race.setLayout(self.from_raceHBox)
self.vbox.addWidget(self.zbTJFrame)
self.vbox.addWidget(self.from_job)
self.vbox.addWidget(self.from_race)
self.vbox.setSpacing(2)
self.setLayout(self.vbox)
self.setStyleSheet('''
#ZhuangbeiFX{
border: 1px solid rgb(185, 185, 185);
background-color: rgb(22,26,32);
border-right-style:none;
border-top-style:none;
}
#Title{
color: #FFFFFF;
background: rgba(22,26,32, 200);
font: 75 12pt "微软雅黑";}
#Doc{
color: #7E807D;
border-left-style: 1px solid rgb(185, 185, 185);
background: rgba(22,26,32, 200) ;
font: 75 10pt "微软雅黑";}
#JB{
color: #FFFFFF;
background: rgba(22,26,32, 200);
font: 75 10pt "微软雅黑";}
QToolTip{
border: 2px solid qconicalgradient(cx:0, cy:0, angle:135, stop:0 rgba(255, 255, 0, 69), stop:0.375 rgba(255, 255, 0, 69), stop:0.423533 rgba(251, 255, 0, 145), stop:0.45 rgba(247, 255, 0, 208), stop:0.477581 rgba(255, 244, 71, 130), stop:0.518717 rgba(255, 218, 71, 130), stop:0.55 rgba(255, 255, 0, 255), stop:0.57754 rgba(255, 203, 0, 130), stop:0.625 rgba(255, 255, 0, 69), stop:1 rgba(255, 255, 0, 69));
background-color: rgb(22,26,32);
ridge:ridge;
padding: 4px;
border-radius:10px;
}
''')
def init_tab_upload(self):
main_v = QtWidgets.QVBoxLayout()
inner_q_up = QFrame()
inner_q_down = QFrame()
inner_q_up.setFrameStyle(QFrame().StyledPanel | QFrame().Sunken)
inner_q_down.setFrameStyle(QFrame().StyledPanel | QFrame().Sunken)
inner_v_up = QVBoxLayout()
in_hb_1 = QHBoxLayout()
file_l = QLabel("File: ")
self.ql_f = QComboBox()
self.ql_f.setEditable(True)
self.ql_f.setInsertPolicy(QComboBox.NoInsert)
self.ql_f.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.ql_f.setMinimumWidth(340)
self.ql_f.setDuplicatesEnabled(False)
usr_dir = self.config.parse['config']['default_dir']
if not usr_dir:
usr_dir = os.environ['USER']
self.update_file_box(usr_dir)
self.ql_f.setCurrentIndex(-1)
self.ql_f.currentTextChanged.connect(self.update_file_box_typing)
self.ql_b = QPushButton("Browse")
self.ql_b.clicked.connect(self.call_file_dialog)
in_hb_1.addWidget(file_l)
in_hb_1.addWidget(self.ql_f)
in_hb_1.addWidget(self.ql_b)
in_hb_2 = QHBoxLayout()
in_hb_left = QVBoxLayout()
in_hb_left_q = QFrame()
in_hb_left_q.setStyleSheet('QCheckBox { margin: 2px; }')
copy_h = QHBoxLayout()
self.copy_check = QCheckBox()
self.copy_check.setChecked(
bool(self.config.parse['config']['upload']['clipboard_state']))
self.copy_check.stateChanged.connect(self.update_upload_copyclip_state)
copy_lab = LabelBoundToCheckbox(self.copy_check,
"Copy link after upload")
copy_h.addWidget(self.copy_check)
copy_h.addWidget(copy_lab)
copy_h.addStretch(1)
name_h = QHBoxLayout()
self.name_check = QCheckBox()
self.name_check.setChecked(
bool(self.config.parse['config']['upload']['random_fname_state']))
self.name_check.stateChanged.connect(self.update_upload_randname_state)
name_lab = LabelBoundToCheckbox(self.name_check,
"Send random filename")
name_h.addWidget(self.name_check)
name_h.addWidget(name_lab)
name_h.addStretch(1)
in_hb_left.addStretch(1)
in_hb_left.addItem(copy_h)
in_hb_left.addItem(name_h)
in_hb_left.addStretch(1)
in_hb_left_q.setLayout(in_hb_left)
tab_v = QtWidgets.QVBoxLayout()
hb_left_tab = QTabWidget()
tab_set = QtWidgets.QWidget()
tab_v.addWidget(in_hb_left_q)
tab_set.setLayout(tab_v)
tab_up = QtWidgets.QWidget()
in_hb_right = QVBoxLayout()
self.up_btn = QPushButton("Upload")
self.up_btn.clicked.connect(self.file_upload)
up_hbox = QHBoxLayout()
up_lab = QLabel("Service: ")
self.up_comb = QComboBox()
self.up_comb.addItem("Imgur")
self.up_comb.addItem("catbox.moe")
self.up_comb.addItem("uguu.se")
last_item = self.config.parse['config']['upload']['last_service']
if last_item == 'catbox.moe':
self.up_comb.setCurrentIndex(1)
elif last_item == 'uguu.se':
self.up_comb.setCurrentIndex(2)
self.up_comb.currentIndexChanged.connect(self.update_last_serv)
up_hbox.addWidget(up_lab)
up_hbox.addWidget(self.up_comb)
in_hb_right.addItem(up_hbox)
in_hb_right.addWidget(self.up_btn)
tab_up.setLayout(in_hb_right)
hb_left_tab.addTab(tab_up, "General")
hb_left_tab.addTab(tab_set, "Settings")
inner_q_res = QFrame()
result_b = QVBoxLayout()
self.result_f = QtWidgets.QTextEdit("")
self.result_f.setFixedHeight(50)
self.result_f.setReadOnly(True)
self.result_f.setTextInteractionFlags(
self.result_f.textInteractionFlags()
| Qt.TextSelectableByKeyboard)
if self.parent.last_url:
self.result_f.setText(self.parent.last_url)
result_btn = QPushButton("Copy")
result_btn.clicked.connect(self.copy_to_clipboard)
result_b.addStretch(1)
result_b.addWidget(self.result_f)
result_b.addWidget(result_btn)
inner_q_res.setLayout(result_b)
in_hb_2.addWidget(hb_left_tab, 50)
in_hb_2.addWidget(inner_q_res, 50)
inner_v_up.addItem(in_hb_1)
inner_v_up.addItem(in_hb_2)
inner_v_down = QVBoxLayout()
self.out = QtWidgets.QTextEdit("Idle")
self.out.setReadOnly(True)
self.out.setTextInteractionFlags(self.out.textInteractionFlags()
| Qt.TextSelectableByKeyboard)
self.out.setStyleSheet(
("QTextEdit { background-color: black; color: white; "
"border: 0; padding-left: 4px; padding-top: 4px;"
"font-family: monospace; }"))
if self.parent.last_out:
self.out.setText(self.parent.last_out)
inner_v_down.addWidget(self.out)
inner_q_up.setLayout(inner_v_up)
inner_q_down.setLayout(inner_v_down)
main_v.addWidget(inner_q_up, 30)
main_v.addWidget(inner_q_down, 70)
self.tab_upload.setLayout(main_v)
def init_tab_settings(self):
main_wrap = QVBoxLayout()
dir_lab = QLabel("Save directory: ")
up_dir = QHBoxLayout()
self.dirline = QLineEdit()
self.dirline.setText(self.config.parse['config']['default_dir'])
self.dirline.setReadOnly(True)
self.dirbtn = QPushButton("Browse")
self.dirbtn.clicked.connect(self.browse_directories)
up_dir.addWidget(dir_lab)
up_dir.addWidget(self.dirline)
up_dir.addWidget(self.dirbtn)
general_frame = QFrame()
general_frame.setFrameStyle(QFrame().StyledPanel | QFrame().Sunken)
general_frame.setStyleSheet('QCheckBox { margin: 2px; }')
general_wrap = QVBoxLayout()
delay_wrap = QHBoxLayout()
self.del_check = QtWidgets.QDoubleSpinBox()
self.del_check.setSingleStep(0.05)
self.del_check.setDecimals(2)
del_lab = QLabel("Default delay (seconds): ")
self.del_check.setValue(self.config.parse['config']['default_delay'])
self.del_check.valueChanged.connect(self.update_delay)
delay_wrap.addWidget(del_lab)
delay_wrap.addWidget(self.del_check)
name_wrap = QHBoxLayout()
fmt_lab = QLabel("Name pattern: ")
self.name_pattern = QLineEdit()
self.name_pattern_help = QPushButton('?')
self.name_pattern_help.setFixedWidth(30)
self.name_pattern_help.clicked.connect(
self.show_name_pattern_help_dialog)
self.name_pattern.setText(
self.config.parse['config']['filename_format'])
self.name_pattern.textChanged.connect(self.update_file_format)
name_wrap.addWidget(fmt_lab)
name_wrap.addWidget(self.name_pattern)
name_wrap.addWidget(self.name_pattern_help)
icon_wrap = QHBoxLayout()
ico_lab = QLabel("Tray icon style: ")
self.ico_comb = QComboBox()
self.ico_comb.addItem("Colored")
self.ico_comb.addItem("White")
self.ico_comb.addItem("Black")
curr_ico = self.config.parse['config']['icon']
if curr_ico == 'white':
self.ico_comb.setCurrentIndex(1)
elif curr_ico == 'black':
self.ico_comb.setCurrentIndex(2)
self.ico_comb.currentIndexChanged.connect(self.update_ico)
icon_wrap.addWidget(ico_lab)
icon_wrap.addWidget(self.ico_comb)
general_wrap.addItem(up_dir)
general_wrap.addItem(name_wrap)
general_wrap.addItem(delay_wrap)
general_wrap.addItem(icon_wrap)
general_frame.setLayout(general_wrap)
canvas_frame = QFrame()
canvas_frame.setStyleSheet('QCheckBox { margin: 2px; }')
canvas_wrap = QVBoxLayout()
canvas_frame.setFrameStyle(QFrame().StyledPanel | QFrame().Sunken)
upload_wrap = QHBoxLayout()
up_lab = QLabel("Upload button service: ")
box = ['Imgur', 'catbox.moe', 'uguu.se', 'Disabled']
self.set_up_comb = QComboBox()
for item in box:
self.set_up_comb.addItem(item)
curr_serv = self.config.parse['config']['canvas']['upload_service']
for count, item in enumerate(box):
if curr_serv == item:
self.set_up_comb.setCurrentIndex(count)
break
self.set_up_comb.currentIndexChanged.connect(self.update_canvas_upload)
upload_wrap.addWidget(up_lab)
upload_wrap.addWidget(self.set_up_comb)
save_btn_wrap = QHBoxLayout()
save_lab = QLabel("Save button: ")
self.set_save = QComboBox()
self.set_save.addItem("Saves to default directory")
self.set_save.addItem("Invokes save dialog")
if self.config.parse['config']['canvas']['save_action'] == 'dialog':
self.set_save.setCurrentIndex(1)
self.set_save.currentIndexChanged.connect(self.update_canvas_save)
save_btn_wrap.addWidget(save_lab)
save_btn_wrap.addWidget(self.set_save)
copy_img_wrap = QHBoxLayout()
self.img_check = QCheckBox()
self.img_check.setChecked(
bool(self.config.parse['config']['canvas']['img_clip']))
self.img_check.stateChanged.connect(self.update_img_clip)
img_clip_lab = LabelBoundToCheckbox(self.img_check,
"Copy image to clipboard on save")
copy_img_wrap.addWidget(self.img_check)
copy_img_wrap.addWidget(img_clip_lab)
copy_img_wrap.addStretch(1)
magn_wrap = QHBoxLayout()
self.magn_defaults = QCheckBox()
self.magn_defaults.setChecked(
bool(self.config.parse['config']['canvas']['magnifier']))
self.magn_defaults.stateChanged.connect(self.update_magnifier_state)
magn_lab = LabelBoundToCheckbox(self.magn_defaults,
"Show magnifier on startup")
magn_wrap.addWidget(self.magn_defaults)
magn_wrap.addWidget(magn_lab)
magn_wrap.addStretch(1)
canvas_wrap.addItem(upload_wrap)
canvas_wrap.addItem(save_btn_wrap)
canvas_wrap.addItem(copy_img_wrap)
canvas_wrap.addItem(magn_wrap)
canvas_frame.setLayout(canvas_wrap)
history_frame = QFrame()
history_wrap = QHBoxLayout()
clear_btn = QPushButton("Clear history")
clear_btn.clicked.connect(self.clear_history_list)
history_wrap.addWidget(clear_btn)
history_frame.setLayout(history_wrap)
history_frame.setStyleSheet('QCheckBox { margin: 2px; }')
history_frame.setFrameStyle(QFrame().StyledPanel | QFrame().Sunken)
bot_wrap = QVBoxLayout()
lab_0 = QLabel(" General")
lab_1 = QLabel(" Paint window")
lab_2 = QLabel(" History")
lab_0.setFixedHeight(30)
lab_1.setFixedHeight(30)
lab_2.setFixedHeight(30)
bot_wrap.addWidget(lab_0)
bot_wrap.addWidget(general_frame)
bot_wrap.addStretch(1)
bot_wrap.addWidget(lab_1)
bot_wrap.addWidget(canvas_frame)
bot_wrap.addStretch(1)
bot_wrap.addWidget(lab_2)
bot_wrap.addWidget(history_frame)
main_wrap.addItem(bot_wrap)
scroll_frame = QFrame()
scroll_frame.setLayout(main_wrap)
scroll = QtWidgets.QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(scroll_frame)
scroll_wrap = QVBoxLayout()
scroll_wrap.addWidget(scroll)
self.tab_settings.setLayout(scroll_wrap)
def __init__(self, engine):
super().__init__()
self.setupUi(self)
self._engine = engine
machines = {
plugin.name: _(plugin.name)
for plugin in registry.list_plugins('machine')
}
mappings = (
(_('Interface'), (
ConfigOption(
_('Start minimized:'), 'start_minimized', BooleanOption,
_('Minimize the main window to systray on startup.')),
ConfigOption(_('Show paper tape:'),
'show_stroke_display', BooleanOption,
_('Open the paper tape on startup.')),
ConfigOption(_('Show suggestions:'),
'show_suggestions_display', BooleanOption,
_('Open the suggestions dialog on startup.')),
ConfigOption(
_('Add translation dialog opacity:'),
'translation_frame_opacity',
partial(IntOption, maximum=100, minimum=0),
_('Set the translation dialog opacity:\n'
'- 0 makes the dialog invisible\n'
'- 100 is fully opaque')),
ConfigOption(
_('Dictionaries display order:'),
'classic_dictionaries_display_order',
partial(BooleanAsDualChoiceOption, _('top-down'),
_('bottom-up')),
_('Set the display order for dictionaries:\n'
'- top-down: match the search order; highest priority first\n'
'- bottom-up: reverse search order; lowest priority first\n'
)),
)),
(_('Logging'), (
ConfigOption(
_('Log file:'), 'log_file_name',
partial(FileOption, _('Select a log file'),
_('Log files') + ' (*.log)'),
_('File to use for logging strokes/translations.')),
ConfigOption(_('Log strokes:'), 'enable_stroke_logging',
BooleanOption, _('Save strokes to the logfile.')),
ConfigOption(_('Log translations:'),
'enable_translation_logging', BooleanOption,
_('Save translations to the logfile.')),
)),
(_('Machine'), (
ConfigOption(
_('Machine:'),
'machine_type',
partial(ChoiceOption, choices=machines),
dependents=(
('machine_specific_options',
self._update_machine_options),
('system_keymap',
lambda v: self._update_keymap(machine_type=v)),
)),
ConfigOption(_('Options:'), 'machine_specific_options',
self._machine_option),
ConfigOption(_('Keymap:'), 'system_keymap', KeymapOption),
)),
(_('Output'), (
ConfigOption(_('Enable at start:'), 'auto_start',
BooleanOption, _('Enable output on startup.')),
ConfigOption(
_('Start attached:'), 'start_attached', BooleanOption,
_('Disable preceding space on first output.\n'
'\n'
'This option is only applicable when spaces are placed before.'
)),
ConfigOption(_('Start capitalized:'), 'start_capitalized',
BooleanOption, _('Capitalize the first word.')),
ConfigOption(
_('Space placement:'), 'space_placement',
partial(ChoiceOption,
choices={
'Before Output': _('Before Output'),
'After Output': _('After Output'),
}),
_('Set automatic space placement: before or after each word.'
)),
ConfigOption(
_('Undo levels:'), 'undo_levels',
partial(IntOption,
maximum=10000,
minimum=MINIMUM_UNDO_LEVELS),
_('Set how many preceding strokes can be undone.\n'
'\n'
'Note: the effective value will take into account the\n'
'dictionaries entry with the maximum number of strokes.')
),
)),
(_('Plugins'), (ConfigOption(
_('Extension:'), 'enabled_extensions',
partial(MultipleChoicesOption,
choices={
plugin.name: plugin.name
for plugin in registry.list_plugins('extension')
},
labels=(_('Name'), _('Enabled'))),
_('Configure enabled plugin extensions.')), )),
(_('System'), (ConfigOption(
_('System:'),
'system_name',
partial(ChoiceOption,
choices={
plugin.name: plugin.name
for plugin in registry.list_plugins('system')
}),
dependents=(
('system_keymap',
lambda v: self._update_keymap(system_name=v)), )), )),
)
# Only keep supported options, to avoid messing with things like
# dictionaries, that are handled by another (possibly concurrent)
# dialog.
self._supported_options = set()
for section, option_list in mappings:
self._supported_options.update(option.option_name
for option in option_list)
self._update_config()
# Create and fill tabs.
options = {}
for section, option_list in mappings:
layout = QFormLayout()
for option in option_list:
widget = self._create_option_widget(option)
options[option.option_name] = option
option.tab_index = self.tabs.count()
option.layout = layout
option.widget = widget
label = QLabel(option.display_name)
label.setToolTip(option.help_text)
layout.addRow(label, widget)
frame = QFrame()
frame.setLayout(layout)
scroll_area = QScrollArea()
scroll_area.setWidgetResizable(True)
scroll_area.setWidget(frame)
self.tabs.addTab(scroll_area, section)
# Update dependents.
for option in options.values():
option.dependents = [
(options[option_name], update_fn)
for option_name, update_fn in option.dependents
]
buttons = self.findChild(QWidget, 'buttons')
buttons.button(QDialogButtonBox.Ok).clicked.connect(self.on_apply)
buttons.button(QDialogButtonBox.Apply).clicked.connect(self.on_apply)
self.restore_state()
self.finished.connect(self.save_state)
class Gui(QWidget):
def __init__(self):
super().__init__()
self.foldername = None
self.server = None
self.initUI()
def initUI(self):
grid = QGridLayout()
self.setLayout(grid)
self.addr_frame = QFrame()
addr_layout = QGridLayout()
self.addr_frame.setLayout(addr_layout)
lbl_host = QLabel('Host:', self)
lbl_port = QLabel('Port:', self)
lbl_msg = QLabel('Msg:', self)
lbl_spin = QLabel('Group number:', self)
self.lbl_msg_wr = QLabel('', self)
self.lbl_err = QLabel('', self)
self.edit_host = QLineEdit()
self.edit_port = QLineEdit('9090')
self.btn_run = QPushButton('Run server', self)
self.btn_stop = QPushButton('Stop server', self)
self.btn_dir = QPushButton('Open folder', self)
self.btn_ext = QPushButton('Quit', self)
self.spin = QSpinBox()
self.spin.setRange(0, 99)
addr_layout.addWidget(lbl_host, 0, 0)
addr_layout.addWidget(self.edit_host, 0, 1)
addr_layout.addWidget(lbl_port, 0, 2)
addr_layout.addWidget(self.edit_port, 0, 3)
addr_layout.addWidget(self.lbl_err, 1, 0, 1, 4)
grid.addWidget(self.addr_frame, 0, 0, 2, 4)
grid.addWidget(lbl_spin, 2, 1, 1, 2)
grid.addWidget(self.spin, 2, 3)
grid.addWidget(lbl_msg, 3, 0)
grid.addWidget(self.lbl_msg_wr, 3, 1, 1, 3)
grid.addWidget(self.btn_run, 4, 0, 1, 4)
grid.addWidget(self.btn_stop, 5, 0, 1, 4)
grid.addWidget(self.btn_dir, 6, 3)
grid.addWidget(self.btn_ext, 6, 0)
self.btn_ext.clicked.connect(QCoreApplication.instance().quit)
self.btn_run.clicked.connect(self.start)
self.btn_dir.clicked.connect(self.get_filename)
self.btn_stop.clicked.connect(self.stop)
self.btn_stop.setDisabled(True)
self.spin.valueChanged.connect(self.set_group)
self.thread = QThread()
self.thread.started.connect(lambda: self.disable_btn(True))
self.thread.finished.connect(lambda: self.disable_btn(False))
self.setWindowTitle('TCP Server')
self.center()
self.show()
def get_filename(self):
self.foldername = QFileDialog.getExistingDirectory(
self, "Set folder", ".")
@pyqtSlot(str)
def show_msg(self, string):
self.lbl_msg_wr.setText(string)
def set_group(self, value):
if self.server:
self.server.group_number = str(value).rjust(2, '0')
def disable_btn(self, value):
self.btn_run.setDisabled(value)
self.btn_stop.setEnabled(value)
self.btn_dir.setDisabled(value)
self.btn_ext.setDisabled(value)
self.addr_frame.setDisabled(value)
def start(self):
file_patch = self.foldername + '/log.csv' if self.foldername else 'log.csv'
self.server = Server(str(self.spin.value()).rjust(2, '0'), file_patch)
self.server.show_string.connect(self.show_msg)
port = self.edit_port.text()
if port:
self.server.create(int(port))
self.server.loop = True
self.server.moveToThread(self.thread)
self.thread.started.connect(self.server.run)
self.thread.setTerminationEnabled()
self.thread.start()
else:
self.lbl_err.setText('Error!')
def stop(self):
if self.server:
self.server.loop = False
self.thread.terminate()
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def initUI(self):
fuenteSiacle = self.font()
fuenteSiacle.setBold(True)
fuenteSiacle.setPointSize(12)
# ================= FRAME PANEL DE CONTROL ===================
paletaBotones = self.palette()
paletaBotones.setColor(QPalette.Background, QColor("#2EFEC8"))
frameBotones = QFrame()
frameBotones.setFrameStyle(QFrame.NoFrame)
frameBotones.setAutoFillBackground(True)
frameBotones.setPalette(paletaBotones)
frameBotones.setFixedWidth(220)
# ============================================================
paletaPanel = self.palette()
paletaPanel.setBrush(QPalette.Background,
QBrush(QColor(255, 90, 0), Qt.SolidPattern))
paletaPanel.setColor(QPalette.Foreground, Qt.white)
labelSiacle = QLabel("PANEL DE CONTROL", frameBotones)
labelSiacle.setAlignment(Qt.AlignCenter)
labelSiacle.setFont(fuenteSiacle)
labelSiacle.setAutoFillBackground(True)
labelSiacle.setPalette(paletaPanel)
labelSiacle.setFixedSize(220, 46)
labelSiacle.move(0, 0)
# ============================================================
botonNuevo = Boton(frameBotones)
botonNuevo.setText(" Nuevo")
botonNuevo.setToolTip("Nuevo cliente")
botonNuevo.setCursor(Qt.PointingHandCursor)
botonNuevo.move(-2, 45)
botonActualizar = Boton(frameBotones)
botonActualizar.setText(" Actualizar")
botonActualizar.setToolTip("Actualizar cliente")
botonActualizar.setCursor(Qt.PointingHandCursor)
botonActualizar.move(-2, 82)
botonEliminar = Boton(frameBotones)
botonEliminar.setText(" Eliminar")
botonEliminar.setToolTip("Eliminar cliente")
botonEliminar.setCursor(Qt.PointingHandCursor)
botonEliminar.move(-2, 119)
botonLimpiar = Boton(frameBotones)
botonLimpiar.setText(" Limpiar tabla")
botonLimpiar.setToolTip("Limpiar tabla")
botonLimpiar.setCursor(Qt.PointingHandCursor)
botonLimpiar.move(-2, 156)
# ============================================================
paletaSuscribete = self.palette()
paletaSuscribete.setBrush(
QPalette.Background, QBrush(QColor(135, 206, 250),
Qt.SolidPattern))
fuenteSuscribete = self.font()
fuenteSuscribete.setBold(True)
fuenteSuscribete.setFamily("Arial")
fuenteSuscribete.setPointSize(11)
labelSuscribete = QLabel(
"<a href='https://www.youtube.com/c/AndresNiñoPython?"
"sub_confirmation=1'>SUSCRIBETE.</a>", frameBotones)
labelSuscribete.setAlignment(Qt.AlignCenter)
labelSuscribete.setOpenExternalLinks(True)
labelSuscribete.setFont(fuenteSuscribete)
labelSuscribete.setAutoFillBackground(True)
labelSuscribete.setPalette(paletaSuscribete)
labelSuscribete.setFixedSize(220, 46)
labelSuscribete.move(0, 210)
# ============ FRAME BIENVENIDO - CONFIGURACIÓN ==============
paletaFrame = self.palette()
paletaFrame.setColor(QPalette.Background, QColor("blue"))
frameBienvenido = QFrame()
frameBienvenido.setFrameStyle(QFrame.NoFrame)
frameBienvenido.setAutoFillBackground(True)
frameBienvenido.setPalette(paletaFrame)
frameBienvenido.setFixedHeight(46)
# ============================================================
paletaTitulo = self.palette()
paletaTitulo.setColor(QPalette.Foreground, Qt.yellow)
labelBienvenido = QLabel("BIENVENIDO A SIACLE")
labelBienvenido.setAlignment(Qt.AlignCenter)
labelBienvenido.setFont(fuenteSiacle)
labelBienvenido.setPalette(paletaTitulo)
botonConfiguracion = QPushButton()
botonConfiguracion.setIcon(QIcon("Imagenes/configuracion.png"))
botonConfiguracion.setIconSize(QSize(24, 24))
botonConfiguracion.setToolTip("Configurar Siacle")
botonConfiguracion.setCursor(Qt.PointingHandCursor)
botonConfiguracion.setFixedWidth(36)
# Primero, creamos los widgets que queremos en el diseño. Luego, creamos el
# objeto QHBoxLayout y agregamos los widgets en el diseño. Finalmente, llamamos
# a QWidget.setLayout(diseño) para instalar el objeto QHBoxLayout en el widget.
disenioFrame = QHBoxLayout()
disenioFrame.addWidget(labelBienvenido, Qt.AlignCenter)
disenioFrame.addStretch()
disenioFrame.addWidget(botonConfiguracion)
disenioFrame.setContentsMargins(0, 0, 5, 0)
frameBienvenido.setLayout(disenioFrame)
# ============================================================
self.buscarLineEdit = QLineEdit()
self.buscarLineEdit.setObjectName("Enter")
self.buscarLineEdit.setPlaceholderText("Nombre del cliente")
self.buscarLineEdit.setMinimumSize(200, 26)
botonBuscar = QPushButton("Buscar")
botonBuscar.setObjectName("Buscar")
botonBuscar.setCursor(Qt.PointingHandCursor)
botonBuscar.setMinimumSize(60, 26)
separadorTodos = QFrame()
separadorTodos.setFrameShape(QFrame.VLine)
separadorTodos.setFrameShadow(QFrame.Raised)
separadorTodos.setFixedSize(1, 26)
botonTodos = QPushButton("Todos")
botonTodos.setObjectName("Todos")
botonTodos.setCursor(Qt.PointingHandCursor)
botonTodos.setMinimumSize(60, 26)
nombreColumnas = ("Id", "Nombre", "Apellido", "Sexo",
"Fecha de nacimiento", "País", "Teléfono o celular")
menuMostrarOcultar = QMenu()
for indice, columna in enumerate(nombreColumnas, start=0):
accion = QAction(columna, menuMostrarOcultar)
accion.setCheckable(True)
accion.setChecked(True)
accion.setData(indice)
menuMostrarOcultar.addAction(accion)
botonMostrarOcultar = QPushButton("Motrar/ocultar columnas")
botonMostrarOcultar.setCursor(Qt.PointingHandCursor)
botonMostrarOcultar.setMenu(menuMostrarOcultar)
botonMostrarOcultar.setMinimumSize(180, 26)
# Crear el objeto QHBoxLayout y agregar los widgets en el diseño.
disenioBuscar = QHBoxLayout()
disenioBuscar.setSpacing(10)
disenioBuscar.addWidget(self.buscarLineEdit)
disenioBuscar.addWidget(botonBuscar)
disenioBuscar.addWidget(separadorTodos)
disenioBuscar.addWidget(botonTodos)
disenioBuscar.addWidget(botonMostrarOcultar)
# =================== WIDGET QTableWidget ===================
self.tabla = QTableWidget()
# Deshabilitar edición
self.tabla.setEditTriggers(QAbstractItemView.NoEditTriggers)
# Deshabilitar el comportamiento de arrastrar y soltar
self.tabla.setDragDropOverwriteMode(False)
# Seleccionar toda la fila
self.tabla.setSelectionBehavior(QAbstractItemView.SelectRows)
# Seleccionar una fila a la vez
self.tabla.setSelectionMode(QAbstractItemView.SingleSelection)
# Especifica dónde deben aparecer los puntos suspensivos "..." cuando se muestran
# textos que no encajan
self.tabla.setTextElideMode(Qt.ElideRight) # Qt.ElideNone
# Establecer el ajuste de palabras del texto
self.tabla.setWordWrap(False)
# Deshabilitar clasificación
self.tabla.setSortingEnabled(False)
# Establecer el número de columnas
self.tabla.setColumnCount(7)
# Establecer el número de filas
self.tabla.setRowCount(0)
# Alineación del texto del encabezado
self.tabla.horizontalHeader().setDefaultAlignment(Qt.AlignHCenter
| Qt.AlignVCenter
| Qt.AlignCenter)
# Deshabilitar resaltado del texto del encabezado al seleccionar una fila
self.tabla.horizontalHeader().setHighlightSections(False)
# Hacer que la última sección visible del encabezado ocupa todo el espacio disponible
self.tabla.horizontalHeader().setStretchLastSection(True)
# Ocultar encabezado vertical
self.tabla.verticalHeader().setVisible(False)
# Dibujar el fondo usando colores alternados
self.tabla.setAlternatingRowColors(True)
# Establecer altura de las filas
self.tabla.verticalHeader().setDefaultSectionSize(20)
# self.tabla.verticalHeader().setHighlightSections(True)
# Establecer las etiquetas de encabezado horizontal usando etiquetas
self.tabla.setHorizontalHeaderLabels(nombreColumnas)
# Menú contextual
self.tabla.setContextMenuPolicy(Qt.CustomContextMenu)
self.tabla.customContextMenuRequested.connect(self.menuContextual)
# Establecer ancho de las columnas
for indice, ancho in enumerate((80, 240, 240, 140, 150, 130), start=0):
self.tabla.setColumnWidth(indice, ancho)
# ============================================================
disenioBuscarTabla = QVBoxLayout()
disenioBuscarTabla.addLayout(disenioBuscar)
disenioBuscarTabla.addWidget(self.tabla)
disenioBuscarTabla.setSpacing(8)
disenioBuscarTabla.setContentsMargins(10, 10, 10, 0)
# ===================== LAYOUT DERECHO =======================
disenioDerecho = QVBoxLayout()
disenioDerecho.addWidget(frameBienvenido)
disenioDerecho.addLayout(disenioBuscarTabla)
disenioDerecho.setContentsMargins(0, 0, 0, 0)
# ====================== LAYOUT FINAL ======================
disenioFinal = QGridLayout()
disenioFinal.addWidget(frameBotones, 0, 0)
disenioFinal.addLayout(disenioDerecho, 0, 1)
disenioFinal.setSpacing(0)
disenioFinal.setContentsMargins(0, 0, 0, 0)
self.setLayout(disenioFinal)
# ========= GUARDAR INFORMACIÓN EN EL PORTAPAPELES =========
self.copiarInformacion = QApplication.clipboard()
def initUI(self):
# class vairables
self.image = None
self.sfh5 = None
self.imgpath = None
self.scanNr = None
self.scanXmot = None
self.scanXpos = None
self.scanLen = None
self.scanData = None
#top level elements of the full window
mainBox = QHBoxLayout(self)
mainBox.setContentsMargins(0, 0, 0, 0)
primSplitter = QSplitter(Qt.Horizontal)
#second level elements
#left
secSplitterLeft = QSplitter(Qt.Vertical)
# third level elements
# top
lefttop = QFrame(self)
lefttop.setFrameShape(QFrame.StyledPanel)
self.loadButton = QPushButton("data")
#self.changeDirButton.setEnabled(False)
#self.changeDirButton.clicked.connect(self.openFile)
filelab = QLabel('File:')
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(self.loadButton, 1, 0,1,3)
self.loadButton.clicked.connect(self.onLoadFile)
grid.addWidget(filelab, 2, 0)
lefttop.setLayout(grid)
#bottom left
leftbottom = QFrame(self)
leftbottom.setFrameShape(QFrame.StyledPanel)
hboxfile = QVBoxLayout(self)
hboxfile.setContentsMargins(0, 0, 0, 0)
leftbottom.setLayout(hboxfile)
#self.tree=QListWidget()
#self.model = QStandardItemModel(self.tree)
#self.tree.clicked.connect(self.onScanSelect)
#hboxfile.addWidget(self.tree)
# finalizing 3rd level
secSplitterLeft.addWidget(lefttop)
secSplitterLeft.addWidget(leftbottom)
secSplitterLeft.setStretchFactor(0,0)
secSplitterLeft.setStretchFactor(1,1)
#right
secSplitterRight = QSplitter(Qt.Vertical)
# plot
hboxplot = QHBoxLayout(self)
hboxplot.setContentsMargins(0, 0, 0, 0)
righttop = QFrame(self)
righttop.setFrameShape(QFrame.NoFrame)
righttop.setLayout(hboxplot)
colormap = {'name': 'temperature', 'normalization': 'log',
'autoscale': True, 'vmin': 0.0, 'vmax': 1.0}
self.myplot = plot.Plot2D()
hboxplot.addWidget(self.myplot)
#topright.setMinimumSize(300, 300)
self.myplot.setDefaultColormap(colormap)
self.myplot.setYAxisInverted()
#bottom text
rightbottom = QFrame(self)
rightbottom.setFrameShape(QFrame.NoFrame)
vboxtextfield = QVBoxLayout(self)
vboxtextfield.setContentsMargins(0, 10, 0, 0)
self.text = QTextEdit()
alab = QLabel('a:')
hboxfile.addWidget(alab)
self.slider_a = QSlider(Qt.Horizontal)
self.slider_a.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_a)
blab = QLabel('b:')
hboxfile.addWidget(blab)
self.slider_b = QSlider(Qt.Horizontal)
self.slider_b.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_b)
clab = QLabel('c:')
hboxfile.addWidget(clab)
self.slider_c = QSlider(Qt.Horizontal)
self.slider_c.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_c)
alphalab = QLabel('alpha:')
hboxfile.addWidget(alphalab)
self.slider_alpha = QSlider(Qt.Horizontal)
self.slider_alpha.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_alpha)
betalab = QLabel('beta:')
hboxfile.addWidget(betalab)
self.slider_beta = QSlider(Qt.Horizontal)
self.slider_beta.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_beta)
gamlab = QLabel('gam:')
hboxfile.addWidget(gamlab)
self.slider_ga = QSlider(Qt.Horizontal)
self.slider_ga.valueChanged.connect(self.onSlide)
hboxfile.addWidget(self.slider_ga)
self.slider_a.setRange(100,1500) ## in 0.01Ang.. jsut to have iteger numbers
self.slider_a.setValue(915)
self.slider_b.setRange(100,2500) ## in 0.01Ang.. jsut to have iteger numbers
self.slider_b.setValue(497)
self.slider_c.setRange(100,5000) ## in 0.01Ang.. jsut to have iteger numbers
self.slider_c.setValue(2180)
self.slider_alpha.setRange(500,1200) ## in 0.1Deg.. jsut to have iteger numbers
self.slider_alpha.setValue(848)
self.slider_beta.setRange(500,1200) ## in 0.1Deg.. jsut to have iteger numbers
self.slider_beta.setValue(1005)
self.slider_ga.setRange(500,1200) ## in 0.1Deg.. jsut to have iteger numbers
self.slider_ga.setValue(679)
self.pbar=QProgressBar()
vboxtextfield.addWidget(self.pbar)
vboxtextfield.addWidget(self.text)
sb=self.text.verticalScrollBar()
sb.maximum()
rightbottom.setLayout(vboxtextfield)
# finalizing 3rd level
secSplitterRight.addWidget(righttop)
secSplitterRight.addWidget(rightbottom)
# finalizing 2nd level components
primSplitter.addWidget(secSplitterLeft)
primSplitter.addWidget(secSplitterRight)
# finalizing first level components
mainBox.addWidget(primSplitter)
self.setLayout(mainBox)
self.setGeometry(300, 300, 700, 600)
self.adjustSize()
self.text.append("ScanViewer for ID03 - still unstable!\n")
self.setWindowTitle('UnitCellIndexerGUI')
self.show()
def initUI(self):
# region vbox1
vbox1 = QVBoxLayout()
vbox1.setAlignment(Qt.AlignCenter)
# model selection & input image
grid_input = QGridLayout()
font_bold = QFont()
font_bold.setBold(True)
lbl_model = QLabel('Model')
lbl_model.setFont(font_bold)
combo_model = QComboBox(self)
combo_model.addItem('')
model_names = self.model.get_data(NN_Vis_Demo_Model.data_idx_model_names)
for model_name in model_names:
combo_model.addItem(model_name)
combo_model.activated[str].connect(self.ctl.set_model)
lbl_input = QLabel('Input')
lbl_input.setFont(font_bold)
self.combo_input_source = QComboBox(self)
self.combo_input_source.addItem('') # null entry
self.combo_input_source.addItem('Image')
self.combo_input_source.addItem('Video')
self.combo_input_source.activated[str].connect(self.ctl.switch_source)
self.combo_input_source.setCurrentText('Image')
self.combo_input_source.setEnabled(False)
self.combo_input_image = QComboBox(self)
self.combo_input_image.addItem('') # null entry
self.combo_input_image.activated[str].connect(self.ctl.set_input_image)
self.combo_input_image.setEnabled(False)
grid_input.addWidget(lbl_model, 0, 1)
grid_input.addWidget(combo_model, 0, 2)
grid_input.addWidget(lbl_input, 1, 1)
grid_input.addWidget(self.combo_input_source, 1, 2)
grid_input.addWidget(self.combo_input_image, 2, 1, 1, 2)
vbox1.addLayout(grid_input)
# input image
pixm_input = QPixmap(QSize(224, 224))
pixm_input.fill(Qt.black)
self.lbl_input_image = DoubleClickableQLabel()
self.lbl_input_image.setAlignment(Qt.AlignCenter)
self.lbl_input_image.setPixmap(pixm_input)
vbox1.addWidget(self.lbl_input_image)
# Arrow
lbl_arrow_input_to_NN = QLabel('⬇️')
lbl_arrow_input_to_NN.setFont(font_bold)
lbl_arrow_input_to_NN.setAlignment(Qt.AlignCenter)
vbox1.addWidget(lbl_arrow_input_to_NN)
# Network overview
gb_network = QGroupBox("Neural network")
self.scroll_network = QScrollArea()
self.scroll_network.setFrameShape(QFrame.Box)
self.scroll_network.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.scroll_network.setAlignment(Qt.AlignCenter)
self.draw_network_overview()
layout_scroll_network = QVBoxLayout()
layout_scroll_network.addWidget(self.scroll_network)
gb_network.setLayout(layout_scroll_network)
vbox1.addWidget(gb_network)
# Arrow
lbl_arrow_NN_to_probs = QLabel('⬇️')
lbl_arrow_NN_to_probs.setFont(font_bold)
lbl_arrow_NN_to_probs.setAlignment(Qt.AlignCenter)
vbox1.addWidget(lbl_arrow_NN_to_probs)
#out_put_image
pixm_output = QPixmap(QSize(224,224))
pixm_output.fill(Qt.black)
self.output_image = DoubleClickableQLabel()
self.output_image.setAlignment(Qt.AlignCenter)
self.output_image.setPixmap(pixm_output)
vbox1.addWidget(self.output_image)
# endregion
# region vbox2
vbox2 = QVBoxLayout()
vbox2.setAlignment(Qt.AlignTop)
# header
self.combo_layer_view = QComboBox(self)
self.combo_layer_view.addItem('Results')
self.combo_layer_view.addItem('Activations')
self.combo_layer_view.addItem('Top 1 images')
self.combo_layer_view.currentTextChanged.connect(self.load_layer_view)
selected_layer_name = ' '
self.lbl_layer_name = QLabel(
"of layer <font color='blue'><b>%r</b></font>" % selected_layer_name) # todo: delete default value
#self.top_act_units = QCheckBox('Top act units')
#self.top_act_units.setCheckState(Qt.Unchecked)
grid_layer_header = QGridLayout()
grid_layer_header.addWidget(self.combo_layer_view, 0, 1)
grid_layer_header.addWidget(self.lbl_layer_name, 0, 2)
#grid_layer_header.addWidget(self.top_act_units , 0, 3)
##grid_layer_header.addWidget(ckb_group_units, 0, 4)
vbox2.addLayout(grid_layer_header)
# layer (units) view
self.layer_view = LayerViewWidget(None)
self.layer_view.clicked_unit_changed.connect(self.select_unit_action)
vbox2.addWidget(self.layer_view)
# endregion
# region vbox3
vbox3 = QVBoxLayout()
vbox3.setAlignment(Qt.AlignTop)
# region unit view
# todo: make a customized widget for this region?
# header
self.combo_unit_view = QComboBox(self)
for member in DetailedUnitViewWidget.WorkingMode:
self.combo_unit_view.addItem(member.value)
self.combo_unit_view.currentTextChanged.connect(self.load_detailed_unit_image)
self.combo_unit_view.setCurrentText(DetailedUnitViewWidget.WorkingMode.ACTIVATION.value)
selected_unit_name = ' '
self.lbl_unit_name = QLabel(
"of unit <font color='blue'><b>%r</b></font>" % selected_unit_name)
hbox_unit_view_header = QHBoxLayout()
hbox_unit_view_header.addWidget(self.combo_unit_view)
hbox_unit_view_header.addWidget(self.lbl_unit_name)
vbox3.addLayout(hbox_unit_view_header)
# overlay setting
hbox_overlay = QHBoxLayout()
hbox_overlay.addWidget(QLabel("Overlay: "))
self.combo_unit_overlay = QComboBox(self)
for member in DetailedUnitViewWidget.OverlayOptions:
self.combo_unit_overlay.addItem(member.value)
self.combo_unit_overlay.activated[str].connect(self.overlay_action)
hbox_overlay.addWidget(self.combo_unit_overlay)
vbox3.addLayout(hbox_overlay)
# unit image
self.detailed_unit_view = DetailedUnitViewWidget()
vbox3.addWidget(self.detailed_unit_view)
# endregion
# spacer
vbox3.addSpacing(10)
frm_line_unit_top9 = QFrame()
frm_line_unit_top9.setFrameShape(QFrame.HLine)
frm_line_unit_top9.setFrameShadow(QFrame.Sunken)
frm_line_unit_top9.setLineWidth(1)
vbox3.addWidget(frm_line_unit_top9)
vbox3.addSpacing(10)
# top 9 images
vbox3.addWidget(QLabel("Top 9 images with highest activations"))
self.combo_top9_images_mode = QComboBox(self)
self.combo_top9_images_mode.addItem("Input")
#self.combo_top9_images_mode.addItem("Deconv")
self.combo_top9_images_mode.currentTextChanged.connect(self.load_top_images)
vbox3.addWidget(self.combo_top9_images_mode)
self.grid_top9 = QGridLayout()
self.last_shown_unit_info = {'model_name':'dummy_model_name', 'layer':'dummy_layer', 'channel':-1}
pixm_top_image = QPixmap(QSize(224, 224))
pixm_top_image.fill(Qt.darkGray)
_top_image_height = 64
pixm_top_image_scaled = pixm_top_image.scaledToHeight(_top_image_height)
positions_top9_images = [(i, j) for i in range(3) for j in range(3)]
for position in positions_top9_images:
lbl_top_image = QLabel()
lbl_top_image.setPixmap(pixm_top_image_scaled)
lbl_top_image.setFixedSize(QSize(_top_image_height + 4, _top_image_height + 4))
self.grid_top9.addWidget(lbl_top_image, *position)
vbox3.addLayout(self.grid_top9)
# spacer
vbox3.addSpacing(10)
frm_line_top9_gd = QFrame()
frm_line_top9_gd.setFrameShape(QFrame.HLine)
frm_line_top9_gd.setFrameShadow(QFrame.Sunken)
frm_line_top9_gd.setLineWidth(1)
vbox3.addWidget(frm_line_top9_gd)
vbox3.addSpacing(10)
# gradient ascent
# btn_gradient_ascent = QPushButton("Find out what was learnt in this unit")
# vbox3.addWidget(btn_gradient_ascent)
# Prob view
self.probs_view = ProbsView()
vbox3.addWidget(self.probs_view)
self.probs_view.tableview.clicked.connect(self.top_9_units)
# endregion
hbox = QHBoxLayout()
widget_vbox1 = QFrame()
widget_vbox1.setLayout(vbox1)
widget_vbox1.setFixedWidth(widget_vbox1.sizeHint().width())
widget_vbox2 = QFrame()
widget_vbox2.setLayout(vbox2)
widget_vbox3 = QFrame()
widget_vbox3.setLayout(vbox3)
widget_vbox3.setFixedWidth(widget_vbox3.sizeHint().width())
frm_line_1_2 = QFrame()
frm_line_1_2.setFrameShape(QFrame.VLine)
frm_line_1_2.setFrameShadow(QFrame.Sunken)
frm_line_1_2.setLineWidth(2)
frm_line_2_3 = QFrame()
frm_line_2_3.setFrameShape(QFrame.VLine)
frm_line_2_3.setFrameShadow(QFrame.Sunken)
frm_line_2_3.setLineWidth(2)
hbox.addWidget(widget_vbox1)
hbox.addWidget(frm_line_1_2)
hbox.addWidget(widget_vbox2)
hbox.addWidget(frm_line_2_3)
hbox.addWidget(widget_vbox3)
central_widget = QWidget()
central_widget.setLayout(hbox)
self.statusbar = self.statusBar()
self.statusbar.showMessage('ready')
self.setCentralWidget(central_widget)
self.setWindowTitle('YOLO V3 Visualizer')
self.center()
self.showMaximized()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setWindowTitle("QAS Editor GUI")
self._items: List[QWidget] = []
self._main_editor = None
self.path: str = None
self.top_quiz = Category()
self.cxt_menu = QMenu(self)
self.cxt_item: QStandardItem = None
self.cxt_data: _Question | Category= None
self.cur_question: _Question = None
self.tagbar: GTagBar = None
self.main_editor: GTextEditor = None
self.is_open_find = self.is_open_dataset = False
with resources.open_text("qas_editor.gui", "stylesheet.css") as ifile:
self.setStyleSheet(ifile.read())
self._add_menu_bars()
# Left side
self.data_view = QTreeView()
self.data_view.setIconSize(QSize(18, 18))
xframe_vbox = self._block_datatree()
left = QWidget()
left.setLayout(xframe_vbox)
# Right side
self.cframe_vbox = QVBoxLayout()
self._block_general_data()
self._block_answer()
self._block_hints()
self._block_units()
self._block_zones()
self._block_solution()
self._block_template()
self.cframe_vbox.addStretch()
self.cframe_vbox.setSpacing(5)
for value in self._items:
value.setEnabled(False)
frame = QFrame()
frame.setLineWidth(2)
frame.setLayout(self.cframe_vbox)
right = QScrollArea()
right.setWidget(frame)
right.setWidgetResizable(True)
# Create main window divider for the splitter
splitter = QSplitter()
splitter.addWidget(left)
splitter.addWidget(right)
splitter.setStretchFactor(1, 1)
splitter.setSizes([250, 100])
self.setCentralWidget(splitter)
# Create lower status bar.
status = QStatusBar()
self.setStatusBar(status)
self.cat_name = QLabel()
status.addWidget(self.cat_name)
self._update_tree_item(self.top_quiz, self.root_item)
self.data_view.expandAll()
self.setGeometry(50, 50, 1200, 650)
self.show()
class BackgroundPlotter(QtInteractor):
ICON_TIME_STEP = 5.0
def __init__(self, show=True, app=None, shape=(1, 1), window_size=None,
off_screen=None, **kwargs):
if not has_pyqt:
raise AssertionError('Requires PyQt5')
self.active = True
self.saved_camera_positions = []
self.counters = []
if window_size is None:
window_size = rcParams['window_size']
# Remove notebook argument in case user passed it
kwargs.pop('notebook', None)
# ipython magic
if scooby.in_ipython(): # pragma: no cover
from IPython import get_ipython
ipython = get_ipython()
ipython.magic('gui qt')
from IPython.external.qt_for_kernel import QtGui
QtGui.QApplication.instance()
else:
ipython = None
# run within python
if app is None:
from PyQt5.QtWidgets import QApplication
app = QApplication.instance()
if not app: # pragma: no cover
app = QApplication([''])
self.app = app
self.app_window = MainWindow()
self.app_window.setWindowTitle(kwargs.get('title', rcParams['title']))
self.frame = QFrame()
self.frame.setFrameStyle(QFrame.NoFrame)
QtInteractor.__init__(self, parent=self.frame, shape=shape,
off_screen=off_screen, **kwargs)
self.app_window.signal_close.connect(self.quit)
# build main menu
main_menu = self.app_window.menuBar()
file_menu = main_menu.addMenu('File')
file_menu.addAction('Take Screenshot', self._qt_screenshot)
file_menu.addAction('Export as VTKjs', self._qt_export_vtkjs)
file_menu.addSeparator()
file_menu.addAction('Exit', self.app_window.close)
view_menu = main_menu.addMenu('View')
view_menu.addAction('Toggle Eye Dome Lighting', self._toggle_edl)
view_menu.addAction('Scale Axes', self.scale_axes_dialog)
view_menu.addAction('Clear All', self.clear)
tool_menu = main_menu.addMenu('Tools')
tool_menu.addAction('Enable Cell Picking (through)', self.enable_cell_picking)
tool_menu.addAction('Enable Cell Picking (visible)', lambda: self.enable_cell_picking(through=False))
cam_menu = view_menu.addMenu('Camera')
cam_menu.addAction('Toggle Parallel Projection', self._toggle_parallel_projection)
cam_menu.addAction('Reset Camera', self.reset_camera)
cam_menu.addAction('Isometric View', self.view_isometric)
cam_menu.addAction('View XY Plane', self.view_xy)
cam_menu.addAction('View XZ Plane', self.view_xz)
cam_menu.addAction('View YZ Plane', self.view_yz)
cam_menu.addSeparator()
cam_menu.addAction('Save Current Camera Position', self.save_camera_position)
cam_menu.addAction('Clear Saved Positions', self.clear_camera_positions)
view_menu.addSeparator()
# Orientation marker
orien_menu = view_menu.addMenu('Orientation Marker')
orien_menu.addAction('Show', self.show_axes)
orien_menu.addAction('Hide', self.hide_axes)
# Bounds axes
axes_menu = view_menu.addMenu('Bounds Axes')
axes_menu.addAction('Add Bounds Axes (front)', self.show_bounds)
axes_menu.addAction('Add Bounds Grid (back)', self.show_grid)
axes_menu.addAction('Add Bounding Box', self.add_bounding_box)
axes_menu.addSeparator()
axes_menu.addAction('Remove Bounding Box', self.remove_bounding_box)
axes_menu.addAction('Remove Bounds', self.remove_bounds_axes)
# A final separator to seperate OS options
view_menu.addSeparator()
self.saved_camera_menu = main_menu.addMenu('Camera Positions')
vlayout = QVBoxLayout()
vlayout.addWidget(self)
self.frame.setLayout(vlayout)
self.app_window.setCentralWidget(self.frame)
if off_screen is None:
off_screen = pyvista.OFF_SCREEN
if show and not off_screen: # pragma: no cover
self.app_window.show()
self.show()
self._spawn_background_rendering()
self.window_size = window_size
self._last_update_time = time.time() - BackgroundPlotter.ICON_TIME_STEP / 2
self._last_window_size = self.window_size
self._last_camera_pos = self.camera_position
def scale_axes_dialog(self, show=True):
""" Open scale axes dialog """
return ScaleAxesDialog(self.app_window, self, show=show)
def clear_camera_positions(self):
""" clears all camera positions """
for action in self.saved_camera_menu.actions():
self.saved_camera_menu.removeAction(action)
def save_camera_position(self):
""" Saves camera position to saved camera menu for recall """
self.saved_camera_positions.append(self.camera_position)
ncam = len(self.saved_camera_positions)
camera_position = self.camera_position[:] # py2.7 copy compatibility
def load_camera_position():
self.camera_position = camera_position
self.saved_camera_menu.addAction('Camera Position %2d' % ncam,
load_camera_position)
def _spawn_background_rendering(self, rate=5.0):
"""
Spawns a thread that updates the render window.
Sometimes directly modifiying object data doesn't trigger
Modified() and upstream objects won't be updated. This
ensures the render window stays updated without consuming too
many resources.
"""
twait = (rate**-1) * 1000.0
self.render_timer = QTimer(parent=self.app_window)
self.render_timer.timeout.connect(self._render)
self.app_window.signal_close.connect(self.render_timer.stop)
self.render_timer.start(twait)
def quit(self):
QtInteractor.quit(self)
def close(self):
self.app_window.close()
def add_actor(self, actor, reset_camera=None, name=None, loc=None, culling=False):
actor, prop = super(BackgroundPlotter, self).add_actor(actor,
reset_camera,
name,
loc)
self.update_app_icon()
return actor, prop
def update_app_icon(self):
"""
Update the app icon if the user is not trying to resize the window.
"""
if os.name == 'nt' or not hasattr(self, '_last_window_size'): # pragma: no cover
# DO NOT EVEN ATTEMPT TO UPDATE ICON ON WINDOWS
return
cur_time = time.time()
if self._last_window_size != self.window_size: # pragma: no cover
# Window size hasn't remained constant since last render.
# This means the user is resizing it so ignore update.
pass
elif ((cur_time - self._last_update_time > BackgroundPlotter.ICON_TIME_STEP)
and self._last_camera_pos != self.camera_position):
# its been a while since last update OR
# the camera position has changed and its been at leat one second
# Update app icon as preview of the window
img = pad_image(self.image)
qimage = QtGui.QImage(img.copy(), img.shape[1],
img.shape[0], QtGui.QImage.Format_RGB888)
icon = QtGui.QIcon(QtGui.QPixmap.fromImage(qimage))
self.app.setWindowIcon(icon)
# Update trackers
self._last_update_time = cur_time
self._last_camera_pos = self.camera_position
# Update trackers
self._last_window_size = self.window_size
def _qt_screenshot(self, show=True):
return FileDialog(self.app_window,
filefilter=['Image File (*.png)',
'JPEG (*.jpeg)'],
show=show,
directory=os.getcwd(),
callback=self.screenshot)
def _qt_export_vtkjs(self, show=True):
"""
Spawn an save file dialog to export a vtkjs file.
"""
return FileDialog(self.app_window,
filefilter=['VTK JS File(*.vtkjs)'],
show=show,
directory=os.getcwd(),
callback=self.export_vtkjs)
def _toggle_edl(self):
if hasattr(self.renderer, 'edl_pass'):
return self.renderer.disable_eye_dome_lighting()
return self.renderer.enable_eye_dome_lighting()
def _toggle_parallel_projection(self):
if self.camera.GetParallelProjection():
return self.disable_parallel_projection()
return self.enable_parallel_projection()
@pyqtSlot()
def _render(self):
super(BackgroundPlotter, self)._render()
self.update_app_icon()
self.ren_win.Render() # force rendering
return
@property
def window_size(self):
""" returns render window size """
the_size = self.app_window.baseSize()
return the_size.width(), the_size.height()
@window_size.setter
def window_size(self, window_size):
""" set the render window size """
BasePlotter.window_size.fset(self, window_size)
self.app_window.setBaseSize(*window_size)
self.app_window.resize(*window_size)
def __del__(self): # pragma: no cover
self.app_window.close()
def add_callback(self, func, interval=1000, count=None):
"""Add a function that can update the scene in the background
Parameters
----------
func : callable
Function to be called with no arguments.
interval : int
Time interval between calls to `func` in milliseconds.
count : int, optional
Number of times `func` will be called. If None,
`func` will be called until the main window is closed.
"""
timer = QTimer(parent=self.app_window)
timer.timeout.connect(func)
timer.start(interval)
self.app_window.signal_close.connect(timer.stop)
if count is not None:
counter = Counter(count)
counter.signal_finished.connect(timer.stop)
timer.timeout.connect(counter.decrease)
self.counters.append(counter)
class Setting_Ui(QWidget):
def __init__(self, persepolis_setting):
super().__init__()
icon = QtGui.QIcon()
self.persepolis_setting = persepolis_setting
# add support for other languages
locale = str(self.persepolis_setting.value('settings/locale'))
QLocale.setDefault(QLocale(locale))
self.translator = QTranslator()
if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
QCoreApplication.installTranslator(self.translator)
self.setWindowIcon(
QIcon.fromTheme('persepolis', QIcon(':/persepolis.svg')))
self.setWindowTitle(
QCoreApplication.translate("setting_ui_tr", 'Preferences'))
# set ui direction
ui_direction = self.persepolis_setting.value('ui_direction')
if ui_direction == 'rtl':
self.setLayoutDirection(Qt.RightToLeft)
elif ui_direction in 'ltr':
self.setLayoutDirection(Qt.LeftToRight)
global icons
icons = ':/' + str(
self.persepolis_setting.value('settings/icons')) + '/'
self.verticalLayout_2 = QVBoxLayout(self)
self.setting_tabWidget = QTabWidget(self)
# download_options_tab
self.download_options_tab = QWidget()
self.layoutWidget = QWidget(self.download_options_tab)
self.download_options_verticalLayout = QVBoxLayout(self.layoutWidget)
self.download_options_verticalLayout.setContentsMargins(21, 21, 0, 0)
self.download_options_verticalLayout.setObjectName(
"download_options_verticalLayout")
self.horizontalLayout_5 = QHBoxLayout()
# tries_label
self.tries_label = QLabel(self.layoutWidget)
self.horizontalLayout_5.addWidget(self.tries_label)
# tries_spinBox
self.tries_spinBox = QSpinBox(self.layoutWidget)
self.tries_spinBox.setMinimum(1)
self.horizontalLayout_5.addWidget(self.tries_spinBox)
self.download_options_verticalLayout.addLayout(self.horizontalLayout_5)
self.horizontalLayout_4 = QHBoxLayout()
# wait_label
self.wait_label = QLabel(self.layoutWidget)
self.horizontalLayout_4.addWidget(self.wait_label)
# wait_spinBox
self.wait_spinBox = QSpinBox(self.layoutWidget)
self.horizontalLayout_4.addWidget(self.wait_spinBox)
self.download_options_verticalLayout.addLayout(self.horizontalLayout_4)
self.horizontalLayout_3 = QHBoxLayout()
# time_out_label
self.time_out_label = QLabel(self.layoutWidget)
self.horizontalLayout_3.addWidget(self.time_out_label)
# time_out_spinBox
self.time_out_spinBox = QSpinBox(self.layoutWidget)
self.horizontalLayout_3.addWidget(self.time_out_spinBox)
self.download_options_verticalLayout.addLayout(self.horizontalLayout_3)
self.horizontalLayout_2 = QHBoxLayout()
# connections_label
self.connections_label = QLabel(self.layoutWidget)
self.horizontalLayout_2.addWidget(self.connections_label)
# connections_spinBox
self.connections_spinBox = QSpinBox(self.layoutWidget)
self.connections_spinBox.setMinimum(1)
self.connections_spinBox.setMaximum(16)
self.horizontalLayout_2.addWidget(self.connections_spinBox)
self.download_options_verticalLayout.addLayout(self.horizontalLayout_2)
# rpc_port_label
self.rpc_port_label = QLabel(self.layoutWidget)
self.rpc_horizontalLayout = QHBoxLayout()
self.rpc_horizontalLayout.addWidget(self.rpc_port_label)
# rpc_port_spinbox
self.rpc_port_spinbox = QSpinBox(self.layoutWidget)
self.rpc_port_spinbox.setMinimum(1024)
self.rpc_port_spinbox.setMaximum(65535)
self.rpc_horizontalLayout.addWidget(self.rpc_port_spinbox)
self.download_options_verticalLayout.addLayout(
self.rpc_horizontalLayout)
# wait_queue
wait_queue_horizontalLayout = QHBoxLayout()
self.wait_queue_label = QLabel(self.layoutWidget)
wait_queue_horizontalLayout.addWidget(self.wait_queue_label)
self.wait_queue_time = QDateTimeEdit(self.layoutWidget)
self.wait_queue_time.setDisplayFormat('H:mm')
wait_queue_horizontalLayout.addWidget(self.wait_queue_time)
self.download_options_verticalLayout.addLayout(
wait_queue_horizontalLayout)
# change aria2 path
aria2_path_verticalLayout = QVBoxLayout()
self.aria2_path_checkBox = QCheckBox(self.layoutWidget)
aria2_path_verticalLayout.addWidget(self.aria2_path_checkBox)
aria2_path_horizontalLayout = QHBoxLayout()
self.aria2_path_lineEdit = QLineEdit(self.layoutWidget)
aria2_path_horizontalLayout.addWidget(self.aria2_path_lineEdit)
self.aria2_path_pushButton = QPushButton(self.layoutWidget)
aria2_path_horizontalLayout.addWidget(self.aria2_path_pushButton)
aria2_path_verticalLayout.addLayout(aria2_path_horizontalLayout)
self.download_options_verticalLayout.addLayout(
aria2_path_verticalLayout)
self.setting_tabWidget.addTab(self.download_options_tab, "")
# save_as_tab
self.save_as_tab = QWidget()
self.layoutWidget1 = QWidget(self.save_as_tab)
self.save_as_verticalLayout = QVBoxLayout(self.layoutWidget1)
self.save_as_verticalLayout.setContentsMargins(20, 30, 0, 0)
self.download_folder_horizontalLayout = QHBoxLayout()
# download_folder_label
self.download_folder_label = QLabel(self.layoutWidget1)
self.download_folder_horizontalLayout.addWidget(
self.download_folder_label)
# download_folder_lineEdit
self.download_folder_lineEdit = QLineEdit(self.layoutWidget1)
self.download_folder_horizontalLayout.addWidget(
self.download_folder_lineEdit)
# download_folder_pushButton
self.download_folder_pushButton = QPushButton(self.layoutWidget1)
self.download_folder_horizontalLayout.addWidget(
self.download_folder_pushButton)
self.save_as_verticalLayout.addLayout(
self.download_folder_horizontalLayout)
self.temp_horizontalLayout = QHBoxLayout()
# temp_download_label
self.temp_download_label = QLabel(self.layoutWidget1)
self.temp_horizontalLayout.addWidget(self.temp_download_label)
# temp_download_lineEdit
self.temp_download_lineEdit = QLineEdit(self.layoutWidget1)
self.temp_horizontalLayout.addWidget(self.temp_download_lineEdit)
# temp_download_pushButton
self.temp_download_pushButton = QPushButton(self.layoutWidget1)
self.temp_horizontalLayout.addWidget(self.temp_download_pushButton)
self.save_as_verticalLayout.addLayout(self.temp_horizontalLayout)
# create subfolder checkBox
self.subfolder_checkBox = QCheckBox(self.layoutWidget1)
self.save_as_verticalLayout.addWidget(self.subfolder_checkBox)
self.setting_tabWidget.addTab(self.save_as_tab, "")
# notifications_tab
self.notifications_tab = QWidget()
self.layoutWidget2 = QWidget(self.notifications_tab)
self.verticalLayout_4 = QVBoxLayout(self.layoutWidget2)
self.verticalLayout_4.setContentsMargins(21, 21, 0, 0)
# enable_notifications_checkBox
self.enable_notifications_checkBox = QCheckBox(self.layoutWidget2)
self.verticalLayout_4.addWidget(self.enable_notifications_checkBox)
# sound_frame
self.sound_frame = QFrame(self.layoutWidget2)
self.sound_frame.setFrameShape(QFrame.StyledPanel)
self.sound_frame.setFrameShadow(QFrame.Raised)
self.verticalLayout = QVBoxLayout(self.sound_frame)
# volume_label
self.volume_label = QLabel(self.sound_frame)
self.verticalLayout.addWidget(self.volume_label)
# volume_dial
self.volume_dial = QDial(self.sound_frame)
self.volume_dial.setProperty("value", 100)
self.verticalLayout.addWidget(self.volume_dial)
self.verticalLayout_4.addWidget(self.sound_frame)
self.setting_tabWidget.addTab(self.notifications_tab, "")
# style_tab
self.style_tab = QWidget()
self.layoutWidget3 = QWidget(self.style_tab)
self.verticalLayout_3 = QVBoxLayout(self.layoutWidget3)
self.verticalLayout_3.setContentsMargins(21, 21, 0, 0)
self.horizontalLayout_8 = QHBoxLayout()
# style_label
self.style_label = QLabel(self.layoutWidget3)
self.horizontalLayout_8.addWidget(self.style_label)
# style_comboBox
self.style_comboBox = QComboBox(self.layoutWidget3)
self.horizontalLayout_8.addWidget(self.style_comboBox)
self.verticalLayout_3.addLayout(self.horizontalLayout_8)
self.horizontalLayout_7 = QHBoxLayout()
# language_combox
self.lang_label = QLabel(self.layoutWidget3)
self.horizontalLayout_7.addWidget(self.lang_label)
self.lang_comboBox = QComboBox(self.layoutWidget3)
self.horizontalLayout_7.addWidget(self.lang_comboBox)
# language_label
self.verticalLayout_3.addLayout(self.horizontalLayout_7)
self.horizontalLayout_7 = QHBoxLayout()
self.lang_label.setText(
QCoreApplication.translate("setting_ui_tr", "Language:"))
# color_label
self.color_label = QLabel(self.layoutWidget3)
self.horizontalLayout_7.addWidget(self.color_label)
# color_comboBox
self.color_comboBox = QComboBox(self.layoutWidget3)
self.horizontalLayout_7.addWidget(self.color_comboBox)
self.verticalLayout_3.addLayout(self.horizontalLayout_7)
# icon_label
self.horizontalLayout_12 = QHBoxLayout()
self.icon_label = QLabel(self.layoutWidget3)
self.horizontalLayout_12.addWidget(self.icon_label)
# icon_comboBox
self.icon_comboBox = QComboBox(self.layoutWidget3)
self.horizontalLayout_12.addWidget(self.icon_comboBox)
self.verticalLayout_3.addLayout(self.horizontalLayout_12)
# icons_size_comboBox
self.icons_size_horizontalLayout = QHBoxLayout()
self.icons_size_label = QLabel(self.layoutWidget3)
self.icons_size_horizontalLayout.addWidget(self.icons_size_label)
self.icons_size_comboBox = QComboBox(self.layoutWidget3)
self.icons_size_horizontalLayout.addWidget(self.icons_size_comboBox)
self.verticalLayout_3.addLayout(self.icons_size_horizontalLayout)
self.horizontalLayout_6 = QHBoxLayout()
# notification_label
self.horizontalLayout_13 = QHBoxLayout()
self.notification_label = QLabel(self.layoutWidget3)
self.horizontalLayout_13.addWidget(self.notification_label)
# notification_comboBox
self.notification_comboBox = QComboBox(self.layoutWidget3)
self.horizontalLayout_13.addWidget(self.notification_comboBox)
self.verticalLayout_3.addLayout(self.horizontalLayout_13)
# font_checkBox
self.font_checkBox = QCheckBox(self.layoutWidget3)
self.horizontalLayout_6.addWidget(self.font_checkBox)
# fontComboBox
self.fontComboBox = QFontComboBox(self.layoutWidget3)
self.horizontalLayout_6.addWidget(self.fontComboBox)
# font_size_label
self.font_size_label = QLabel(self.layoutWidget3)
self.horizontalLayout_6.addWidget(self.font_size_label)
# font_size_spinBox
self.font_size_spinBox = QSpinBox(self.layoutWidget3)
self.font_size_spinBox.setMinimum(1)
self.horizontalLayout_6.addWidget(self.font_size_spinBox)
self.verticalLayout_3.addLayout(self.horizontalLayout_6)
self.setting_tabWidget.addTab(self.style_tab, "")
self.verticalLayout_2.addWidget(self.setting_tabWidget)
self.horizontalLayout = QHBoxLayout()
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
# Enable system tray icon
self.enable_system_tray_checkBox = QCheckBox(self.layoutWidget3)
self.verticalLayout_3.addWidget(self.enable_system_tray_checkBox)
# after_download dialog
self.after_download_checkBox = QCheckBox()
self.verticalLayout_3.addWidget(self.after_download_checkBox)
# show_menubar_checkbox
self.show_menubar_checkbox = QCheckBox()
self.verticalLayout_3.addWidget(self.show_menubar_checkbox)
# show_sidepanel_checkbox
self.show_sidepanel_checkbox = QCheckBox()
self.verticalLayout_3.addWidget(self.show_sidepanel_checkbox)
# hide progress window
self.show_progress_window_checkbox = QCheckBox()
self.verticalLayout_3.addWidget(self.show_progress_window_checkbox)
# add persepolis to startup
self.startup_checkbox = QCheckBox()
self.verticalLayout_3.addWidget(self.startup_checkbox)
# keep system awake
self.keep_awake_checkBox = QCheckBox()
self.verticalLayout_3.addWidget(self.keep_awake_checkBox)
# columns_tab
self.columns_tab = QWidget()
layoutWidget4 = QWidget(self.columns_tab)
column_verticalLayout = QVBoxLayout(layoutWidget4)
column_verticalLayout.setContentsMargins(21, 21, 0, 0)
# creating checkBox for columns
self.show_column_label = QLabel()
self.column0_checkBox = QCheckBox()
self.column1_checkBox = QCheckBox()
self.column2_checkBox = QCheckBox()
self.column3_checkBox = QCheckBox()
self.column4_checkBox = QCheckBox()
self.column5_checkBox = QCheckBox()
self.column6_checkBox = QCheckBox()
self.column7_checkBox = QCheckBox()
self.column10_checkBox = QCheckBox()
self.column11_checkBox = QCheckBox()
self.column12_checkBox = QCheckBox()
column_verticalLayout.addWidget(self.show_column_label)
column_verticalLayout.addWidget(self.column0_checkBox)
column_verticalLayout.addWidget(self.column1_checkBox)
column_verticalLayout.addWidget(self.column2_checkBox)
column_verticalLayout.addWidget(self.column3_checkBox)
column_verticalLayout.addWidget(self.column4_checkBox)
column_verticalLayout.addWidget(self.column5_checkBox)
column_verticalLayout.addWidget(self.column6_checkBox)
column_verticalLayout.addWidget(self.column7_checkBox)
column_verticalLayout.addWidget(self.column10_checkBox)
column_verticalLayout.addWidget(self.column11_checkBox)
column_verticalLayout.addWidget(self.column12_checkBox)
self.setting_tabWidget.addTab(self.columns_tab, '')
# video_finder_tab
self.video_finder_tab = QWidget()
self.layoutWidgetYTD = QWidget(self.video_finder_tab)
self.video_finder_layout = QVBoxLayout(self.layoutWidgetYTD)
self.video_finder_layout.setContentsMargins(20, 30, 0, 0)
self.video_finder_verticalLayout = QVBoxLayout()
# Whether to enable video link capturing.
self.enable_video_finder_checkbox = QCheckBox(self.layoutWidgetYTD)
self.video_finder_layout.addWidget(self.enable_video_finder_checkbox)
# If we should hide videos with no audio
self.hide_no_audio_checkbox = QCheckBox(self.layoutWidgetYTD)
self.video_finder_verticalLayout.addWidget(self.hide_no_audio_checkbox)
# If we should hide audios without video
self.hide_no_video_checkbox = QCheckBox(self.layoutWidgetYTD)
self.video_finder_verticalLayout.addWidget(self.hide_no_video_checkbox)
self.max_links_horizontalLayout = QHBoxLayout()
# max_links_label
self.max_links_label = QLabel(self.layoutWidgetYTD)
self.max_links_horizontalLayout.addWidget(self.max_links_label)
# max_links_spinBox
self.max_links_spinBox = QSpinBox(self.layoutWidgetYTD)
self.max_links_spinBox.setMinimum(1)
self.max_links_spinBox.setMaximum(16)
self.max_links_horizontalLayout.addWidget(self.max_links_spinBox)
self.video_finder_verticalLayout.addLayout(
self.max_links_horizontalLayout)
self.video_finder_dl_path_horizontalLayout = QHBoxLayout()
self.video_finder_frame = QFrame(self.video_finder_tab)
self.video_finder_frame.setLayout(self.video_finder_verticalLayout)
self.video_finder_layout.addWidget(self.video_finder_frame)
self.setting_tabWidget.addTab(self.video_finder_tab, "")
# defaults_pushButton
self.defaults_pushButton = QPushButton(self)
self.horizontalLayout.addWidget(self.defaults_pushButton)
# cancel_pushButton
self.cancel_pushButton = QPushButton(self)
self.cancel_pushButton.setIcon(QIcon(icons + 'remove'))
self.horizontalLayout.addWidget(self.cancel_pushButton)
# ok_pushButton
self.ok_pushButton = QPushButton(self)
self.ok_pushButton.setIcon(QIcon(icons + 'ok'))
self.horizontalLayout.addWidget(self.ok_pushButton)
self.verticalLayout_2.addLayout(self.horizontalLayout)
self.setting_tabWidget.setCurrentIndex(3)
self.setWindowTitle(
QCoreApplication.translate("setting_ui_tr", "Preferences"))
self.tries_label.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set number of tries if download failed.</p></body></html>"
))
self.tries_label.setText(
QCoreApplication.translate("setting_ui_tr", "Number of tries: "))
self.tries_spinBox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set number of tries if download failed.</p></body></html>"
))
self.wait_label.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set the seconds to wait between retries. Download manager will retry downloads when the HTTP server returns a 503 response.</p></body></html>"
))
self.wait_label.setText(
QCoreApplication.translate("setting_ui_tr",
"Wait between retries (seconds): "))
self.wait_spinBox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set the seconds to wait between retries. Download manager will retry downloads when the HTTP server returns a 503 response.</p></body></html>"
))
self.time_out_label.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set timeout in seconds. </p></body></html>"
))
self.time_out_label.setText(
QCoreApplication.translate("setting_ui_tr", "Timeout (seconds): "))
self.time_out_spinBox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Set timeout in seconds. </p></body></html>"
))
self.connections_label.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Using multiple connections can help speed up your download.</p></body></html>"
))
self.connections_label.setText(
QCoreApplication.translate("setting_ui_tr",
"Number of connections: "))
self.connections_spinBox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Using multiple connections can help speed up your download.</p></body></html>"
))
self.rpc_port_label.setText(
QCoreApplication.translate("setting_ui_tr", "RPC port number: "))
self.rpc_port_spinbox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p> Specify a port number for JSON-RPC/XML-RPC server to listen to. Possible Values: 1024 - 65535 Default: 6801 </p></body></html>"
))
self.wait_queue_label.setText(
QCoreApplication.translate(
"setting_ui_tr", 'Wait between every downloads in queue:'))
self.aria2_path_checkBox.setText(
QCoreApplication.translate("setting_ui_tr",
'Change Aria2 default path'))
self.aria2_path_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", 'Change'))
aria2_path_tooltip = QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Attention: Wrong path may have caused problem! Do it carefully or don't change default setting!</p></body></html>"
)
self.aria2_path_checkBox.setToolTip(aria2_path_tooltip)
self.aria2_path_lineEdit.setToolTip(aria2_path_tooltip)
self.aria2_path_pushButton.setToolTip(aria2_path_tooltip)
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.download_options_tab),
QCoreApplication.translate("setting_ui_tr", "Download Options"))
self.download_folder_label.setText(
QCoreApplication.translate("setting_ui_tr", "Download Folder: "))
self.download_folder_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", "Change"))
self.temp_download_label.setText(
QCoreApplication.translate("setting_ui_tr",
"Temporary Download Folder: "))
self.temp_download_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", "Change"))
self.subfolder_checkBox.setText(
QCoreApplication.translate(
"setting_ui_tr",
"Create subfolders for Music,Videos,... in default download folder"
))
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.save_as_tab),
QCoreApplication.translate("setting_ui_tr", "Save as"))
self.enable_notifications_checkBox.setText(
QCoreApplication.translate("setting_ui_tr",
"Enable notification sounds"))
self.volume_label.setText(
QCoreApplication.translate("setting_ui_tr", "Volume: "))
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.notifications_tab),
QCoreApplication.translate("setting_ui_tr", "Notifications"))
self.style_label.setText(
QCoreApplication.translate("setting_ui_tr", "Style: "))
self.color_label.setText(
QCoreApplication.translate("setting_ui_tr", "Color scheme: "))
self.icon_label.setText(
QCoreApplication.translate("setting_ui_tr", "Icons: "))
self.icons_size_label.setText(
QCoreApplication.translate("setting_ui_tr",
"Toolbar's icons size: "))
self.notification_label.setText(
QCoreApplication.translate("setting_ui_tr", "Notification type: "))
self.font_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", "Font: "))
self.font_size_label.setText(
QCoreApplication.translate("setting_ui_tr", "Size: "))
self.enable_system_tray_checkBox.setText(
QCoreApplication.translate("setting_ui_tr",
"Enable system tray icon."))
self.after_download_checkBox.setText(
QCoreApplication.translate(
"setting_ui_tr",
"Show download complete dialog when download has finished."))
self.show_menubar_checkbox.setText(
QCoreApplication.translate("setting_ui_tr", "Show menubar."))
self.show_sidepanel_checkbox.setText(
QCoreApplication.translate("setting_ui_tr", "Show side panel."))
self.show_progress_window_checkbox.setText(
QCoreApplication.translate("setting_ui_tr",
"Show download's progress window"))
self.startup_checkbox.setText(
QCoreApplication.translate("setting_ui_tr",
"Run Persepolis at startup"))
self.keep_awake_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", "Keep system awake!"))
self.keep_awake_checkBox.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>This option is preventing system from going to sleep.\
This is necessary if your power manager is suspending system automatically. </p></body></html>"
))
self.wait_queue_time.setToolTip(
QCoreApplication.translate(
"setting_ui_tr",
"<html><head/><body><p>Format HH:MM</p></body></html>"))
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.style_tab),
QCoreApplication.translate("setting_ui_tr", "Preferences"))
# columns_tab
self.show_column_label.setText(
QCoreApplication.translate("setting_ui_tr", 'Show this columns:'))
self.column0_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'File Name'))
self.column1_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Status'))
self.column2_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Size'))
self.column3_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Downloaded'))
self.column4_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Percentage'))
self.column5_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Connections'))
self.column6_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Transfer rate'))
self.column7_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Estimated time left'))
self.column10_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'First try date'))
self.column11_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Last try date'))
self.column12_checkBox.setText(
QCoreApplication.translate("setting_ui_tr", 'Category'))
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.columns_tab),
QCoreApplication.translate("setting_ui_tr",
"Columns customization"))
# Video Finder options tab
self.setting_tabWidget.setTabText(
self.setting_tabWidget.indexOf(self.video_finder_tab),
QCoreApplication.translate("setting_ui_tr",
"Video Finder Options"))
self.enable_video_finder_checkbox.setText(
QCoreApplication.translate("setting_ui_tr", 'Enable Video Finder'))
self.hide_no_audio_checkbox.setText(
QCoreApplication.translate("setting_ui_tr",
'Hide videos with no audio'))
self.hide_no_video_checkbox.setText(
QCoreApplication.translate("setting_ui_tr",
'Hide audios with no video'))
self.max_links_label.setText(
QCoreApplication.translate(
"setting_ui_tr", 'Maximum number of links to capture:<br/>'
'<small>(If browser sends multiple video links at a time)</small>'
))
# window buttons
self.defaults_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", "Defaults"))
self.cancel_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", "Cancel"))
self.ok_pushButton.setText(
QCoreApplication.translate("setting_ui_tr", "OK"))
class Display(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle('Display Player')
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setMinimumWidth(800)
self.displayGrid = QGridLayout()
self.img = self.images()
# display team image and position image
self.teamImgLbl = QLabel(self)
self.teamImage = QPixmap('Images/Teams/shield.png')
self.teamImgLbl.setPixmap(self.teamImage)
# this work???
self.teamImgLbl.setStyleSheet('padding-left: 100px')
self.posLabel = QLabel(self)
self.posLabel.setPixmap(self.img['Football'])
self.displayGrid.addWidget(self.posLabel, 0, 2, 1, 2)
self.displayGrid.addWidget(self.teamImgLbl, 0, 0, 1, 2)
# Player stat labels, blank initially
self.nameFrame = QFrame()
nameHBox = QHBoxLayout()
nameFont = QFont("Times", 40, QFont.Bold)
self.nameLbl = QLabel()
self.nameLbl.setStyleSheet("""
QLabel {
color: rgb(0, 128, 255);
}
""")
self.nameLbl.setFont(nameFont)
nameHBox.addWidget(self.nameLbl)
self.teamLbl = QLabel()
self.teamLbl.setStyleSheet("""
QLabel {
color: rgb(204, 0, 0);
padding-left: 20px
}
""")
self.teamLbl.setFont(nameFont)
nameHBox.addWidget(self.teamLbl)
self.nameFrame.setLayout(nameHBox)
self.displayGrid.addWidget(self.nameFrame, 1, 0, 1, 4)
# dictionary used to name labels and position labels on grid
self.titleLbl = {}
self.statLbl = {}
self.projTitle = {}
self.projStat = {}
lblNum = {
'1': 2,
'2': 3,
'3': 4,
'4': 5,
'5': 6,
'6': 7,
'7': 8,
'8': 9,
'9': 10,
'10': 11,
'11': 12,
'12': 13
}
statFont = QFont('Times', 15)
for num, row in lblNum.items():
self.titleLbl[num] = QLabel()
self.statLbl[num] = QLabel()
self.projTitle[num] = QLabel()
self.projStat[num] = QLabel()
self.titleLbl[num].setGeometry(0, 0, 25, 25)
self.statLbl[num].setGeometry(0, 0, 15, 25)
self.titleLbl[num].setFont(statFont)
self.statLbl[num].setFont(statFont)
self.projTitle[num].setFont(statFont)
self.projStat[num].setFont(statFont)
self.statLbl[num].setStyleSheet("padding-left: 10px")
self.displayGrid.addWidget(self.titleLbl[num], row, 0)
self.displayGrid.addWidget(self.statLbl[num], row, 1)
self.displayGrid.addWidget(self.projTitle[num], row, 2)
self.displayGrid.addWidget(self.projStat[num], row, 3)
# TODO upload 2020 projected stats here
# for i in range(2, 5):
# self.projTitle[str(i)].setText("2020 Label")
# self.projStat[str(i)].setText("2020 Projected Stat")
# hidden labels, used to hold index of player
self.position = QLabel()
self.posNum = QLabel()
self.setLayout(self.displayGrid)
self.resize(500, 800)
self.show()
# definition accepts key word arguments from PlayerData.py, iterates through dictionary, places data in specified
# labels on display frame
def displayPlayer(self, **kwargs):
self.clearDisplay()
i = 1
for key in kwargs:
if key == 'Pos':
self.posLabel.setPixmap(self.img[kwargs[key]])
self.position.setText(kwargs[key])
continue
if key == 'PosNum':
self.posNum.setText(kwargs[key])
continue
if key == 'Name':
self.nameLbl.setText(kwargs['Name'])
continue
if key == 'Team':
self.teamLbl.setText(kwargs['Team'])
self.teamImgLbl.setPixmap(self.img[kwargs[key]])
else:
self.titleLbl[str(i)].setText(key)
self.statLbl[str(i)].setText(kwargs[key])
i += 1
self.update()
# definition creates dictionary of images used in Display frame, returns dictionary
def images(self):
imgFootball = QPixmap('Images/football.jpg')
imgQB = QPixmap('Images/QB.jpg')
imgRB = QPixmap('Images/RB.jpg')
imgWR = QPixmap('Images/WR.jpg')
imgTE = QPixmap('Images/TE.jpg')
imgK = QPixmap('Images/K.jpg')
imgDEF = QPixmap('Images/DEF.jpg')
nan = QPixmap("Images/Teams/shield.png")
img = {
'Football': imgFootball,
'QB': imgQB,
'RB': imgRB,
'WR': imgWR,
'TE': imgTE,
'K': imgK,
'DEF': imgDEF,
'nan': nan,
}
path = r'Images/Teams'
for filename in os.listdir(path):
if filename.endswith(".png"):
fileSplit = filename.split('.')
name = fileSplit[0]
logo = QPixmap(os.path.join(path, filename))
img[name] = logo
return img
# clears display frame
def clearDisplay(self):
self.posLabel.setPixmap(self.img['Football'])
self.teamImgLbl.setPixmap(self.img['nan'])
self.nameLbl.setText('')
self.teamLbl.setText('')
for i in range(1, 13):
self.titleLbl[str(i)].setText('')
self.statLbl[str(i)].setText('')
class GcodeEditor(QWidget, _HalWidgetBase):
percentDone = pyqtSignal(int)
def __init__(self, parent=None):
super(GcodeEditor, self).__init__(parent)
self.load_dialog_code = 'LOAD'
self.save_dialog_code = 'SAVE'
STATUS.connect('general', self.returnFromDialog)
self.isCaseSensitive = 0
self.setMinimumSize(QSize(300, 200))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0, 0, 0, 0)
self.setLayout(lay)
# make editor
self.editor = GcodeDisplay(self)
# class patch editor's function to ours
# so we get the lines percent update
self.editor.emit_percent = self.emit_percent
self.editor.setReadOnly(True)
self.editor.setModified(False)
################################
# add menubar actions
################################
# Create new action
newAction = QAction(QIcon.fromTheme('document-new'), 'New', self)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('New document')
newAction.triggered.connect(self.newCall)
# Create open action
openAction = QAction(QIcon.fromTheme('document-open'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open document')
openAction.triggered.connect(self.openCall)
# Create save action
saveAction = QAction(QIcon.fromTheme('document-save'), '&save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('save document')
saveAction.triggered.connect(self.saveCall)
# Create exit action
exitAction = QAction(QIcon.fromTheme('application-exit'), '&Exit',
self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create gcode lexer action
gCodeLexerAction = QAction(QIcon.fromTheme('lexer.png'),
'&Gcode\n lexer', self)
gCodeLexerAction.setCheckable(1)
gCodeLexerAction.setShortcut('Ctrl+G')
gCodeLexerAction.setStatusTip('Set Gcode highlighting')
gCodeLexerAction.triggered.connect(self.gcodeLexerCall)
# Create gcode lexer action
pythonLexerAction = QAction(QIcon.fromTheme('lexer.png'),
'&python\n lexer', self)
pythonLexerAction.setShortcut('Ctrl+P')
pythonLexerAction.setStatusTip('Set Python highlighting')
pythonLexerAction.triggered.connect(self.pythonLexerCall)
# Create toolbar and add action
toolBar = QToolBar('File')
toolBar.addAction(newAction)
toolBar.addAction(openAction)
toolBar.addAction(saveAction)
toolBar.addAction(exitAction)
toolBar.addSeparator()
# add lexer actions
toolBar.addAction(gCodeLexerAction)
toolBar.addAction(pythonLexerAction)
toolBar.addSeparator()
toolBar.addWidget(
QLabel(
'<html><head/><body><p><span style=" font-size:20pt; font-weight:600;">Edit Mode</span></p></body></html>'
))
# create a frame for buttons
box = QHBoxLayout()
box.addWidget(toolBar)
self.topMenu = QFrame()
self.topMenu.setLayout(box)
# add widgets
lay.addWidget(self.topMenu)
lay.addWidget(self.editor)
lay.addWidget(self.createGroup())
self.readOnlyMode()
def createGroup(self):
self.bottomMenu = QFrame()
self.searchText = QLineEdit(self)
self.replaceText = QLineEdit(self)
toolBar = QToolBar()
# Create new action
undoAction = QAction(QIcon.fromTheme('edit-undo'), 'Undo', self)
undoAction.setStatusTip('Undo')
undoAction.triggered.connect(self.undoCall)
toolBar.addAction(undoAction)
# create redo action
redoAction = QAction(QIcon.fromTheme('edit-redo'), 'Redo', self)
redoAction.setStatusTip('Undo')
redoAction.triggered.connect(self.redoCall)
toolBar.addAction(redoAction)
toolBar.addSeparator()
# create replace action
replaceAction = QAction(QIcon.fromTheme('edit-find-replace'),
'Replace', self)
replaceAction.triggered.connect(self.replaceCall)
toolBar.addAction(replaceAction)
# create find action
findAction = QAction(QIcon.fromTheme('edit-find'), 'Find', self)
findAction.triggered.connect(self.findCall)
toolBar.addAction(findAction)
# create next action
nextAction = QAction(QIcon.fromTheme('go-previous'), 'Find Previous',
self)
nextAction.triggered.connect(self.nextCall)
toolBar.addAction(nextAction)
toolBar.addSeparator()
# create case action
caseAction = QAction(QIcon.fromTheme('edit-case'), 'Aa', self)
caseAction.setCheckable(1)
caseAction.triggered.connect(self.caseCall)
toolBar.addAction(caseAction)
box = QHBoxLayout()
box.addWidget(toolBar)
box.addWidget(self.searchText)
box.addWidget(self.replaceText)
box.addStretch(1)
self.bottomMenu.setLayout(box)
return self.bottomMenu
# callback functions built for easy class patching ##########
# want to refrain from renaming these functions as it will break
# any class patch user's use
# we split them like this so a user can intercept the callback
# but still call the original functionality
def caseCall(self):
self.case()
def case(self):
self.isCaseSensitive -= 1
self.isCaseSensitive *= -1
print self.isCaseSensitive
def exitCall(self):
self.exit()
def exit(self):
if self.editor.isModified():
result = self.killCheck()
if result:
self.readOnlyMode()
def findCall(self):
self.find()
def find(self):
self.editor.search(str(self.searchText.text()),
re=False,
case=self.isCaseSensitive,
word=False,
wrap=False,
fwd=True)
def gcodeLexerCall(self):
self.gcodeLexer()
def gcodeLexer(self):
self.editor.set_gcode_lexer()
def nextCall(self):
self.next()
def next(self):
self.editor.search(str(self.searchText.text()), False)
self.editor.search_Next()
def newCall(self):
self.new()
def new(self):
if self.editor.isModified():
result = self.killCheck()
if result:
self.editor.new_text()
def openCall(self):
self.open()
def open(self):
self.getFileName()
def openReturn(self, f):
ACTION.OPEN_PROGRAM(f)
self.editor.setModified(False)
def pythonLexerCall(self):
self.pythonLexer()
def pythonLexer(self):
self.editor.set_python_lexer()
def redoCall(self):
self.redo()
def redo(self):
self.editor.redo()
def replaceCall(self):
self.replace()
def replace(self):
self.editor.replace_text(str(self.replaceText.text()))
def saveCall(self):
self.save()
def save(self):
self.getSaveFileName()
def saveReturn(self, fname):
ACTION.SAVE_PROGRAM(self.editor.text(), fname)
self.editor.setModified(False)
ACTION.OPEN_PROGRAM(fname)
def undoCall(self):
self.undo()
def undo(self):
self.editor.undo()
# helper functions ############################################
def _hal_init(self):
# name the top and bottom frames so it's easier to style
self.bottomMenu.setObjectName('%sBottomButtonFrame' %
self.objectName())
self.topMenu.setObjectName('%sTopButtonFrame' % self.objectName())
def editMode(self):
self.topMenu.show()
self.bottomMenu.show()
self.editor.setReadOnly(False)
def readOnlyMode(self):
self.topMenu.hide()
self.bottomMenu.hide()
self.editor.setReadOnly(True)
def getFileName(self):
mess = {
'NAME': self.load_dialog_code,
'ID': '%s__' % self.objectName(),
'TITLE': 'Load Editor'
}
STATUS.emit('dialog-request', mess)
def getSaveFileName(self):
mess = {
'NAME': self.save_dialog_code,
'ID': '%s__' % self.objectName(),
'TITLE': 'Save Editor'
}
STATUS.emit('dialog-request', mess)
# process the STATUS return message
def returnFromDialog(self, w, message):
if message.get('NAME') == self.load_dialog_code:
path = message.get('RETURN')
code = bool(message.get('ID') == '%s__' % self.objectName())
if path and code:
self.openReturn(path)
elif message.get('NAME') == self.save_dialog_code:
path = message.get('RETURN')
code = bool(message.get('ID') == '%s__' % self.objectName())
if path and code:
self.saveReturn(path)
def killCheck(self):
choice = QMessageBox.question(
self, 'Warning!!',
"This file has changed since loading...Still want to proceed?",
QMessageBox.Yes | QMessageBox.No)
if choice == QMessageBox.Yes:
return True
else:
return False
def emit_percent(self, percent):
self.percentDone.emit(percent)
# designer recognized getter/setters
# auto_show_mdi status
# These adjust the self.editor instance
def set_auto_show_mdi(self, data):
self.editor.auto_show_mdi = data
def get_auto_show_mdi(self):
return self.editor.auto_show_mdi
def reset_auto_show_mdi(self):
self.editor.auto_show_mdi = True
auto_show_mdi_status = pyqtProperty(bool, get_auto_show_mdi,
set_auto_show_mdi, reset_auto_show_mdi)
def initUI(self):
self.setWindowTitle( self.default_title )
layout = QVBoxLayout()
self.setLayout(layout)
# 'File' button bar
file_group = QFrame()
layout.addWidget(file_group)
file_layout = QHBoxLayout()
file_group.setLayout( file_layout )
new = QPushButton('New')
new.clicked.connect(self.new_design)
file_layout.addWidget(new)
open = QPushButton('Open...')
open.clicked.connect(self.open_home)
file_layout.addWidget(open)
open = QPushButton('Load Example...')
open.clicked.connect(self.load_example)
file_layout.addWidget(open)
save = QPushButton('Save')
save.clicked.connect(self.save)
file_layout.addWidget(save)
saveas = QPushButton('Save As...')
saveas.clicked.connect(self.saveas)
file_layout.addWidget(saveas)
quit = QPushButton('Quit')
quit.clicked.connect(self.quit)
file_layout.addWidget(quit)
file_layout.addStretch(1)
# Main work area
self.tabs = QTabWidget()
layout.addWidget( self.tabs )
self.overview = Overview(changefunc=self.onChange)
self.tabs.addTab( self.overview.get_widget(), "Overview" );
# 'Command' button bar
cmd_group = QFrame()
layout.addWidget(cmd_group)
cmd_layout = QHBoxLayout()
cmd_group.setLayout( cmd_layout )
cmd_layout.addWidget( QLabel("<b>Design Tools:</b> ") )
add_wing = QPushButton('Add Wing...')
add_wing.clicked.connect(self.add_wing)
cmd_layout.addWidget(add_wing)
#add_fuse = QPushButton('Add Fuselage...')
#add_fuse.clicked.connect(self.add_fuse)
#cmd_layout.addWidget(add_fuse)
fast_build = QPushButton('Fast Build...')
fast_build.clicked.connect(self.build_fast)
cmd_layout.addWidget(fast_build)
detail_build = QPushButton('Detail Build...')
detail_build.clicked.connect(self.build_detail)
cmd_layout.addWidget(detail_build)
view3d = QPushButton('View 3D')
view3d.clicked.connect(self.view3d)
cmd_layout.addWidget(view3d)
cmd_layout.addStretch(1)
self.resize(800, 700)
self.show()
spectrogram = Spectrogram(data)
pixmap = QPixmap.fromImage(spectrogram.create_spectrogram_image(transpose=True))
scene.setSceneRect(scene.sceneRect().adjusted(0, 0, 0, pixmap.height()))
item = scene.addPixmap(pixmap)
item.setPos(x_pos, y_pos)
y_pos += pixmap.height()
graphic_view.fitInView(scene.sceneRect())
status_label.setText("Height: {0:.0f} // Speed: {1:.2f} // Total Time: {2:.2f}".format(scene.sceneRect().height(),
1/(time.time()-speed),
time.time()-t))
QApplication.instance().processEvents()
if __name__ == '__main__':
global graphic_view, status_label
app = QApplication(["spectrum"])
widget = QFrame()
layout = QVBoxLayout()
graphic_view = QGraphicsView()
layout.addWidget(graphic_view)
status_label = QLabel()
layout.addWidget(status_label)
btn = QPushButton("Go")
layout.addWidget(btn)
btn.clicked.connect(go)
widget.setLayout(layout)
widget.showMaximized()
app.exec_()
class CustomMainWindow(QMainWindow):
def __init__(self):
super(CustomMainWindow, self).__init__()
# Create Stock DataFrame
try:
data = pd.read_csv(path_to_temp('stocks.txt'), sep='\t', header=None)
except:
data = pd.DataFrame(columns=["name", "price", "number"])
data.columns = ["name", "price", "number"]
self.stockFrame = pd.DataFrame(data)
# Define the geometry of the main window
self.setGeometry(300, 300, 800, 700)
self.setWindowTitle("Stock Sim")
# self.setWindowTitle(path_to_temp(""))
# Create FRAME_A
self.FRAME_A = QFrame(self)
self.FRAME_A.setStyleSheet("QWidget { background-color: %s }" % QtGui.QColor(210,210,235,255).name())
self.setCentralWidget(self.FRAME_A)
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.FRAME_A.setLayout(self.horizontalLayout)
# # Create FRAME_B
self.LAYOUT_Left = QtWidgets.QVBoxLayout()
self.horizontalLayout.addLayout(self.LAYOUT_Left)
# # Place the zoom In button
self.zoomInBtn = QPushButton(text = 'Zoom In')
setCustomSize(self.zoomInBtn, 100, 50)
self.zoomOutBtn = QPushButton(text = 'Zoom Out')
setCustomSize(self.zoomOutBtn, 100, 50)
self.zoomInBtn.clicked.connect(self.zoomInBtnAction)
self.zoomOutBtn.clicked.connect(self.zoomOutBtnAction)
self.LAYOUT_Left.addWidget(self.zoomInBtn)
self.LAYOUT_Left.addWidget(self.zoomOutBtn)
# # Place the matplotlib figure
self.myFig = CustomFigCanvas(self.stockFrame)
self.horizontalLayout.addWidget(self.myFig)
# # Add other windows
print("sdfg")
self.transactionWindow = transactionWindow(self.stockFrame)
self.stocksWindow = stocksWindow(self.stockFrame)
# # Add menu bar
mainMenu = self.menuBar()
mainMenu.setNativeMenuBar(False)
fileMenu = mainMenu.addMenu("File")
viewMenu = mainMenu.addMenu("View")
viewActionRecordTransaction = QAction("View Transaction", self, checkable = True)
viewActionRecordTransaction.setStatusTip("View Transaction Window")
viewActionRecordTransaction.setChecked(False)
viewActionRecordTransaction.triggered.connect(self.toggleViewRecordTransaction)
viewActionStocks = QAction("View Stocks", self, checkable = True)
viewActionStocks.setStatusTip("View Stocks Window")
viewActionStocks.setChecked(False)
viewActionStocks.triggered.connect(self.toggleViewStocks)
viewMenu.addAction(viewActionRecordTransaction)
viewMenu.addAction(viewActionStocks)
# Add status bar
self.statusbar = self.statusBar()
# Add the callbackfunc to ..
myDataLoop = threading.Thread(name = 'myDataLoop', target = dataSendLoop, daemon = True, args = (self.addData_callbackFunc,self.stockFrame,))
myDataLoop.start()
self.show()
''''''
def toggleViewRecordTransaction(self, state):
if state:
self.transactionWindow.show()
self.statusbar.showMessage("On")
else:
self.transactionWindow.hide()
self.statusbar.showMessage("Off")
''''''
def toggleViewStocks(self, state):
if state:
self.stocksWindow.show()
self.statusbar.showMessage("On")
else:
self.stocksWindow.hide()
self.statusbar.showMessage("Off")
''''''
def zoomInBtnAction(self):
# print("zoom in")
self.myFig.zoomIn(5)
''''''
def zoomOutBtnAction(self):
# print("zoom out")
self.myFig.zoomOut(5)
''''''
def addData_callbackFunc(self, value):
# print("Add data: " + str(value))
self.myFig.addData(value)
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()
def _updateLayout(self, node):
layout = self._layout
# Meta Args
meta_args = node.params.get('meta_args')
if meta_args and self._show_meta:
meta_arg_data = node.params_info["meta_args"]
# Create container
if self._show_compact:
this_layout = layout
else:
box = QFrame()
box.setFrameShape(QFrame.StyledPanel)
this_layout = QFormLayout()
box.setLayout(this_layout)
layout.addRow(self.tr("Meta Args"), box)
for name, value in meta_args.items():
try:
inspector_option = meta_arg_data[name]
# This happens with hidden args passed to factory (currently only exists for meta args
# [hive.pull/push in/out])
# Hidden args means that the inspector didn't find these args, but they were passed in the args dict
except KeyError:
continue
widget, controller = create_widget(inspector_option.data_type,
inspector_option.options)
widget.setEnabled(False)
controller.value = value
this_layout.addRow(self.tr(name), widget)
edit_button = QPushButton('Re-configure')
edit_button.setToolTip(
"Re-create this node with new meta-args, and attempt to preserve state"
)
edit_button.clicked.connect(lambda: self.doMorphNode.emit(node))
this_layout.addRow(edit_button)
# Args
for wrapper_name, title_name in (("args", "Builder Args"),
("cls_args", "Class Args")):
try:
args = node.params[wrapper_name]
except KeyError:
continue
arg_data = node.params_info[wrapper_name]
# Create container
if self._show_compact:
this_layout = layout
else:
box = QFrame()
box.setFrameShape(QFrame.StyledPanel)
this_layout = QFormLayout()
box.setLayout(this_layout)
layout.addRow(self.tr(title_name), box)
for name, value in args.items():
# Get data type
inspector_option = arg_data[name]
widget, controller = create_widget(inspector_option.data_type,
inspector_option.options)
widget.controller = controller
def on_changed(value, name=name, wrapper_name=wrapper_name):
self.updateParam.emit(node, wrapper_name, name, value)
controller.value = value
controller.on_changed.subscribe(on_changed)
this_layout.addRow(self.tr(name), widget)
class GcodeEditor(QWidget, _HalWidgetBase):
percentDone = pyqtSignal(int)
def __init__(self, parent=None):
super(GcodeEditor, self).__init__(parent)
self.isCaseSensitive = 0
self.setMinimumSize(QSize(300, 200))
self.setWindowTitle("PyQt5 editor test example")
lay = QVBoxLayout()
lay.setContentsMargins(0,0,0,0)
self.setLayout(lay)
# make editor
self.editor = GcodeDisplay(self)
# class patch editor's function to ours
# so we get the lines percent update
self.editor.emit_percent = self.emit_percent
self.editor.setReadOnly(True)
################################
# add menubar actions
################################
# Create new action
newAction = QAction(QIcon.fromTheme('document-new'), 'New', self)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('New document')
newAction.triggered.connect(self.newCall)
# Create open action
openAction = QAction(QIcon.fromTheme('document-open'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open document')
openAction.triggered.connect(self.openCall)
# Create save action
saveAction = QAction(QIcon.fromTheme('document-save'), '&save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('save document')
saveAction.triggered.connect(self.saveCall)
# Create exit action
exitAction = QAction(QIcon.fromTheme('application-exit'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall)
# Create gcode lexer action
gCodeLexerAction = QAction(QIcon.fromTheme('lexer.png'), '&Gcode\n lexer', self)
gCodeLexerAction.setCheckable(1)
gCodeLexerAction.setShortcut('Ctrl+G')
gCodeLexerAction.setStatusTip('Set Gcode highlighting')
gCodeLexerAction.triggered.connect(self.editor.set_gcode_lexer)
# Create gcode lexer action
pythonLexerAction = QAction(QIcon.fromTheme('lexer.png'), '&python\n lexer', self)
pythonLexerAction.setShortcut('Ctrl+P')
pythonLexerAction.setStatusTip('Set Python highlighting')
pythonLexerAction.triggered.connect(self.editor.set_python_lexer)
# Create toolbar and add action
toolBar = QToolBar('File')
toolBar.addAction(newAction)
toolBar.addAction(openAction)
toolBar.addAction(saveAction)
toolBar.addAction(exitAction)
toolBar.addSeparator()
# add lexer actions
toolBar.addAction(gCodeLexerAction)
toolBar.addAction(pythonLexerAction)
toolBar.addSeparator()
toolBar.addWidget(QLabel('<html><head/><body><p><span style=" font-size:20pt; font-weight:600;">Edit Mode</span></p></body></html>'))
# create a frame for buttons
box = QHBoxLayout()
box.addWidget(toolBar)
self.topMenu = QFrame()
self.topMenu.setLayout(box)
# add widgets
lay.addWidget(self.topMenu)
lay.addWidget(self.editor)
lay.addWidget(self.createGroup())
self.readOnlyMode()
def createGroup(self):
self.bottomMenu = QFrame()
self.searchText = QLineEdit(self)
self.replaceText = QLineEdit(self)
toolBar = QToolBar()
# Create new action
undoAction = QAction(QIcon.fromTheme('edit-undo'), 'Undo', self)
undoAction.setStatusTip('Undo')
undoAction.triggered.connect(self.undoCall)
toolBar.addAction(undoAction)
# create redo action
redoAction = QAction(QIcon.fromTheme('edit-redo'), 'Redo', self)
redoAction.setStatusTip('Undo')
redoAction.triggered.connect(self.redoCall)
toolBar.addAction(redoAction)
toolBar.addSeparator()
# create replace action
replaceAction = QAction(QIcon.fromTheme('edit-find-replace'), 'Replace', self)
replaceAction.triggered.connect(self.replaceCall)
toolBar.addAction(replaceAction)
# create find action
findAction = QAction(QIcon.fromTheme('edit-find'), 'Find', self)
findAction.triggered.connect(self.findCall)
toolBar.addAction(findAction)
# create next action
nextAction = QAction(QIcon.fromTheme('go-previous'), 'Find Previous', self)
nextAction.triggered.connect(self.nextCall)
toolBar.addAction(nextAction)
toolBar.addSeparator()
# create case action
caseAction = QAction(QIcon.fromTheme('edit-case'), 'Aa', self)
caseAction.setCheckable(1)
caseAction.triggered.connect(self.caseCall)
toolBar.addAction(caseAction)
box = QHBoxLayout()
box.addWidget(toolBar)
box.addWidget(self.searchText)
box.addWidget(self.replaceText)
box.addStretch(1)
self.bottomMenu.setLayout(box)
return self.bottomMenu
def _hal_init(self):
# name the top and bottom frames so it's easier to style
#print '%sBottomButtonFrame'% self.objectName()
self.bottomMenu.setObjectName('%sBottomButtonFrame'% self.objectName())
self.topMenu.setObjectName('%sTopButtonFrame'% self.objectName())
def editMode(self):
self.topMenu.show()
self.bottomMenu.show()
self.editor.setReadOnly(False)
def readOnlyMode(self):
self.topMenu.hide()
self.bottomMenu.hide()
self.editor.setReadOnly(True)
def openCall(self):
print('Open')
f = self.getFileName()
self.editor.load_text(f)
self.editor.setModified(False)
def saveCall(self):
print('save')
self.saveFile()
def newCall(self):
if self.editor.isModified():
result = self.killCheck()
if result:
self.editor.new_text()
def exitCall(self):
print('Exit app')
if self.editor.isModified():
result = self.killCheck()
if result:
self.readOnlyMode()
def undoCall(self):
self.editor.undo()
def redoCall(self):
self.editor.redo()
def replaceCall(self):
self.editor.replace_text(str(self.replaceText.text()))
def findCall(self):
self.editor.search(str(self.searchText.text()),
re=False, case=self.isCaseSensitive,
word=False, wrap= False, fwd=True)
def nextCall(self):
self.editor.search(str(self.searchText.text()),False)
self.editor.search_Next()
def caseCall(self):
self.isCaseSensitive -=1
self.isCaseSensitive *=-1
print self.isCaseSensitive
def getFileName(self):
name = QFileDialog.getOpenFileName(self, 'Open File')
return str(name[0])
def killCheck(self):
choice = QMessageBox.question(self, 'Warning!!',
"This file has changed since loading...Still want to proceed?",
QMessageBox.Yes | QMessageBox.No)
if choice == QMessageBox.Yes:
return True
else:
return False
def saveFile(self):
if self.editor.text() == '': return
name = QFileDialog.getSaveFileName(self, 'Save File')
print name
if name[0]:
file = open(name[0],'w')
file.write(self.editor.text())
file.close()
def emit_percent(self, percent):
self.percentDone.emit(percent)
def _initUI(self):
# 分割窗口，并添加控件
# 右半部分
rSplitter = QSplitter(Qt.Vertical)
rFrame = QFrame()
rLayout = QVBoxLayout()
rLayout.addWidget(self.vtkWidget)
rLayout.setContentsMargins(0, 0, 0, 0) # ?
rFrame.setLayout(rLayout)
rSplitter.addWidget(rFrame)
# status bar
self.window_status_label = QLabel()
self.window_status_label.setMinimumWidth(200)
self.window_status_label.setAlignment(Qt.AlignRight)
self.statusBar = QStatusBar()
self.statusBar.setMinimumWidth(300)
self.statusBar.addPermanentWidget(self.window_status_label)
rSplitter.addWidget(self.statusBar)
# 拉伸比例
rSplitter.setStretchFactor(0, 9)
rSplitter.setStretchFactor(1, 1)
# 左边
self.lSplitter = QSplitter(Qt.Vertical)
lFrame = QFrame()
lLayout = QVBoxLayout()
# 大标题2016HO3
lLabel0 = QLabel()
lLabel0.setText("2016HO3")
lLabel0.setFont(QFont("Microsoft YaHei", 30, QFont.Bold))
lLabel0.setAlignment(Qt.AlignCenter)
lLayout.addWidget(lLabel0) # 0
lLayout.setStretch(0, 1.5)
# Select start date
lLabel = QLabel()
# lLabel.setText("Select start date: ")
# lLabel.setFont(QFont("Microsoft YaHei", 20, QFont.Bold))
lLabel.setAlignment(Qt.AlignCenter)
lLayout.addWidget(lLabel) # 1
lLayout.setStretch(1, 1)
# 日历
self.calendar = QCalendarWidget()
self.calendar.setGridVisible(True)
self.calendar.setDateRange(QDate(1900, 1, 1), QDate(2195, 12, 24))
self.calendar.setMaximumHeight(300)
# lLayout.addWidget(self.calendar) # 2
# 速度控制控件
self.speed_box = QWidget()
self.speed_layout = QHBoxLayout()
self.speed_box.setLayout(self.speed_layout)
speed_button_width = 40 # 按钮宽度
self.speedButton_moreSlower = QPushButton("<<<")
self.speedButton_moreSlower.setMaximumWidth(speed_button_width)
self.speedButton_slower = QPushButton("<")
self.speedButton_slower.setMaximumWidth(speed_button_width)
self.speedButton_origion = QPushButton("▶")
self.speedButton_origion.setMaximumWidth(speed_button_width)
self.speedButton_faster = QPushButton(">")
self.speedButton_faster.setMaximumWidth(speed_button_width)
self.speedButton_moreFaster = QPushButton(">>>")
self.speedButton_moreFaster.setMaximumWidth(speed_button_width)
self.speed_layout.addWidget(self.speedButton_moreSlower)
self.speed_layout.addWidget(self.speedButton_slower)
self.speed_layout.addWidget(self.speedButton_origion)
self.speed_layout.addWidget(self.speedButton_faster)
self.speed_layout.addWidget(self.speedButton_moreFaster)
lLayout.addWidget(self.speed_box)
lLayout.setStretch(2, 4)
# 日历标签
self.calendar_label = QLabel()
self.calendar_label.setFont(QFont("Microsoft YaHei", 10, QFont.Bold))
self.calendar_label.setAlignment(Qt.AlignCenter)
self._onCalChanged()
lLayout.addWidget(self.calendar_label) # 3
lLayout.setStretch(3, 1)
# OK按钮
self.okButton = QPushButton("▶")
self.okButton.setMinimumHeight(50)
self.okButton.setFont(QFont("Microsoft YaHei", 20, QFont.Bold))
lLayout.addWidget(self.okButton) # 4
lLayout.setStretch(4, 1)
# 空标签(为了占地方)
tempLabel = QLabel()
tempLabel.setMaximumHeight(50)
lLayout.addWidget(tempLabel) # 5
lLayout.setStretch(5, 1)
lFrame.setLayout(lLayout)
self.lSplitter.addWidget(lFrame)
# 总布局
splitter_main = QSplitter(Qt.Horizontal)
splitter_main.addWidget(self.lSplitter) # 左边
splitter_main.addWidget(rSplitter) # 右边
splitter_main.setStretchFactor(0, 1)
splitter_main.setStretchFactor(1, 5)
self.setCentralWidget(splitter_main)
return
def prepare_gui(self):
self.setWindowTitle('inzynierka')
self.setBaseSize(1200, 800)
left_panel = QVBoxLayout()
left_panel.setAlignment(Qt.AlignTop)
left_part = QVBoxLayout()
left_part.addWidget(self.algorithmLabel)
checkboxes = QVBoxLayout()
checkboxes.addWidget(self.simpleCNN)
checkboxes.addWidget(self.knn)
checkboxes.addWidget(self.customCNN)
left_part.addLayout(checkboxes)
left_part.addWidget(self.parameterLabel)
left_part.addWidget(self.parameter)
left_part.addWidget(self.errorLabel)
cnnParameters = QGridLayout()
cnnParameters.addWidget(self.optimizerLabel, 0, 0)
cnnParameters.addWidget(self.optimizer, 0, 1)
cnnParametersFrame = QFrame()
cnnParametersFrame.setLayout(cnnParameters)
left_part.addWidget(cnnParametersFrame)
left_panel.addLayout(left_part)
right_panel = QGridLayout()
label1 = QLabel('Graphs for your algoritm')
right_panel.addWidget(label1, 0, 0)
right_panel.addWidget(self.graphs, 1, 0)
self.graphs.setTabEnabled(1, False)
self.graphs.setTabEnabled(2, False)
top_layout = QHBoxLayout()
top_layout.addLayout(left_panel)
top_layout.addLayout(right_panel)
topFrame = QFrame()
topFrame.setLayout(top_layout)
topFrame.setMinimumHeight(600)
bottom_layout = QHBoxLayout()
buttons = QVBoxLayout()
buttons.addWidget(self.createButton)
buttons.addWidget(self.trainButton)
buttons.addWidget(self.evaluateButton)
buttons.addWidget(self.loadModelButton)
buttons.addWidget(self.saveModelButton)
bottom_layout.addLayout(buttons)
bottom_layout.addWidget(self.consolePrint)
bottomFrame = QFrame()
bottomFrame.setLayout(bottom_layout)
bottomFrame.setMaximumHeight(300)
main_layout = QGridLayout()
main_layout.addWidget(topFrame, 0, 0)
main_layout.addWidget(bottomFrame, 1, 0)
main_widget = QWidget()
main_widget.setLayout(main_layout)
self.setCentralWidget(main_widget)
def __init__(self, parent, worker, config, configfile):
QDialog.__init__(self, parent)
self.worker = worker
self.config = config
self.configfile = configfile
self.setStyleSheet("QGroupBox { font-weight: bold; } ")
self.setWindowTitle('Settings')
layout = QGridLayout()
# Categories
self.category_list = QListWidget()
category_media = QListWidgetItem(getIcon('media-playback-start'), 'Media', self.category_list)
category_sync = QListWidgetItem(getIcon('view-refresh'), 'Sync', self.category_list)
category_ui = QListWidgetItem(getIcon('window-new'), 'User Interface', self.category_list)
category_theme = QListWidgetItem(getIcon('applications-graphics'), 'Theme', self.category_list)
self.category_list.setSelectionMode(QAbstractItemView.SingleSelection)
self.category_list.setCurrentRow(0)
self.category_list.setMaximumWidth(self.category_list.sizeHintForColumn(0) + 15)
self.category_list.setFocus()
self.category_list.currentItemChanged.connect(self.s_switch_page)
# Media tab
page_media = QWidget()
page_media_layout = QVBoxLayout()
page_media_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Media settings
g_media = QGroupBox('Media settings')
g_media.setFlat(True)
g_media_layout = QFormLayout()
self.tracker_enabled = QCheckBox()
self.tracker_enabled.toggled.connect(self.tracker_type_change)
self.tracker_type = QComboBox()
for (n, label) in utils.available_trackers:
self.tracker_type.addItem(label, n)
self.tracker_type.currentIndexChanged.connect(self.tracker_type_change)
self.tracker_interval = QSpinBox()
self.tracker_interval.setRange(5, 1000)
self.tracker_interval.setMaximumWidth(60)
self.tracker_process = QLineEdit()
self.tracker_update_wait = QSpinBox()
self.tracker_update_wait.setRange(0, 1000)
self.tracker_update_wait.setMaximumWidth(60)
self.tracker_update_close = QCheckBox()
self.tracker_update_prompt = QCheckBox()
self.tracker_not_found_prompt = QCheckBox()
g_media_layout.addRow('Enable tracker', self.tracker_enabled)
g_media_layout.addRow('Tracker type', self.tracker_type)
g_media_layout.addRow('Tracker interval (seconds)', self.tracker_interval)
g_media_layout.addRow('Process name (regex)', self.tracker_process)
g_media_layout.addRow('Wait before updating (seconds)', self.tracker_update_wait)
g_media_layout.addRow('Wait until the player is closed', self.tracker_update_close)
g_media_layout.addRow('Ask before updating', self.tracker_update_prompt)
g_media_layout.addRow('Ask to add new shows', self.tracker_not_found_prompt)
g_media.setLayout(g_media_layout)
# Group: Plex settings
g_plex = QGroupBox('Plex Media Server')
g_plex.setFlat(True)
self.plex_host = QLineEdit()
self.plex_port = QLineEdit()
self.plex_user = QLineEdit()
self.plex_passw = QLineEdit()
self.plex_passw.setEchoMode(QLineEdit.Password)
self.plex_obey_wait = QCheckBox()
g_plex_layout = QGridLayout()
g_plex_layout.addWidget(QLabel('Host and Port'), 0, 0, 1, 1)
g_plex_layout.addWidget(self.plex_host, 0, 1, 1, 1)
g_plex_layout.addWidget(self.plex_port, 0, 2, 1, 2)
g_plex_layout.addWidget(QLabel('Use "wait before updating" time'), 1, 0, 1, 1)
g_plex_layout.addWidget(self.plex_obey_wait, 1, 2, 1, 1)
g_plex_layout.addWidget(QLabel('myPlex login (claimed server)'), 2, 0, 1, 1)
g_plex_layout.addWidget(self.plex_user, 2, 1, 1, 1)
g_plex_layout.addWidget(self.plex_passw, 2, 2, 1, 2)
g_plex.setLayout(g_plex_layout)
# Group: Library
g_playnext = QGroupBox('Library')
g_playnext.setFlat(True)
self.player = QLineEdit()
self.player_browse = QPushButton('Browse...')
self.player_browse.clicked.connect(self.s_player_browse)
lbl_searchdirs = QLabel('Media directories')
lbl_searchdirs.setAlignment(QtCore.Qt.AlignTop)
self.searchdirs = QListWidget()
self.searchdirs_add = QPushButton('Add...')
self.searchdirs_add.clicked.connect(self.s_searchdirs_add)
self.searchdirs_remove = QPushButton('Remove')
self.searchdirs_remove.clicked.connect(self.s_searchdirs_remove)
self.searchdirs_buttons = QVBoxLayout()
self.searchdirs_buttons.setAlignment(QtCore.Qt.AlignTop)
self.searchdirs_buttons.addWidget(self.searchdirs_add)
self.searchdirs_buttons.addWidget(self.searchdirs_remove)
self.searchdirs_buttons.addWidget(QSplitter())
self.library_autoscan = QCheckBox()
self.scan_whole_list = QCheckBox()
self.library_full_path = QCheckBox()
g_playnext_layout = QGridLayout()
g_playnext_layout.addWidget(QLabel('Player'), 0, 0, 1, 1)
g_playnext_layout.addWidget(self.player, 0, 1, 1, 1)
g_playnext_layout.addWidget(self.player_browse, 0, 2, 1, 1)
g_playnext_layout.addWidget(lbl_searchdirs, 1, 0, 1, 1)
g_playnext_layout.addWidget(self.searchdirs, 1, 1, 1, 1)
g_playnext_layout.addLayout(self.searchdirs_buttons, 1, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Rescan Library at startup'), 2, 0, 1, 2)
g_playnext_layout.addWidget(self.library_autoscan, 2, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Scan through whole list'), 3, 0, 1, 2)
g_playnext_layout.addWidget(self.scan_whole_list, 3, 2, 1, 1)
g_playnext_layout.addWidget(QLabel('Take subdirectory name into account'), 4, 0, 1, 2)
g_playnext_layout.addWidget(self.library_full_path, 4, 2, 1, 1)
g_playnext.setLayout(g_playnext_layout)
# Media form
page_media_layout.addWidget(g_media)
page_media_layout.addWidget(g_plex)
page_media_layout.addWidget(g_playnext)
page_media.setLayout(page_media_layout)
# Sync tab
page_sync = QWidget()
page_sync_layout = QVBoxLayout()
page_sync_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Autoretrieve
g_autoretrieve = QGroupBox('Autoretrieve')
g_autoretrieve.setFlat(True)
self.autoretrieve_off = QRadioButton('Disabled')
self.autoretrieve_always = QRadioButton('Always at start')
self.autoretrieve_days = QRadioButton('After n days')
self.autoretrieve_days.toggled.connect(self.s_autoretrieve_days)
self.autoretrieve_days_n = QSpinBox()
self.autoretrieve_days_n.setRange(1, 100)
g_autoretrieve_layout = QGridLayout()
g_autoretrieve_layout.setColumnStretch(0, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_off, 0, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_always, 1, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_days, 2, 0, 1, 1)
g_autoretrieve_layout.addWidget(self.autoretrieve_days_n, 2, 1, 1, 1)
g_autoretrieve.setLayout(g_autoretrieve_layout)
# Group: Autosend
g_autosend = QGroupBox('Autosend')
g_autosend.setFlat(True)
self.autosend_off = QRadioButton('Disabled')
self.autosend_always = QRadioButton('Immediately after every change')
self.autosend_minutes = QRadioButton('After n minutes')
self.autosend_minutes.toggled.connect(self.s_autosend_minutes)
self.autosend_minutes_n = QSpinBox()
self.autosend_minutes_n.setRange(1, 1000)
self.autosend_size = QRadioButton('After the queue reaches n items')
self.autosend_size.toggled.connect(self.s_autosend_size)
self.autosend_size_n = QSpinBox()
self.autosend_size_n.setRange(2, 20)
self.autosend_at_exit = QCheckBox('At exit')
g_autosend_layout = QGridLayout()
g_autosend_layout.setColumnStretch(0, 1)
g_autosend_layout.addWidget(self.autosend_off, 0, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_always, 1, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_minutes, 2, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_minutes_n, 2, 1, 1, 1)
g_autosend_layout.addWidget(self.autosend_size, 3, 0, 1, 1)
g_autosend_layout.addWidget(self.autosend_size_n, 3, 1, 1, 1)
g_autosend_layout.addWidget(self.autosend_at_exit, 4, 0, 1, 1)
g_autosend.setLayout(g_autosend_layout)
# Group: Extra
g_extra = QGroupBox('Additional options')
g_extra.setFlat(True)
self.auto_status_change = QCheckBox('Change status automatically')
self.auto_status_change.toggled.connect(self.s_auto_status_change)
self.auto_status_change_if_scored = QCheckBox('Change status automatically only if scored')
self.auto_date_change = QCheckBox('Change start and finish dates automatically')
g_extra_layout = QVBoxLayout()
g_extra_layout.addWidget(self.auto_status_change)
g_extra_layout.addWidget(self.auto_status_change_if_scored)
g_extra_layout.addWidget(self.auto_date_change)
g_extra.setLayout(g_extra_layout)
# Sync layout
page_sync_layout.addWidget(g_autoretrieve)
page_sync_layout.addWidget(g_autosend)
page_sync_layout.addWidget(g_extra)
page_sync.setLayout(page_sync_layout)
# UI tab
page_ui = QWidget()
page_ui_layout = QFormLayout()
page_ui_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Icon
g_icon = QGroupBox('Notification Icon')
g_icon.setFlat(True)
self.tray_icon = QCheckBox('Show tray icon')
self.tray_icon.toggled.connect(self.s_tray_icon)
self.close_to_tray = QCheckBox('Close to tray')
self.start_in_tray = QCheckBox('Start minimized to tray')
self.tray_api_icon = QCheckBox('Use API icon as tray icon')
self.notifications = QCheckBox('Show notification when tracker detects new media')
g_icon_layout = QVBoxLayout()
g_icon_layout.addWidget(self.tray_icon)
g_icon_layout.addWidget(self.close_to_tray)
g_icon_layout.addWidget(self.start_in_tray)
g_icon_layout.addWidget(self.tray_api_icon)
g_icon_layout.addWidget(self.notifications)
g_icon.setLayout(g_icon_layout)
# Group: Window
g_window = QGroupBox('Window')
g_window.setFlat(True)
self.remember_geometry = QCheckBox('Remember window size and position')
self.remember_columns = QCheckBox('Remember column layouts and widths')
self.columns_per_api = QCheckBox('Use different visible columns per API')
g_window_layout = QVBoxLayout()
g_window_layout.addWidget(self.remember_geometry)
g_window_layout.addWidget(self.remember_columns)
g_window_layout.addWidget(self.columns_per_api)
g_window.setLayout(g_window_layout)
# Group: Lists
g_lists = QGroupBox('Lists')
g_lists.setFlat(True)
self.filter_bar_position = QComboBox()
filter_bar_positions = [(FilterBar.PositionHidden, 'Hidden'),
(FilterBar.PositionAboveLists, 'Above lists'),
(FilterBar.PositionBelowLists, 'Below lists')]
for (n, label) in filter_bar_positions:
self.filter_bar_position.addItem(label, n)
self.inline_edit = QCheckBox('Enable in-line editing')
g_lists_layout = QFormLayout()
g_lists_layout.addRow('Filter bar position:', self.filter_bar_position)
g_lists_layout.addRow(self.inline_edit)
g_lists.setLayout(g_lists_layout)
# UI layout
page_ui_layout.addWidget(g_icon)
page_ui_layout.addWidget(g_window)
page_ui_layout.addWidget(g_lists)
page_ui.setLayout(page_ui_layout)
# Theming tab
page_theme = QWidget()
page_theme_layout = QFormLayout()
page_theme_layout.setAlignment(QtCore.Qt.AlignTop)
# Group: Episode Bar
g_ep_bar = QGroupBox('Episode Bar')
g_ep_bar.setFlat(True)
self.ep_bar_style = QComboBox()
ep_bar_styles = [(ShowsTableDelegate.BarStyleBasic, 'Basic'),
(ShowsTableDelegate.BarStyle04, 'Trackma'),
(ShowsTableDelegate.BarStyleHybrid, 'Hybrid')]
for (n, label) in ep_bar_styles:
self.ep_bar_style.addItem(label, n)
self.ep_bar_style.currentIndexChanged.connect(self.s_ep_bar_style)
self.ep_bar_text = QCheckBox('Show text label')
g_ep_bar_layout = QFormLayout()
g_ep_bar_layout.addRow('Style:', self.ep_bar_style)
g_ep_bar_layout.addRow(self.ep_bar_text)
g_ep_bar.setLayout(g_ep_bar_layout)
# Group: Colour scheme
g_scheme = QGroupBox('Color Scheme')
g_scheme.setFlat(True)
col_tabs = [('rows', '&Row highlights'),
('progress', '&Progress widget')]
self.colors = {}
self.colors['rows'] = [('is_playing', 'Playing'),
('is_queued', 'Queued'),
('new_episode', 'New Episode'),
('is_airing', 'Airing'),
('not_aired', 'Unaired')]
self.colors['progress'] = [('progress_bg', 'Background'),
('progress_fg', 'Watched bar'),
('progress_sub_bg', 'Aired episodes'),
('progress_sub_fg', 'Stored episodes'),
('progress_complete', 'Complete')]
self.color_buttons = []
self.syscolor_buttons = []
g_scheme_layout = QGridLayout()
tw_scheme = QTabWidget()
for (key, tab_title) in col_tabs:
page = QFrame()
page_layout = QGridLayout()
col = 0
# Generate widgets from the keys and values
for (key, label) in self.colors[key]:
self.color_buttons.append(QPushButton())
# self.color_buttons[-1].setStyleSheet('background-color: ' + getColor(self.config['colors'][key]).name())
self.color_buttons[-1].setFocusPolicy(QtCore.Qt.NoFocus)
self.color_buttons[-1].clicked.connect(self.s_color_picker(key, False))
self.syscolor_buttons.append(QPushButton('System Colors'))
self.syscolor_buttons[-1].clicked.connect(self.s_color_picker(key, True))
page_layout.addWidget(QLabel(label), col, 0, 1, 1)
page_layout.addWidget(self.color_buttons[-1], col, 1, 1, 1)
page_layout.addWidget(self.syscolor_buttons[-1], col, 2, 1, 1)
col += 1
page.setLayout(page_layout)
tw_scheme.addTab(page, tab_title)
g_scheme_layout.addWidget(tw_scheme)
g_scheme.setLayout(g_scheme_layout)
# UI layout
page_theme_layout.addWidget(g_ep_bar)
page_theme_layout.addWidget(g_scheme)
page_theme.setLayout(page_theme_layout)
# Content
self.contents = QStackedWidget()
self.contents.addWidget(page_media)
self.contents.addWidget(page_sync)
self.contents.addWidget(page_ui)
self.contents.addWidget(page_theme)
if pyqt_version is not 5:
self.contents.layout().setMargin(0)
# Bottom buttons
bottombox = QDialogButtonBox(
QDialogButtonBox.Ok
| QDialogButtonBox.Apply
| QDialogButtonBox.Cancel
)
bottombox.accepted.connect(self.s_save)
bottombox.button(QDialogButtonBox.Apply).clicked.connect(self._save)
bottombox.rejected.connect(self.reject)
# Main layout finish
layout.addWidget(self.category_list, 0, 0, 1, 1)
layout.addWidget(self.contents, 0, 1, 1, 1)
layout.addWidget(bottombox, 1, 0, 1, 2)
layout.setColumnStretch(1, 1)
self._load()
self.update_colors()
self.setLayout(layout)
def __init__(self, parent=None, modal=False):
super().__init__(parent)
self.setWindowFlags(Qt.Dialog)
layout = QVBoxLayout()
self.setLayout(layout)
if modal:
frame = QFrame()
frame.setFrameShape(frame.StyledPanel)
modal_layout = QHBoxLayout()
frame.setLayout(modal_layout)
layout.addWidget(frame)
info = QLabel('This mode let\'s you add galleries from ' +
'different folders.')
f_folder = QPushButton('Add folders')
f_folder.clicked.connect(self.from_folder)
f_files = QPushButton('Add files')
f_files.clicked.connect(self.from_files)
modal_layout.addWidget(info, 3, Qt.AlignLeft)
modal_layout.addWidget(f_folder, 0, Qt.AlignRight)
modal_layout.addWidget(f_files, 0, Qt.AlignRight)
check_layout = QHBoxLayout()
layout.addLayout(check_layout)
if modal:
check_layout.addWidget(QLabel('Please uncheck galleries you do' +
' not want to add. (Exisiting galleries won\'t be added'),
3)
else:
check_layout.addWidget(QLabel('Please uncheck galleries you do' +
' not want to add. (Existing galleries are hidden)'),
3)
self.check_all = QCheckBox('Check/Uncheck All', self)
self.check_all.setChecked(True)
self.check_all.stateChanged.connect(self.all_check_state)
check_layout.addWidget(self.check_all)
self.view_list = QListWidget()
self.view_list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.view_list.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
layout.addWidget(self.view_list)
add_btn = QPushButton('Add checked')
add_btn.clicked.connect(self.return_gallery)
cancel_btn = QPushButton('Cancel')
cancel_btn.clicked.connect(self.close_window)
btn_layout = QHBoxLayout()
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
btn_layout.addWidget(spacer)
btn_layout.addWidget(add_btn)
btn_layout.addWidget(cancel_btn)
layout.addLayout(btn_layout)
self.resize(500,550)
frect = self.frameGeometry()
frect.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(frect.topLeft())
self.setWindowTitle('Gallery List')
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
class Welcome(QWidget):
def __init__(self, parent, controller, app):
super().__init__(parent)
self.controller = controller
self.controller.add(self)
self.timer = QTimer()
self.app = app
self.activeHighScore = False
self.pop = True
# # #
# # # Definition du layout Vertical Gauche
# # #
self.layoutVG = QVBoxLayout()
self.spacerItem1 = QSpacerItem(5, 2, QSizePolicy.Maximum,
QSizePolicy.Expanding)
self.layoutVG.addItem(self.spacerItem1)
# titre paramètre en gras
self.parameters = QLabel("Paramètres")
self.parameters.setFont(QFont("?", 14, QFont.Bold))
self.layoutVG.addWidget(self.parameters)
# fonctions cliquables
self.player1_human = lambda: self.setPlayer(0, Controller.PLAYER)
self.player1_robot = lambda: self.setPlayer(0, Controller.AI)
self.player2_human = lambda: self.setPlayer(1, Controller.PLAYER)
self.player2_robot = lambda: self.setPlayer(1, Controller.AI)
self.setPlayer1Name = lambda: self.setPlayerName(
0, self.paramPlayer1NameEdit.text())
self.setPlayer2Name = lambda: self.setPlayerName(
1, self.paramPlayer2NameEdit.text())
self.activateFrame1 = lambda: self.activate(1)
self.activateFrame2 = lambda: self.activate(2)
self.activateFrame3 = lambda: self.activate(3)
self.unactivateFrame1 = lambda: self.unactivate(1)
self.unactivateFrame2 = lambda: self.unactivate(2)
self.unactivateFrame3 = lambda: self.unactivate(3)
# paramètre joueurs
self.paramPlayer1_stat = QLabel("Le joueur 1 est-t-il humain ou IA ?")
self.paramPlayer2_stat = QLabel("Le joueur 2 est-t-il humain ou IA ?")
self.paramPlayer1_human = QPushButton("Humain")
self.paramPlayer1_human.clicked.connect(self.player1_human)
self.paramPlayer1_robot = QPushButton("IA")
self.paramPlayer1_robot.clicked.connect(self.player1_robot)
self.paramPlayer2_human = QPushButton("Humain")
self.paramPlayer2_human.clicked.connect(self.player2_human)
self.paramPlayer2_robot = QPushButton("IA")
self.paramPlayer2_robot.clicked.connect(self.player2_robot)
self.paramPlayer1Name = QLabel("Nom")
self.paramPlayer2Name = QLabel("Nom")
self.paramPlayer1NameEdit = QLineEdit("Joueur 1")
self.paramPlayer1NameConfirm = QPushButton("Ok")
self.paramPlayer1NameConfirm.clicked.connect(self.setPlayer1Name)
self.paramPlayer2NameEdit = QLineEdit("Joueur 2")
self.paramPlayer2NameConfirm = QPushButton("Ok")
self.paramPlayer2NameConfirm.clicked.connect(self.setPlayer2Name)
self.paramPlayer1ColorTitle = QLabel("Couleur")
self.paramPlayer2ColorTitle = QLabel("Couleur")
self.paramPlayer1Color = DropDownMenu(self, self.controller,
"couleur 1", COLOR_LIST)
self.paramPlayer2Color = DropDownMenu(self, self.controller,
"couleur 2", COLOR_LIST)
self.paramPlayer1_Ok = QPushButton("Valider")
self.paramPlayer1_Ok.clicked.connect(self.unactivateFrame1)
self.paramPlayer2_Ok = QPushButton("Valider")
self.paramPlayer2_Ok.clicked.connect(self.unactivateFrame2)
self.player1Buttons = QLabel("Utiliser les flèches pour jouer")
self.player2Buttons = QLabel("Utliser les touches Z Q S D pour jouer")
# bouton Joueur 1
self.paramPlayer1 = QPushButton("Joueur 1")
self.paramPlayer1.clicked.connect(self.activateFrame1)
self.layoutVG.addWidget(self.paramPlayer1)
# layer paramètre joueur 1
self.frame1 = QFrame()
self.layoutV1 = QVBoxLayout()
self.frame1.setLayout(self.layoutV1)
self.layoutV1.addWidget(self.paramPlayer1_stat)
# under-layout: select player status
self.underLayout1 = QHBoxLayout()
self.underLayout1.addWidget(self.paramPlayer1_human)
self.underLayout1.addWidget(self.paramPlayer1_robot)
self.layoutV1.addLayout(self.underLayout1)
# under-layout: select player name
self.underLayout2 = QHBoxLayout()
self.underLayout2.addWidget(self.paramPlayer1Name)
self.underLayout2.addWidget(self.paramPlayer1NameEdit)
self.underLayout2.addWidget(self.paramPlayer1NameConfirm)
self.layoutV1.addLayout(self.underLayout2)
# under-layout: select player color
self.underLayout3 = QHBoxLayout()
self.underLayout3.addWidget(self.paramPlayer1ColorTitle)
self.underLayout3.addWidget(self.paramPlayer1Color)
self.layoutV1.addLayout(self.underLayout3)
self.layoutV1.addWidget(self.paramPlayer1_Ok)
self.frame1.hide()
self.layoutVG.addWidget(self.frame1)
self.frame1_1 = QFrame()
self.underLayout4 = QHBoxLayout()
self.frame1_1.setLayout(self.underLayout4)
self.underLayout4.addWidget(self.player1Buttons)
self.frame1_1.hide()
self.layoutVG.addWidget(self.frame1_1)
# bouton Joueur 2
self.paramPlayer2 = QPushButton("Joueur 2")
self.paramPlayer2.clicked.connect(self.activateFrame2)
self.layoutVG.addWidget(self.paramPlayer2)
# layer paramètre joueur 2
self.frame2 = QFrame()
self.layoutV2 = QVBoxLayout()
self.frame2.setLayout(self.layoutV2)
self.layoutV2.addWidget(self.paramPlayer2_stat)
# under-layout: select player status
self.underLayout1 = QHBoxLayout()
self.underLayout1.addWidget(self.paramPlayer2_human)
self.underLayout1.addWidget(self.paramPlayer2_robot)
self.layoutV2.addLayout(self.underLayout1)
# under-layout: select player name
self.underLayout2 = QHBoxLayout()
self.underLayout2.addWidget(self.paramPlayer2Name)
self.underLayout2.addWidget(self.paramPlayer2NameEdit)
self.underLayout2.addWidget(self.paramPlayer2NameConfirm)
self.layoutV2.addLayout(self.underLayout2)
# under-layout: select player color
self.underLayout3 = QHBoxLayout()
self.underLayout3.addWidget(self.paramPlayer2ColorTitle)
self.underLayout3.addWidget(self.paramPlayer2Color)
self.layoutV2.addLayout(self.underLayout3)
self.layoutV2.addWidget(self.paramPlayer2_Ok)
self.frame2.hide()
self.layoutVG.addWidget(self.frame2)
self.frame2_1 = QFrame()
self.underLayout4 = QHBoxLayout()
self.frame2_1.setLayout(self.underLayout4)
self.underLayout4.addWidget(self.player2Buttons)
self.frame2_1.hide()
self.layoutVG.addWidget(self.frame2_1)
# bouton paramètre game
self.paramGame = QPushButton("Paramètres du jeu")
self.paramGame.clicked.connect(self.activateFrame3)
self.layoutVG.addWidget(self.paramGame)
# paramètre game
self.paramGame_title = QLabel("Mode de jeu :")
self.paramGame_menu = DropDownMenu(self, self.controller, "mode",
GAMEMODES)
self.paramGame_time = QSlider(Qt.Horizontal)
self.paramGame_time.setMinimum(15)
self.paramGame_time.setMaximum(300)
self.paramGame_time.setValue(120)
self.paramGame_time.setTickInterval(10)
self.paramGame_time.valueChanged.connect(self.setLimitTime)
self.paramGame_timeTitle = QLabel("{} secondes".format(\
self.paramGame_time.value()))
self.paramGame_score = QSlider(Qt.Horizontal)
self.paramGame_score.setMinimum(2)
self.paramGame_score.setMaximum(30)
self.paramGame_score.setValue(10)
self.paramGame_score.setTickInterval(1)
self.paramGame_score.valueChanged.connect(self.setLimitScore)
self.paramGame_scoreTitle = QLabel(" Choisir le score : {} points"\
.format(self.paramGame_score.value()))
self.design_title = QLabel("Fond du jeu :")
self.design_menu = DropDownMenu(self, self.controller, "fond",
BACKGROUND_LIST)
self.paramGame_Ok = QPushButton("Valider")
self.paramGame_Ok.clicked.connect(self.unactivateFrame3)
# layout paramètre game
self.frame3 = QFrame()
self.layoutV3 = QVBoxLayout()
self.frame3.setLayout(self.layoutV3)
self.layoutV3.addWidget(self.paramGame)
self.layoutV3.addWidget(self.paramGame_title)
self.layoutV3.addWidget(self.paramGame_menu)
self.frame3_1 = QFrame()
self.underLayout1 = QVBoxLayout()
self.frame3_1.setLayout(self.underLayout1)
self.underLayout1.addWidget(self.paramGame_timeTitle)
self.underLayout1.addWidget(self.paramGame_time)
self.frame3_1.hide()
self.layoutV3.addWidget(self.frame3_1)
self.frame3_2 = QFrame()
self.underLayout3 = QVBoxLayout()
self.frame3_2.setLayout(self.underLayout3)
self.underLayout3.addWidget(self.paramGame_scoreTitle)
self.underLayout3.addWidget(self.paramGame_score)
self.frame3_2.hide()
self.layoutV3.addWidget(self.frame3_2)
self.layoutV3.addWidget(self.design_title)
self.layoutV3.addWidget(self.design_menu)
self.layoutV3.addWidget(self.paramGame_Ok)
self.frame3.hide()
self.layoutVG.addWidget(self.frame3)
self.layoutVG.addItem(self.spacerItem1)
self.score1 = QLabel("Score : ")
self.score2 = QLabel("{} : {} \ {} : {}".format(
self.controller.playerList[0].name,
self.controller.playerList[0].score,
self.controller.playerList[1].name,
self.controller.playerList[1].score))
self.score2.setFont(QFont("?", 16, QFont.Bold))
self.chrono = QLabel("00:00:00")
self.chrono.setFont(QFont("?", 16, QFont.Bold))
self.launch = QPushButton("Lancer une partie")
self.launch.clicked.connect(self.launchGame)
self.leave = QPushButton("Quitter")
self.leave.clicked.connect(self.leaveGame)
self.highScore = QPushButton("Highscores")
self.highScore.clicked.connect(self.showHighScore)
self.pause = QLabel("Appuyer sur la touche P pour mettre la partie en"\
" pause")
self.view = GraphicView(self, self.timer, self.controller)
layoutH1 = QHBoxLayout()
layoutH1.addWidget(self.launch)
layoutH1.addWidget(self.leave)
layoutH1.addWidget(self.highScore)
layoutH3 = QHBoxLayout()
layoutH3.addSpacing(150)
layoutH3.addWidget(self.pause)
layoutH2 = QHBoxLayout()
layoutH2.addSpacing(150)
layoutH2.addWidget(self.score2)
layoutH2.addWidget(self.chrono)
layoutVC = QVBoxLayout()
layoutVC.addLayout(layoutH1)
layoutVC.addLayout(layoutH3)
layoutVC.addWidget(self.view)
layoutVC.addLayout(layoutH2)
self.frameD = QFrame()
self.frameD.hide()
layoutVD = QHBoxLayout()
self.frameD.setLayout(layoutVD)
layoutV_gamemode1 = QVBoxLayout()
layoutV_gamemode2 = QVBoxLayout()
layoutVD.addLayout(layoutV_gamemode1)
layoutVD.addSpacing(20)
layoutVD.addLayout(layoutV_gamemode2)
highScoreTitle1 = QLabel("Best time")
highScoreTitle1.setFont(QFont("?", 12, QFont.Bold))
highScoreSubtitle1 = QLabel("score 10 goals")
highScoreSubtitle1.setFont(QFont("?", 12, QFont.Bold))
gm1_score1 = QLabel()
gm1_score2 = QLabel()
gm1_score3 = QLabel()
gm1_score4 = QLabel()
gm1_score5 = QLabel()
highScoreTitle2 = QLabel("Number of goals")
highScoreTitle2.setFont(QFont("?", 12, QFont.Bold))
highScoreSubtitle2 = QLabel("in 2 min")
highScoreSubtitle2.setFont(QFont("?", 12, QFont.Bold))
gm2_score1 = QLabel()
gm2_score2 = QLabel()
gm2_score3 = QLabel()
gm2_score4 = QLabel()
gm2_score5 = QLabel()
self.highscore_gm1 = [
gm1_score1, gm1_score2, gm1_score3, gm1_score4, gm1_score5
]
self.highscore_gm2 = [
gm2_score1, gm2_score2, gm2_score3, gm2_score4, gm2_score5
]
layoutV_gamemode1.addSpacing(100)
layoutV_gamemode1.addWidget(highScoreTitle1)
layoutV_gamemode1.addWidget(highScoreSubtitle1)
layoutV_gamemode1.addSpacing(50)
layoutV_gamemode2.addSpacing(100)
layoutV_gamemode2.addWidget(highScoreTitle2)
layoutV_gamemode2.addWidget(highScoreSubtitle2)
layoutV_gamemode2.addSpacing(50)
for qlabel in self.highscore_gm1:
layoutV_gamemode1.addWidget(qlabel)
for qlabel in self.highscore_gm2:
layoutV_gamemode2.addWidget(qlabel)
layoutV_gamemode1.addSpacing(400)
layoutV_gamemode2.addSpacing(400)
self.mainLayout = QHBoxLayout()
self.mainLayout.addLayout(self.layoutVG)
self.mainLayout.addLayout(layoutVC)
self.mainLayout.addWidget(self.frameD)
self.setLayout(self.mainLayout)
self.controller.refresh()
def refresh(self):
self.score2.setText(
("{} : {} | {} : {}".format(self.controller.playerList[0].name,
self.controller.playerList[0].score,
self.controller.playerList[1].name,
self.controller.playerList[1].score)))
self.chrono.setText(self.controller.getTime())
self.paramGame_scoreTitle.setText("Choisir le score : {} \
points" .format(\
self.paramGame_score.value()))
self.paramGame_timeTitle.setText("Choisir le temps : {} \
secondes" .format(\
self.paramGame_time.value()))
self.activateFrame()
if self.pop == True:
self.popUp()
# mode de jeu
def activate(self, number):
if number == 1:
self.frame1.show()
elif number == 2:
self.frame2.show()
elif number == 3:
self.frame3.show()
def unactivate(self, number):
if number == 1:
self.frame1.hide()
elif number == 2:
self.frame2.hide()
elif number == 3:
self.frame3.hide()
def setPlayer(self, playerNum, playerType):
"""
define if player is robot or human (user choice)
"""
self.controller.setPlayer(playerNum, playerType)
if playerNum == 0:
if playerType == Controller.PLAYER:
self.frame1_1.show()
elif playerType == Controller.AI:
self.frame1_1.hide()
if playerNum == 1:
if playerType == Controller.PLAYER:
self.frame2_1.show()
elif playerType == Controller.AI:
self.frame2_1.hide()
self.controller.refresh()
def setPlayerName(self, playerNum, name):
self.controller.setPlayerName(playerNum, name)
self.controller.refresh()
def activateFrame(self):
if self.controller.game.gamemode == GAMEMODES[2]:
self.frame3_2.show()
else:
self.frame3_2.hide()
if self.controller.game.gamemode == GAMEMODES[3]:
self.frame3_1.show()
else:
self.frame3_1.hide()
def setLimitTime(self):
self.controller.setLimitTime(self.paramGame_time.value())
def setLimitScore(self):
self.controller.setLimitScore(self.paramGame_score.value())
def launchGame(self):
self.controller.setGame()
self.pop = True
def popUp(self):
winner = self.controller.game.winner
score = self.controller.game.getScore()
time = self.controller.time
convertedTime = self.controller.convertTime(time)
self.window = QMessageBox()
if winner:
self.window.setText("Le joueur {} a gagné sur le score de {} en {}"\
.format(winner, score, convertedTime))
else:
self.window.setText("Match nul")
if self.controller.game.stop:
self.window.show()
self.pop = False
def leaveGame(self):
self.app.quit()
def showHighScore(self):
highscore = self.controller.getHighScore()
if self.activeHighScore is False:
self.activeHighScore = True
self.frameD.show()
for indice, liste in enumerate(
[self.highscore_gm1, self.highscore_gm2]):
h = highscore[indice]
for i, qlabel in enumerate(liste):
string = h[i]
qlabel.setText("{}. {}".format(i + 1, string))
else:
self.activeHighScore = False
self.frameD.hide()
class CustomMainWindow(QMainWindow):
def __init__(self):
super(CustomMainWindow, self).__init__()
# -------------------------------- #
# Window setup #
# -------------------------------- #
# 1. Define the geometry of the main window
# ------------------------------------------
self.setGeometry(300, 300, 800, 400)
self.setWindowTitle("QScintilla Test")
# 2. Create frame and layout
# ---------------------------
self.__frm = QFrame(self)
self.__frm.setStyleSheet("QWidget { background-color: #ffeaeaea }")
self.__lyt = QVBoxLayout()
self.__frm.setLayout(self.__lyt)
self.setCentralWidget(self.__frm)
self.__myFont = QFont()
self.__myFont.setPointSize(14)
# 3. Place a button
# ------------------
self.__btn = QPushButton("Qsci")
self.__btn.setFixedWidth(50)
self.__btn.setFixedHeight(50)
self.__btn.clicked.connect(self.__btn_action)
self.__btn.setFont(self.__myFont)
self.__lyt.addWidget(self.__btn)
# -------------------------------- #
# QScintilla editor setup #
# -------------------------------- #
# ! Make instance of QSciScintilla class!
# ----------------------------------------
self.__editor = QsciScintilla()
self.__editor.setText("This\n") # Line 1
self.__editor.append("is\n") # Line 2
self.__editor.append("a\n") # Line 3
self.__editor.append("QScintilla\n") # Line 4
self.__editor.append("test\n") # Line 5
self.__editor.append("program\n") # Line 6
self.__editor.append("to\n") # Line 7
self.__editor.append("illustrate\n") # Line 8
self.__editor.append("some\n") # Line 9
self.__editor.append("basic\n") # Line 10
self.__editor.append("functions.") # Line 11
self.__editor.setLexer(None)
self.__editor.setUtf8(True) # Set encoding to UTF-8
self.__editor.setFont(self.__myFont)
# 1. Text wrapping
# -----------------
self.__editor.setWrapMode(QsciScintilla.WrapWord)
self.__editor.setWrapVisualFlags(QsciScintilla.WrapFlagByText)
self.__editor.setWrapIndentMode(QsciScintilla.WrapIndentIndented)
# 2. End-of-line mode
# --------------------
self.__editor.setEolMode(QsciScintilla.EolWindows)
self.__editor.setEolVisibility(False)
# 3. Indentation
# ---------------
self.__editor.setIndentationsUseTabs(False)
self.__editor.setTabWidth(4)
self.__editor.setIndentationGuides(True)
self.__editor.setTabIndents(True)
self.__editor.setAutoIndent(True)
# 4. Caret
# ---------
self.__editor.setCaretForegroundColor(QColor("#ff0000ff"))
self.__editor.setCaretLineVisible(True)
self.__editor.setCaretLineBackgroundColor(QColor("#1f0000ff"))
self.__editor.setCaretWidth(2)
# 5. Margins
# -----------
# Margin 0 = Line nr margin
self.__editor.setMarginType(0, QsciScintilla.NumberMargin)
self.__editor.setMarginWidth(0, "0000")
self.__editor.setMarginsForegroundColor(QColor("#ff888888"))
# Margin 1 = Symbol margin
self.__editor.setMarginType(1, QsciScintilla.SymbolMargin)
self.__editor.setMarginWidth(1, "00000")
sym_0 = QImage("icons/sym_0.png").scaled(QSize(16, 16))
sym_1 = QImage("icons/sym_1.png").scaled(QSize(16, 16))
sym_2 = QImage("icons/sym_2.png").scaled(QSize(16, 16))
sym_3 = QImage("icons/sym_3.png").scaled(QSize(16, 16))
self.__editor.markerDefine(sym_0, 0)
self.__editor.markerDefine(sym_1, 1)
self.__editor.markerDefine(sym_2, 2)
self.__editor.markerDefine(sym_3, 3)
self.__editor.setMarginMarkerMask(1, 0b1111)
# Display a few symbols, and keep their handles stored
handle_01 = self.__editor.markerAdd(0, 0) # Green dot on line 0+1
handle_02 = self.__editor.markerAdd(4, 0) # Green dot on line 4+1
handle_03 = self.__editor.markerAdd(5, 0) # Green dot on line 5+1
handle_04 = self.__editor.markerAdd(8, 3) # Red arrow on line 8+1
handle_05 = self.__editor.markerAdd(9, 2) # Red dot on line 9+1
# ! Add editor to layout !
# -------------------------
self.__lyt.addWidget(self.__editor)
self.show()
''''''
def __btn_action(self):
print("Hello World!")
''''''
def make_page(self):
page = QFrame()
layout = QVBoxLayout()
page.setLayout( layout )
line1 = QFrame()
layout1 = QHBoxLayout()
line1.setLayout( layout1 )
layout.addWidget( line1 )
line2 = QFrame()
layout2 = QHBoxLayout()
line2.setLayout( layout2 )
layout.addWidget( line2 )
self.edit_style = QComboBoxNoWheel()
self.edit_style.addItem("Radius")
self.edit_style.addItem("% Height")
self.edit_style.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_style)
layout1.addWidget( QLabel("<b>Radius:</b> ") )
self.edit_size = QLineEdit()
self.edit_size.setFixedWidth(50)
self.edit_size.textChanged.connect(self.onChange)
layout1.addWidget( self.edit_size )
self.edit_start = QComboBoxNoWheel()
self.edit_start.addItem("-")
self.edit_start.addItem("1")
self.edit_start.addItem("2")
self.edit_start.addItem("3")
self.edit_start.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_start)
self.edit_end = QComboBoxNoWheel()
self.edit_end.addItem("-")
self.edit_end.addItem("1")
self.edit_end.addItem("2")
self.edit_end.addItem("3")
self.edit_end.currentIndexChanged.connect(self.onChange)
layout1.addWidget(self.edit_end)
layout1.addStretch(1)
delete = QPushButton('Delete')
delete.clicked.connect(self.delete_self)
layout1.addWidget(delete)
layout2.addWidget( QLabel("<b>Pos:</b> ") )
self.edit_posref = QComboBoxNoWheel()
self.edit_posref.addItem("Chord %")
self.edit_posref.addItem("Rel Front")
self.edit_posref.addItem("Rel Rear")
self.edit_posref.addItem("Abs Pos")
self.edit_posref.currentIndexChanged.connect(self.onChange)
layout2.addWidget(self.edit_posref)
self.edit_pos = QLineEdit()
self.edit_pos.setFixedWidth(50)
self.edit_pos.textChanged.connect(self.onChange)
layout2.addWidget( self.edit_pos )
layout2.addStretch(1)
return page
def __init_ui(self):
layout = QVBoxLayout()
layout.setContentsMargins(2, 2, 2, 2)
layout.setSpacing(2)
control_frame = QFrame(self)
control_frame.setFrameStyle(QFrame.Panel)
control_frame.setLineWidth(1)
control_layout = QHBoxLayout()
control_layout.setAlignment(Qt.AlignLeft)
control_layout.setContentsMargins(2, 2, 2, 2)
control_layout.setSpacing(3)
low_label = QLabel("low limit:")
low_label.setFixedWidth(60)
control_layout.addWidget(low_label)
self.__lower_edit: LimitValueLineEdit = LimitValueLineEdit(
"lower limit")
self.__lower_edit.setMaximumWidth(80)
self.__lower_edit.deselect()
self.__lower_edit.setAlignment(Qt.AlignLeft)
self.__lower_edit.value_changed.connect(self.__handle_lower_limit_edit)
control_layout.addWidget(self.__lower_edit)
control_layout.addSpacing(10)
high_label = QLabel("high limit:")
high_label.setFixedWidth(60)
control_layout.addWidget(high_label)
self.__upper_edit: LimitValueLineEdit = LimitValueLineEdit(
"upper limit")
self.__upper_edit.setMaximumWidth(80)
self.__upper_edit.deselect()
self.__upper_edit.setAlignment(Qt.AlignLeft)
self.__upper_edit.value_changed.connect(self.__handle_upper_limit_edit)
control_layout.addWidget(self.__upper_edit)
control_layout.addSpacing(10)
self.__reset_button = QPushButton("Reset")
self.__reset_button.setFixedWidth(60)
self.__reset_button.clicked.connect(self.__handle_reset_clicked)
control_layout.addWidget(self.__reset_button)
control_frame.setLayout(control_layout)
layout.addWidget(control_frame)
# plot_frame = QGroupBox(self)
plot_frame = QFrame(self)
plot_frame.setFrameStyle(QFrame.Panel)
plot_frame.setLineWidth(1)
# plot_frame = QWidget(self)
plot_layout = QHBoxLayout()
plot_layout.setContentsMargins(2, 2, 2, 2)
plot_layout.setSpacing(2)
plot_layout.addWidget(self.__raw_data_canvas)
plot_layout.addWidget(self.__adjusted_data_canvas)
plot_frame.setLayout(plot_layout)
layout.addWidget(plot_frame)
self.setLayout(layout)
class VideoFinderAddLink(AddLinkWindow):
formats_showing = []
media_title = ''
running_thread = None
threadPool = {}
def __init__(self, parent, receiver_slot, settings, video_dict={}):
super().__init__(parent, receiver_slot, settings, video_dict)
self.setWindowTitle(
QCoreApplication.translate("ytaddlink_src_ui_tr", 'Video Finder'))
self.size_label.hide()
# add support for other languages
locale = str(self.persepolis_setting.value('settings/locale'))
QLocale.setDefault(QLocale(locale))
self.translator = QTranslator()
if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
QCoreApplication.installTranslator(self.translator)
# Fetch Button
self.url_submit_button = QPushButton(self.link_frame)
self.link_horizontalLayout.addWidget(self.url_submit_button)
# Status Box
self.status_box = QTextEdit(self.link_frame)
self.status_box.setMaximumHeight(150)
self.link_verticalLayout.addWidget(self.status_box)
# Select format horizontal layout
select_format_hl = QHBoxLayout()
# Selection Label
select_format_label = QLabel(self.link_frame)
select_format_hl.addWidget(select_format_label)
# Selection combobox
self.media_combo = QComboBox(self.link_frame)
self.media_combo.setMinimumWidth(200)
select_format_hl.addWidget(self.media_combo)
# Duration label
self.duration_label = QLabel(self.link_frame)
select_format_hl.addWidget(self.duration_label)
self.selection_line = QFrame(self)
self.selection_line.setLayout(select_format_hl)
self.link_verticalLayout.addWidget(self.selection_line)
# Set Texts
self.url_submit_button.setText(
QCoreApplication.translate("ytaddlink_src_ui_tr",
'Fetch Media List'))
self.ok_pushButton.setText(
QCoreApplication.translate("ytaddlink_src_ui_tr", 'Download Now'))
select_format_label.setText(
QCoreApplication.translate("ytaddlink_src_ui_tr",
'Select a format'))
# Add Slot Connections
self.url_submit_button.setEnabled(False)
self.change_name_lineEdit.setEnabled(False)
self.ok_pushButton.setEnabled(False)
self.download_later_pushButton.setEnabled(False)
self.url_submit_button.clicked.connect(self.submit_clicked)
self.media_combo.currentIndexChanged.connect(
self.media_selection_changed)
self.link_lineEdit.textChanged.disconnect(
super().linkLineChanged) # Should be disconnected.
self.link_lineEdit.textChanged.connect(self.linkLineChangedHere)
self.setMinimumSize(500, 400)
self.status_box.hide()
self.selection_line.hide()
if 'link' in video_dict.keys() and video_dict['link']:
self.link_lineEdit.setText(video_dict['link'])
self.url_submit_button.setEnabled(True)
else:
# check clipboard
clipboard = QApplication.clipboard()
text = clipboard.text()
if (("tp:/" in text[2:6]) or ("tps:/" in text[2:7])):
self.link_lineEdit.setText(str(text))
self.url_submit_button.setEnabled(True)
# Define native slots
def url_changed(self, value):
if ' ' in value or value == '':
self.url_submit_button.setEnabled(False)
self.url_submit_button.setToolTip(
QCoreApplication.translate("ytaddlink_src_ui_tr",
'Please enter a valid video link'))
else:
self.url_submit_button.setEnabled(True)
self.url_submit_button.setToolTip('')
def submit_clicked(self, button=None):
# Clear media list
self.media_combo.clear()
self.selection_line.hide()
self.change_name_lineEdit.clear()
self.threadPool.clear()
self.change_name_checkBox.setChecked(False)
self.formats_showing.clear()
self.url_submit_button.setEnabled(False)
self.status_box.setText(
QCoreApplication.translate("ytaddlink_src_ui_tr",
'Fetching Media Info...'))
self.status_box.show()
self.ok_pushButton.setEnabled(False)
self.download_later_pushButton.setEnabled(False)
dictionary_to_send = deepcopy(self.plugin_add_link_dictionary)
# More options
more_options = self.collect_more_options()
for k in more_options.keys():
dictionary_to_send[k] = more_options[k]
dictionary_to_send['link'] = self.link_lineEdit.text()
fetcher_thread = MediaListFetcherThread(self.fetched_result,
dictionary_to_send, self)
self.running_thread = fetcher_thread
fetcher_thread.start()
def filename_changed(self, value):
if value.strip() == '':
self.ok_pushButton.setEnabled(False)
def media_selection_changed(self):
try:
self.change_name_lineEdit.setText(
self.media_title + '.' +
self.formats_showing[self.media_combo.currentIndex()]['ext'])
self.change_name_checkBox.setChecked(True)
except Exception as ex:
logger.sendToLog(ex, "ERROR")
def okButtonPressed(self, button, download_later):
index = self.media_combo.currentIndex()
self.link_lineEdit.setText(self.formats_showing[index]['url'])
super().okButtonPressed(button, download_later)
def fetched_result(self, media_dict):
self.url_submit_button.setEnabled(True)
if STATUS.DOWNLOAD.ERROR in media_dict.keys():
self.status_box.setText('<font color="#f11">' +
str(media_dict[STATUS.DOWNLOAD.ERROR]) +
'</font>')
self.status_box.show()
else: # Show the media list
self.media_title = media_dict['title']
i = 0
if 'formats' not in media_dict.keys(
) and 'entries' in media_dict.keys():
formats = media_dict['entries']
formats = formats[0]
media_dict['formats'] = formats['formats']
elif 'formats' not in media_dict.keys(
) and 'format' in media_dict.keys():
media_dict['formats'] = [media_dict.copy()]
try:
for f in media_dict['formats']:
text = ''
if 'acodec' in f.keys():
if f['acodec'] == 'none' and f[
'vcodec'] != 'none' and self.persepolis_setting.value(
'settings/video_finder/hide_no_audio',
'yes') == 'yes':
continue
if f['acodec'] == 'none':
text = text + '- No Audio'
if 'vcodec' in f.keys():
if f['vcodec'] == 'none' and f[
'acodec'] != 'none' and self.persepolis_setting.value(
'settings/video_finder/hide_no_video',
'yes') == 'yes':
continue
if f['vcodec'] == 'none': # No video, show audio bit rate
text = text + '- Only Audio {}kbps'.format(
f['abr'])
if 'height' in f.keys():
text = text + ' ' + '{}p'.format(f['height'])
if 'ext' in f.keys():
text = text + ' ' + '.{}'.format(f['ext'])
if 'filesize' in f.keys() and f['filesize']:
# Youtube api does not supply file size for some formats, so check it.
text = text + ' ' + '{}'.format(
get_readable_size(f['filesize']))
else: # Start spider to find file size
input_dict = deepcopy(self.plugin_add_link_dictionary)
# input_dict['out'] = self.media_title + str(f['ext'])
input_dict['link'] = f['url']
more_options = self.collect_more_options()
for key in more_options.keys():
input_dict[key] = more_options[key]
size_fetcher = FileSizeFetcherThread(
input_dict, i, self.file_size_found)
self.threadPool[str(i)] = {
'thread': size_fetcher,
'item_id': i
}
size_fetcher.start()
# Add current format to combobox
self.formats_showing.append(f)
self.media_combo.addItem(text)
i = i + 1
except Exception as ex:
logger.sendToLog(ex, "ERROR")
self.status_box.hide()
if 'duration' in media_dict.keys():
self.duration_label.setText(
'Duration ' +
get_readable_duration(media_dict['duration']))
self.selection_line.show()
self.ok_pushButton.setEnabled(True)
self.download_later_pushButton.setEnabled(True)
def file_size_found(self, result):
try:
item_id = self.threadPool[str(result['thread_key'])]['item_id']
if result['file_size'] and result['file_size'] != '0':
text = self.media_combo.itemText(item_id)
self.media_combo.setItemText(
item_id, '{} - {}'.format(text, result['file_size']))
else: # Retry
sleep(0.8)
self.threadPool[str(result['thread_key'])]['thread'].start()
except Exception as ex:
logger.sendToLog(ex, "ERROR")
def linkLineChangedHere(self, lineEdit):
if str(lineEdit) == '':
self.url_submit_button.setEnabled(False)
else:
self.url_submit_button.setEnabled(True)
# This method collects additional information like proxy ip, user, password etc.
def collect_more_options(self):
options = {
'ip': None,
'port': None,
'proxy_user': None,
'proxy_passwd': None,
'download_user': None,
'download_passwd': None
}
if self.proxy_checkBox.isChecked():
options['ip'] = self.ip_lineEdit.text()
options['port'] = self.port_spinBox.value()
options['proxy_user'] = self.proxy_user_lineEdit.text()
options['proxy_passwd'] = self.proxy_pass_lineEdit.text()
if self.download_checkBox.isChecked():
options['download_user'] = self.download_user_lineEdit.text()
options['download_passwd'] = self.download_pass_lineEdit.text()
# These info (keys) are required for spider to find file size, because spider() does not check if key exists.
additional_info = [
'header', 'load_cookies', 'user_agent', 'referer', 'out'
]
for i in additional_info:
if i not in self.plugin_add_link_dictionary.keys():
options[i] = None
return options
def _setup_(self):
self._image_control = ImageRenderWidget()
self._image_control.overlay_layers.append(self._selection_layer)
self._layout.addWidget(self._image_control, 0, 0, 1, 10,
Qt.AlignCenter)
self._timeline = QJumpSlider(Qt.Horizontal)
self._timeline.setEnabled(False)
self._timeline.valueChangedSmart.connect(self._display_time_code_)
self._layout.addWidget(self._timeline, 1, 4)
self._current_time = QLabel('0.000')
self._total_time = QLabel('0.000')
self._frame_box = QLabel('(Frame: 0000)')
self._layout.addWidget(self._current_time, 1, 5)
self._layout.addWidget(QLabel('/'), 1, 6)
self._layout.addWidget(self._total_time, 1, 7)
self._layout.addWidget(QLabel(' s'), 1, 8)
self._layout.addWidget(self._frame_box, 1, 9)
self._play_button = QPushButton()
self._play_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self._play_button.setEnabled(False)
self._play_button.clicked.connect(self._play_pause_)
self._layout.addWidget(self._play_button, 1, 0)
self._stop_button = QPushButton()
self._stop_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaStop))
self._stop_button.setEnabled(False)
self._stop_button.clicked.connect(self.stop)
self._layout.addWidget(self._stop_button, 1, 1)
self._next_frame_button = QPushButton()
self._next_frame_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipForward))
self._next_frame_button.setEnabled(False)
self._next_frame_button.clicked.connect(self.next_frame)
self._layout.addWidget(self._next_frame_button, 1, 3)
self._previous_frame_button = QPushButton()
self._previous_frame_button.setIcon(self.style().standardIcon(
QStyle.SP_MediaSkipBackward))
self._previous_frame_button.setEnabled(False)
self._previous_frame_button.clicked.connect(self.previous_frame)
self._layout.addWidget(self._previous_frame_button, 1, 2)
roi_frame = QFrame()
roi_layout = QHBoxLayout()
roi_frame.setLayout(roi_layout)
roi_frame.setFixedHeight(38)
roi_layout.addWidget(QLabel('ROI: ['))
roi_layout.addWidget(QLabel('x:'))
self._box_roi_x = QSpinBox()
roi_layout.addWidget(self._box_roi_x)
roi_layout.addWidget(QLabel('y:'))
self._box_roi_y = QSpinBox()
roi_layout.addWidget(self._box_roi_y)
roi_layout.addWidget(QLabel('width:'))
self._box_roi_width = QSpinBox()
roi_layout.addWidget(self._box_roi_width)
roi_layout.addWidget(QLabel('height:'))
self._box_roi_height = QSpinBox()
roi_layout.addWidget(self._box_roi_height)
roi_layout.addWidget(QLabel(']'))
roi_reset_button = QPushButton('Reset')
roi_reset_button.clicked.connect(self.reset_roi)
roi_layout.addWidget(roi_reset_button)
self._box_roi_x.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_y.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_width.valueChanged.connect(self._roi_box_value_changed_)
self._box_roi_height.valueChanged.connect(self._roi_box_value_changed_)
self._layout.addWidget(roi_frame, 2, 0, 1, 9, Qt.AlignLeft)
def __setup_ui__(self):
# 工具栏
self.frame_tool = QFrame(self)
self.frame_tool.setObjectName("frame_tool")
self.frame_tool.setGeometry(0, 0, self.width(), 25)
self.frame_tool.setStyleSheet("border-color: rgb(0, 0, 0);")
self.frame_tool.setFrameShape(QFrame.Panel)
self.frame_tool.setFrameShadow(QFrame.Raised)
# 1.1 界面1按钮
self.window1_btn = QToolButton(self.frame_tool)
self.window1_btn.setCheckable(True)
self.window1_btn.setText("window1")
self.window1_btn.setObjectName("menu_btn")
self.window1_btn.resize(100, 25)
self.window1_btn.clicked.connect(self.click_window1)
self.window1_btn.setAutoRaise(
True) # 去掉工具按钮的边框线如果是QPushButton按钮的话，就是用setFlat(True)这个方法，用法相同
# 1.2 界面2按钮
self.window2_btn = QToolButton(self.frame_tool)
self.window2_btn.setCheckable(True)
self.window2_btn.setText("window2")
self.window2_btn.setObjectName("menu_btn")
self.window2_btn.resize(100, 25)
self.window2_btn.move(self.window1_btn.width(), 0)
self.window2_btn.clicked.connect(self.click_window2)
self.window2_btn.setAutoRaise(True)
self.btn_group = QButtonGroup(self.frame_tool)
self.btn_group.addButton(self.window1_btn, 1)
self.btn_group.addButton(self.window2_btn, 2)
# 1.3 帮助下拉菜单栏
# 创建帮助工具按钮
help_btn = QToolButton(self.frame_tool)
help_btn.setText("帮助")
help_btn.setObjectName("menu_btn")
help_btn.resize(100, 25)
help_btn.move(self.window2_btn.x() + self.window2_btn.width(), 0)
help_btn.setAutoRaise(True)
help_btn.setPopupMode(QToolButton.InstantPopup)
# 创建关于菜单
help_menu = QMenu("帮助", self.frame_tool)
feedback_action = QAction(QIcon("xxx.png"), "反馈", help_menu)
feedback_action.triggered.connect(self.click_feedback)
about_action = QAction(QIcon("xxx.png"), "关于", help_menu)
about_action.triggered.connect(self.click_about)
# 把两个QAction放入help_menu
help_menu.addAction(feedback_action)
help_menu.addAction(about_action)
# 把help_menu放入help_btn
help_btn.setMenu(help_menu)
# 2. 工作区域
self.main_frame = QFrame(self)
self.main_frame.setGeometry(0, 25, self.width(),
self.height() - self.frame_tool.height())
# self.main_frame.setStyleSheet("background-color: rgb(65, 95, 255)")
# 创建堆叠布局
self.stacked_layout = QStackedLayout(self.main_frame)
# 第一个布局
self.main_frame1 = QMainWindow()
self.frame1_bar = QStatusBar()
self.frame1_bar.setObjectName("frame1_bar")
self.main_frame1.setStatusBar(self.frame1_bar)
self.frame1_bar.showMessage("欢迎进入frame1")
rom_frame = QFrame(self.main_frame1)
rom_frame.setGeometry(0, 0, self.width(),
self.main_frame.height() - 25)
rom_frame.setFrameShape(QFrame.Panel)
rom_frame.setFrameShadow(QFrame.Raised)
# 超链接
self.super_link = QLabel(rom_frame)
self.super_link.setText("""
超链接: <a href="https://blog.csdn.net/s_daqing">点击打开查看</a>
""")
self.super_link.setGeometry(20, 30, 300, 25)
self.super_link.setFont(self.content_font) # 使用字体样式
self.super_link.setOpenExternalLinks(True) # 使其成为超链接
self.super_link.setTextInteractionFlags(
Qt.TextBrowserInteraction) # 双击可以复制文本
self.start_btn = QPushButton("开 始", rom_frame)
self.start_btn.setGeometry(self.width() * 0.7,
self.height() * 0.8, 100, 40)
# self.start_btn.clicked.connect(self.start_btn_click)
self.quit_btn = QPushButton("退 出", rom_frame)
self.quit_btn.setGeometry(self.width() * 0.85,
self.height() * 0.8, 100, 40)
self.quit_btn.setStatusTip("点击关闭程序")
# self.quit_btn.clicked.connect(QCoreApplication.instance().quit) # 点击退出可以直接退出
self.quit_btn.clicked.connect(self.close) # 点击退出按钮的退出槽函数
#rom_frame1 = QFrame()
#rom_frame1.setFrameShape(QFrame.Panel)
#rom_frame1.setFrameShadow(QFrame.Raised)
#rom_frame2 = QFrame()
#rom_frame2.setFrameShape(QFrame.Panel)
#rom_frame2.setFrameShadow(QFrame.Raised)
# 创建布局管理器
self.layout1 = QBoxLayout(QBoxLayout.TopToBottom)
# 给管理器对象设置父控件
rom_frame.setLayout(self.layout1)
self.main_frame1.setCentralWidget(rom_frame)
# 把子控件添加到布局管理器中
#self.layout1.addWidget(rom_frame1, 1)
#self.layout1.addWidget(rom_frame2, 1)
self.layout1.setContentsMargins(0, 0, 0, 0) # 设置布局的左上右下外边距
self.layout1.setSpacing(0) # 设置子控件的内边距
frame1_bar_frame = QFrame(self.main_frame1)
frame1_bar_frame.setGeometry(0, self.main_frame.height(), self.width(),
25)
# 第二个布局
self.main_frame2 = QMainWindow()
self.frame2_bar = QStatusBar()
self.frame2_bar.setObjectName("frame2_bar")
self.main_frame2.setStatusBar(self.frame2_bar)
self.frame2_bar.showMessage("欢迎进入frame2")
custom_frame = QFrame(self.main_frame2)
custom_frame.setGeometry(0, 0, self.width(),
self.main_frame.height() - 25)
custom_frame.setFrameShape(QFrame.Panel)
custom_frame.setFrameShadow(QFrame.Raised)
custom_frame1 = QFrame()
custom_frame1.setFrameShape(QFrame.Panel)
custom_frame1.setFrameShadow(QFrame.Raised)
custom_frame2 = QFrame()
custom_frame2.setFrameShape(QFrame.Panel)
custom_frame2.setFrameShadow(QFrame.Raised)
custom_frame3 = QFrame()
custom_frame3.setFrameShape(QFrame.Panel)
custom_frame3.setFrameShadow(QFrame.Raised)
# 创建布局管理器
self.layout2 = QBoxLayout(QBoxLayout.TopToBottom)
# 给管理器对象设置父控件
custom_frame.setLayout(self.layout2)
"""
使用了父类为QMainWindow的话，在里面使用布局类，QGridLayout， QHBoxLayout ，QVBoxLayout 等等时，发现不好用，
加上下面这句代码就可以了，QMainWindow对象.setCentralWidget(这里填布局管理器的父控件对象)
"""
self.main_frame2.setCentralWidget(custom_frame)
# 把子控件添加到布局管理器中
self.layout2.addWidget(custom_frame1, 1)
self.layout2.addWidget(custom_frame2, 1)
self.layout2.addWidget(custom_frame3, 1)
self.layout2.setContentsMargins(0, 0, 0, 0) # 设置布局的左上右下外边距
self.layout2.setSpacing(0) # 设置子控件的内边距
frame2_bar_frame = QFrame(self.main_frame2)
frame2_bar_frame.setGeometry(0, self.main_frame.height(), self.width(),
25)
# 把两个布局放进去
self.stacked_layout.addWidget(self.main_frame1)
self.stacked_layout.addWidget(self.main_frame2)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowSystemMenuHint)
self.setWindowModality(QtCore.Qt.WindowModal)
global par
par = parent
global int_lng
int_lng = par.interface_lng_val
# ------------------------------------Первый блок формы--------------------------------------
if int_lng == 'Russian':
file_create_lbl = QLabel("Укажите имя файла:")
elif int_lng == 'English':
file_create_lbl = QLabel("Enter file name:")
file_hbox = QHBoxLayout()
file_hbox.addWidget(file_create_lbl)
self.file_edit = QLineEdit()
self.file_edit.setFixedSize(200, 27)
file_hbox.addWidget(self.file_edit)
if int_lng == 'Russian':
object_create_lbl = QLabel("Укажите имя объекта:")
elif int_lng == 'English':
object_create_lbl = QLabel("Enter object name:")
object_hbox = QHBoxLayout()
object_hbox.addWidget(object_create_lbl)
self.object_edit = QLineEdit()
self.object_edit.setFixedSize(200, 27)
object_hbox.addWidget(self.object_edit)
block_grid = QGridLayout()
block_grid.addLayout(file_hbox, 0, 0)
block_grid.addLayout(object_hbox, 1, 0)
# ---------------------Кнопки сохранения и отмены и их блок-------------------------
if int_lng == 'Russian':
save_button = QPushButton("Сохранить")
cancel_button = QPushButton("Отмена")
elif int_lng == 'English':
save_button = QPushButton("Save")
cancel_button = QPushButton("Cancel")
save_button.setFixedSize(80, 25)
save_button.clicked.connect(self.on_save_clicked)
cancel_button.setFixedSize(80, 25)
cancel_button.clicked.connect(self.on_cancel_clicked)
buttons_hbox = QHBoxLayout()
buttons_hbox.addWidget(save_button)
buttons_hbox.addWidget(cancel_button)
# -------------------------Фрейм формы---------------------------
bound_grid = QGridLayout()
bound_grid.addLayout(block_grid, 0, 0, alignment=QtCore.Qt.AlignCenter)
bound_grid.addLayout(buttons_hbox, 1, 0, alignment=QtCore.Qt.AlignCenter)
bound_frame = QFrame()
bound_frame.setStyleSheet(open("./styles/properties_form_style.qss", "r").read())
bound_frame.setLayout(bound_grid)
bound_vbox = QVBoxLayout()
bound_vbox.addWidget(bound_frame)
# --------------------Размещение на форме всех компонентов---------
form_1 = QFormLayout()
form_1.addRow(bound_vbox)
self.setLayout(form_1)
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_()
def out_frame_func(int_lng, prj_path, mesh_name_txt, patches_visible):
patches_2_obj = None
#----------------Если файл patches_2.pkl существует, получаем данные из него для вывода в форму---------------#
if patches_visible == True:
patches_2_path_file = prj_path + '/' + mesh_name_txt + '/' + 'patches_2.pkl'
if os.path.exists(patches_2_path_file):
input = open(patches_2_path_file, 'rb')
patches_2_obj = pickle.load(input)
input.close()
main_lbl = QLabel()
if int_lng == 'Russian':
main_lbl.setText("Список граней для патчей")
elif int_lng == 'English':
main_lbl.setText("List of faces for patches")
#-------------Формируем внешний вид формы для файла patches_2.pkl на основе данных файла patches_1.pkl----------#
patches_1_path_file = prj_path + '/' + mesh_name_txt + '/' + 'patches_1.pkl'
if os.path.exists(patches_1_path_file):
input = open(patches_1_path_file, 'rb')
obj = pickle.load(input)
input.close()
k = 1
i = 0
p_list = []
fe_main_list = []
f_vbox = QVBoxLayout()
for el_m in obj:
p_name = el_m['patch_' + str(k)]
p_list.append(p_name)
t_name = el_m['type_' + str(k)]
f_name = el_m['faces_' + str(k)]
if el_m['type_' + str(k)] == 'cyclic':
n_name = el_m['neighb_' + str(k)]
patch_lbl = QLabel("Патч: " + p_name + ", " + "Тип: " +
t_name + ", " + "Сосед: " + n_name)
else:
patch_lbl = QLabel("Патч: " + p_name + ", " + "Тип: " +
t_name)
g = 1
b = 0
f_grid = QGridLayout()
f_frame = QFrame()
prs_grid = QGridLayout()
fe_pred_main = []
while g <= f_name:
t = 1
validator = QtGui.QRegExpValidator(
QtCore.QRegExp("[0-9]+"))
f_hbox = QHBoxLayout()
fe_list = []
p = 0
while t <= 4:
face_edit = QLineEdit()
if t == 1:
if int_lng == 'Russian':
face_edit.setToolTip(
"Метка 1 грани блока, входящей в патч")
elif int_lng == 'English':
face_edit.setToolTip(
"Label 1 of the edge of the block included in the patch"
)
elif t == 2:
if int_lng == 'Russian':
face_edit.setToolTip(
"Метка 2 грани блока, входящей в патч")
elif int_lng == 'English':
face_edit.setToolTip(
"Label 2 of the edge of the block included in the patch"
)
elif t == 3:
if int_lng == 'Russian':
face_edit.setToolTip(
"Метка 3 грани блока, входящей в патч")
elif int_lng == 'English':
face_edit.setToolTip(
"Label 3 of the edge of the block included in the patch"
)
elif t == 4:
if int_lng == 'Russian':
face_edit.setToolTip(
"Метка 4 грани блока, входящей в патч")
elif int_lng == 'English':
face_edit.setToolTip(
"Label 4 of the edge of the block included in the patch"
)
if patches_2_obj != None:
face_edit.setText(patches_2_obj[i][p_name][b][p])
face_edit.setFixedSize(30, 21)
face_edit.setValidator(validator)
f_hbox.addWidget(face_edit)
fe_list.append(face_edit)
t = t + 1
p = p + 1
if f_name == 1 and g == 1:
f_grid.addLayout(f_hbox, b, 0)
fe_main_list.append(fe_list)
else:
f_grid.addLayout(f_hbox, b, 0)
fe_pred_main.append(fe_list)
g = g + 1
b = b + 1
if fe_pred_main != []:
fe_main_list.append(fe_pred_main)
prs_grid.addLayout(f_grid, 0, 0)
prs_grid.addWidget(patch_lbl, 0, 1)
f_frame.setLayout(prs_grid)
f_vbox.addWidget(f_frame)
k = k + 1
i = i + 1
prs_frame = QFrame()
prs_frame.setLayout(f_vbox)
# -----------------------Кнопка сохранения------------------------#
patches_2_btnSave = QPushButton()
patches_2_btnSave.setFixedSize(80, 25)
buttons_hbox = QHBoxLayout()
buttons_hbox.addWidget(patches_2_btnSave)
if int_lng == 'Russian':
patches_2_btnSave.setText("Записать")
elif int_lng == 'English':
patches_2_btnSave.setText("Write")
# ---------------------Групповой элемент формы--------------------#
patches_2_grid = QGridLayout()
patches_2_grid.addWidget(main_lbl,
0,
0,
alignment=QtCore.Qt.AlignCenter)
patches_2_grid.addWidget(prs_frame,
1,
0,
alignment=QtCore.Qt.AlignCenter)
patches_2_grid.addLayout(buttons_hbox,
2,
0,
alignment=QtCore.Qt.AlignCenter)
patches_2_grid.setRowStretch(3, 6)
patches_2_group = QGroupBox()
patches_2_group.setLayout(patches_2_grid)
return patches_2_group, patches_2_btnSave, p_list, fe_main_list
def propertyInserted(self, index, afterIndex):
afterItem = self.m_indexToItem[afterIndex]
parentItem = self.m_indexToItem.value(index.parent())
newItem = WidgetItem()
newItem.parent = parentItem
layout = 0
parentWidget = 0
row = -1
if (not afterItem):
row = 0
if (parentItem):
parentItem.children.insert(0, newItem)
else:
self.m_children.insert(0, newItem)
else:
row = self.gridRow(afterItem) + self.gridSpan(afterItem)
if (parentItem):
parentItem.children.insert(parentItem.children.indexOf(afterItem) + 1, newItem)
else:
self.m_children.insert(self.m_children.indexOf(afterItem) + 1, newItem)
if (not parentItem):
layout = self.m_mainLayout
parentWidget = self.q_ptr
else:
if (not parentItem.container):
self.m_recreateQueue.removeAll(parentItem)
grandParent = parentItem.parent
l = 0
oldRow = self.gridRow(parentItem)
if (grandParent):
l = grandParent.layout
else:
l = self.m_mainLayout
container = QFrame()
container.setFrameShape(QFrame.Panel)
container.setFrameShadow(QFrame.Raised)
parentItem.container = container
parentItem.button = self.createButton()
self.m_buttonToItem[parentItem.button] = parentItem
parentItem.button.toggled.connect(self.slotToggled)
parentItem.layout = QGridLayout()
container.setLayout(parentItem.layout)
if (parentItem.label):
l.removeWidget(parentItem.label)
parentItem.label.close()
parentItem.label = 0
span = 1
if (not parentItem.widget and not parentItem.widgetLabel):
span = 2
l.addWidget(parentItem.button, oldRow, 0, 1, span)
self.updateItem(parentItem)
layout = parentItem.layout
parentWidget = parentItem.container
newItem.label = QLabel(parentWidget)
newItem.label.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
newItem.widget = self.createEditor(index.property(), parentWidget)
if (newItem.widget):
newItem.widget.destroyed.connect(self.slotEditorDestroyed)
self.m_widgetToItem[newItem.widget] = newItem
elif (index.property().hasValue()):
newItem.widgetLabel = QLabel(parentWidget)
newItem.widgetLabel.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed))
self.insertRow(layout, row)
span = 1
if (newItem.widget):
layout.addWidget(newItem.widget, row, 1)
elif (newItem.widgetLabel):
layout.addWidget(newItem.widgetLabel, row, 1)
else:
span = 2
layout.addWidget(newItem.label, row, 0, span, 1)
self.m_itemToIndex[newItem] = index
self.m_indexToItem[index] = newItem
self.updateItem(newItem)
def out_frame_func(int_lng, prj_path, mesh_name_txt, pd_2, layers_visible):
layers_obj = None
#----------------Если файл layers.pkl существует, получаем данные из него для вывода в форму---------------#
if layers_visible == True:
layers_path_file = prj_path + '/' + mesh_name_txt + '_' + pd_2 + '/' + 'layers.pkl'
if os.path.exists(layers_path_file):
input = open(layers_path_file, 'rb')
layers_obj = pickle.load(input)
input.close()
#---------------Формируем внешний вид формы для файла layers.pkl на основе данных файла initial.pkl-------------#
main_lbl = QLabel()
if int_lng == 'Russian':
main_lbl.setText("Управление слоями")
elif int_lng == 'English':
main_lbl.setText("Layers control")
initial_path_file = prj_path + '/' + mesh_name_txt + '_' + pd_2 + '/' + 'initial.pkl'
if os.path.exists(initial_path_file):
input = open(initial_path_file, 'rb')
obj_initial = pickle.load(input)
input.close()
prs_grid = QGridLayout()
###########################################Базовые параметры###################################################
layers_prs_base_lbl = QLabel()
if int_lng == 'Russian':
layers_prs_base_lbl.setText("Базовые параметры слоев:")
elif int_lng == 'English':
layers_prs_base_lbl.setText("Base layers parameters:")
prs_grid.addWidget(layers_prs_base_lbl,
0,
0,
alignment=QtCore.Qt.AlignCenter)
layers_prs_base_table = QTableWidget()
layers_prs_base_table.setRowCount(obj_initial['l'])
layers_prs_base_table.setColumnCount(2)
layers_prs_base_table.verticalHeader().hide()
layers_prs_base_table.horizontalHeader().resizeSection(0, 150)
layers_prs_base_table.horizontalHeader().setResizeMode(
0, QtGui.QHeaderView.Fixed)
column_1 = QTableWidgetItem()
layers_prs_base_table.setHorizontalHeaderItem(0, column_1)
layers_prs_base_table.horizontalHeader().setStyleSheet(
"color: steelblue")
layers_prs_base_table.horizontalHeader().resizeSection(1, 120)
layers_prs_base_table.horizontalHeader().setResizeMode(
1, QtGui.QHeaderView.Fixed)
column_2 = QTableWidgetItem()
layers_prs_base_table.setHorizontalHeaderItem(1, column_2)
layers_prs_base_table.horizontalHeader().setStyleSheet(
"color: steelblue")
if int_lng == 'Russian':
column_1.setText("Название слоя")
column_2.setText("Количество")
elif int_lng == 'English':
column_1.setText("Layer name")
column_2.setText("Number")
i = 1
k = 0
height = 60
while i <= obj_initial['l']:
layers_prs_base_table.setFixedSize(277, height)
#layer#
layer_edit = QLineEdit()
layer_edit.setFixedSize(120, 25)
layer_hbox = QHBoxLayout()
layer_hbox.setContentsMargins(0, 0, 0, 0)
layer_hbox.addWidget(layer_edit)
layer_cell_widget = QWidget()
layer_cell_widget.setLayout(layer_hbox)
if layers_obj != None:
layer_edit.setText(layers_obj['layers_base'][k]['layer_' +
str(i)])
#nSurfaceLayers
sSL_val = QSpinBox()
sSL_val.setFixedSize(70, 25)
sSL_val.setRange(1, 1000)
sSL_val_hbox = QHBoxLayout()
sSL_val_hbox.setContentsMargins(0, 0, 0, 0)
sSL_val_hbox.addWidget(sSL_val)
sSL_val_cell_widget = QWidget()
sSL_val_cell_widget.setLayout(sSL_val_hbox)
if layers_obj != None:
sSL_val.setValue(
layers_obj['layers_base'][k]['layer_val_' + str(i)])
layers_prs_base_table.setCellWidget(k, 0, layer_cell_widget)
layers_prs_base_table.setCellWidget(k, 1, sSL_val_cell_widget)
height = height + 30
k = k + 1
i = i + 1
prs_grid.addWidget(layers_prs_base_table,
1,
0,
alignment=QtCore.Qt.AlignCenter)
##################################Дополнительные параметры#########################################
layers_prs_add_lbl = QLabel()
if int_lng == 'Russian':
layers_prs_add_lbl.setText("Дополнительные параметры слоев:")
elif int_lng == 'English':
layers_prs_add_lbl.setText("Additional layers parameters:")
prs_grid.addWidget(layers_prs_add_lbl,
2,
0,
alignment=QtCore.Qt.AlignCenter)
layers_prs_add_table = QTableWidget()
layers_prs_add_table.setFixedSize(695, 460)
layers_prs_add_table.setRowCount(16)
layers_prs_add_table.setColumnCount(3)
layers_prs_add_table.verticalHeader().hide()
layers_prs_add_table.horizontalHeader().resizeSection(0, 150)
layers_prs_add_table.horizontalHeader().setResizeMode(
0, QtGui.QHeaderView.Fixed)
column_3 = QTableWidgetItem()
layers_prs_add_table.setHorizontalHeaderItem(0, column_3)
layers_prs_add_table.horizontalHeader().setStyleSheet(
"color: steelblue")
layers_prs_add_table.horizontalHeader().resizeSection(1, 430)
layers_prs_add_table.horizontalHeader().setResizeMode(
1, QtGui.QHeaderView.Fixed)
column_4 = QTableWidgetItem()
layers_prs_add_table.setHorizontalHeaderItem(1, column_4)
layers_prs_add_table.horizontalHeader().setStyleSheet(
"color: steelblue")
layers_prs_add_table.horizontalHeader().resizeSection(2, 100)
layers_prs_add_table.horizontalHeader().setResizeMode(
2, QtGui.QHeaderView.Fixed)
column_5 = QTableWidgetItem()
layers_prs_add_table.setHorizontalHeaderItem(2, column_5)
layers_prs_add_table.horizontalHeader().setStyleSheet(
"color: steelblue")
if int_lng == 'Russian':
column_3.setText("Параметр")
column_4.setText("Описание")
column_5.setText("Значение")
elif int_lng == 'English':
column_3.setText("Parameter")
column_4.setText("Definition")
column_5.setText("Value")
#1)finalLayerThickness
fLT_val_pr = QLabel()
fLT_val_pr.setText('finalLayerThickness')
layers_prs_add_table.setCellWidget(0, 0, fLT_val_pr)
fLT_val_def = QLabel()
layers_prs_add_table.setCellWidget(0, 1, fLT_val_def)
fLT_val = QDoubleSpinBox()
fLT_val.setFixedSize(70, 25)
fLT_val_hbox = QHBoxLayout()
fLT_val_hbox.setContentsMargins(0, 0, 0, 0)
fLT_val_hbox.addWidget(fLT_val)
fLT_val_cell_widget = QWidget()
fLT_val_cell_widget.setLayout(fLT_val_hbox)
layers_prs_add_table.setCellWidget(0, 2, fLT_val_cell_widget)
if int_lng == 'Russian':
fLT_val_def.setText(
"Толщина конечного слоя добавленной ячейки")
elif int_lng == 'English':
fLT_val_def.setText(
"Thickness of the final layer of the added cell")
if layers_obj != None:
fLT_val.setValue(
layers_obj['layers_add']['finalLayerThickness'])
#2)expansionRatio
eR_val_pr = QLabel()
eR_val_pr.setText('expansionRatio')
layers_prs_add_table.setCellWidget(1, 0, eR_val_pr)
eR_val_def = QLabel()
layers_prs_add_table.setCellWidget(1, 1, eR_val_def)
eR_val = QDoubleSpinBox()
eR_val.setFixedSize(70, 25)
eR_val_hbox = QHBoxLayout()
eR_val_hbox.setContentsMargins(0, 0, 0, 0)
eR_val_hbox.addWidget(eR_val)
eR_val_cell_widget = QWidget()
eR_val_cell_widget.setLayout(eR_val_hbox)
layers_prs_add_table.setCellWidget(1, 2, eR_val_cell_widget)
if int_lng == 'Russian':
eR_val_def.setText("Коэффициент расширения для слоя")
elif int_lng == 'English':
eR_val_def.setText("Expansion factor for layer mesh")
if layers_obj != None:
eR_val.setValue(layers_obj['layers_add']['expansionRatio'])
#3)minThickness
mT_val_pr = QLabel()
mT_val_pr.setText('minThickness')
layers_prs_add_table.setCellWidget(2, 0, mT_val_pr)
mT_val_def = QLabel()
layers_prs_add_table.setCellWidget(2, 1, mT_val_def)
mT_val = QDoubleSpinBox()
mT_val.setFixedSize(70, 25)
mT_val_hbox = QHBoxLayout()
mT_val_hbox.setContentsMargins(0, 0, 0, 0)
mT_val_hbox.addWidget(mT_val)
mT_val_cell_widget = QWidget()
mT_val_cell_widget.setLayout(mT_val_hbox)
layers_prs_add_table.setCellWidget(2, 2, mT_val_cell_widget)
if int_lng == 'Russian':
mT_val_def.setText("Минимальная толщина клеточного слоя")
elif int_lng == 'English':
mT_val_def.setText("The minimum thickness of the cell layer")
if layers_obj != None:
mT_val.setValue(layers_obj['layers_add']['minThickness'])
#4)relativeSizes
rS_val_pr = QLabel()
rS_val_pr.setText('relativeSizes')
layers_prs_add_table.setCellWidget(3, 0, rS_val_pr)
rS_val_def = QLabel()
layers_prs_add_table.setCellWidget(3, 1, rS_val_def)
rS_val = QComboBox()
rS_val.setFixedSize(70, 25)
rS_val_list = ['true', 'false']
rS_val.addItems(rS_val_list)
rS_val_hbox = QHBoxLayout()
rS_val_hbox.setContentsMargins(0, 0, 0, 0)
rS_val_hbox.addWidget(rS_val)
rS_val_cell_widget = QWidget()
rS_val_cell_widget.setLayout(rS_val_hbox)
layers_prs_add_table.setCellWidget(3, 2, rS_val_cell_widget)
if int_lng == 'Russian':
rS_val_def.setText("Установить относительные размеры ячеек")
elif int_lng == 'English':
rS_val_def.setText("Set the relative sizes of cells")
if layers_obj != None:
rS_val_mas = rS_val.count()
for t in range(rS_val_mas):
if rS_val.itemText(
t) == layers_obj['layers_add']['relativeSizes']:
rS_val.setCurrentIndex(t)
#5)featureAngle
fA_val_pr = QLabel()
fA_val_pr.setText('featureAngle')
layers_prs_add_table.setCellWidget(4, 0, fA_val_pr)
fA_val_def = QLabel()
layers_prs_add_table.setCellWidget(4, 1, fA_val_def)
fA_val = QSpinBox()
fA_val.setFixedSize(70, 25)
fA_val_hbox = QHBoxLayout()
fA_val_hbox.setContentsMargins(0, 0, 0, 0)
fA_val_hbox.addWidget(fA_val)
fA_val_cell_widget = QWidget()
fA_val_cell_widget.setLayout(fA_val_hbox)
layers_prs_add_table.setCellWidget(4, 2, fA_val_cell_widget)
if int_lng == 'Russian':
fA_val_def.setText("Угол обзора")
elif int_lng == 'English':
fA_val_def.setText("Viewing Angle")
if layers_obj != None:
fA_val.setValue(layers_obj['layers_add']['featureAngle'])
#6)nSmoothSurfaceNormals
nSSN_val_pr = QLabel()
nSSN_val_pr.setText('nSmoothSurfaceNormals')
layers_prs_add_table.setCellWidget(5, 0, nSSN_val_pr)
nSSN_val_def = QLabel()
layers_prs_add_table.setCellWidget(5, 1, nSSN_val_def)
nSSN_val = QSpinBox()
nSSN_val.setFixedSize(70, 25)
nSSN_val_hbox = QHBoxLayout()
nSSN_val_hbox.setContentsMargins(0, 0, 0, 0)
nSSN_val_hbox.addWidget(nSSN_val)
nSSN_val_cell_widget = QWidget()
nSSN_val_cell_widget.setLayout(nSSN_val_hbox)
layers_prs_add_table.setCellWidget(5, 2, nSSN_val_cell_widget)
if int_lng == 'Russian':
nSSN_val_def.setText(
"Число сглаживающих итераций поверхностных нормалей")
elif int_lng == 'English':
nSSN_val_def.setText(
"Number of smoothing iterations of surface normals")
if layers_obj != None:
nSSN_val.setValue(
layers_obj['layers_add']['nSmoothSurfaceNormals'])
#7)nSmoothNormals
nSN_val_pr = QLabel()
nSN_val_pr.setText('nSmoothNormals')
layers_prs_add_table.setCellWidget(6, 0, nSN_val_pr)
nSN_val_def = QLabel()
layers_prs_add_table.setCellWidget(6, 1, nSN_val_def)
nSN_val = QSpinBox()
nSN_val.setFixedSize(70, 25)
nSN_val_hbox = QHBoxLayout()
nSN_val_hbox.setContentsMargins(0, 0, 0, 0)
nSN_val_hbox.addWidget(nSN_val)
nSN_val_cell_widget = QWidget()
nSN_val_cell_widget.setLayout(nSN_val_hbox)
layers_prs_add_table.setCellWidget(6, 2, nSN_val_cell_widget)
if int_lng == 'Russian':
nSN_val_def.setText(
"Количество сглаживающих итераций напр. движ. внутренней сетки"
)
elif int_lng == 'English':
nSN_val_def.setText(
"Number of smoothing iterations of interior mesh movement direction"
)
if layers_obj != None:
nSN_val.setValue(layers_obj['layers_add']['nSmoothNormals'])
#8)nSmoothThickness
nST_val_pr = QLabel()
nST_val_pr.setText('nSmoothThickness')
layers_prs_add_table.setCellWidget(7, 0, nST_val_pr)
nST_val_def = QLabel()
layers_prs_add_table.setCellWidget(7, 1, nST_val_def)
nST_val = QSpinBox()
nST_val.setFixedSize(70, 25)
nST_val_hbox = QHBoxLayout()
nST_val_hbox.setContentsMargins(0, 0, 0, 0)
nST_val_hbox.addWidget(nST_val)
nST_val_cell_widget = QWidget()
nST_val_cell_widget.setLayout(nST_val_hbox)
layers_prs_add_table.setCellWidget(7, 2, nST_val_cell_widget)
if int_lng == 'Russian':
nST_val_def.setText("Толщина слоя над поверхностными патчами")
elif int_lng == 'English':
nST_val_def.setText("Layer thickness over surface patches")
if layers_obj != None:
nST_val.setValue(layers_obj['layers_add']['nSmoothThickness'])
#9)minMedianAxisAngle
mMAA_val_pr = QLabel()
mMAA_val_pr.setText('minMedianAxisAngle')
layers_prs_add_table.setCellWidget(8, 0, mMAA_val_pr)
mMAA_val_def = QLabel()
layers_prs_add_table.setCellWidget(8, 1, mMAA_val_def)
mMAA_val = QSpinBox()
mMAA_val.setFixedSize(70, 25)
mMAA_val_hbox = QHBoxLayout()
mMAA_val_hbox.setContentsMargins(0, 0, 0, 0)
mMAA_val_hbox.addWidget(mMAA_val)
mMAA_val_cell_widget = QWidget()
mMAA_val_cell_widget.setLayout(mMAA_val_hbox)
layers_prs_add_table.setCellWidget(8, 2, mMAA_val_cell_widget)
if int_lng == 'Russian':
mMAA_val_def.setText(
"Угол, используемый для получения точек медиальной оси")
elif int_lng == 'English':
mMAA_val_def.setText(
"Angle used to pick up medial axis points")
if layers_obj != None:
mMAA_val.setValue(
layers_obj['layers_add']['minMedianAxisAngle'])
#10)maxThicknessToMedialRatio
mTTMR_val_pr = QLabel()
mTTMR_val_pr.setText('maxThicknessToMedialRatio')
layers_prs_add_table.setCellWidget(9, 0, mTTMR_val_pr)
mTTMR_val_def = QLabel()
layers_prs_add_table.setCellWidget(9, 1, mTTMR_val_def)
mTTMR_val = QDoubleSpinBox()
mTTMR_val.setFixedSize(70, 25)
mTTMR_val_hbox = QHBoxLayout()
mTTMR_val_hbox.setContentsMargins(0, 0, 0, 0)
mTTMR_val_hbox.addWidget(mTTMR_val)
mTTMR_val_cell_widget = QWidget()
mTTMR_val_cell_widget.setLayout(mTTMR_val_hbox)
layers_prs_add_table.setCellWidget(9, 2, mTTMR_val_cell_widget)
if int_lng == 'Russian':
mTTMR_val_def.setText(
"Максимальная толщина слоя к медиальному расстоянию")
elif int_lng == 'English':
mTTMR_val_def.setText(
"Maximum layer thickness to the medial distance")
if layers_obj != None:
mTTMR_val.setValue(
layers_obj['layers_add']['maxThicknessToMedialRatio'])
#11)maxFaceThicknessRatio
mFTR_val_pr = QLabel()
mFTR_val_pr.setText('maxFaceThicknessRatio')
layers_prs_add_table.setCellWidget(10, 0, mFTR_val_pr)
mFTR_val_def = QLabel()
layers_prs_add_table.setCellWidget(10, 1, mFTR_val_def)
mFTR_val = QDoubleSpinBox()
mFTR_val.setFixedSize(70, 25)
mFTR_val_hbox = QHBoxLayout()
mFTR_val_hbox.setContentsMargins(0, 0, 0, 0)
mFTR_val_hbox.addWidget(mFTR_val)
mFTR_val_cell_widget = QWidget()
mFTR_val_cell_widget.setLayout(mFTR_val_hbox)
layers_prs_add_table.setCellWidget(10, 2, mFTR_val_cell_widget)
if int_lng == 'Russian':
mFTR_val_def.setText(
"Максимальный рост слоя на деформированных клетках")
elif int_lng == 'English':
mFTR_val_def.setText(
"Maximum growth of a layer on deformed cells")
if layers_obj != None:
mFTR_val.setValue(
layers_obj['layers_add']['maxFaceThicknessRatio'])
#12)nLayerIter
nLI_val_pr = QLabel()
nLI_val_pr.setText('nLayerIter')
layers_prs_add_table.setCellWidget(11, 0, nLI_val_pr)
nLI_val_def = QLabel()
layers_prs_add_table.setCellWidget(11, 1, nLI_val_def)
nLI_val = QSpinBox()
nLI_val.setFixedSize(70, 25)
nLI_val_hbox = QHBoxLayout()
nLI_val_hbox.setContentsMargins(0, 0, 0, 0)
nLI_val_hbox.addWidget(nLI_val)
nLI_val_cell_widget = QWidget()
nLI_val_cell_widget.setLayout(nLI_val_hbox)
layers_prs_add_table.setCellWidget(11, 2, nLI_val_cell_widget)
if int_lng == 'Russian':
nLI_val_def.setText(
"Общее максимальное количество итераций добавления слоев")
elif int_lng == 'English':
nLI_val_def.setText(
"Overall max number of layer addition iterations")
if layers_obj != None:
nLI_val.setValue(layers_obj['layers_add']['nLayerIter'])
#13)nRelaxedIter
nRI_val_pr = QLabel()
nRI_val_pr.setText('nRelaxedIter')
layers_prs_add_table.setCellWidget(12, 0, nRI_val_pr)
nRI_val_def = QLabel()
layers_prs_add_table.setCellWidget(12, 1, nRI_val_def)
nRI_val = QSpinBox()
nRI_val.setFixedSize(70, 25)
nRI_val_hbox = QHBoxLayout()
nRI_val_hbox.setContentsMargins(0, 0, 0, 0)
nRI_val_hbox.addWidget(nRI_val)
nRI_val_cell_widget = QWidget()
nRI_val_cell_widget.setLayout(nRI_val_hbox)
layers_prs_add_table.setCellWidget(12, 2, nRI_val_cell_widget)
if int_lng == 'Russian':
nRI_val_def.setText(
"Макс. кол-во итераций, после которых применимы узлы meshQuality"
)
elif int_lng == 'English':
nRI_val_def.setText(
"Max number of iter-s after which relaxed meshQuality controls get used"
)
if layers_obj != None:
nRI_val.setValue(layers_obj['layers_add']['nRelaxedIter'])
#14)nRelaxIter
nRiter_val_pr = QLabel()
nRiter_val_pr.setText('nRelaxIter')
layers_prs_add_table.setCellWidget(13, 0, nRiter_val_pr)
nRiter_val_def = QLabel()
layers_prs_add_table.setCellWidget(13, 1, nRiter_val_def)
nRiter_val = QSpinBox()
nRiter_val.setFixedSize(70, 25)
nRiter_val_hbox = QHBoxLayout()
nRiter_val_hbox.setContentsMargins(0, 0, 0, 0)
nRiter_val_hbox.addWidget(nRiter_val)
nRiter_val_cell_widget = QWidget()
nRiter_val_cell_widget.setLayout(nRiter_val_hbox)
layers_prs_add_table.setCellWidget(13, 2, nRiter_val_cell_widget)
if int_lng == 'Russian':
nRiter_val_def.setText(
"Максимальное количество релаксационных итераций привязки")
elif int_lng == 'English':
nRiter_val_def.setText(
"Maximum number of snapping relaxation iterations")
if layers_obj != None:
nRiter_val.setValue(layers_obj['layers_add']['nRelaxIter'])
#15)nGrow
nG_val_pr = QLabel()
nG_val_pr.setText('nGrow')
layers_prs_add_table.setCellWidget(14, 0, nG_val_pr)
nG_val_def = QLabel()
layers_prs_add_table.setCellWidget(14, 1, nG_val_def)
nG_val = QSpinBox()
nG_val.setFixedSize(70, 25)
nG_val_hbox = QHBoxLayout()
nG_val_hbox.setContentsMargins(0, 0, 0, 0)
nG_val_hbox.addWidget(nG_val)
nG_val_cell_widget = QWidget()
nG_val_cell_widget.setLayout(nG_val_hbox)
layers_prs_add_table.setCellWidget(14, 2, nG_val_cell_widget)
if int_lng == 'Russian':
nG_val_def.setText("Конвергенция для слоя")
elif int_lng == 'English':
nG_val_def.setText("Convergence for the layer")
if layers_obj != None:
nG_val.setValue(layers_obj['layers_add']['nGrow'])
#16)nBufferCellsNoExtrude
nBCNE_val_pr = QLabel()
nBCNE_val_pr.setText('nBufferCellsNoExtrude')
layers_prs_add_table.setCellWidget(15, 0, nBCNE_val_pr)
nBCNE_val_def = QLabel()
layers_prs_add_table.setCellWidget(15, 1, nBCNE_val_def)
nBCNE_val = QSpinBox()
nBCNE_val.setFixedSize(70, 25)
nBCNE_val_hbox = QHBoxLayout()
nBCNE_val_hbox.setContentsMargins(0, 0, 0, 0)
nBCNE_val_hbox.addWidget(nBCNE_val)
nBCNE_val_cell_widget = QWidget()
nBCNE_val_cell_widget.setLayout(nBCNE_val_hbox)
layers_prs_add_table.setCellWidget(15, 2, nBCNE_val_cell_widget)
if int_lng == 'Russian':
nBCNE_val_def.setText(
"Величина буферной области для завершения нового слоя")
elif int_lng == 'English':
nBCNE_val_def.setText(
"The value of the buffer area for completing a new layer")
if layers_obj != None:
nBCNE_val.setValue(
layers_obj['layers_add']['nBufferCellsNoExtrude'])
prs_grid.addWidget(layers_prs_add_table,
3,
0,
alignment=QtCore.Qt.AlignCenter)
prs_frame = QFrame()
prs_frame.setLayout(prs_grid)
# -------------------------Кнопка сохранения --------------------------#
layers_btnSave = QPushButton()
layers_btnSave.setFixedSize(80, 25)
buttons_hbox = QHBoxLayout()
buttons_hbox.addWidget(layers_btnSave)
if int_lng == 'Russian':
layers_btnSave.setText("Записать")
elif int_lng == 'English':
layers_btnSave.setText("Write")
# -----------------------Групповой элемент формы-----------------------#
layers_grid = QGridLayout()
layers_grid.addWidget(main_lbl,
0,
0,
alignment=QtCore.Qt.AlignCenter)
layers_grid.addWidget(prs_frame,
1,
0,
alignment=QtCore.Qt.AlignCenter)
layers_grid.addLayout(buttons_hbox,
2,
0,
alignment=QtCore.Qt.AlignCenter)
layers_grid.setRowStretch(3, 6)
layers_group = QGroupBox()
layers_group.setLayout(layers_grid)
return layers_group, layers_btnSave, layers_prs_base_table, layers_prs_add_table
