def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.connect_handlers()
# Sub Views
self.server_form = ServerForm()
self.server_form.set_main_window(self)
self.server_form.hide()
# Initiate empty list
self.data = []
self.notifications = []
# Refresh list
self.refresh_list()
# Set icons
icon = QtGui.QIcon(os.path.join(os.path.dirname(__file__), "icon.png"))
self.setWindowIcon(icon)
self.msgIcon = QSystemTrayIcon.MessageIcon(QSystemTrayIcon.Information)
self.systray_icon = QSystemTrayIcon(icon)
self.systray_icon.activated.connect(self.toggle_window)
self.systray_icon.show()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainView()
self.ui.setupUi(self)
self.ui.retranslateUi(self)
self.ui.menubar.setNativeMenuBar(False)
self.set_icons()
def __init__(self, parent=None):
QMainWindow.__init__(self,parent)
self.ui = uic.loadUi("inicial.ui",self)
self.ui.buttonBox.accepted.connect(self.ok)
self.ui.buttonBox.rejected.connect(self.cancel)
self.ui.radioButton_2.toggled.connect(self.set_mochila)
self.es_mochila=True
def __init__(self,parent=None):
QMainWindow.__init__(self,parent)
loadUi("ui/MainWindow.ui",self)
print(self.menuBar().__dir__())
self.ogrenci_ekle.triggered.connect(self.ogrenciEkleWindowShow)
self.ogrenciList.triggered.connect(self.ogrenciListesi)
self.db = Database("db/main.db")
def __init__(self):
"""
Initialize everything. Connect signals and slots. Read repo.
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.group_infos = GroupInfos(repo_path='')
self.csv_files = dict()
self.settings = Settings()
self.git_interactions = GitInteractions(self.settings, self.action_commit_and_push)
self.file_combobox.currentIndexChanged.connect(self.load_group_data)
self.group_combobox.currentIndexChanged.connect(self.populate_files)
self.group_type_combobox.currentIndexChanged.connect(self.fill_group_names_combobox)
self.console.returnPressed.connect(self.execute_console)
self.action_new.triggered.connect(self.new_csv)
self.action_add_student.triggered.connect(self.new_student)
self.action_undo.triggered.connect(self.table_widget.undo_history)
self.action_redo.triggered.connect(lambda: self.table_widget.undo_history(True))
self.action_about.triggered.connect(self.show_about)
self.action_settings.triggered.connect(self.open_settings)
self.action_get_email.triggered.connect(self.get_email)
self.action_commit_and_push.triggered.connect(self.open_git_dialog)
self.action_load_test_applications.triggered.connect(self.open_load_test_mode)
self.read_repo()
if not self.settings.repo_path:
self.open_settings()
def __init__(self,singleton,singleton_idusu):
#Iniciar el objeto QMainWindow
QMainWindow.__init__(self)
self.obj_form_main = Ui_MainWindow()
self.obj_form_main.setupUi(self)
self.obj_form_main.actionEmpresa.triggered.connect(self.empresanuevo12)
self.obj_form_main.actionEmpresaActualizar.triggered.connect(self.empresa_actualizar12)
self.obj_form_main.action_alta_cliente_nuevo.triggered.connect(self.Agregar_cliente)
self.obj_form_main.action_cliente_actualizar.triggered.connect(self.Actualizar_cliente)
self.obj_form_main.action_buscar_cliente.triggered.connect(self.buscar_clientes)
self.obj_form_main.action_credito_agregar_nuevo.triggered.connect(self.credito_nuevo)
self.obj_form_main.actionCobradores.triggered.connect(self.cobradores)
self.obj_form_main.actionREPORTE_DE_CUOTAS.triggered.connect(self.REPORTE_DE_CUOTAS)
self.obj_form_main.actionCOBRAR_CUOTAS.triggered.connect(self.Cuotas)
self.obj_form_main.actionEgresos.triggered.connect(self.egresos)
self.obj_form_main.actionIngresos.triggered.connect(self.ingresos_diarios)
self.obj_form_main.actionCALCULADOR.triggered.connect(self.CALCULADOR)
self.obj_form_main.actionHISTORIAL_GARANTE.triggered.connect(self.garante_historial12)
self.obj_form_main.actionUsu.triggered.connect(self.usuario)
self.obj_form_main.actionUsu_Act.triggered.connect(self.usuario_actualizar)
self.obj_form_main.actionGenerador_punitorios.triggered.connect(self.Punitorios)
#self.obj_form_main.actionGenerador_punitorios.triggered.connect(self.Buscar_apellido)
self.obj_form_main.actionBuscar_apellido.triggered.connect(self.Buscar_apellido)
self.obj_form_main.actionReparar_Cuotas.triggered.connect(self.reparar_cta)
self.obj_form_main.actionHist_cred_y_ctas.triggered.connect(self.credito_buscar_estado)
self.obj_form_main.actionRefinanciar.triggered.connect(self.refinanciar)
self.obj_form_main.actionCalcular_Creditos.triggered.connect(self.CALCULADOR)
self.obj_form_main.actionReporte_deuda_cliente.triggered.connect(self.Reporte_deuda_cliente)
self.singleton =singleton
self.singleton_idusu =singleton_idusu
def __init__(self):
QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("程序主窗口")
self.file_menu = QMenu('&File', self)
self.file_menu.addAction('&Quit', self.fileQuit,
QtCore.Qt.CTRL + QtCore.Qt.Key_Q)
self.menuBar().addMenu(self.file_menu)
self.help_menu = QMenu('&Help', self)
self.menuBar().addSeparator()
self.menuBar().addMenu(self.help_menu)
self.help_menu.addAction('&About', self.about)
self.main_widget = QWidget(self)
l = QVBoxLayout(self.main_widget)
sc = MyStaticMplCanvas(self.main_widget, width=5, height=4, dpi=100)
dc = MyDynamicMplCanvas(self.main_widget, width=5, height=4, dpi=100)
l.addWidget(sc)
l.addWidget(dc)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
# 状态条显示2秒
self.statusBar().showMessage("matplotlib 万岁!", 2000)
def __init__(self):
QMainWindow.__init__(self)
self.setWindowTitle(self.tr("[Amaru]"))
#FIXME: read from settings
self.showMaximized()
# Menu bar
menu_bar = self.menuBar()
self._install_menubar(menu_bar)
# Status bar
self.status_bar = Amaru.get_component("status_bar")
self.setStatusBar(self.status_bar)
# Central
self.load_central_widget()
# Change tabs ALT + 1-9
key = Qt.Key_1
tab_shortcuts = type('TabShortcuts', (QShortcut,), {'index': None})
for index in range(10):
short = tab_shortcuts(QKeySequence(Qt.ALT + key), self)
short.index = index
key += 1
short.activated.connect(self._change_tab)
Amaru.load_component("amaru", self)
def __init__(self):
QMainWindow.__init__(self)
self.src = self.queue = self.scale = self.sink = self.bus = self.pipeline = None
container = QWidget(self)
self.setCentralWidget(container)
self.winId = container.winId()
self.resize(800, 450)
self.pipeline = Gst.Pipeline()
# Create GStreamer elements
self.src = Gst.ElementFactory.make('ximagesrc', None)
self.src.set_property('startx', 0)
# Hardcoded for the moment. Monitors on nvidia seems to be merge together into a huge one :/
self.src.set_property('endx', 1920)
self.src.set_property('use-damage', 0)
self.queue = Gst.ElementFactory.make('queue', None)
self.scale = Gst.ElementFactory.make('videoscale', None)
self.sink = Gst.ElementFactory.make('ximagesink', None)
# Add elements to the pipeline
self.pipeline.add(self.src)
self.pipeline.add(self.queue)
self.pipeline.add(self.scale)
self.pipeline.add(self.sink)
# Link elements
self.src.link(self.queue)
self.queue.link(self.scale)
self.scale.link(self.sink)
# Create bus to get events from GStreamer pipeline
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.enable_sync_message_emission()
self.bus.connect('sync-message::element', self.on_sync_message)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.py = Ui_MainWindow()
self.py.setupUi(self)
""" combobox"""
self.py.buttonBox.button(QDialogButtonBox.Close).clicked.connect(lambda: self.close())
self.py.buttonBox.button(QDialogButtonBox.Save).clicked.connect(self.docSave)
""" клик на таблицу"""
self.py.tableView.doubleClicked.connect(self.twoClick)
""" кнопки действия с таблицей"""
self.py.addPeople.clicked.connect(lambda: self.addPeople(False))
self.py.editPeople.clicked.connect(lambda: self.addPeople(True))
self.py.delPeople.clicked.connect(self.delPeople)
self.py.upTable.clicked.connect(lambda: self.tableFill())
""" работа с проектом"""
self.py.newProject.clicked.connect(lambda: self.newProject(False))
self.py.editProject.clicked.connect(lambda: self.newProject(True))
self.py.saveProject.clicked.connect(self.saveProject)
self.py.loadProject.clicked.connect(self.loadProject)
self.py.deleteProject.clicked.connect(self.deleteProject)
""" проверка связи при запуске"""
if not(connDB()):
QMessageBox.question(self, 'Cообщение', 'Проблемы с БД', QMessageBox.Yes)
table = selectProject()
if table is not None:
for i in table:
self.py.nameProject.addItem(i[1], i[0])
self.tableFill()
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.squid_setup = SquidSetup()
self._plotdt = SquidGui.defaults['plotdt']
self._plot_dict = defaultdict(list)
self.setWindowTitle('Squid Axon simulation')
self.setDockNestingEnabled(True)
self._createRunControl()
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock)
self._runControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._createChannelControl()
self._channelCtrlBox.setWindowTitle('Channel properties')
self._channelControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._channelControlDock)
self._createElectronicsControl()
self._electronicsDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._electronicsDock.setWindowTitle('Electronics')
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock)
self._createPlotWidget()
self.setCentralWidget(self._plotWidget)
self._createStatePlotWidget()
self._createHelpMessage()
self._helpWindow.setVisible(False)
self._statePlotWidget.setWindowFlags(QtCore.Qt.Window)
self._statePlotWidget.setWindowTitle('State plot')
self._initActions()
self._createRunToolBar()
self._createPlotToolBar()
def __init__(self, parent):
QMainWindow.__init__(self)
self.printer = QPrinter()
self.load_img = self.load_img_fit
self.reload_img = self.reload_auto
self.open_new = parent.open_win
self.exit = parent.closeAllWindows
self.scene = QGraphicsScene()
self.img_view = ImageView(self)
self.img_view.setScene(self.scene)
self.setCentralWidget(self.img_view)
self.create_actions()
self.create_menu()
self.create_dict()
self.slides_next = True
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.showMenu)
self.read_prefs()
self.read_list = parent.read_list
self.write_list = parent.write_list
self.pics_dir = os.path.expanduser('~/Pictures') or QDir.currentPath()
self.resize(700, 500)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle('Shortcut')
self.setWindowIcon(QIcon(os.path.join(os.curdir, 'icons/Shortcut.ico')))
self.resize(300, 400)
screenRect = QDesktopWidget().screenGeometry()
self.move((screenRect.width() - self.width()) / 2, (screenRect.height() - self.height()) / 2)
self.mainWidget = QWidget()
self.gridlayout = QGridLayout()
self.mainWidget.setLayout(self.gridlayout)
self.setCentralWidget(self.mainWidget)
try:
configloader = ConfigLoader()
except ConfigError as e:
QMessageBox.about(self, 'Config Error', str(e))
return
for i, (title, action) in enumerate(configloader.config.items()):
if 'open' in action[0]:
button = OpenButton(title, action[1])
elif 'edit' in action[0]:
button = EditButton(title, action[1], action[2])
elif 'cmd' in action[0]:
button = CmdButton(title, action[1])
else:
continue
colnum = 2
self.gridlayout.addWidget(button, i / colnum, i % colnum)
def __init__(self, settings, tribler_version):
self._logger = logging.getLogger(self.__class__.__name__)
QMainWindow.__init__(self)
self.request_mgr = None
self.cpu_plot = None
self.memory_plot = None
self.initialized_cpu_plot = False
self.initialized_memory_plot = False
self.cpu_plot_timer = None
self.memory_plot_timer = None
self.tribler_version = tribler_version
self.profiler_enabled = False
self.toggling_profiler = False
uic.loadUi(get_ui_file_path('debugwindow.ui'), self)
self.setWindowTitle("Tribler debug pane")
self.window().dump_memory_core_button.clicked.connect(lambda: self.on_memory_dump_button_clicked(True))
self.window().dump_memory_gui_button.clicked.connect(lambda: self.on_memory_dump_button_clicked(False))
self.window().toggle_profiler_button.clicked.connect(self.on_toggle_profiler_button_clicked)
self.window().debug_tab_widget.setCurrentIndex(0)
self.window().ipv8_tab_widget.setCurrentIndex(0)
self.window().tunnel_tab_widget.setCurrentIndex(0)
self.window().system_tab_widget.setCurrentIndex(0)
self.window().debug_tab_widget.currentChanged.connect(self.tab_changed)
self.window().ipv8_tab_widget.currentChanged.connect(self.ipv8_tab_changed)
self.window().tunnel_tab_widget.currentChanged.connect(self.tunnel_tab_changed)
self.window().events_tree_widget.itemClicked.connect(self.on_event_clicked)
self.window().system_tab_widget.currentChanged.connect(self.system_tab_changed)
self.load_general_tab()
self.window().open_files_tree_widget.header().setSectionResizeMode(0, QHeaderView.Stretch)
# Enable/disable tabs, based on settings
self.window().debug_tab_widget.setTabEnabled(2, settings and settings['trustchain']['enabled'])
self.window().debug_tab_widget.setTabEnabled(3, settings and settings['ipv8']['enabled'])
self.window().system_tab_widget.setTabEnabled(3, settings and settings['resource_monitor']['enabled'])
self.window().system_tab_widget.setTabEnabled(4, settings and settings['resource_monitor']['enabled'])
# Refresh logs
self.window().log_refresh_button.clicked.connect(lambda: self.load_logs_tab())
self.window().log_tab_widget.currentChanged.connect(lambda index: self.load_logs_tab())
# IPv8 statistics enabled?
self.ipv8_statistics_enabled = settings['ipv8']['statistics']
# Libtorrent tab
self.init_libtorrent_tab()
# Position to center
frame_geometry = self.frameGeometry()
screen = QDesktopWidget().screenNumber(QDesktopWidget().cursor().pos())
center_point = QDesktopWidget().screenGeometry(screen).center()
frame_geometry.moveCenter(center_point)
self.move(frame_geometry.topLeft())
# Refresh timer
self.refresh_timer = None
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.init_vars()
self.init_texts()
self.init_connexions()
def __init__(self):
QMainWindow.__init__(self)
self.set_defaults()
self.init_ui()
self.run_simulation()
self.update_plots()
def __init__(self):
QMainWindow.__init__(self)
self.problemMap = None
self.population = None
self.generation = 0
self.statusbarMapMessage = "No problem map"
self.statusbarPopulationMessage = "No population"
self.statusbarBestUnitMessage = "No best unit"
# Setup UI elements
self.ui = Ui_TSPGenMainWindow()
self.ui.setupUi(self)
self.ui.statusbarLabel = QLabel("", self)
self.ui.statusbarLabel.setObjectName("statusbarLabel")
self.ui.statusbar.addPermanentWidget(self.ui.statusbarLabel)
# Setup asynchronous objects
self.mapGenerator = MapGenerator(self)
self.evolutionProcessor = EvolutionProcessor(self)
self.populationGenerator = PopulationGenerator(self)
# Map painter
displayCities = self.ui.checkBoxDisplayCities.isChecked()
displayConnections = self.ui.checkBoxDisplayConnections.isChecked()
displayBestUnit = self.ui.checkBoxDisplayBestUnit.isChecked()
self.mapPainter = MapPainter(self, self.ui.graphicsViewMap, displayCities, displayConnections, displayBestUnit)
# Refresh display elements
self.refreshStatusbarMessage()
# Setup UI actions - signals/slots
self.setupUIActions()
def __init__(self):
QMainWindow.__init__(self)
self.resize(800, 600)
# Create the main content widget
mainWidget = QWidget(self)
self.setCentralWidget(mainWidget)
# Create a text component at the top area of the main widget
self.output = HexEditWidget(mainWidget)
mainLayout = QVBoxLayout(mainWidget)
mainLayout.addWidget(self.output)
# Create buttons in a grid layout below the top area
buttonWidget = QWidget(mainWidget)
self.buttonLayout = QGridLayout(buttonWidget)
mainLayout.addWidget(buttonWidget)
theButton = QPushButton("Load...")
theButton.clicked.connect(self.chooseFile)
self.buttonLayout.addWidget(theButton, 0, 0)
statusBar = self.statusBar();
self.loadFile("__pycache__/helloPyside.cpython-33.pyc")
def __init__(self):
# Parent constructor(s)
QMainWindow.__init__(self)
self.controller = None
# Main widget
self.mainWidget = QWidget(self)
self.setCentralWidget(self.mainWidget)
self.setWindowTitle("dotEd")
# Menu
self.createMenu()
# Status bar just for a test
self.statusBar().showMessage("Double click to create a node")
# Layout/Splitter which will contain all widgets
self.splitter = QSplitter(Qt.Horizontal)
layout = QVBoxLayout(self.mainWidget)
layout.addWidget(self.splitter)
# Clear graph button
clearGraphButton = QPushButton("Clear graph")
clearGraphButton.clicked.connect(self.onClearGraph)
layout.addWidget(clearGraphButton)
def __init__(self, parent = None):
"""
Constructor
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.logsource = None
def __init__(self):
QMainWindow.__init__(self)
# Create the File menu
self.menuFile = self.menuBar().addMenu("&File")
self.actionSaveAs = QAction("&Save As", self)
self.actionSaveAs.triggered.connect(self.saveas)
self.actionQuit = QAction("&Quit", self)
self.actionQuit.triggered.connect(self.close)
self.menuFile.addActions([self.actionSaveAs, self.actionQuit])
# Create the Help menu
self.menuHelp = self.menuBar().addMenu("&Help")
self.actionAbout = QAction("&About",self)
self.actionAbout.triggered.connect(self.about)
self.menuHelp.addActions([self.actionAbout])
# Setup main widget
widget = QDialog()
edit1 = QLineEdit("widget 1")
edit2 = QLineEdit("widget 2")
layout = QVBoxLayout()
layout.addWidget(edit1)
layout.addWidget(edit2)
widget.setLayout(layout)
self.setCentralWidget(widget)
def __init__(self, parent=None):
"""Constructor."""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.parent = parent
self.core = self.parent.worker.core
self.qset = self.parent.settings.qset
self.title_item = None
self.snapshot_item = None
rect = self.frameGeometry()
rect.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(rect.topLeft())
self.splitter.setStretchFactor(0, 1)
self.splitter.setStretchFactor(1, 2)
self.reader = ROMReader(self)
try:
self.rom_list = self.qset.value("rom_list", [])
except TypeError:
self.rom_list = []
self.user_data_path = self.core.config.get_path("UserData")
if self.rom_list:
self.add_items()
else:
self.read_items()
self.connect_signals()
self.show()
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
def create_figures():
self.matplotlibwidget = MatplotlibWidget(self.plot)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.matplotlibwidget.sizePolicy().hasHeightForWidth())
self.matplotlibwidget.setSizePolicy(sizePolicy)
self.matplotlibwidget.setMinimumSize(QtCore.QSize(200, 200))
# self.matplotlibwidget.setObjectName(QtCore.QString.fromUtf8("matplotlibwidget"))
self.horizontalLayout_3.addWidget(self.matplotlibwidget)
self.mpl_toolbar = NavigationToolbar(self.matplotlibwidget.canvas, self.toolbar_space)
self.horizontalLayout_2.addWidget(self.mpl_toolbar)
self.peak_vals = None
def setup_connections():
self.btn_fit.clicked.connect(self.btn_clicked)
self.btn_clear.clicked.connect(self.btn_clicked)
self.btn_next.clicked.connect(self.btn_clicked)
self.matplotlibwidget.mpl_connect('button_press_event', self.plot_clicked)
self.btn_open.clicked.connect(self.open_file_dialog)
self.btn_run.clicked.connect(self.btn_clicked)
self.btn_goto.clicked.connect(self.btn_clicked)
self.btn_prev.clicked.connect(self.btn_clicked)
self.btn_skip.clicked.connect(self.btn_clicked)
create_figures()
setup_connections()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.pushButton_iv.clicked.connect(self.measure_iv)
self.pushButton_it.clicked.connect(self.measure_it)
self.pushButton_idvd.clicked.connect(self.measure_idvd)
self.pushButton_idvg.clicked.connect(self.measure_idvg)
self.pushButton_iv_save.clicked.connect(self.save_iv)
self.pushButton_it_save.clicked.connect(self.save_it)
self.pushButton_idvd_save.clicked.connect(self.save_idvd)
self.pushButton_idvg_save.clicked.connect(self.save_idvg)
self.pushButton_stop.clicked.connect(self.stop_measurement)
# save config
self.pushButton_iv_save_config.clicked.connect(self.save_config_iv)
self.pushButton_idvd_save_config.clicked.connect(self.save_config_idvd)
self.pushButton_idvg_save_config.clicked.connect(self.save_config_idvg)
# recall config
self.pushButton_iv_recall_config.clicked.connect(self.recall_config_iv)
self.pushButton_idvd_recall_config.clicked.connect(self.recall_config_idvd)
self.pushButton_idvg_recall_config.clicked.connect(self.recall_config_idvg)
self.saved_configs = {}
self.pushButton_folder.clicked.connect(self.selectFile)
self.stop_engaged = False
# hardware setup
self.daq = NI6030E()
self.daq.set_voltage_ao0(0)
self.ammeter = Keithley6487()
self.ammeter.voltage(0)
self.ammeter.voltage_source_state(True)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.homeDir=None
self.envPath=None
if str(os.sys.platform) == 'win32':
self.homeDir=os.getenv('APPDATA')
else:
self.homeDir=os.path.join(os.getenv('HOME'),'.local/share')
try:
self.envPath=os.path.join(self.homeDir,'psi+')
except:
self.envPath=self.homeDir
self.fm = FileManager()
self.readed=False
#init window
self.setWindowTitle("Psi/Psi+ history merger")
self.resloader = loadResFile()
iconname = self.resloader.get('psihismerger', 'icon32.png')
self.setWindowIcon(QIcon(iconname))
#Adding widgets
self.main_widget = QWidget()
self.setCentralWidget(self.main_widget)
self.btnOpen = QPushButton("Add")
self.btnClean = QPushButton("Clear")
self.btnQuit = QPushButton("Exit")
self.btnSave = QPushButton("Save")
self.btnFN = QPushButton("Choose")
self.label = QLabel('Savefile name')
self.listV = QListWidget()
self.textEdit = QLineEdit()
self.backupCheckBox = QCheckBox('Backup output file')
#setup layouts
self.main_layout = QVBoxLayout()
self.main_widget.setLayout(self.main_layout)
self.buttons_layout = QHBoxLayout()
self.hlayout2 = QHBoxLayout()
self.main_layout.addWidget(self.listV)
self.hlayout3 =QHBoxLayout()
self.main_layout.addLayout(self.hlayout3)
self.hlayout3.addWidget(self.btnOpen)
self.hlayout3.addWidget(self.btnClean)
self.main_layout.addWidget(self.label)
self.main_layout.addLayout(self.hlayout2)
self.hlayout2.addWidget(self.textEdit)
self.hlayout2.addWidget(self.btnFN)
self.main_layout.addWidget(self.backupCheckBox)
self.main_layout.addLayout(self.buttons_layout)
self.buttons_layout.addWidget(self.btnSave)
self.buttons_layout.addWidget(self.btnQuit)
#connect signals
self.fm.showinfo.connect(self.showInfo)
self.btnOpen.clicked.connect(self.showDialog)
self.btnClean.clicked.connect(self.clearList)
self.btnQuit.clicked.connect(self.onExit)
self.btnSave.clicked.connect(self.saveData)
self.btnFN.clicked.connect(self.chooseFile)
self.listV.itemDoubleClicked.connect(self.getListItem)
self.backupCheckBox.stateChanged.connect(self.backupStateChanged)
#disabling some buttons
self.enableButtons(False)
def __init__(self, logger):
QMainWindow.__init__(self)
# exception hook that logs to console, file, and display a message box
self.errorDialogOpened = False
sys.excepthook = self.excepthook
# logger
self.logger = logger
# Setup the user interface
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Initialize the audio data ring buffer
self.audiobuffer = AudioBuffer(self.logger)
# Initialize the audio backend
self.audiobackend = AudioBackend(self.logger)
# signal containing new data from the audio callback thread, processed as numpy array
self.audiobackend.new_data_available.connect(self.audiobuffer.handle_new_data)
# this timer is used to update widgets that just need to display as fast as they can
self.display_timer = QtCore.QTimer()
self.display_timer.setInterval(SMOOTH_DISPLAY_TIMER_PERIOD_MS) # constant timing
# slow timer
self.slow_timer = QtCore.QTimer()
self.slow_timer.setInterval(SLOW_TIMER_PERIOD_MS) # constant timing
self.about_dialog = About_Dialog(self, self.logger, self.audiobackend, self.slow_timer)
self.settings_dialog = Settings_Dialog(self, self.logger, self.audiobackend)
self.centralwidget = CentralWidget(self.ui.centralwidget, self.logger, "central_widget", 0)
self.centralLayout = QVBoxLayout(self.ui.centralwidget)
self.centralLayout.setContentsMargins(0, 0, 0, 0)
self.centralLayout.addWidget(self.centralwidget)
self.dockmanager = DockManager(self, self.logger)
# timer ticks
self.display_timer.timeout.connect(self.centralwidget.canvasUpdate)
self.display_timer.timeout.connect(self.dockmanager.canvasUpdate)
# toolbar clicks
self.ui.actionStart.triggered.connect(self.timer_toggle)
self.ui.actionSettings.triggered.connect(self.settings_called)
self.ui.actionAbout.triggered.connect(self.about_called)
self.ui.actionNew_dock.triggered.connect(self.dockmanager.new_dock)
# restore the settings and widgets geometries
self.restoreAppState()
# start timers
self.timer_toggle()
self.slow_timer.start()
self.logger.push("Init finished, entering the main loop")
def __init__(self): QMainWindow.__init__(self) self.setupUi(self) self.actionAbout.triggered.connect(self.About) self.actionExit.triggered.connect(self.close) # Save actions self.actionSave.triggered.connect(self.saveData) self.Save.clicked.connect(self.saveData)
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.cw = QWidget(self)
self.setCentralWidget(self.cw)
self.btn1 = QPushButton("Click me", self.cw)
self.btn1.setGeometry(QRect(0, 0, 100, 30))
# self.connect(self.btn1, SIGNAL("clicked()"), self.doit)
self.w = None
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.setWindowTitle("OpenGamePad")
self.info = QLabel()
self.info.setFixedSize(640, 20)
self.statusBar.addWidget(self.info)
def __init__(self, parent = None):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.graphicsView.setScene(QGraphicsScene())
self.skiplist = Skiplist(self.ui.graphicsView.scene())
self.skiplist.addNode.connect(self.addNode)
self.skiplist.clear()
def __init__(self):
QMainWindow.__init__(self)
self.setFixedSize(700, 500)
self.setWindowTitle("GRAPHICAL PASSWORD SYSTEM")
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = uic.loadUi("gui/main_window.ui")
self.timestamp_filename = None
self.video_filename = None
self.media_start_time = None
self.media_end_time = None
self.restart_needed = False
self.timer_period = 100
self.is_full_screen = False
self.media_started_playing = False
self.media_is_playing = False
self.original_geometry = None
self.mute = False
self.timestamp_model = TimestampModel(None, self)
self.proxy_model = QSortFilterProxyModel(self)
self.ui.list_timestamp.setModel(self.timestamp_model)
self.ui.list_timestamp.doubleClicked.connect(
lambda event: self.ui.list_timestamp.indexAt(event.pos()).isValid()
and self.run()
)
self.timer = QTimer()
self.timer.timeout.connect(self.update_ui)
self.timer.timeout.connect(self.timer_handler)
self.timer.start(self.timer_period)
self.vlc_instance = vlc.Instance()
self.media_player = self.vlc_instance.media_player_new()
# if sys.platform == "darwin": # for MacOS
# self.ui.frame_video = QMacCocoaViewContainer(0)
self.ui.frame_video.doubleClicked.connect(self.toggle_full_screen)
self.ui.frame_video.wheel.connect(self.wheel_handler)
self.ui.frame_video.keyPressed.connect(self.key_handler)
# Set up buttons
self.ui.button_run.clicked.connect(self.run)
self.ui.button_timestamp_browse.clicked.connect(
self.browse_timestamp_handler
)
self.ui.button_video_browse.clicked.connect(
self.browse_video_handler
)
self.play_pause_model = ToggleButtonModel(None, self)
self.play_pause_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.play", scale_factor=0.7)
},
False: {
"text": "",
"icon": qta.icon("fa.pause", scale_factor=0.7)
}
}
)
self.ui.button_play_pause.setModel(self.play_pause_model)
self.ui.button_play_pause.clicked.connect(self.play_pause)
self.mute_model = ToggleButtonModel(None, self)
self.mute_model.setStateMap(
{
True: {
"text": "",
"icon": qta.icon("fa.volume-up", scale_factor=0.8)
},
False: {
"text": "",
"icon": qta.icon("fa.volume-off", scale_factor=0.8)
}
}
)
self.ui.button_mute_toggle.setModel(self.mute_model)
self.ui.button_mute_toggle.clicked.connect(self.toggle_mute)
self.ui.button_full_screen.setIcon(
qta.icon("ei.fullscreen", scale_factor=0.6)
)
self.ui.button_full_screen.setText("")
self.ui.button_full_screen.clicked.connect(self.toggle_full_screen)
self.ui.button_speed_up.clicked.connect(self.speed_up_handler)
self.ui.button_speed_up.setIcon(
qta.icon("fa.arrow-circle-o-up", scale_factor=0.8)
)
self.ui.button_speed_up.setText("")
self.ui.button_slow_down.clicked.connect(self.slow_down_handler)
self.ui.button_slow_down.setIcon(
qta.icon("fa.arrow-circle-o-down", scale_factor=0.8)
)
self.ui.button_slow_down.setText("")
self.ui.button_mark_start.setIcon(
qta.icon("fa.quote-left", scale_factor=0.7)
)
self.ui.button_mark_start.setText("")
self.ui.button_mark_end.setIcon(
qta.icon("fa.quote-right", scale_factor=0.7)
)
self.ui.button_mark_end.setText("")
self.ui.button_add_entry.clicked.connect(self.add_entry)
self.ui.button_remove_entry.clicked.connect(self.remove_entry)
self.ui.button_mark_start.clicked.connect(
lambda: self.set_mark(start_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.button_mark_end.clicked.connect(
lambda: self.set_mark(end_time=int(
self.media_player.get_position() *
self.media_player.get_media().get_duration()))
)
self.ui.slider_progress.setTracking(False)
self.ui.slider_progress.valueChanged.connect(self.set_media_position)
self.ui.slider_volume.valueChanged.connect(self.set_volume)
self.ui.entry_description.setReadOnly(True)
# Mapper between the table and the entry detail
self.mapper = QDataWidgetMapper()
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.ui.button_save.clicked.connect(self.mapper.submit)
# Set up default volume
self.set_volume(self.ui.slider_volume.value())
self.vlc_events = self.media_player.event_manager()
self.vlc_events.event_attach(
vlc.EventType.MediaPlayerTimeChanged, self.media_time_change_handler
)
# Let our application handle mouse and key input instead of VLC
self.media_player.video_set_mouse_input(False)
self.media_player.video_set_key_input(False)
self.ui.show()
def __init__(self, interval=10):
QMainWindow.__init__(self)
self.setupUi(self)
self.interval = interval
self.initWindow()
def __init__(self):
QMainWindow.__init__(self)
self.menu = None
self.file_menu = None
self.init_ui()
def __init__(self):
QMainWindow.__init__(self)
loadUi('Project.ui', self)
def __init__(hangman):
QMainWindow.__init__(hangman)
hangman.setMinimumSize(QSize(800, 600))
hangman.setWindowTitle("Hangman v0.1a")
centralWidget = QWidget(hangman)
hangman.setCentralWidget(centralWidget)
gridLayout = QGridLayout(hangman)
centralWidget.setLayout(gridLayout)
title = QLabel("Velkommen til Jon og Martins hangman", hangman)
title.setAlignment(QtCore.Qt.AlignTop)
title.setAlignment(QtCore.Qt.AlignHCenter)
gridLayout.addWidget(title, 0, 0)
######################################################
# #
# Denne funksjonen er unødvendig lang, om vi hadde #
# hatt mer tid skulle denne blitt ryddet oppp #
# og debug-prints blitt fjernet #
# #
######################################################
def enter_press():
print(hmf.random_word)
enter_value = hangman.input_box.text()
print(type(enter_value))
hmf.input_letter = enter_value
hmf.solve_index = hmf.find_placement(hmf.input_letter)
print(hmf.solve_index)
print(hmf.input_letter)
hmf.check_input()
hmf.solve_word()
hangman.input_box.clear()
used_letters_string = ''.join(hmf.used_letters)
input_letter_show.setText(used_letters_string)
guess_word_output = ''.join(hmf.guess_word)
guess_word_show.setText(guess_word_output)
##########################################
# Enkle knappe-definisjoner for hva #
# som skal skje når man trykker på #
# en knapp. #
# #
##########################################
def knapp1_clicked():
print(hmf.random_word)
def knapp2_clicked():
sys.exit()
def knapp3_clicked():
value = enter_press
print(value)
##############################################
# #
# QLabel er en funksjon for å printe tekst #
# til standard-vinduet som lages. #
# #
# #
##############################################
input_letter_show = QLabel(hangman)
input_letter_show.setText(hmf.input_letter)
input_letter_show.move(250, 400)
input_letter_show.setFont(QtGui.QFont("Times", 24, QtGui.QFont.Bold))
input_letter_show.show()
guess_word_show = QLabel(hangman)
guess_word_show.setText(guess_word_output)
guess_word_show.move(90, 400)
guess_word_show.setFont(QtGui.QFont("Times", 24, QtGui.QFont.Bold))
guess_word_show.show()
##########################################
# #
# #
# Setter opp trykk-knapper #
# #
##########################################
knapp1 = QPushButton(hangman)
knapp1.setText("Skriv inn løsningsord")
knapp1.move(150, 520)
knapp1.resize(220, 30)
knapp1.clicked.connect(knapp1_clicked)
knapp2 = QPushButton(hangman)
knapp2.setText("Avslutt spill")
knapp2.move(32, 520)
knapp2.clicked.connect(knapp2_clicked)
knapp3 = QPushButton(hangman)
knapp3.setText("Nytt spill")
knapp3.move(380, 520)
knapp3.clicked.connect(knapp3_clicked)
########################################
# #
# QLineEdit gir oss en tekst-boks som #
# vi kan skrive input i. #
# returnPressed.connect betyr at #
# funksjonen i parantes blir kjørt når #
# man trykker enter. #
# #
########################################
hangman.input_box = QLineEdit(hangman)
hangman.nameLabel = QLabel(hangman)
hangman.nameLabel.setText('Skriv inn bokstav:')
hangman.input_box.setMaxLength(1)
hangman.input_box.move(152, 460)
hangman.input_box.resize(200, 32)
hangman.nameLabel.move(32, 460)
hangman.nameLabel.resize(200, 32)
hangman.input_box.returnPressed.connect(enter_press)
def __init__(self):
QMainWindow.__init__(self)
self.setMinimumSize(QSize(1350, 700))
self.setWindowTitle("Система масового обслуговування")
central_widget = QWidget(self)
central_widget.setStyleSheet("background-color: #D8F7D7")
self.setCentralWidget(central_widget)
self.ROWS = 0
self.COLUMNS = 8
self.table = QTableWidget(self)
self.table.setColumnCount(8)
self.table.setRowCount(0)
self.table.setHorizontalHeaderLabels(ROWS_NAMES)
self.table.resizeColumnsToContents()
self.clients_edit = QLineEdit(central_widget)
self.t1_start_edit = QLineEdit(central_widget)
self.t1_end_edit = QLineEdit(central_widget)
self.t2_start_edit = QLineEdit(central_widget)
self.t2_end_edit = QLineEdit(central_widget)
self.clients_edit.setText("20")
self.t1_start_edit.setText("1")
self.t1_end_edit.setText("20")
self.t2_start_edit.setText("1")
self.t2_end_edit.setText("25")
clients_label = QLabel(central_widget)
clients_label.setText("Кількість клієнтів: ")
t1_label = QLabel(central_widget)
t1_label.setText("t1 = ")
t2_label = QLabel(central_widget)
t2_label.setText("t2 = ")
button = QPushButton(central_widget)
button.setText("Обчислити")
button.clicked.connect(self.calculate)
button.setStyleSheet("background-color: #A9DAFA")
avg_buyer_time_label = QLabel(central_widget)
avg_buyer_time_label.setText(
"Середній час перебування покупця біля прилавку:")
self.avg_buyer_time_entry = QLineEdit(central_widget)
unproduct_time = QLabel(central_widget)
unproduct_time.setText(
"Відсоток непродуктивного часу продавця дорівнює:")
self.unproduct_time_entry = QLineEdit(central_widget)
clients_label.move(5, 7)
self.t1_start_edit.resize(20, 20)
self.t1_end_edit.resize(20, 20)
self.t2_start_edit.resize(20, 20)
self.t2_end_edit.resize(20, 20)
self.clients_edit.resize(40, 20)
self.clients_edit.move(100, 5)
t1_label.move(5, 42)
self.t1_start_edit.move(5 + 25, 40)
self.t1_end_edit.move(40 + 25, 40)
t2_label.move(5, 72)
self.t2_start_edit.move(5 + 25, 70)
self.t2_end_edit.move(40 + 25, 70)
self.table.resize(1160, 600)
self.table.move(150, 5)
button.resize(120, 20)
button.move(15, 105)
avg_buyer_time_label.move(150, 610)
self.avg_buyer_time_entry.move(420, 607)
self.avg_buyer_time_entry.resize(200, 20)
unproduct_time.move(150, 640)
self.unproduct_time_entry.move(425, 637)
self.unproduct_time_entry.resize(60, 20)
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
## PRINT ==> SYSTEM
#print('System: ' + platform.system())
#print('Version: ' +platform.release())
########################################################################
## START - WINDOW ATTRIBUTES
########################################################################
## REMOVE ==> STANDARD TITLE BAR
UIFunctions.removeTitleBar(True)
## ==> END ##
## SET ==> WINDOW TITLE
self.setWindowTitle('CARE Desktop')
UIFunctions.labelTitle(self, 'CARE')
UIFunctions.labelDescription(self, 'CARE')
## ==> END ##
## REMOVE ==> STANDARD TITLE BAR
startSize = QSize(1000, 720)
self.resize(startSize)
self.setMinimumSize(startSize)
#UIFunctions.enableMaximumSize(self, 500, 720)
## ==> END ##
## ==> ADD CUSTOM MENUS
UIFunctions.addNewMenu(self, "Home", "home_button",
"url(:/20x20/icons/20x20/cil-home.png)", True)
UIFunctions.addNewMenu(self, "Add Dataset", "add_dataset_button",
"url(:/20x20/icons/20x20/cil-user-follow.png)",
True)
UIFunctions.addNewMenu(self, "Attendance", "attendance_button",
"url(:/20x20/icons/cli-attend.png)", True)
UIFunctions.addNewMenu(self, "In and Out Movement", "in_out_button",
"url(:/16x16/icons/16x16/cil-transfer.png)",
True)
UIFunctions.addNewMenu(self, "Detail", "detail_button",
"url(:/20x20/icons/20x20/cil-description.png)",
True)
## ==> END ##
# START MENU => SELECTION
UIFunctions.selectStandardMenu(self, "home_button")
## ==> END ##
## ==> START PAGE
self.ui.stackedWidget.setCurrentWidget(self.ui.home)
## ==> END ##
## ==> MOVE WINDOW / MAXIMIZE / RESTORE
########################################################################
def moveWindow(event):
# IF MAXIMIZED CHANGE TO NORMAL
if UIFunctions.returStatus() == 1:
UIFunctions.maximize_restore(self)
# MOVE WINDOW
if event.buttons() == Qt.LeftButton:
self.move(self.pos() + event.globalPos() - self.dragPos)
self.dragPos = event.globalPos()
event.accept()
# WIDGET TO MOVE
self.ui.frame_label_top_btns.mouseMoveEvent = moveWindow
## ==> END ##
## ==> LOAD DEFINITIONS
########################################################################
UIFunctions.uiDefinitions(self)
## ==> END ##
########################################################################
## END - WINDOW ATTRIBUTES
############################## ---/--/--- ##############################
## SHOW ==> MAIN WINDOW
########################################################################
self.show()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.fig1()
def __init__(self):
QMainWindow.__init__(self)
self.init_widget()
def __init__(self):
QMainWindow.__init__(self)
self.initUI()
self.setAcceptDrops(True)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
#self.x, self.y = self.get_data()
self.data = self.get_data2()
self.create_main_frame()
self.on_draw()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle("viewPAR")
self.area = 1
self.filename = ""
self.settings = QSettings('org.dyerga', 'viewPAR')
self.lastpath = str(self.settings.value("lastpath"))
self.ui = Ui_ViewWindow()
self.ui.setupUi(self)
self.actionOpen = self.ui.actionOpen
self.actionOpen.triggered.connect(lambda: self.openFile(False))
self.actionOverlay = self.ui.actionOverlay
self.actionOverlay.triggered.connect(lambda: self.openFile(True))
self.actionClear = self.ui.actionClear
self.actionClear.triggered.connect(self.clear_figure)
self.actionDeriv = self.ui.actionDeriv
self.actionDeriv.triggered.connect(self.derivativeCurve)
self.actionSmooth = self.ui.actionSmooth
self.actionSmooth.triggered.connect(self.showSmoothdialog)
self.actioniR = self.ui.actioniR
self.actioniR.triggered.connect(self.showIRdialog)
self.actionREF = self.ui.actionREF
self.actionREF.triggered.connect(self.showREFdialog)
self.actionTafel = self.ui.actionTafel
self.actionTafel.triggered.connect(self.showTafeldialog)
self.actionPeaks = self.ui.actionPeaks
self.actionPeaks.triggered.connect(self.showFitdialog)
self.actionExport = self.ui.actionExport
self.actionExport.triggered.connect(lambda: self.exportData(self.canvas, False))
self.actionMulti = self.ui.actionMulti
self.actionMulti.triggered.connect(self.showMultiCVdialog)
self.actionArea = self.ui.actionArea
self.actionArea.triggered.connect(self.showAreaDialog)
self.actionRotate = self.ui.actionRotate
self.actionRotate.triggered.connect(self.showRotateDialog)
self.actionIntTime = self.ui.actionIntTime
self.actionIntTime.triggered.connect(self.integrateOverTime)
self.actionMultiPulse = self.ui.actionmultiPulse
self.actionMultiPulse.triggered.connect(self.openMultiPulse)
self.actionMultiPulseQ = self.ui.actionmultiPulseQ
self.actionMultiPulseQ.triggered.connect(self.chargeMultiPulse)
self.centralLayout = self.ui.verticalLayout
self.statusbar = self.ui.statusbar
self.canvas = MyStaticMplCanvas(self, width=4, height=3, dpi=100)
#self.canvas.mpl_connect('button_press_event', self.onclickCanvas)
toolbar = NavigationToolbar(self.canvas, self)
self.centralLayout.addWidget(toolbar)
self.centralLayout.addWidget(self.canvas)
self.setFocus()
def __init__(self):
QMainWindow.__init__(self)
Ui_EditWindow.__init__(self)
def __init__(self):
QMainWindow.__init__(self)
# Set up the user interface from Designer.
self.ui = Ui_AppName()
self.ui.setupUi(self)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.pushButton.clicked.connect(self.onClicked)
def __init__(self):
QMainWindow.__init__(self)
self.main_ui = Ui_Panel()
self.main_ui.setupUi(self)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self._initUI()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.resize(950, 700)
screenRect = QDesktopWidget().screenGeometry()
if globalSettings.windowGeometry:
self.restoreGeometry(globalSettings.windowGeometry)
else:
self.move((screenRect.width()-self.width())/2, (screenRect.height()-self.height())/2)
if not screenRect.contains(self.geometry()):
self.showMaximized()
if sys.platform.startswith('darwin'):
# https://github.com/retext-project/retext/issues/198
searchPaths = QIcon.themeSearchPaths()
searchPaths.append('/opt/local/share/icons')
searchPaths.append('/usr/local/share/icons')
QIcon.setThemeSearchPaths(searchPaths)
setIconThemeFromSettings()
if QFile.exists(getBundledIcon('retext')):
self.setWindowIcon(QIcon(getBundledIcon('retext')))
elif QFile.exists('/usr/share/pixmaps/retext.png'):
self.setWindowIcon(QIcon('/usr/share/pixmaps/retext.png'))
else:
self.setWindowIcon(QIcon.fromTheme('retext',
QIcon.fromTheme('accessories-text-editor')))
self.tabWidget = QTabWidget(self)
self.initTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.currentChanged.connect(self.changeIndex)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
self.toolBar = QToolBar(self.tr('File toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, self.toolBar)
self.editBar = QToolBar(self.tr('Edit toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, self.editBar)
self.searchBar = QToolBar(self.tr('Search toolbar'), self)
self.addToolBar(Qt.BottomToolBarArea, self.searchBar)
self.toolBar.setVisible(not globalSettings.hideToolBar)
self.editBar.setVisible(not globalSettings.hideToolBar)
self.actionNew = self.act(self.tr('New'), 'document-new',
self.createNew, shct=QKeySequence.New)
self.actionNew.setPriority(QAction.LowPriority)
self.actionOpen = self.act(self.tr('Open'), 'document-open',
self.openFile, shct=QKeySequence.Open)
self.actionOpen.setPriority(QAction.LowPriority)
self.actionSetEncoding = self.act(self.tr('Set encoding'),
trig=self.showEncodingDialog)
self.actionSetEncoding.setEnabled(False)
self.actionReload = self.act(self.tr('Reload'), 'view-refresh',
lambda: self.currentTab.readTextFromFile())
self.actionReload.setEnabled(False)
self.actionSave = self.act(self.tr('Save'), 'document-save',
self.saveFile, shct=QKeySequence.Save)
self.actionSave.setEnabled(False)
self.actionSave.setPriority(QAction.LowPriority)
self.actionSaveAs = self.act(self.tr('Save as'), 'document-save-as',
self.saveFileAs, shct=QKeySequence.SaveAs)
self.actionNextTab = self.act(self.tr('Next tab'), 'go-next',
lambda: self.switchTab(1), shct=Qt.CTRL+Qt.Key_PageDown)
self.actionPrevTab = self.act(self.tr('Previous tab'), 'go-previous',
lambda: self.switchTab(-1), shct=Qt.CTRL+Qt.Key_PageUp)
self.actionCloseCurrentTab = self.act(self.tr('Close tab'), 'window-close',
lambda: self.closeTab(self.ind), shct=QKeySequence.Close)
self.actionPrint = self.act(self.tr('Print'), 'document-print',
self.printFile, shct=QKeySequence.Print)
self.actionPrint.setPriority(QAction.LowPriority)
self.actionPrintPreview = self.act(self.tr('Print preview'), 'document-print-preview',
self.printPreview)
self.actionViewHtml = self.act(self.tr('View HTML code'), 'text-html', self.viewHtml)
self.actionChangeEditorFont = self.act(self.tr('Change editor font'),
trig=self.changeEditorFont)
self.actionChangePreviewFont = self.act(self.tr('Change preview font'),
trig=self.changePreviewFont)
self.actionSearch = self.act(self.tr('Find text'), 'edit-find',
self.search, shct=QKeySequence.Find)
self.actionGoToLine = self.act(self.tr('Go to line'),
trig=self.goToLine, shct=Qt.CTRL+Qt.Key_G)
self.searchBar.visibilityChanged.connect(self.searchBarVisibilityChanged)
self.actionPreview = self.act(self.tr('Preview'), shct=Qt.CTRL+Qt.Key_E,
trigbool=self.preview)
if QIcon.hasThemeIcon('document-preview'):
self.actionPreview.setIcon(QIcon.fromTheme('document-preview'))
elif QIcon.hasThemeIcon('preview-file'):
self.actionPreview.setIcon(QIcon.fromTheme('preview-file'))
elif QIcon.hasThemeIcon('x-office-document'):
self.actionPreview.setIcon(QIcon.fromTheme('x-office-document'))
else:
self.actionPreview.setIcon(QIcon(getBundledIcon('document-preview')))
self.actionLivePreview = self.act(self.tr('Live preview'), shct=Qt.CTRL+Qt.Key_L,
trigbool=self.enableLivePreview)
menuPreview = QMenu()
menuPreview.addAction(self.actionLivePreview)
self.actionPreview.setMenu(menuPreview)
self.actionInsertTable = self.act(self.tr('Insert table'),
trig=lambda: self.insertFormatting('table'))
self.actionTableMode = self.act(self.tr('Table editing mode'),
shct=Qt.CTRL+Qt.Key_T,
trigbool=lambda x: self.currentTab.editBox.enableTableMode(x))
self.actionInsertImages = self.act(self.tr('Insert images by file path'),
trig=lambda: self.insertImages())
if ReTextFakeVimHandler:
self.actionFakeVimMode = self.act(self.tr('FakeVim mode'),
shct=Qt.CTRL+Qt.ALT+Qt.Key_V, trigbool=self.enableFakeVimMode)
if globalSettings.useFakeVim:
self.actionFakeVimMode.setChecked(True)
self.enableFakeVimMode(True)
self.actionFullScreen = self.act(self.tr('Fullscreen mode'), 'view-fullscreen',
shct=Qt.Key_F11, trigbool=self.enableFullScreen)
self.actionFullScreen.setChecked(self.isFullScreen())
self.actionFullScreen.setPriority(QAction.LowPriority)
self.actionConfig = self.act(self.tr('Preferences'), icon='preferences-system',
trig=self.openConfigDialog)
self.actionConfig.setMenuRole(QAction.PreferencesRole)
self.actionSaveHtml = self.act('HTML', 'text-html', self.saveFileHtml)
self.actionPdf = self.act('PDF', 'application-pdf', self.savePdf)
self.actionOdf = self.act('ODT', 'x-office-document', self.saveOdf)
self.getExportExtensionsList()
self.actionQuit = self.act(self.tr('Quit'), 'application-exit', shct=QKeySequence.Quit)
self.actionQuit.setMenuRole(QAction.QuitRole)
self.actionQuit.triggered.connect(self.close)
self.actionUndo = self.act(self.tr('Undo'), 'edit-undo',
lambda: self.currentTab.editBox.undo(), shct=QKeySequence.Undo)
self.actionRedo = self.act(self.tr('Redo'), 'edit-redo',
lambda: self.currentTab.editBox.redo(), shct=QKeySequence.Redo)
self.actionCopy = self.act(self.tr('Copy'), 'edit-copy',
lambda: self.currentTab.editBox.copy(), shct=QKeySequence.Copy)
self.actionCut = self.act(self.tr('Cut'), 'edit-cut',
lambda: self.currentTab.editBox.cut(), shct=QKeySequence.Cut)
self.actionPaste = self.act(self.tr('Paste'), 'edit-paste',
lambda: self.currentTab.editBox.paste(), shct=QKeySequence.Paste)
self.actionPasteImage = self.act(self.tr('Paste image'), 'edit-paste',
lambda: self.currentTab.editBox.pasteImage(), shct=Qt.CTRL+Qt.SHIFT+Qt.Key_V)
self.actionMoveUp = self.act(self.tr('Move line up'), 'go-up',
lambda: self.currentTab.editBox.moveLineUp(), shct=Qt.ALT+Qt.Key_Up)
self.actionMoveDown = self.act(self.tr('Move line down'), 'go-down',
lambda: self.currentTab.editBox.moveLineDown(), shct=Qt.ALT+Qt.Key_Down)
self.actionUndo.setEnabled(False)
self.actionRedo.setEnabled(False)
self.actionCopy.setEnabled(False)
self.actionCut.setEnabled(False)
qApp = QApplication.instance()
qApp.clipboard().dataChanged.connect(self.clipboardDataChanged)
self.clipboardDataChanged()
if enchant is not None:
self.actionEnableSC = self.act(self.tr('Enable'), trigbool=self.enableSpellCheck)
self.actionSetLocale = self.act(self.tr('Set locale'), trig=self.changeLocale)
self.actionWebKit = self.act(self.tr('Use WebKit renderer'), trigbool=self.enableWebKit)
if ReTextWebKitPreview is None:
globalSettings.useWebKit = False
self.actionWebKit.setEnabled(False)
self.actionWebKit.setChecked(globalSettings.useWebKit)
self.actionWebEngine = self.act(self.tr('Use WebEngine (Chromium) renderer'),
trigbool=self.enableWebEngine)
if ReTextWebEnginePreview is None:
globalSettings.useWebEngine = False
self.actionWebEngine.setChecked(globalSettings.useWebEngine)
self.actionShow = self.act(self.tr('Show directory'), 'system-file-manager', self.showInDir)
self.actionFind = self.act(self.tr('Next'), 'go-next', self.find,
shct=QKeySequence.FindNext)
self.actionFindPrev = self.act(self.tr('Previous'), 'go-previous',
lambda: self.find(back=True), shct=QKeySequence.FindPrevious)
self.actionReplace = self.act(self.tr('Replace'), 'edit-find-replace',
lambda: self.find(replace=True))
self.actionReplaceAll = self.act(self.tr('Replace all'), trig=self.replaceAll)
menuReplace = QMenu()
menuReplace.addAction(self.actionReplaceAll)
self.actionReplace.setMenu(menuReplace)
self.actionCloseSearch = self.act(self.tr('Close'), 'window-close',
lambda: self.searchBar.setVisible(False),
shct=QKeySequence.Cancel)
self.actionCloseSearch.setPriority(QAction.LowPriority)
self.actionHelp = self.act(self.tr('Get help online'), 'help-contents', self.openHelp)
self.aboutWindowTitle = self.tr('About ReText')
self.actionAbout = self.act(self.aboutWindowTitle, 'help-about', self.aboutDialog)
self.actionAbout.setMenuRole(QAction.AboutRole)
self.actionAboutQt = self.act(self.tr('About Qt'))
self.actionAboutQt.setMenuRole(QAction.AboutQtRole)
self.actionAboutQt.triggered.connect(qApp.aboutQt)
availableMarkups = markups.get_available_markups()
if not availableMarkups:
print('Warning: no markups are available!')
if len(availableMarkups) > 1:
self.chooseGroup = QActionGroup(self)
markupActions = []
for markup in availableMarkups:
markupAction = self.act(markup.name, trigbool=self.markupFunction(markup))
if markup.name == globalSettings.defaultMarkup:
markupAction.setChecked(True)
self.chooseGroup.addAction(markupAction)
markupActions.append(markupAction)
self.actionBold = self.act(self.tr('Bold'), shct=QKeySequence.Bold,
trig=lambda: self.insertFormatting('bold'))
self.actionItalic = self.act(self.tr('Italic'), shct=QKeySequence.Italic,
trig=lambda: self.insertFormatting('italic'))
self.actionUnderline = self.act(self.tr('Underline'), shct=QKeySequence.Underline,
trig=lambda: self.insertFormatting('underline'))
self.usefulTags = ('header', 'italic', 'bold', 'underline', 'numbering',
'bullets', 'image', 'link', 'inline code', 'code block', 'blockquote',
'table')
self.usefulChars = ('deg', 'divide', 'euro', 'hellip', 'laquo', 'larr',
'lsquo', 'mdash', 'middot', 'minus', 'nbsp', 'ndash', 'raquo',
'rarr', 'rsquo', 'times')
self.formattingBox = QComboBox(self.editBar)
self.formattingBox.addItem(self.tr('Formatting'))
self.formattingBox.addItems(self.usefulTags)
self.formattingBox.activated[str].connect(self.insertFormatting)
self.symbolBox = QComboBox(self.editBar)
self.symbolBox.addItem(self.tr('Symbols'))
self.symbolBox.addItems(self.usefulChars)
self.symbolBox.activated.connect(self.insertSymbol)
self.updateStyleSheet()
menubar = self.menuBar()
menuFile = menubar.addMenu(self.tr('File'))
menuEdit = menubar.addMenu(self.tr('Edit'))
menuHelp = menubar.addMenu(self.tr('Help'))
menuFile.addAction(self.actionNew)
menuFile.addAction(self.actionOpen)
self.menuRecentFiles = menuFile.addMenu(self.tr('Open recent'))
self.menuRecentFiles.aboutToShow.connect(self.updateRecentFiles)
menuFile.addAction(self.actionShow)
menuFile.addAction(self.actionSetEncoding)
menuFile.addAction(self.actionReload)
menuFile.addSeparator()
menuFile.addAction(self.actionSave)
menuFile.addAction(self.actionSaveAs)
menuFile.addSeparator()
menuFile.addAction(self.actionNextTab)
menuFile.addAction(self.actionPrevTab)
menuFile.addAction(self.actionCloseCurrentTab)
menuFile.addSeparator()
menuExport = menuFile.addMenu(self.tr('Export'))
menuExport.addAction(self.actionSaveHtml)
menuExport.addAction(self.actionOdf)
menuExport.addAction(self.actionPdf)
if self.extensionActions:
menuExport.addSeparator()
for action, mimetype in self.extensionActions:
menuExport.addAction(action)
menuExport.aboutToShow.connect(self.updateExtensionsVisibility)
menuFile.addAction(self.actionPrint)
menuFile.addAction(self.actionPrintPreview)
menuFile.addSeparator()
menuFile.addAction(self.actionQuit)
menuEdit.addAction(self.actionUndo)
menuEdit.addAction(self.actionRedo)
menuEdit.addSeparator()
menuEdit.addAction(self.actionCut)
menuEdit.addAction(self.actionCopy)
menuEdit.addAction(self.actionPaste)
menuEdit.addAction(self.actionPasteImage)
menuEdit.addSeparator()
menuEdit.addAction(self.actionMoveUp)
menuEdit.addAction(self.actionMoveDown)
menuEdit.addSeparator()
if enchant is not None:
menuSC = menuEdit.addMenu(self.tr('Spell check'))
menuSC.addAction(self.actionEnableSC)
menuSC.addAction(self.actionSetLocale)
menuEdit.addAction(self.actionSearch)
menuEdit.addAction(self.actionGoToLine)
menuEdit.addAction(self.actionChangeEditorFont)
menuEdit.addAction(self.actionChangePreviewFont)
menuEdit.addSeparator()
if len(availableMarkups) > 1:
self.menuMode = menuEdit.addMenu(self.tr('Default markup'))
for markupAction in markupActions:
self.menuMode.addAction(markupAction)
menuFormat = menuEdit.addMenu(self.tr('Formatting'))
menuFormat.addAction(self.actionBold)
menuFormat.addAction(self.actionItalic)
menuFormat.addAction(self.actionUnderline)
if ReTextWebKitPreview is not None or ReTextWebEnginePreview is None:
menuEdit.addAction(self.actionWebKit)
else:
menuEdit.addAction(self.actionWebEngine)
menuEdit.addSeparator()
menuEdit.addAction(self.actionViewHtml)
menuEdit.addAction(self.actionPreview)
menuEdit.addAction(self.actionInsertTable)
menuEdit.addAction(self.actionTableMode)
menuEdit.addAction(self.actionInsertImages)
if ReTextFakeVimHandler:
menuEdit.addAction(self.actionFakeVimMode)
menuEdit.addSeparator()
menuEdit.addAction(self.actionFullScreen)
menuEdit.addAction(self.actionConfig)
menuHelp.addAction(self.actionHelp)
menuHelp.addSeparator()
menuHelp.addAction(self.actionAbout)
menuHelp.addAction(self.actionAboutQt)
self.toolBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.toolBar.addAction(self.actionNew)
self.toolBar.addSeparator()
self.toolBar.addAction(self.actionOpen)
self.toolBar.addAction(self.actionSave)
self.toolBar.addAction(self.actionPrint)
self.toolBar.addSeparator()
self.toolBar.addAction(self.actionPreview)
self.toolBar.addAction(self.actionFullScreen)
self.editBar.addAction(self.actionUndo)
self.editBar.addAction(self.actionRedo)
self.editBar.addSeparator()
self.editBar.addAction(self.actionCut)
self.editBar.addAction(self.actionCopy)
self.editBar.addAction(self.actionPaste)
self.editBar.addSeparator()
self.editBar.addWidget(self.formattingBox)
self.editBar.addWidget(self.symbolBox)
self.searchEdit = QLineEdit(self.searchBar)
self.searchEdit.setPlaceholderText(self.tr('Search'))
self.searchEdit.returnPressed.connect(self.find)
self.replaceEdit = QLineEdit(self.searchBar)
self.replaceEdit.setPlaceholderText(self.tr('Replace with'))
self.replaceEdit.returnPressed.connect(self.find)
self.csBox = QCheckBox(self.tr('Case sensitively'), self.searchBar)
self.searchBar.addWidget(self.searchEdit)
self.searchBar.addWidget(self.replaceEdit)
self.searchBar.addSeparator()
self.searchBar.addWidget(self.csBox)
self.searchBar.addAction(self.actionFindPrev)
self.searchBar.addAction(self.actionFind)
self.searchBar.addAction(self.actionReplace)
self.searchBar.addAction(self.actionCloseSearch)
self.searchBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.searchBar.setVisible(False)
self.autoSaveEnabled = globalSettings.autoSave
if self.autoSaveEnabled:
timer = QTimer(self)
timer.start(60000)
timer.timeout.connect(self.saveAll)
self.ind = None
if enchant is not None:
self.sl = globalSettings.spellCheckLocale
try:
enchant.Dict(self.sl or None)
except enchant.errors.Error as e:
warnings.warn(str(e), RuntimeWarning)
globalSettings.spellCheck = False
if globalSettings.spellCheck:
self.actionEnableSC.setChecked(True)
self.fileSystemWatcher = QFileSystemWatcher()
self.fileSystemWatcher.fileChanged.connect(self.fileChanged)
def __init__(self, socket, login):
QMainWindow.__init__(self)
Employee.socket = socket
Employee.login = login
Employee.employee = self
print 'Employee'
def __init__(self):
Form.__init__(self)
QMainWindow.__init__(self)
self.setupUi(self)
self.pushButton.clicked.connect(self.start)
def __init__(self, vv):
Form.__init__(self)
QMainWindow.__init__(self)
self.setupUi(self)
print('ggg')
print(vv)
print('hhh')
#Request to find current locations
self.info = requests.get('http://ipinfo.io/json').json()
self.lat = self.info['loc'].split(',')[0]
self.lon = self.info['loc'].split(',')[1]
#set Text of label based on current location
self.label_5.setText(str(self.lat))
self.label_6.setText(str(self.lon))
#set text of label based on username
self.label_8.setText(str(vv))
#Request to get map from map.ir
self.response = requests.get(
'https://map.ir/static',
params={
'width':
450,
'height':
450,
'zoom_level':
12,
'markers':
'color:origin|label:Map|' + str(self.lon) + ',' + str(self.lat)
},
headers={
'x-api-key':
'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6IjU4ZDZjNGQ4YTFmY2M1N2U2OWEzOTQ2MjA3Mjg2YmMzZjVkOGFkOWMwOWNiMTVlNjVhMmE2MTk3MjM0NzQyNDk3MWUwYTI5YjEyMGFmNTRmIn0.eyJhdWQiOiJteWF3ZXNvbWVhcHAiLCJqdGkiOiI1OGQ2YzRkOGExZmNjNTdlNjlhMzk0NjIwNzI4NmJjM2Y1ZDhhZDljMDljYjE1ZTY1YTJhNjE5NzIzNDc0MjQ5NzFlMGEyOWIxMjBhZjU0ZiIsImlhdCI6MTU1ODE2MTAwMSwibmJmIjoxNTU4MTYxMDAxLCJleHAiOjE1NTgxNjQ2MDEsInN1YiI6IiIsInNjb3BlcyI6WyJiYXNpYyIsImVtYWlsIl19.dEvjipQtrDBcIT9N0BJnH_ds70Z9rE3tR6Nkyt0y0_VFlXq8VD-DsCUy5IRfThaujghvcxLZE6DD_pS5PnkFzfx2tKwJpfJjHhztWxZyrnWnmHd7u6zBkXnaCE4_Sa0jqEu797xnslkOjUoim-4sDkNn6kNaVkvLHTtQj6mpkTZUujkpi6y_UZplfNGR0erWv9UfhsjUwhcrIULCqJPDKjDvIJd8817aREfueQiCu92kmE-ez-jZKPgS93PBIc3KO8KSQzSHg4gn36EOFUeCN8ra0Obfr-gfcz605Ty4DKFUz3mXZRCRViBbNFRNSiSnml3gn1l3oC9GAgYomseUUQ'
})
self.img = self.response.content
#convert bytes array to PngImageFile
image = Image.open(io.BytesIO(self.img))
#convert PngImageFile to png
qimage = ImageQt(image)
#add image of map to label
pixmap = QtGui.QPixmap.fromImage(qimage)
self.label_9.setPixmap(pixmap)
#self.resize(pixmap.width(),pixmap.height())
#self.thread = PThread()
#self.thread.update_plot.connect(self.update)
#def update(self,num):
# print(num)
# print('100')
#select from location to add to tabel
self.stmt = "select user_id ,lat,lon from locations where user_id =? "
self.args = (vv, )
c.execute(self.stmt, self.args)
self.rows_loc = c.fetchall()
print('YYY')
print(self.rows_loc)
for i in range(len(self.rows_loc)):
self.rowPosition = self.tableWidget.rowCount()
self.tableWidget.insertRow(self.rowPosition)
self.tableWidget.setItem(
self.rowPosition, 0,
QtWidgets.QTableWidgetItem(str(self.rows_loc[i][1])))
self.tableWidget.setItem(
self.rowPosition, 1,
QtWidgets.QTableWidgetItem(str(self.rows_loc[i][2])))
self.tableWidget.setItem(self.rowPosition, 2,
QtWidgets.QTableWidgetItem("2019-01-21"))
def __init__(self):
QMainWindow.__init__(self)
self.UI = uic.loadUi('main2.ui', self)
self.init_buttons()
self.init_graph_Spatial()
self.init_graph_ARPES()
def __init__(self):
QMainWindow.__init__(self)
uic.loadUi("login.ui", self)
self.setMinimumSize(294, 461)
self.setMaximumSize(294, 461)
self.inicio.clicked.connect(self.login)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self._label = QLabel("Hello PyQt5 World")
self.setCentralWidget(self._label)
def __init__(self):
QMainWindow.__init__(self)
def __init__(self, working_directory=None):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
# Initialization
self.feature_engineering = {}
self.configuration_file = ""
# Set appearance
# try:
self.set_run_appearance()
# except ModuleNotFoundError:
# pass
# Debug
cgitb.enable(display=1, logdir=None)
# Connect configuration functions
self.actionLoad_configuration.triggered.connect(
self.load_configuration)
self.actionSave_configuration.triggered.connect(
self.save_configuration)
# connect preprocessing setting signal to slot: switche to corresponding stackedWidget
self.preprocessing_stackedwedge_dict = {
"Z-score normalization": 0,
"Scaling": 1,
"De-mean": 2,
"None": 3
}
self.radioButton_zscore.clicked.connect(
self.switche_stacked_wedge_for_preprocessing)
self.radioButton_scaling.clicked.connect(
self.switche_stacked_wedge_for_preprocessing)
self.radioButton_demean.clicked.connect(
self.switche_stacked_wedge_for_preprocessing)
self.radioButton_none_methods.clicked.connect(
self.switche_stacked_wedge_for_preprocessing)
# connect dimreduction setting signal to slot: switche to corresponding stackedWidget
self.dimreduction_stackedwedge_dict = {
"Principal component analysis": 0,
"Independent component analysis": 1,
"Latent Dirichlet Allocation": 2,
"Non-negative matrix factorization": 3,
"None": 4
}
self.radioButton_pca.clicked.connect(
self.switche_stacked_wedge_for_dimreduction)
self.radioButton_ica.clicked.connect(
self.switche_stacked_wedge_for_dimreduction)
self.radioButton_lda.clicked.connect(
self.switche_stacked_wedge_for_dimreduction)
self.radioButton_nmf.clicked.connect(
self.switche_stacked_wedge_for_dimreduction)
self.radioButton_none.clicked.connect(
self.switche_stacked_wedge_for_dimreduction)
# connect feature selection setting signal to slot: switche to corresponding stackedWidget
self.feature_selection_stackedwedge_dict = {
"Variance threshold": 0,
"Correlation": 1,
"Distance correlation": 2,
"F-Score (classification)": 3,
"Mutual information (classification)": 4,
"Mutual information (regression)": 5,
"ReliefF": 6,
"ANOVA/Ttest2 (classification)": 7,
"RFE": 8,
"L1 regularization (Lasso)": 9,
"L1 + L2 regularization (Elastic net regression)": 10,
"None": 11
}
self.radioButton_variance_threshold.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_correlation.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_distancecorrelation.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_fscore.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_mutualinfo_cls.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_mutualinfo_regression.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_relieff.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_anova.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_rfe.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_l1.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_elasticnet.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
self.radioButton_featureselection_none.clicked.connect(
self.switche_stacked_wedge_for_feature_selection)
# Skins
self.skins = {
"Dark": "style_Dark",
"Black": "style_black",
"DarkOrange": "style_DarkOrange",
"Gray": "style_gray",
"Blue": "style_blue",
"Navy": "style_navy",
"Classic": "style_Classic"
}
self.actionDark.triggered.connect(self.set_run_appearance)
self.actionBlack.triggered.connect(self.set_run_appearance)
self.actionDarkOrange.triggered.connect(self.set_run_appearance)
self.actionGray.triggered.connect(self.set_run_appearance)
self.actionBlue.triggered.connect(self.set_run_appearance)
self.actionNavy.triggered.connect(self.set_run_appearance)
self.actionClassic.triggered.connect(self.set_run_appearance)
def __init__(self):
self.st = ''
QMainWindow.__init__(self)
loadUi('UI.ui', self)
def __init__(self, windowTitle=None):
'''Constructor'''
QMainWindow.__init__(self)
self._setupUi(windowTitle)
self.storm = None
self.setStorm(Storm())
def __init__(self, core_args=None, core_env=None):
QMainWindow.__init__(self)
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.gui_settings = QSettings()
api_port = int(
get_gui_setting(self.gui_settings, "api_port", DEFAULT_API_PORT))
dispatcher.update_worker_settings(port=api_port)
self.navigation_stack = []
self.tribler_started = False
self.tribler_settings = None
self.debug_window = None
self.core_manager = CoreManager(api_port)
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.request_mgr = None
self.search_request_mgr = None
self.search_suggestion_mgr = None
self.selected_torrent_files = []
self.vlc_available = True
self.has_search_results = False
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.exception_handler_called = False
self.token_refresh_timer = None
sys.excepthook = self.on_exception
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
self.tribler_status_bar.hide()
# Load dynamic widgets
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.channel_page_container)
self.channel_torrents_list = self.channel_page_container.items_list
self.channel_torrents_detail_widget = self.channel_page_container.details_tab_widget
self.channel_torrents_detail_widget.initialize_details_widget()
self.channel_torrents_list.itemClicked.connect(
self.channel_page.clicked_item)
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.search_page_container)
self.search_results_list = self.search_page_container.items_list
self.search_torrents_detail_widget = self.search_page_container.details_tab_widget
self.search_torrents_detail_widget.initialize_details_widget()
self.search_results_list.itemClicked.connect(
self.on_channel_item_click)
self.search_results_list.itemClicked.connect(
self.search_results_page.clicked_item)
self.token_balance_widget.mouseReleaseEvent = self.on_token_balance_click
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
self.core_manager.core_state_update.connect(on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler,
"on_open_magnet_link")
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
self.debug_pane_shortcut.activated.connect(
self.clicked_menu_button_debug)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(
QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [
self.left_menu_button_home, self.left_menu_button_search,
self.left_menu_button_my_channel,
self.left_menu_button_subscriptions,
self.left_menu_button_video_player,
self.left_menu_button_downloads, self.left_menu_button_discovered
]
self.video_player_page.initialize_player()
self.search_results_page.initialize_search_results_page()
self.settings_page.initialize_settings_page()
self.subscribed_channels_page.initialize()
self.edit_channel_page.initialize_edit_channel_page()
self.downloads_page.initialize_downloads_page()
self.home_page.initialize_home_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_discovered_page()
self.trust_page.initialize_trust_page()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
use_monochrome_icon = get_gui_setting(self.gui_settings,
"use_monochrome_icon",
False,
is_bool=True)
self.update_tray_icon(use_monochrome_icon)
# Create the tray icon menu
menu = self.create_add_torrent_menu()
show_downloads_action = QAction('Show downloads', self)
show_downloads_action.triggered.connect(
self.clicked_menu_button_downloads)
token_balance_action = QAction('Show token balance', self)
token_balance_action.triggered.connect(
lambda: self.on_token_balance_click(None))
quit_action = QAction('Quit Tribler', self)
quit_action.triggered.connect(self.close_tribler)
menu.addSeparator()
menu.addAction(show_downloads_action)
menu.addAction(token_balance_action)
menu.addSeparator()
menu.addAction(quit_action)
self.tray_icon.setContextMenu(menu)
else:
self.tray_icon = None
self.hide_left_menu_playlist()
self.left_menu_button_debug.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.token_balance_widget.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Toggle debug if developer mode is enabled
self.window().left_menu_button_debug.setHidden(not get_gui_setting(
self.gui_settings, "debug", False, is_bool=True))
# Start Tribler
self.core_manager.start(core_args=core_args, core_env=core_env)
self.core_manager.events_manager.received_search_result_channel.connect(
self.search_results_page.received_search_result_channel)
self.core_manager.events_manager.received_search_result_torrent.connect(
self.search_results_page.received_search_result_torrent)
self.core_manager.events_manager.torrent_finished.connect(
self.on_torrent_finished)
self.core_manager.events_manager.new_version_available.connect(
self.on_new_version_available)
self.core_manager.events_manager.tribler_started.connect(
self.on_tribler_started)
self.core_manager.events_manager.events_started.connect(
self.on_events_started)
self.core_manager.events_manager.low_storage_signal.connect(
self.on_low_storage)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
self.installEventFilter(self.video_player_page)
# Resize the window according to the settings
center = QApplication.desktop().availableGeometry(self).center()
pos = self.gui_settings.value(
"pos",
QPoint(center.x() - self.width() * 0.5,
center.y() - self.height() * 0.5))
size = self.gui_settings.value("size", self.size())
self.move(pos)
self.resize(size)
self.show()
