def __init__(self, parent=None, plotView=None, width=100):
QtGui.QFrame.__init__(self, parent)
self.setFrameShape(QtGui.QFrame.StyledPanel)
self.setFrameShadow(QtGui.QFrame.Plain)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.setMinimumWidth(width)
self.setMaximumWidth(width)
self.plotView = plotView
layout = QtGui.QVBoxLayout()
plot_configs = self.plotView.getPlotConfigList()
tabbed_panel = QTabWidget()
tabbed_panel.setTabPosition(QTabWidget.West)
for plot_config in plot_configs:
config_panel = PlotConfigPanel(plot_config)
tabbed_panel.addTab(config_panel, plot_config.name)
#self.connect(config_panel, SIGNAL('plotConfigChanged()'), self.plotView.drawPlot)
layout.addWidget(tabbed_panel)
tabbed_panel = QTabWidget()
#tabbed_panel.setTabPosition(QTabWidget.West)
tabbed_panel.addTab(self.createMemberSelectionPanel(), "Members")
tabbed_panel.addTab(self.createPlotRangePanel(), "Plot")
tabbed_panel.addTab(self.createButtonLayout(), "Production")
tabbed_panel.setMaximumHeight(250)
layout.addWidget(tabbed_panel)
self.setLayout(layout)
def __init__(self, apply, parent=None):
"""
Setup the layout for the widget.
Arguments:
apply - If True, the changes will be applied after saving.
parent - Parent widget (default None)
Return:
None
"""
super(DefaultSettings, self).__init__(parent)
# Add new tab widget for the settings to layout
layout = QVBoxLayout(self)
self.tab_widget = QTabWidget(self)
layout.addWidget(self.tab_widget)
self.tab_widget.setObjectName('tab')
self.default_tabs = {
'External software': [['CTFFIND4', 'Gctf', 'CTER', 'MotionCor2'],
QTabWidget(self)],
'TranSPHIRE settings': [[
'Mount', 'Pipeline', 'General', 'Notification', 'Others',
'Font', 'Copy', 'Path'
],
QTabWidget(self)]
}
for tab_name in self.default_tabs:
self.default_tabs[tab_name][1].setObjectName('tab')
self.tab_widget.addTab(self.default_tabs[tab_name][1], tab_name)
# Variables
self.apply = False
self.overwrite = True
# Add buttons
done_button = QPushButton('Done', self)
done_button.clicked.connect(
lambda: self.check_modified_widgets(done=True))
layout.addWidget(Separator(typ='horizontal', color='blue'))
layout.addWidget(done_button)
if apply:
layout.addWidget(Separator(typ='horizontal', color='blue'))
apply_button = QPushButton('Apply', self)
apply_button.clicked.connect(
lambda: self.check_modified_widgets(done=False))
layout.addWidget(apply_button)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_ScriptEditor()
self.ui.setupUi(self)
#self.connect(self.ui.actionExit, SIGNAL("triggered()"), self.exit)
self.splitter = QSplitter(Qt.Vertical, self)
self.setCentralWidget(self.splitter)
self.edit_tab = QTabWidget(self.splitter)
self.console_tab = QTabWidget(self.splitter)
self.py_console = PythonConsole(self.console_tab)
self.console_tab.addTab(self.py_console, "&Python console")
self.js_console = QtScriptConsole(self.console_tab)
self.console_tab.addTab(self.js_console, "&QtScript console")
self.editors = []
self.on_actionNewPython_triggered()
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.ipcon = parent.ipcon
self.imu = parent.imu
self.cal_acc = CalibrateAccelerometer(self)
self.cal_mag = CalibrateMagnetometer(self)
self.cal_gyr_bias = CalibrateGyroscopeBias(self)
self.cal_gyr_bias = CalibrateGyroscopeBias(self)
self.cal_gyr_gain = CalibrateGyroscopeGain(self)
self.cal_imex = CalibrateImportExport(self)
self.tab_widget = QTabWidget()
self.tab_widget.currentChanged.connect(self.current_tab_changed)
self.tab_widget.addTab(self.cal_acc, "Accelerometer")
self.tab_widget.addTab(self.cal_mag, "Magnetometer")
self.tab_widget.addTab(self.cal_gyr_bias, "Gyroscope Bias")
self.tab_widget.addTab(self.cal_gyr_gain, "Gyroscope Gain")
self.tab_widget.addTab(self.cal_imex, "Import/Export")
self.vlayout.addWidget(self.tab_widget)
self.refresh_values()
def setup_tabs(self):
self.top_tab = QTabWidget(self)
runview_config = lInterfaces.runview_config()
# Do the sensor overview adjustments here.
self.prepSensorOverview(runview_config)
i = 1
self.tab_options = lTabOptions.lTabOptions(self, self.run_data_dir)
nTabs = len(runview_config)
for key, val in runview_config.iteritems():
msg = 'Preparing tab (' + str(i) + '/' + str(
nTabs) + '): ' + val['title']
print msg
page = lTab.lTab(val, self)
if val['title'] == 'IV': page.modifyPageForIV(self.IV_directory)
self.top_tab.addTab(page, val['title'])
self.pages.append(page)
i += 1
self.grid_layout.addWidget(self.top_tab, 0, 1)
self.top_tab.currentChanged.connect(self.tab_changed)
self.tab_options.state_change.connect(self.tab_changed)
self.grid_layout.addWidget(self.tab_options, 0, 0)
msg = "Current run number: " + self.tab_options.state().runNum
self.tab_options.notify(msg)
self.tab_changed()
def setup_tabs(self):
self.top_tab = QTabWidget(self)
veloview_config = lInterfaces.veloview_config()
self.tab_options = lTabOptions.lTabOptions(self, self.run_data_dir)
nTabs = len(veloview_config)
i = 1
for key, val in veloview_config.iteritems():
msg = 'Preparing tab (' + str(i) + '/' + str(
nTabs) + '): ' + val['title']
print msg
page = lTab.lTab(val, self)
if val['title'] == 'Trends':
page.modifyPageForTrending(self.run_data_dir, False)
if val['title'] == 'Detailed trends':
page.modifyPageForTrending(self.run_data_dir, True)
self.top_tab.addTab(page, val['title'])
self.pages.append(page)
i += 1
self.grid_layout.addWidget(self.top_tab, 0, 0)
self.top_tab.currentChanged.connect(self.tab_changed)
if self.tab_options:
self.tab_options.state_change.connect(self.tab_changed)
self.grid_layout.addWidget(self.tab_options, 1, 0)
# Keep options stored but don't show corresponding widget in GUI
self.tab_options.setVisible(False)
self.tab_changed()
def __init__(self, parent, state_colors):
super(DetailedProgressWidget, self).__init__(parent)
self.setWindowTitle("Realization Progress")
layout = QGridLayout(self)
self.iterations = QTabWidget()
self.state_colors = state_colors
self.single_view = SingleTableView()
self.single_view.setModel(
SingleProgressModel(self.single_view, state_colors))
self.single_view_label = QLabel("Realization details")
layout.addWidget(self.iterations, 1, 0)
layout.addWidget(self.single_view_label, 2, 0)
layout.addWidget(self.single_view, 3, 0)
self.setLayout(layout)
self.layout().setRowStretch(1, 1)
self.layout().setRowStretch(3, 1)
self.progress = None
self.selected_realization = -1
self.current_iteration = -1
self.resize(parent.width(), parent.height())
self.progress = {}
def open_gui(self):
self.main = MainWindow(self)
self.main.setFixedSize(930, 530)
self.main.setWindowIcon(
QIcon(load_pixmap('starter_kit_weather_station_demo-icon.png')))
self.tabs = QTabWidget()
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.tabs)
widget.setLayout(layout)
self.main.setCentralWidget(widget)
self.projects.append(ProjectEnvDisplay(self.tabs, self))
self.projects.append(ProjectStatistics(self.tabs, self))
self.projects.append(ProjectXively(self.tabs, self))
self.tabs.addTab(self.projects[0], "Display Environment Measurements")
self.tabs.addTab(self.projects[1],
"Show Statistics with Button Control")
self.tabs.addTab(self.projects[2], "Connect to Xively")
self.active_project = self.projects[0]
self.tabs.currentChanged.connect(self.tabChangedSlot)
self.tabs.setCurrentIndex(1)
self.main.setWindowTitle("Starter Kit: Weather Station Demo " +
DEMO_VERSION)
self.main.show()
def __init__(self):
QWidget.__init__(self)
self._main_container = main_container.MainContainer()
self._explorer_container = explorer_container.ExplorerContainer()
self.tabs = QTabWidget(self)
#Graph widget
self._graph = GraphicsView()
self._graphMl = GraphicsView()
# Graph scene
self.scene = GraphicsScene(self._graph)
self.sceneMl = GraphicsScene(self._graphMl)
path = os.path.join(PRJ_PATH, "img", 'textX-ninja.svg')
self.scene.webview = QGraphicsWebView()
self.create_webview(path, self.scene, self._graph)
self.scene.addItem(self.scene.webview)
self._graph.setScene(self.scene)
self.set_view(self._graph)
self._graphMl.setScene(self.sceneMl)
self.set_view(self._graphMl)
self.tabs.addTab(self._graph, "Metamodel")
self.tabs.addTab(self._graphMl, "Model")
#Main Layout
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
main_layout.addWidget(self.tabs)
def __init__(self, bind_address: str, port: int, filesToRead: [str]):
"""
:param bind_address: address to bind to when listening for live connections.
:param port: port to bind to when listening for live connections.
:param filesToRead: replay files to open.
"""
QMainWindow.__init__(self)
self.liveWindow = LivePlayerWindow(bind_address, port)
self.replayWindow = ReplayWindow()
self.tabManager = QTabWidget()
self.tabManager.addTab(self.replayWindow, "Replays")
self.tabManager.addTab(self.liveWindow, "Live connections")
self.setCentralWidget(self.tabManager)
openAction = QAction("Open...", self)
openAction.setShortcut("Ctrl+O")
openAction.setStatusTip("Open a replay file")
openAction.triggered.connect(self.onOpenFile)
menuBar = self.menuBar()
fileMenu = menuBar.addMenu("File")
fileMenu.addAction(openAction)
for fileName in filesToRead:
self.replayWindow.openFile(fileName)
def __init__(self, parent):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Language Manager"))
self.setModal(True)
self.resize(700, 500)
vbox = QVBoxLayout(self)
self._tabs = QTabWidget()
vbox.addWidget(self._tabs)
btnReload = QPushButton(self.tr("Reload"))
btnReload.setMaximumWidth(100)
vbox.addWidget(btnReload)
self.overlay = ui_tools.Overlay(self)
self.overlay.show()
self._languages = []
self._loading = True
self.downloadItems = []
#Load Themes with Thread
self.connect(btnReload, SIGNAL("clicked()"), self._reload_languages)
self._thread = ui_tools.ThreadCallback(self.execute_thread)
self.connect(self._thread, SIGNAL("finished()"),
self.load_languages_data)
self._reload_languages()
def __init__(self, parent):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Plugins Manager"))
self.setModal(True)
self.resize(700, 500)
vbox = QVBoxLayout(self)
self._tabs = QTabWidget()
vbox.addWidget(self._tabs)
btnReload = QPushButton(self.tr("Reload"))
btnReload.setMaximumWidth(100)
vbox.addWidget(btnReload)
self.overlay = ui_tools.Overlay(self)
self.overlay.hide()
self._oficial_available = []
self._community_available = []
self._locals = []
self._updates = []
self._loading = True
self.connect(btnReload, SIGNAL("clicked()"), self._reload_plugins)
self.thread = ThreadLoadPlugins(self)
self.connect(self.thread, SIGNAL("finished()"),
self._load_plugins_data)
self.connect(self.thread, SIGNAL("plugin_downloaded(PyQt_PyObject)"),
self._after_download_plugin)
self.connect(self.thread, SIGNAL("plugin_uninstalled(PyQt_PyObject)"),
self._after_uninstall_plugin)
self.overlay.show()
self._reload_plugins()
def __init__(self, mainwindow):
super(ScoreWizardDialog, self).__init__(mainwindow)
self.addAction(mainwindow.actionCollection.help_whatsthis)
self._pitchLanguage = None
layout = QVBoxLayout()
self.setLayout(layout)
self.tabs = QTabWidget()
b = self.dialogButtons = QDialogButtonBox()
b.setStandardButtons(QDialogButtonBox.Reset
| QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
b.accepted.connect(self.accept)
b.rejected.connect(self.reject)
userguide.addButton(b, "scorewiz")
b.button(QDialogButtonBox.Reset).clicked.connect(self.reset)
self.previewButton = b.addButton('', QDialogButtonBox.ActionRole)
self.previewButton.clicked.connect(self.showPreview)
layout.addWidget(self.tabs)
layout.addWidget(b)
self.header = Header(self)
self.tabs.addTab(self.header, '')
self.parts = Parts(self)
self.tabs.addTab(self.parts, '')
self.settings = Settings(self)
self.tabs.addTab(self.settings, '')
self.tabs.setCurrentIndex(0)
self.tabs.widget(0).widget() # activate it
self.tabs.currentChanged.connect(self.slotCurrentChanged)
qutil.saveDialogSize(self, "scorewiz/dialog/size")
app.translateUI(self)
self.accepted.connect(self.slotAccepted)
def __set_layout(self, surface_manager, character, action_factory, config,
parent):
"""
Set layout of this widget
"""
self.keymap = self._construct_keymap(config)
self.setWindowTitle('Menu')
self.inventory = InventoryWidget(surface_manager=surface_manager,
character=character,
action_factory=action_factory,
config=config,
parent=parent)
self.character = CharacterWidget(surface_manager=surface_manager,
character=character,
parent=parent)
self.tabs = QTabWidget()
self.tabs.addTab(self.inventory, 'Inventory')
self.tabs.addTab(self.character, 'Character')
layout = QVBoxLayout()
layout.addWidget(self.tabs)
self.setLayout(layout)
self.inventory.items_carried.items[0].setFocus()
def __init__(self, parent, devmgr):
QWidget.__init__(self, parent)
self.devmgr = devmgr
self.devmgr.registerPreUpdateCallback(self.devlistPreUpdate)
self.devmgr.registerPostUpdateCallback(self.devlistPostUpdate)
self.devmgr.registerUpdateCallback(self.devlistUpdate)
self.devmgr.registerDestroyedCallback(self.devmgrDestroyed)
# maps a device GUID to a QT panel
self.panels = {}
# a layout for ourselves
self.layout = QVBoxLayout(self)
# the tabs
self.tabs = QTabWidget(self)
self.tabs.hide()
self.layout.addWidget(self.tabs)
# a dialog that is shown during update
self.status = PanelManagerStatus(self)
self.status.lblMessage.setText("Initializing...")
self.layout.addWidget(self.status)
self.status.show()
# live check timer
self.alivetimer = QTimer()
QObject.connect(self.alivetimer, SIGNAL('timeout()'), self.commCheck)
self.alivetimer.start(2000)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.layout = QGridLayout(self)
self.setLayout(self.layout)
self.tabs = QTabWidget(self)
self.tabs.setTabPosition(QTabWidget.West)
self.layout.addWidget(self.tabs)
def __init__(self, project, parent=None):
super(ProjectProperties, self).__init__(parent, Qt.Dialog)
self.parent = parent
self.project = project
self.setWindowTitle(translations.TR_PROJECT_PROPERTIES)
self.resize(600, 500)
vbox = QVBoxLayout(self)
self.tab_widget = QTabWidget()
self.projectData = ProjectData(self)
self.projectExecution = ProjectExecution(self)
self.projectMetadata = ProjectMetadata(self)
self.tab_widget.addTab(self.projectData, translations.TR_PROJECT_DATA)
self.tab_widget.addTab(self.projectExecution,
translations.TR_PROJECT_EXECUTION)
self.tab_widget.addTab(self.projectMetadata,
translations.TR_PROJECT_METADATA)
vbox.addWidget(self.tab_widget)
self.btnSave = QPushButton(translations.TR_SAVE)
self.btnCancel = QPushButton(translations.TR_CANCEL)
hbox = QHBoxLayout()
hbox.addWidget(self.btnCancel)
hbox.addWidget(self.btnSave)
vbox.addLayout(hbox)
self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
def initUI(self):
mainWidget = QWidget()
mainWidget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.setCentralWidget(mainWidget)
top = QVBoxLayout(mainWidget)
tabs = QTabWidget(self)
top.addWidget(tabs)
logTab = QWidget()
debugLogTabLayout = QVBoxLayout(logTab)
debugLogTabLayout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
tabs.addTab(logTab, "Log")
self.debugLogWidget = DebugLogWidget(self)
self.debugLogWidget.addToWidget(debugLogTabLayout)
self.testLogButton = QPushButton("Test Log", self)
self.testLogButton.clicked.connect(self._testLog)
top.addWidget(self.testLogButton)
self.setGeometry(0, 0, 800, 400)
self.setWindowTitle('Log Test')
self.show()
def __init__(self, app = None, filename='.'):
super(mainWindow, self).__init__()
self.resize(1800,900)
self.centralWidget = QWidget()
self.layout = QHBoxLayout()
self.centralWidget.setLayout(self.layout)
self.tab = QTabWidget()
self.astraPlot = astraHDFPlotWidget(filename)
self.layout.addWidget(self.astraPlot)
self.setCentralWidget(self.centralWidget)
self.setWindowTitle("ASTRA Data Plotter")
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
# reloadSettingsAction = QAction('Reload Settings', self)
# reloadSettingsAction.setStatusTip('Reload Settings YAML File')
# reloadSettingsAction.triggered.connect(self.picklePlot.reloadSettings)
# fileMenu.addAction(reloadSettingsAction)
exitAction = QAction('&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(app.quit)
fileMenu.addAction(exitAction)
def __init__(self, application=None, title="VISPA"):
#logging.debug(__name__ + ": __init__")
self._justActivated = False
self._startupScreen = None
self._application = application
QMainWindow.__init__(self)
self._tabWidget = QTabWidget(self)
self._tabWidget.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self._tabWidget.setUsesScrollButtons(True)
self.setCentralWidget(self._tabWidget)
if hasattr(self._tabWidget, "setTabsClosable"):
self._tabWidget.setTabsClosable(True)
if "vispa" in title.lower():
self.createStartupScreen()
self._fileMenu = self.menuBar().addMenu("&File")
self._editMenu = self.menuBar().addMenu("&Edit")
self._helpMenu = self.menuBar().addMenu("&Help")
self._fileToolBar = self.addToolBar("File")
self.ensurePolished()
self.setWindowIcon(QIcon(":/resources/vispabutton.png"))
self.setWindowTitle(title)
self.statusBar()
self._loadIni()
if self._startupScreen:
self._startupScreen.raise_()
self.updateStartupScreenGeometry()
def __init__(self):
super().__init__()
self.createMenus()
self.createStatusBar()
# main widget
self.main = QTabWidget()
self.overview = eu4cd.overview.OverviewWidget()
self.ideas = eu4cd.idea.IdeasWidget()
self.rating = eu4cd.rating.RatingWidget()
self.main.addTab(self.overview, "Overview")
self.main.addTab(self.ideas, "Ideas")
self.main.addTab(self.rating, "Rating")
self.ideas.costChanged.connect(self.handleCostChanged)
self.ideas.costChanged.connect(self.handlePenaltiesChanged)
self.ideas.ideaNamesChanged.connect(self.handleIdeaNamesChanged)
self.overview.countryLoaded.connect(self.handleCountryLoaded)
self.overview.penaltiesChanged.connect(self.handlePenaltiesChanged)
self.overview.adjectiveChanged.connect(self.handleAdjectiveChanged)
self.setCentralWidget(self.main)
self.setWindowTitle(
"Unofficial Europa Universalis IV Country Designer")
self.loadConfig()
def createWidgets(self):
"""
QtWidgets creation
"""
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMinMaxButtonsHint)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStyleSheet("""QDialogButtonBox {
dialogbuttonbox-buttons-have-icons: 1;
dialog-ok-icon: url(:/ok.png);
dialog-cancel-icon: url(:/ko.png);
}""")
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.xmlWidget = RawView(self,
self.__dataXml,
toCsv=False,
toHtml=False,
toXml=True,
toPrinter=True,
toTxt=False,
toPdf=True)
layout = QVBoxLayout()
self.mainTab = QTabWidget()
self.mainTab.addTab(self.xmlWidget, 'Xml')
layout.addWidget(self.mainTab)
layout.addWidget(self.buttonBox)
self.setWindowTitle("Export Test Statistics")
self.setLayout(layout)
def g_display(self):
QWidget.__init__(self)
self.evtWidget = None
self.evtxWidget = None
layout = QHBoxLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
widget = QTabWidget()
layout.addWidget(widget)
processus_manager = ModuleProcessusManager()
evtx = processus_manager.get('evtx')
evt = processus_manager.get('evt')
try:
self.evtxWidgets = evtx.getall('/')
if self.evtxWidgets:
if self.evtxWidgets.list_widget.count():
widget.addTab(self.evtxWidgets, "Events logs (.evtx)")
except Exception as e:
pass
try:
self.evtWidgets = evt.getAllEvtFiles('/')
if self.evtWidgets.evtFileListWidget.count():
widget.addTab(self.evtWidgets, "Events logs (.evt)")
except Exception as e:
pass
def __init__(self, item, parent=None):
QDialog.__init__(self, parent, Qt.Dialog)
self._item = item
self.setWindowTitle(self.tr("Project Properties"))
vbox = QVBoxLayout(self)
self.tab_widget = QTabWidget()
self.projectData = ProjectData(self)
self.projectExecution = ProjectExecution(self)
self.projectMetadata = ProjectMetadata(self)
self.tab_widget.addTab(self.projectData, self.tr("Project Data"))
self.tab_widget.addTab(self.projectExecution,
self.tr("Project Execution"))
self.tab_widget.addTab(self.projectMetadata,
self.tr("Project Metadata"))
vbox.addWidget(self.tab_widget)
self.btnSave = QPushButton(self.tr("Save"))
self.btnCancel = QPushButton(self.tr("Cancel"))
hbox = QHBoxLayout()
hbox.addWidget(self.btnCancel)
hbox.addWidget(self.btnSave)
vbox.addLayout(hbox)
self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
def createWidgets(self):
"""
Create all widgets
"""
self.setWindowIcon(QIcon(':/plugin.png'))
self.mainTab = QTabWidget()
self.aboutPage = AboutPage(parent=self)
self.debugPage = DebugPage(parent=self)
self.mainTab.addTab(self.aboutPage, "About")
self.mainTab.addTab(self.debugPage, "Debug")
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.mainTab)
self.setLayout(mainLayout)
self.setWindowTitle("%s - %s - %s" %
(Settings.instance().readValue(key='Common/name'),
self.pluginName, self.pluginVersion))
flags = Qt.WindowFlags()
if not self.debugMode: flags |= Qt.WindowStaysOnTopHint
self.setWindowFlags(flags)
def __init__(self, parent):
QDialog.__init__(self, parent, Qt.Dialog)
self.setWindowTitle(self.tr("Themes Manager"))
self.resize(700, 500)
vbox = QVBoxLayout(self)
self._tabs = QTabWidget()
vbox.addWidget(self._tabs)
# Footer
hbox = QHBoxLayout()
btn_close = QPushButton(self.tr('Close'))
btnReload = QPushButton(self.tr("Reload"))
hbox.addWidget(btn_close)
hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
hbox.addWidget(btnReload)
vbox.addLayout(hbox)
self.overlay = ui_tools.Overlay(self)
self.overlay.show()
self._schemes = []
self._loading = True
self.downloadItems = []
#Load Themes with Thread
self.connect(btnReload, SIGNAL("clicked()"), self._reload_themes)
self._thread = ui_tools.ThreadExecution(self.execute_thread)
self.connect(self._thread, SIGNAL("finished()"), self.load_skins_data)
self.connect(btn_close, SIGNAL('clicked()'), self.close)
self._reload_themes()
def buildMixer(self):
self.Selectors = {}
self.Pannings = {}
self.Volumes = {}
self.Mutes = {}
self.Mixers = {}
self.FW410HP = 0
model = self.configrom.getModelId()
if model not in self.info:
return
self.id = self.info[model][0]
name = self.info[model][1]
tabs_layout = QHBoxLayout(self)
tabs = QTabWidget(self)
self.addInputTab(tabs)
self.addMixTab(tabs)
if self.aux[self.id] is not None:
self.addAuxTab(tabs)
self.addOutputTab(tabs)
tabs_layout.addWidget(tabs)
def __init__(self, controller):
QMainWindow.__init__(self)
# set controller
self.controller = controller
# set position & size
self.setGeometry(550, 100, 10, 10)
# set title
self.setWindowTitle("Crops")
# create main widget
self.main_widget = QWidget(self)
# create main layout
self.main_layout = QVBoxLayout(self.main_widget)
self.main_layout.setAlignment(Qt.AlignTop)
self.main_layout.addStretch(1)
self.main_layout.setSpacing(5)
# initialize list of dicts used for accessing all crop parameter controls
self.crop_param_controls = []
# create tabs widget
self.crop_tabs_widget = QTabWidget()
self.crop_tabs_widget.setUsesScrollButtons(True)
self.crop_tabs_widget.tabCloseRequested.connect(
self.controller.remove_crop)
self.crop_tabs_widget.currentChanged.connect(
self.controller.change_crop)
self.crop_tabs_widget.setElideMode(Qt.ElideLeft)
self.crop_tabs_widget.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.crop_tabs_widget.setMinimumSize(276, 300)
self.main_layout.addWidget(self.crop_tabs_widget)
# create tabs layout
crop_tabs_layout = QHBoxLayout(self.crop_tabs_widget)
# create lists for storing all crop tab widgets & layouts
self.crop_tab_layouts = []
self.crop_tab_widgets = []
# add crop button layout
crop_button_layout = QHBoxLayout()
crop_button_layout.setSpacing(5)
crop_button_layout.addStretch(1)
self.main_layout.addLayout(crop_button_layout)
# set main widget
self.setCentralWidget(self.main_widget)
# set window buttons
self.setWindowFlags(Qt.CustomizeWindowHint
| Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint)
self.show()
def createWidgets(self):
"""
QtWidgets creation
"""
self.mainTab = QTabWidget()
mainLayout = QVBoxLayout()
self.toRead = QLabel( "%s" % "Release notes are specific to each version of the server, SUT adapters, libraries and toolbox. More details on each HISTORY files." )
mainLayout.addWidget(self.toRead)
mainLayout.addWidget(self.mainTab)
palette = QPalette()
brush = QBrush(QColor(240, 240, 240))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Base, brush)
# treewidget for server rn
self.rn = QTreeWidget(self)
self.rn.setHeaderHidden(True)
self.rn.setFrameShape(QFrame.NoFrame)
self.rn.setSelectionMode(QAbstractItemView.NoSelection)
self.rn.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.rn.setRootIsDecorated(False)
self.rn.setPalette(palette)
# treewidget for adapter rn
self.rnAdp = QTreeWidget(self)
self.rnAdp.setHeaderHidden(True)
self.rnAdp.setFrameShape(QFrame.NoFrame)
self.rnAdp.setSelectionMode(QAbstractItemView.NoSelection)
self.rnAdp.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.rnAdp.setRootIsDecorated(False)
self.rnAdp.setPalette(palette)
# treewidget for library rn
self.rnLibAdp = QTreeWidget(self)
self.rnLibAdp.setHeaderHidden(True)
self.rnLibAdp.setFrameShape(QFrame.NoFrame)
self.rnLibAdp.setSelectionMode(QAbstractItemView.NoSelection)
self.rnLibAdp.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.rnLibAdp.setRootIsDecorated(False)
self.rnLibAdp.setPalette(palette)
# treewidget for agent rn
self.rnToolbox = QTreeWidget(self)
self.rnToolbox.setHeaderHidden(True)
self.rnToolbox.setFrameShape(QFrame.NoFrame)
self.rnToolbox.setSelectionMode(QAbstractItemView.NoSelection)
self.rnToolbox.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.rnToolbox.setRootIsDecorated(False)
self.rnToolbox.setPalette(palette)
self.mainTab.addTab( self.rn, Settings.instance().readValue( key = 'Common/acronym-server' ) )
self.mainTab.addTab( self.rnAdp, "Sut Adapters" )
self.mainTab.addTab( self.rnLibAdp, "Sut Librairies" )
self.mainTab.addTab( self.rnToolbox, "Toolbox" )
self.setLayout(mainLayout)
def __init__(self, gui_configuration = None):
QMainWindow.__init__(self)
self.setupUi(self)
# Bind the application global instance for to this window
set_opusgui_instance(self)
self.thread().setPriority(QThread.HighestPriority)
self.tabWidget = QTabWidget(self.splitter)
self.splitter.setSizes([400, 500])
# Create a log window
self.log_tab = LogWidget(self.tabWidget)
self.log_tab.start_stdout_capture()
# Initialize empty project
self.project = OpusProject()
# Read database connection names
settings_directory = os.path.join(os.environ['OPUS_HOME'], 'settings')
db_con_file = os.path.join(settings_directory, 'database_server_configurations.xml')
db_config_node = ElementTree(file=db_con_file).getroot()
self.db_connection_names = [node.tag for node in db_config_node if
node.tag != Comment and node.get('hidden') != "True" and node.tag != 'xml_version']
# Application default configuration
self.gui_config = gui_configuration
# Bind actions
self._setup_actions()
# Manager collection -- initialized by openProject()
self.managers = {}
# # Delay before hiding the splash screen
# time.sleep(1)
# self.gui_config.splash_screen.hide()
# Restoring application geometry from last shut down
settings = QSettings()
self.restoreGeometry(settings.value("Geometry").toByteArray())
self.updateFontSize()
self.setFocus()
# Variable library
self.variable_library = None
# Load the latest project file if that flag is set in GUI configuration
if self.gui_config.load_latest_on_start:
self.openProject(self.gui_config.latest_project_filename or '')
###T: removing these until they serve a purpose
self.menuUtilities.removeAction(self.actPythonView)
#self.menuUtilities.removeAction(self.actionLog_View)
self.menuUtilities.removeAction(self.actEditorView)
self.connect(self, SIGNAL('variables_updated'), self.update_saved_state)
self.update_saved_state()
