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):
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, 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):
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, 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):
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, *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 keyPressEvent(self, event):
key = event.key()
#Duplicate the frame step size (speed) when pressed > or .:
if key == 46 or key == 62:
self.frame_step *= 2
self.ui.spinBox_step.setValue(self.frame_step)
#Half the frame step size (speed) when pressed: < or ,
elif key == 44 or key == 60:
self.frame_step //=2
if self.frame_step<1:
self.frame_step = 1
self.ui.spinBox_step.setValue(self.frame_step)
#print(event.key())
elif self.fid == -1:
return
#Move backwards when are pressed
elif key == Qt.Key_Left or key == 39:
self.frame_number -= self.frame_step
if self.frame_number<0:
self.frame_number = 0
self.ui.spinBox_frame.setValue(self.frame_number)
#Move forward when are pressed
elif key == Qt.Key_Right or key == 92:
self.frame_number += self.frame_step
if self.frame_number >= self.tot_frames:
self.frame_number = self.tot_frames-1
self.ui.spinBox_frame.setValue(self.frame_number)
else:
QMainWindow.keyPressEvent(self, event)
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,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, 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 = Ui_MainWindow()
self.ui.setupUi(self)
self.init_vars()
self.init_texts()
self.init_connexions()
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):
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, 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,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, 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):
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):
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.logsource = None
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, 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):
QMainWindow.__init__(self)
self.set_defaults()
self.init_ui()
self.run_simulation()
self.update_plots()
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, 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.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.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 mainloop():
"""Run the graphics interface for the program.
"""
def on_click():
l = []
for k in lands:
if k[1].value() > 0:
l += [k[0] for i in range(k[1].value())]
res, avghand = simulate(l, turns.value(), deck.value(), numruns.value())
i = 0
output.setRowCount(2)
output.setColumnCount(len(res)+1)
for k, v in res.items():
output.setItem(0, i, QTableWidgetItem(k))
output.setItem(1, i, QTableWidgetItem(str(100*sum(v)/numruns.value())))
i += 1
output.setItem(0, i, QTableWidgetItem("Hand"))
output.setItem(1, i, QTableWidgetItem(str(sum(avghand)/numruns.value())))
output.resizeColumnsToContents()
output.resizeRowsToContents()
def land_table_layout(k, j):
for i in range(k, j):
c = LandMeta.CHILDREN[i]
x = 0 if k == 1 else 3*(k-6)//10+3
layout.addWidget(QLabel(c.name()), i-k+1+loy, x+lox)
layout.addWidget(QLabel(c.get_colors()), i-k+1+loy, x+1+lox)
lands.append((c, QSpinBox()))
if i > 5:
lands[i-1][1].setMaximum(4)
layout.addWidget(lands[i-1][1], i-k+1+loy, x+2+lox)
app = QApplication([])
main = QMainWindow()
main.setWindowTitle("Land Simulator (Standard)")
window = QWidget()
window.resize(800, 600)
layout = QGridLayout()
lands = []
output = QTableWidget()
output.horizontalHeader().hide()
output.verticalHeader().hide()
output.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
layout.addWidget(output, 0, 0, 1, 15)
controlslayout = QGridLayout()
controlslayout.addWidget(QLabel("Runs: "), 0, 0)
controlslayout.setContentsMargins(0, 0, 0, 20)
numruns = QSpinBox()
numruns.setMaximum(1000000)
numruns.setValue(10000)
controlslayout.addWidget(numruns, 0, 1)
controlslayout.addWidget(QLabel("Turns: "), 0, 2)
turns = QSpinBox()
turns.setValue(4)
controlslayout.addWidget(turns, 0, 3)
controlslayout.addWidget(QLabel("Deck size: "), 0, 4)
deck = QSpinBox()
deck.setValue(60)
controlslayout.addWidget(deck, 0, 5)
layout.addLayout(controlslayout, 1, 0, 1, 4)
titlefont = QFont()
titlefont.setBold(True)
titles = [
QLabel("Basic Lands"),
QLabel("Checklands"),
QLabel("Shocklands"),
QLabel("Gatelands"),
QLabel("Taplands")
]
[i.setFont(titlefont) or i.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignBottom) for i in titles]
lox = 0
loy = 2
layout.addWidget(titles[0], loy, lox)
land_table_layout(1, 6)
layout.addWidget(titles[1], loy, 3+lox)
land_table_layout(6, 16)
layout.addWidget(titles[2], loy, 6+lox)
land_table_layout(16, 26)
layout.addWidget(titles[3], loy, 9+lox)
land_table_layout(26, 36)
layout.addWidget(titles[4], loy, 12+lox)
land_table_layout(36, 46)
button = QPushButton("Calculate")
button.clicked.connect(on_click)
layout.addWidget(button, 8, 0, 1, 3)
window.setLayout(layout)
main.setCentralWidget(window)
main.show()
app.exec_()
if parent in nodeDic:
for child in children:
if child in nodeDic:
qgv.addEdge(nodeDic[parent]["node"],
nodeDic[child]["node"], {})
else:
print("The childe with ID: " + child + " not found")
else:
print("The parent node with ID: " + parent + " not found")
# Build the graph (the layout engine organizes where the nodes and connections are)
qgv.build()
# Save it to a file to be loaded by Graphviz if needed
qgv.save("test.gv")
# Create a Main window
w = QMainWindow()
w.setWindowTitle('Graph View')
# Create a central widget to handle the QGraphViz object
wi = QWidget()
wi.setLayout(QVBoxLayout())
w.setCentralWidget(wi)
# Add the QGraphViz object to the layout
wi.layout().addWidget(qgv)
# Add a horizontal layout (a pannel to select what to do)
hpanel = QHBoxLayout()
wi.layout().addLayout(hpanel)
# Add few buttons to the panel
def manipulate():
qgv.manipulation_mode = QGraphVizManipulationMode.Nodes_Move_Mode
def __init__(self):
QMainWindow.__init__(self)
MainWindowFront.Ui_MainWindow.__init__(self)
self.setupUi(self)
self.initTable()
def replot(self):
self.freeze()
showList = self.inputPrior_table.getShowInputList()
if len(showList) == 0:
QMessageBox.information(self, 'Bayesian Inference Plot', 'At least one input must be selected for display.')
self.unfreeze()
return
if self.inputPrior_table.getNumVariables() == 1:
SolventFit.plotSingleRandomSample(*self.solventFitPlotArgs)
else:
SolventFit.plotsample(*self.solventFitPlotArgs, show = showList)
self.unfreeze()
if __name__ == "__main__":
app = QApplication(sys.argv)
MainWindow = QMainWindow(parent=None)
MainFrame = solventFitSetupFrame()
MainWindow.setCentralWidget(MainFrame)
#MainFrameLayout = QVBoxLayout(MainFrame)
#label = QLabel('A Label')
#MainFrameLayout.addWidget(label)
MainWindow.show()
sys.exit(app.exec_())
type=gtk.MESSAGE_INFO,
buttons=gtk.BUTTONS_OK,
message_format=_("Graph created"))
diainfo.format_secondary_text(self.exportFile)
diainfo.run()
diainfo.destroy()
#end of def exportGraph
if __name__ == "__main__":
import Configuration
config = Configuration.Config()
settings = {}
settings.update(config.get_db_parameters())
settings.update(config.get_import_parameters())
settings.update(config.get_default_paths())
from PyQt5.QtWidgets import QApplication, QMainWindow
app = QApplication([])
import SQL
sql = SQL.Sql(db_server=settings['db-server'])
i = GuiTourneyGraphViewer(sql, config, None, None)
main_window = QMainWindow()
main_window.setCentralWidget(i)
main_window.show()
main_window.resize(1400, 800)
app.exec_()
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 624, 23))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.label.setText(_translate("MainWindow", " 长"))
self.pushButton.setText(_translate("MainWindow", "确定"))
self.label_2.setText(_translate("MainWindow", " 宽"))
self.pushButton_2.setText(_translate("MainWindow", "取消"))
if __name__ == "__main__":
app = QApplication(sys.argv)
MainWindow = QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
ex = FirstWindow()
ex.btn.clicked.connect(MainWindow.show)
ex.show()
sys.exit(app.exec_())
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle("MainWindow")
self.label.setText("TISAUTORY")
self.edit_filePath.setPlaceholderText("문단 파일 경로")
self.button_file.setText("파일 열기")
self.button_login.setText("로그인")
self.label_2.setText("URL")
self.label_3.setText("ID")
self.label_4.setText("PASSWORD")
self.label_5.setText("게시 시간 설정")
self.label_6.setText("게시 시작 날짜")
self.label_7.setText("게시 주기")
self.edit_period.setPlaceholderText("분단위 주기")
self.label_8.setText("분")
self.button_write.setText("자동 등록 시작")
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
MainWindow = QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
import sys
import MainWinSignalSlot
from PyQt5.QtWidgets import QApplication,QMainWindow
# 主程序调用
if __name__ == '__main__':
# 整个程序
app = QApplication(sys.argv)
# 创建一个窗口
mainWindow = QMainWindow()
# 调用 demo中的ui
ui = MainWinSignalSlot.Ui_MainWindow()
# 调用 setupUi 的布局
ui.setupUi(mainWindow)
# 窗口显示
mainWindow.show()
# 主循环，安全退出
sys.exit(app.exec_())
def __init__(self):
QMainWindow.__init__(self)
self.calculator = CalcTree()
widget = QWidget()
self.input_str = []
self.cur_num = []
main_box = QVBoxLayout()
self.display_area = QTextEdit(readOnly=True)
keyboard = QGridLayout()
self.display_area.setFixedHeight(50)
self.button_clear = QPushButton('C')
self.button_sign = QPushButton('+/-')
self.button_percent = QPushButton('%')
self.button_dot = QPushButton('.')
self.button_0 = QPushButton('0')
self.button_1 = QPushButton('1')
self.button_2 = QPushButton('2')
self.button_3 = QPushButton('3')
self.button_4 = QPushButton('4')
self.button_5 = QPushButton('5')
self.button_6 = QPushButton('6')
self.button_7 = QPushButton('7')
self.button_8 = QPushButton('8')
self.button_9 = QPushButton('9')
self.button_plus = QPushButton('+')
self.button_minus = QPushButton('-')
self.button_mul = QPushButton('x')
self.button_div = QPushButton('/')
self.button_run = QPushButton('=')
keyboard.addWidget(self.button_clear, 0, 0)
keyboard.addWidget(self.button_sign, 0, 1)
keyboard.addWidget(self.button_percent, 0, 2)
keyboard.addWidget(self.button_plus, 0, 3)
keyboard.addWidget(self.button_7, 1, 0)
keyboard.addWidget(self.button_8, 1, 1)
keyboard.addWidget(self.button_9, 1, 2)
keyboard.addWidget(self.button_minus, 1, 3)
keyboard.addWidget(self.button_4, 2, 0)
keyboard.addWidget(self.button_5, 2, 1)
keyboard.addWidget(self.button_6, 2, 2)
keyboard.addWidget(self.button_mul, 2, 3)
keyboard.addWidget(self.button_1, 3, 0)
keyboard.addWidget(self.button_2, 3, 1)
keyboard.addWidget(self.button_3, 3, 2)
keyboard.addWidget(self.button_div, 3, 3)
keyboard.addWidget(self.button_0, 4, 0, 1, 2)
keyboard.addWidget(self.button_dot, 4, 2)
keyboard.addWidget(self.button_run, 4, 3)
self.set_listeners()
main_box.addWidget(self.display_area)
main_box.addLayout(keyboard)
widget.setLayout(main_box)
self.setCentralWidget(widget)
class MainWindow:
def __init__(self):
self.main_win = QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.main_win)
self.ui.MainWindow_PageGroup.setCurrentWidget(self.ui.LoginPage)
self.ui.Login_RegisterButton.clicked.connect(self.showRegister)
#Available Functionalities for Users (Non-Admins)
self.ui.UserMenu_SearchButton.clicked.connect(self.showSearch)
self.ui.UserMenu_PurchaseHistoryButton.clicked.connect(
self.showPurchaseHistory)
self.ui.UserMenu_RecentlySeenButton.clicked.connect(
self.showRecentlySeen)
self.ui.UserMenu_MessagesButton.clicked.connect(self.showMessages)
self.ui.UserMenu_SellingButton.clicked.connect(self.showSelling)
self.ui.UserMenu_ReviewsButton.clicked.connect(self.showReviews)
self.ui.UserMenu_WishlistButton.clicked.connect(self.showWishlist)
self.ui.Wishlist_OpenProductButton.clicked.connect(self.showProduct)
self.ui.UserMenu_ListsButton.clicked.connect(self.showLists)
self.ui.UserMenu_CartButton.clicked.connect(self.showCart)
self.ui.UserMenu_Username.clicked.connect(self.showUserEdit)
self.ui.UserEdit_ApplyButton.clicked.connect(self.showSearch)
self.ui.UserMenu_LogoutButton.clicked.connect(self.showLogin)
#Extra Functionalities for Admins (includes the ones before)
self.ui.UserMenu_StatisticsButton.clicked.connect(self.showStatistics)
self.ui.UserMenu_QueriesButton.clicked.connect(self.showQueries)
self.ui.UserMenu_TableButton.clicked.connect(self.showTable)
self.ui.Table_EditSelectedButton.clicked.connect(self.showEditTable)
def show(self):
self.main_win.show()
def showLogin(self):
self.ui.MainWindow_PageGroup.setCurrentWidget(self.ui.LoginPage)
def showRegister(self):
self.ui.MainWindow_PageGroup.setCurrentWidget(self.ui.RegisterPage)
def showUserMenu(self):
self.ui.MainWindow_PageGroup.setCurrentWidget(self.ui.UserMenuPage)
def showSearch(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.SearchPage)
def showProduct(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.ProductPage)
def showPurchaseHistory(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(
self.ui.PurchaseHistoryPage)
def showRecentlySeen(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.RecentlySeenPage)
def showMessages(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.MessagesPage)
def showSelling(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.SellingPage)
def showReviews(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.ReviewsPage)
def showWishlist(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.WishlistPage)
def showLists(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.ListsPage)
def showCart(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.CartPage)
def showUserEdit(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.UserEditPage)
def showStatistics(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.StatisticsPage)
def showQueries(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.QueriesPage)
def showTable(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.TablePage)
def showEditTable(self):
self.ui.UserMenu_WidgetGroup.setCurrentWidget(self.ui.EditTablePage)
def __init__(self):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.initUI()
print('Always Run This Script as ADMIN')
# 保存
workbook.save('..\\data.xls')
ui.prompt.setText("文件已保存至当前目录下的data.xls当中")
def execCmd(cmd):
"""执行控制台命令"""
result = os.popen(cmd)
text = result.readlines()
result.close()
return text
if __name__ == "__main__":
app = QApplication(sys.argv)
mw = QMainWindow()
ui = barcode.Ui_MainWindow()
ui.setupUi(mw)
mw.show()
# 主体代码
# 字段显示宽度
ui.fileList.setColumnWidth(0, 150)
ui.fileList.setColumnWidth(1, 150)
ui.fileList.setColumnWidth(2, 500)
ui.fileList.setColumnWidth(3, 200)
ui.fileList.setColumnWidth(4, 200)
ui.resultList.setColumnWidth(0, 150)
ui.resultList.setColumnWidth(1, 150)
ui.resultList.setColumnWidth(2, 400)
ui.resultList.setColumnWidth(3, 400)
def __init__(self, start_server=False):
QMainWindow.__init__(self)
self.setWindowTitle('NINJA-IDE {Ninja-IDE Is Not Just Another IDE}')
self.setMinimumSize(750, 500)
QToolTip.setFont(QFont(settings.FONT.family(), 10))
# Load the size and the position of the main window
self.load_window_geometry()
# self.__project_to_open = 0
# Editables
self.__neditables = {}
# Filesystem
self.filesystem = nfilesystem.NVirtualFileSystem()
# Sessions handler
self._session = None
# Opacity
self.opacity = settings.MAX_OPACITY
# ToolBar
self.toolbar = QToolBar(self)
if settings.IS_MAC_OS:
self.toolbar.setIconSize(QSize(36, 36))
else:
self.toolbar.setIconSize(QSize(24, 24))
self.toolbar.setToolTip(translations.TR_IDE_TOOLBAR_TOOLTIP)
self.toolbar.setToolButtonStyle(Qt.ToolButtonIconOnly)
# Set toggleViewAction text and tooltip
self.toggleView = self.toolbar.toggleViewAction()
self.toggleView.setText(translations.TR_TOOLBAR_VISIBILITY)
self.toggleView.setToolTip(translations.TR_TOOLBAR_VISIBILITY)
self.addToolBar(settings.TOOLBAR_AREA, self.toolbar)
if settings.HIDE_TOOLBAR:
self.toolbar.hide()
# Notificator
self.notification = notification.Notification(self)
# Plugin Manager
# CHECK ACTIVATE PLUGINS SETTING
# services = {
# 'editor': plugin_services.MainService(),
# 'toolbar': plugin_services.ToolbarService(self.toolbar),
# 'menuApp': plugin_services.MenuAppService(self.pluginsMenu),
# 'menuApp': plugin_services.MenuAppService(None),
# 'explorer': plugin_services.ExplorerService(),
# 'misc': plugin_services.MiscContainerService(self.misc)}
# serviceLocator = plugin_manager.ServiceLocator(services)
# serviceLocator = plugin_manager.ServiceLocator(None)
# self.plugin_manager = plugin_manager.PluginManager(resources.PLUGINS,
# serviceLocator)
# self.plugin_manager.discover()
# load all plugins!
# self.plugin_manager.load_all()
# Tray Icon
# self.trayIcon = updates.TrayIconUpdates(self)
# self.trayIcon.closeTrayIcon.connect(self._close_tray_icon)
# self.trayIcon.show()
# TODO:
# key = Qt.Key_1
# for i in range(10):
# if settings.IS_MAC_OS:
# short = ui_tools.TabShortcuts(
# QKeySequence(Qt.CTRL + Qt.ALT + key), self, i)
# else:
# short = ui_tools.TabShortcuts(
# QKeySequence(Qt.ALT + key), self, i)
# key += 1
# short.activated.connect(self._change_tab_index)
# short = ui_tools.TabShortcuts(
# QKeySequence(Qt.ALT + Qt.Key_0), self, 10)
# short.activated.connect(self._change_tab_index)
# Register menu categories
IDE.register_bar_category(translations.TR_MENU_FILE, 100)
IDE.register_bar_category(translations.TR_MENU_EDIT, 110)
IDE.register_bar_category(translations.TR_MENU_VIEW, 120)
IDE.register_bar_category(translations.TR_MENU_SOURCE, 130)
IDE.register_bar_category(translations.TR_MENU_PROJECT, 140)
IDE.register_bar_category(translations.TR_MENU_EXTENSIONS, 150)
IDE.register_bar_category(translations.TR_MENU_ABOUT, 160)
# Register General Menu Items
ui_tools.install_shortcuts(self, actions.ACTIONS_GENERAL, self)
self.register_service('ide', self)
self.register_service('toolbar', self.toolbar)
self.register_service('filesystem', self.filesystem)
# Register signals connections
connections = ({
"target": "main_container",
"signal_name": "fileSaved",
"slot": self.show_message
}, {
"target": "main_container",
"signal_name": "currentEditorChanged",
"slot": self.change_window_title
}, {
"target": "main_container",
"signal_name": "openPreferences",
"slot": self.show_preferences
}, {
"target": "main_container",
"signal_name": "currentEditorChanged",
"slot": self._change_item_in_project
})
self.register_signals('ide', connections)
# connections = (
# {'target': 'main_container',
# 'signal_name': 'openPreferences()',
# 'slot': self.show_preferences},
# {'target': 'main_container',
# 'signal_name': 'allTabsClosed()',
# 'slot': self._last_tab_closed},
# {'target': 'explorer_container',
# 'signal_name': 'changeWindowTitle(QString)',
# 'slot': self.change_window_title},
# {'target': 'explorer_container',
# 'signal_name': 'projectClosed(QString)',
# 'slot': self.close_project},
# )
# Central Widget MUST always exists
self.central = IDE.get_service('central_container')
self.setCentralWidget(self.central)
# Install Services
for service_name in self.__IDESERVICES:
self.install_service(service_name)
IDE.__created = True
# Place Status Bar
main_container = IDE.get_service('main_container')
status_bar = IDE.get_service('status_bar')
main_container.add_status_bar(status_bar)
# Load Menu Bar
menu_bar = IDE.get_service('menu_bar')
if menu_bar:
# These two are the same service, I think that's ok
menu_bar.load_menu(self)
menu_bar.load_toolbar(self)
# Start server if needed
self.s_listener = None
if start_server:
self.s_listener = QLocalServer()
self.s_listener.listen("ninja-ide")
self.s_listener.newConnection.connect(self._process_connection)
IDE.__instance = self
import sys
import MainWindows_组合布局
from PyQt5.QtWidgets import QApplication, QMainWindow
if __name__ == '__main__':
app = QApplication(sys.argv)
mianWindow = QMainWindow()
#初始化类
ui = MainWindows_组合布局.Ui_MainWindow()
#向主窗口添加控件
ui.setupUi(mianWindow)
#主窗口显示
mianWindow.show()
#进入程序的主循环、并通过exit函数确保主函数安全结束
sys.exit(app.exec_())
#-*- coding: utf-8 -*-
__author__ = 'Ese'
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from formLayout2 import Ui_MainWindow
app = QApplication(sys.argv)
window = QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(window)
window.setWindowTitle("Layout...")
window.show()
sys.exit(app.exec_())
def __init__(self, parent=None):
QMainWindow.__init__(self, parent=parent)
Ui_MainWindow.__init__(self)
self.setupUi(self)
#area exclusiva para a imagem
self.R = []
self.G = []
self.B = []
self.R_noise = []
self.G_noise = []
self.B_noise = []
self.R_envio = []
self.G_envio = []
self.B_envio = []
self.R_envio_noise = []
self.G_envio_noise = []
self.B_envio_noise = []
#criando o label da imagem
self.labelIMAGE = QLabel()
self.labelIMAGE.setBackgroundRole(QPalette.Base)
self.labelIMAGE.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.labelIMAGE.setScaledContents(True)
#criando uma area para por o label e configurar sua escala
self.scrollAreaIMAGE = QScrollArea()
self.scrollAreaIMAGE.setBackgroundRole(QPalette.Dark)
self.scrollAreaIMAGE.setWidget(self.labelIMAGE)
self.scrollAreaIMAGE.setVisible(False)
#self.mdi = QMdiArea()
self.sub = QMdiSubWindow()
self.sub.setWidget(self.scrollAreaIMAGE)
self.sub.resize(400,400)
self.sub.setWindowTitle("Image Viewer")
self.mdiArea.addSubWindow(self.sub)
#criando menus para imagem
self.createActions()
self.createMenus()
#deixando menu grafico indisponivel
self.fileMenu.setEnabled(False)
self.viewMenu.setEnabled(False)
self.x = []
self.y = []
self.x_bin = []
self.y_bin = []
self.x_noise = []
self.y_noise = []
self.binario = []
self.binario_noise = []
self.listaPortas = []
#variaveis para a resolucao da tela
self.width = 1080
self.height = 950
self.height_main = 500
self.controle = False #variavel que controla a exclusao do grafico
self.controleReceive = False
self.controleSend = False
self.timer = QTimer(self)
self.actions()
self.incializationMain()
self.createGraph()
#caso escolha a opcao ASCII
self.pushButton1.clicked.connect(self.optionASCII)
self.pushButton2.clicked.connect(self.optionIMAGE)
self.pushButton6.clicked.connect(self.browseASCII)
self.pushButton7.clicked.connect(self.lerEntrada)
self.pushButton8.clicked.connect(self.lerEntradaRecebida)
self.pushButton10.clicked.connect(self.lerEntradaIMG)
self.pushButton11.clicked.connect(self.lerEntradaRecebidaIMG)
self.pushButtonCRC.clicked.connect(self.verificaCRC_ASCII)
self.pushButtonCRC_IMG.clicked.connect(self.verificaCRC_IMG)
#fixando o tamanho da janela inicial
self.resize(self.width, self.height_main)
self.events()
self.timer.setInterval(300)
self.timer.start()
#fifth Default Selected Item Position
items = ("Red", "Blue", "Green")
data = QInputDialog.getItem(qWidget, "Color Dialog", "Colors", items, 2)
if data[1]:
print("Press Ok Value is : " + str(data[0]))
else:
print("Press Cancel Value is : " + str(data[0]))
def showItem(text):
print("Input is : " + text)
app = QApplication(sys.argv)
qMainWindow = QMainWindow()
qMainWindow.resize(400, 500)
qMainWindow.setWindowTitle("All Gui Element")
qWidget = QWidget()
vertlical_Layout = QVBoxLayout()
#Input Number Dialog Button
button_number_dialog = QPushButton("Show Number Dialog")
button_number_dialog.clicked.connect(showNumberDialog)
vertlical_Layout.addWidget(button_number_dialog)
button_text_dialog = QPushButton("Show Text Dialog")
button_text_dialog.clicked.connect(showTextDialog)
vertlical_Layout.addWidget(button_text_dialog)
button_choice_dialog = QPushButton("Show Choice Dialog")
def __init__(self):
QMainWindow.__init__(self)
self.method()
class HeatMapUI:
def __init__(self):
ui_name = "heatmap"
self.app = QApplication([ui_name])
self.app.setObjectName(ui_name)
self.UI_name = ui_name
# set app style
self.app.setStyle("Fusion")
# create main window
self.window = QMainWindow()
self.window.setWindowTitle(ui_name)
self.window.setObjectName(ui_name)
# set window geometry
ag = QDesktopWidget().availableGeometry()
self.window.move(int(ag.width()*0.15), int(ag.height()*0.05))
window_dim = 0.15
self.window.setMinimumWidth(int(ag.width()*window_dim))
self.window.setMinimumHeight(int(ag.height()*window_dim*2))
self.window.setMaximumWidth(int(ag.width()*window_dim))
self.window.setMaximumHeight(int(ag.height()*window_dim*2))
# create placeholders for widget
self.pressure_map_group = None
self.raw_value_group = None
self.point_labels = []
self.point_values = []
self.heatmap_height = 80
self.heatmap_width = 80
self.nradius = 8
self.step_mod = 256
self.add_widgets()
# set layout inside window
self.window.show()
def start(self):
return self.app.exec()
def add_widgets(self):
self.pressure_map_group = QGroupBox("Pressure map")
layout = QGridLayout()
tiles_grid = []
# create grid of tiles
for i in range(self.heatmap_height):
row = []
for j in range(self.heatmap_width):
tile = TileWidget(step_mod=self.step_mod, nradius=self.nradius)
row.append((tile, (i, j)))
layout.addWidget(tile, i, j, 1, 1)
tiles_grid.append(row)
# feed neighbours to each tile
def dist(p1, p2):
return np.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)
# we now iterate over the grid of tiles
for row in tiles_grid:
for tile, coords in row:
i, j = coords
# now for the neighbours in as square neighbourhood of side nradius, we check who is at a distance d
for neighbour_row in tiles_grid[max(0, i - self.nradius):min(self.heatmap_height, i + self.nradius)]:
for neighbour_tile in neighbour_row[max(0, j - self.nradius):min(self.heatmap_width, j + self.nradius)]:
ncoords = neighbour_tile[1]
ntile = neighbour_tile[0]
d = dist(coords, ncoords)
if coords != ncoords and d < self.nradius:
tile.add_neighbour(ntile, d)
# remove space between tiles
layout.setSpacing(0)
self.pressure_map_group.setLayout(layout)
# set main group as central widget
self.window.setCentralWidget(self.pressure_map_group)
"""
Gets called when the user tries to quit.
Make sure things are saved before quitting.
"""
self.ExecuteRunnerPlugin.closing()
if __name__ == "__main__":
from PyQt5.QtWidgets import QApplication, QMainWindow
from peacock.utils import Testing
import argparse
import sys
parser = argparse.ArgumentParser(description='Execute tab')
main_win = QMainWindow()
ExecuteTabPlugin.commandLineArgs(parser)
exe = Testing.find_moose_test_exe()
def needInputFile(input_file):
this_dir = os.path.dirname(os.path.abspath(__file__))
peacock_dir = os.path.dirname(this_dir)
test_file = os.path.join(peacock_dir, "tests", "common", "transient.i")
with open(test_file, "r") as fin:
data = fin.read()
with open(input_file, "w") as fout:
fout.write(data)
parsed = parser.parse_args(["-e", exe])
qapp = QApplication(sys.argv)
w = ExecuteTabPlugin()
# self.model(100, 2)
for row in range(100):
for column in range(2):
item = QStandardItem(str(row + column))
item.setData(QColor(60, 69, 77), Qt.BackgroundRole)
item.setSelectable(False)
self.d_ptr.m_pListModel.setItem(row, column, item)
itemDelegate = StockItemDelegate(self.d_ptr.m_pStockPreview)
self.d_ptr.m_pStockPreview.setItemDelegate(itemDelegate)
itemDelegate.setView(self.d_ptr.m_pStockPreview)
self.d_ptr.m_pStockPreviewWidget.setWindowFlags(Qt.FramelessWindowHint
| Qt.Tool | Qt.Popup)
self.d_ptr.m_pFilterModel.setSourceModel(self.d_ptr.m_pListModel)
self.d_ptr.m_pStockPreview.setModel(self.d_ptr.m_pFilterModel)
self.d_ptr.m_pStockPreviewWidget.setFixedWidth(DropWidgetMaxWidth)
app = QApplication(sys.argv)
mainWidget = QMainWindow()
w = StockListWidget()
# app.installNativeEventFilter(w)
mainWidget.setCentralWidget(w)
mainWidget.show()
# w.show()
app.exec_()
def __init__(self, parent=None):
QMainWindow.__init__(self)
loadUi("pyzcto.ui", self)
self.settings = {}
self.load_settings()
fd = open(os.path.expanduser('~/.zcash/zcash.conf'))
fdl = fd.readlines()
fd.close()
userlines = [l for l in fdl if 'rpcuser' in l]
passlines = [l for l in fdl if 'rpcpassword' in l]
if not userlines or not passlines:
raise Error('setup rpcuser and rpcpassword in zcash.conf')
username = userlines[-1].replace(' ', '').split('=')[1]
password = passlines[-1].replace(' ', '').split('=')[1]
self.line_user.setText(username.replace('\n', ''))
self.line_password.setText(password.replace('\n', ''))
self.torproc = QProcess()
self.tableWidget_ownaddresses.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableWidget_otheraddresses.horizontalHeader(
).setSectionResizeMode(QHeaderView.ResizeToContents)
self.tableWidget_traddr.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableWidget_shaddr.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.transtable_input.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.transtable_output.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.pushButton_importmultisig.setEnabled(False)
self.pushButton_importmultisig.clicked.connect(self.importmultisig)
self.torconnectbutton.clicked.connect(self.torconnect)
self.pushButton_newtr.clicked.connect(self.newtraddr)
self.pushButton_newsh.clicked.connect(self.newshaddr)
self.sendButton.clicked.connect(self.send)
self.listaddresses_receive.currentItemChanged.connect(
self.geneartereceiveqr)
self.line_receiveamount.textChanged.connect(self.geneartereceiveqr)
self.line_receivedesc.textChanged.connect(self.geneartereceiveqr)
self.plainTextEdit_sendmultiple.textChanged.connect(
self.check_is_send_correct)
self.comboBox_sendaccounts.currentIndexChanged.connect(
self.check_is_send_correct)
self.line_sendaccount1.currentTextChanged.connect(
self.check_is_send_correct)
self.line_fee.textChanged.connect(self.check_is_send_correct)
self.line_sendamount1.textChanged.connect(self.check_is_send_correct)
self.line_sendmemo1.textChanged.connect(self.check_is_send_correct)
self.transtable_input.clicked.connect(self.show_transaction_details)
self.transtable_output.clicked.connect(self.show_transaction_details)
self.pushButton_addotheraddress.clicked.connect(
self.tableWidget_otheraddresses.insertRow, 0)
self.pushButton_deleteotheraddress.clicked.connect(
self.removerowfromaccounts)
self.tableWidget_otheraddresses.cellChanged.connect(
self.updateotheraccounts)
self.tableWidget_otheraddresses.cellChanged.connect(
self.updatelinesendaccount)
self.plainTextEdit_multisigkeys.textChanged.connect(
self.generatemultisig)
self.spinBox_multisign.valueChanged.connect(self.generatemultisig)
self.plainTextEdit_spendscript.textChanged.connect(self.verifymultisig)
self.plainTextEdit_to_address_ms.textChanged.connect(
self.createmultisigtx)
self.comboBox_from_addr_ms.currentTextChanged.connect(
self.createmultisigtx)
self.plainTextEdit_raw_ms_tx.textChanged.connect(self.parserawhex)
self.pushButton_ms_sign.clicked.connect(self.signrawtransaction)
self.pushButton_ms_broadcast.clicked.connect(
self.broadcastrawtransaction)
self.tableWidget_ownaddresses.horizontalHeader(
).sectionClicked.connect(self.tableWidget_ownaddresses.sortByColumn)
self.pushButton_add_multisig_addr.clicked.connect(
self.addmultisigaddrtolist)
self.tabWidget.setCurrentIndex(0)
self.utxos = []
self.shreceived = []
self.balances = {}
self.addressesalias = {}
self.otheralias = {}
self.transactions = []
self.receiveaddresses = []
self.sendadrresses = []
self.pubkeys = {}
self.readaliasesfromfile()
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(2000)
self.tableWidget_ownaddresses.setContextMenuPolicy(
Qt.CustomContextMenu)
self.tableWidget_ownaddresses.customContextMenuRequested.connect(
self.showpkmenu)
self.pushButton_newpubkey.clicked.connect(self.newpubkey)
self.pushButton_showorbotqr.clicked.connect(self.showorbotqr)
self.pushButton_showzcpqr.clicked.connect(self.showzcpqr)
self.pushButton_hideqr.clicked.connect(self.hideqr)
try:
with open('./hidden_service/hostname') as fd:
line = fd.readline()
if len(line.split()) > 1:
self.checkBox_stealth.setChecked(True)
except:
pass
self.update()
self.show()
chartView.chart().setAnimationOptions(options)
alignment = self.m_legendComboBox.itemData(
self.m_legendComboBox.currentIndex())
for chartView in self.m_charts:
legend = chartView.chart().legend()
if alignment == 0:
legend.hide()
else:
legend.setAlignment(Qt.Alignment(alignment))
legend.show()
if __name__ == '__main__':
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow
app = QApplication(sys.argv)
window = QMainWindow()
widget = ThemeWidget()
window.setCentralWidget(widget)
window.resize(900, 600)
window.show()
sys.exit(app.exec_())
class MainWindow:
setup_ui = Ui_MainWindow()
custom_ui = Ui_CustomWindow()
def __init__(self):
self.win = QMainWindow()
self.setup_ui.setupUi(self.win)
self.win.setWindowTitle("Penguin Minesweeper")
self.setup_ui.easyLevelButton.clicked.connect(self.actionELB)
self.setup_ui.midLevelButton.clicked.connect(self.actionMLB)
self.setup_ui.hardLevelButton.clicked.connect(self.actionHLB)
self.setup_ui.customButton.clicked.connect(self.actionCB)
self.custom_win = QMainWindow()
self.custom_ui.setupUi(self.custom_win)
self.custom_win.setWindowTitle("Custom")
def show(self):
self.win.show()
def actionELB(self):
self.level = "easy"
# Create a new game window
self.game_window = GameWindow(8, 8, 10, 500, 500, 800, 600, 800, 700,
self, self.level)
self.game_window.show()
# Close this window
self.win.close()
def actionMLB(self):
self.level = "mid"
# Create a new game window
self.game_window = GameWindow(16, 16, 40, 500, 500, 1000, 800, 800,
700, self, self.level)
self.game_window.show()
# Close this window
self.win.close()
def actionHLB(self):
self.level = "hard"
# Create a new game window
self.game_window = GameWindow(16, 32, 80, 500, 500, 1600, 800, 1600,
800, self, self.level)
self.game_window.show()
# Close this window
self.win.close()
def actionCB(self):
self.width_value = 8
self.height_value = 8
self.mines_value = 8
self.custom_ui.setupUi(self.custom_win)
self.custom_win.setWindowTitle("Custom")
self.custom_win.show()
self.custom_ui.widthPlusButton.clicked.connect(self.actionWPB)
self.custom_ui.widthMinusButton.clicked.connect(self.actionWMB)
self.custom_ui.heightPlusButton.clicked.connect(self.actionHPB)
self.custom_ui.heightMinusButton.clicked.connect(self.actionHMB)
self.custom_ui.minesPlusButton.clicked.connect(self.actionMPB)
self.custom_ui.minesMinusButton.clicked.connect(self.actionMHB)
self.custom_ui.playGameButton.clicked.connect(self.actionPGB)
self.custom_ui.cancelButton.clicked.connect(self.actionCNB)
def actionWPB(self):
if self.width_value != 40:
self.width_value += 1
self.custom_ui.widthNumber.setProperty("intValue",
self.width_value)
def actionWMB(self):
if self.width_value != 8:
self.width_value -= 1
self.custom_ui.widthNumber.setProperty("intValue",
self.width_value)
def actionHPB(self):
if self.height_value != 40:
self.height_value += 1
self.custom_ui.heightNumber.setProperty("intValue",
self.height_value)
def actionHMB(self):
if self.height_value != 8:
self.height_value -= 1
self.custom_ui.heightNumber.setProperty("intValue",
self.height_value)
def actionMPB(self):
if self.mines_value != 200:
self.mines_value += 1
self.custom_ui.minesNumber.setProperty("intValue",
self.mines_value)
def actionMHB(self):
if self.mines_value != 8:
self.mines_value -= 1
self.custom_ui.minesNumber.setProperty("intValue",
self.mines_value)
def actionPGB(self):
self.level = "custom"
self.game_window = GameWindow(self.width_value, self.height_value,
self.mines_value, 500, 500, 1000, 800,
800, 700, self, self.level)
self.game_window.show()
self.custom_win.close()
self.win.close()
def actionCNB(self):
self.custom_win.close()
self.buttons[a].setDisabled(True)
def isWinner(self):
def set_text(a):
self.line.setText("player {} win!".format(str(a)))
line = {0, 3, 6}
for i in range(3):
if line.issubset(self.player[self.step % 2]):
set_text(self.step % 2 + 1)
line = {i + 1 for i in line}
line = {0, 1, 2}
for i in range(3):
if line.issubset(self.player[self.step % 2]):
set_text(self.step % 2 + 1)
line = {i + 3 for i in line}
line = {0, 4, 8}
if line.issubset(self.player[self.step % 2]):
set_text(self.step % 2 + 1)
line = {2, 4, 6}
if line.issubset(self.player[self.step % 2]):
set_text(self.step % 2 + 1)
if __name__ == '__main__':
app = QApplication(sys.argv)
main_windows = QMainWindow()
main_windows.resize(300, 200)
game = TicTacToe(main_windows)
main_windows.show()
app.exec_()
def __init__(self):
QMainWindow.__init__(self)
self.reporte = Ui_MainWindow1()
self.reporte.setupUi(self)
series = QHorizontalStackedBarSeries()
series.append(set0)
series.append(set1)
series.append(set2)
series.append(set3)
series.append(set4)
chart = QChart()
chart.addSeries(series)
chart.setTitle("Simple horizontal stacked barchart example")
chart.setAnimationOptions(QChart.SeriesAnimations)
categories = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
axis = QBarCategoryAxis()
axis.append(categories)
chart.createDefaultAxes()
chart.setAxisY(axis, series)
chart.legend().setVisible(True)
chart.legend().setAlignment(Qt.AlignBottom)
chartView = QChartView(chart)
chartView.setRenderHint(QPainter.Antialiasing)
window = QMainWindow()
window.setCentralWidget(chartView)
window.resize(400, 300)
window.show()
sys.exit(app.exec_())
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setup_window()
def setup_ui(self, Helix: QMainWindow) -> None:
"""Builds the widgets for the window.
Args:
Helix (:obj:`QMainWindow`):
The child window inheriting this builder class. The
child will hold the references to every widget built in
this class.
Example Usage:
>>> class Window(Ui_Helix, QMainWindow):
...
... def __init__(self) -> None:
... super().__init__()
...
... self.setup_ui(self)
"""
# Create base window
Helix.resize(1920, 1080)
Helix.setMinimumSize(QSize(800, 600))
Helix.setObjectName("Helix")
size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(Helix.sizePolicy().hasHeightForWidth())
Helix.setSizePolicy(size_policy)
Helix.setStyleSheet("* { \n"
" background-color: rgb(60, 62, 83);\n"
" color: white;\n"
"}\n"
"\n"
"QFrame, QToolButton {\n"
" background-color: rgb(42, 43, 64);\n"
" border: none;\n"
"}\n"
"\n"
"QToolButton:hover {\n"
" background-color: rgb(26, 30, 50);\n"
"}\n"
"\n"
"QToolButton:pressed {\n"
" background-color: rgb(60, 62, 83);\n"
"}\n"
"\n"
"#image {\n"
" background-color: rgb(26, 30, 50);\n"
"}\n"
"\n"
"#main_content {\n"
" background-color: rgb(26, 30, 50);\n"
"}")
self._setup_central_widgets(Helix)
self._setup_navbar()
self._setup_topbar()
self._setup_central_content()
Helix.setCentralWidget(self.central_widget)
self._retranslate_ui(Helix)
else:
ui.spin_text += str(v)
#print(v, str(v), ui.spin_text)
sv = ui.doubleSpinBox.valueFromText(ui.spin_text)
#print(sv)
ui.doubleSpinBox.setValue(sv)
# connect up buttons
for i in range(10):
w = getattr(ui, 'pushButton_%i' % i)
w.clicked.connect(lambda c, v=i: next_value(c, v))
ui.pushButton_p.clicked.connect(lambda c: next_value(c, '.'))
ui.pushButton_n.clicked.connect(lambda c: next_value(c, '-'))
if dialog.exec_(): # 0 if closed/canceled, 1 if OK
# set new value
var['value'] = type(var['value'])(ui.doubleSpinBox.value())
print("New value: %s" % var['value'])
app = QApplication(sys.argv)
win = QMainWindow()
btn = QPushButton(win)
btn.setText("Hi")
btn.move(50, 50)
btn.clicked.connect(launch_dialog)
win.show()
sys.exit(app.exec_())
