def keyPressEvent(self, event):
""" When Alt pressed, note number will be shown in viewedList. """
if event.key() == Qt.Key_Alt:
self.altPressed = True
self.updateRecentViewedNotes()
else:
QMainWindow.keyPressEvent(self, event)
def changeEvent(self, event):
if event.type() == QEvent.WindowStateChange:
self._enableWindowActions(not self.isMinimized())
controller = self.app.documentController
if controller.documents and controller.documents[-1] == self:
NodeBoxDocumentBaseClass.windowMaximized = self.isMaximized()
QMainWindow.changeEvent(self, event)
def __init__(self, parent=None, scan_on_startup=False):
QMainWindow.__init__(self, parent)
self.resize(800, 500)
self._widget = MainWidget(self, scan_on_startup=scan_on_startup)
self.setCentralWidget(self._widget)
settings = QSettings()
self.restoreGeometry(settings.value('geometry', b'', QByteArray))
self.setWindowTitle('Marche')
menu = self.menuBar()
menuFile = menu.addMenu('File')
menuFile.addAction(self._widget.actionAdd_host)
menuFile.addAction(self._widget.actionScan_network)
menuFile.addSeparator()
menuFile.addAction(self._widget.actionLoad_session)
menuFile.addAction(self._widget.actionSave_session_as)
menuFile.addSeparator()
menuFile.addAction(self._widget.actionExit)
self._widget.actionExit.triggered.connect(self.close)
menuEdit = menu.addMenu('Edit')
menuEdit.addAction(self._widget.actionPreferences)
menuJobs = menu.addMenu('Jobs')
menuJobs.addAction(self._widget.actionReload)
menuHelp = menu.addMenu('Help')
menuHelp.addAction(self._widget.actionAbout)
menuHelp.addAction(self._widget.actionAbout_Qt)
self.statusBar().showMessage('Welcome!', 1000)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self._config = {}
SubscriberApplication.instance().subscribed.connect(self.statusBar().clearMessage)
SubscriberApplication.instance().subscriptionError.connect(self._subscriptionError)
QTimer.singleShot(0, self._chooseTeam)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowFlags(Qt.Window)
self._mdi_area = QMdiArea()
self._mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self._mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setCentralWidget(self._mdi_area)
# set the size of mid_area and DocumentViewManager based on the
# screen size.
screen = QDesktopWidget().availableGeometry()
self._mdi_area.resize(screen.width() - 30, screen.height() - 80)
self.resize(self._mdi_area.size())
self._mdi_area.subWindowActivated.connect(self.update_actions)
self._viewer_mapper = QSignalMapper(self)
self._viewer_mapper.mapped[QWidget].connect(self.set_active_sub_window)
win_title = QApplication.translate(
"DocumentViewManager",
"Document Viewer"
)
self.setWindowTitle(win_title)
self.setUnifiedTitleAndToolBarOnMac(True)
self.statusBar().showMessage(
QApplication.translate(
"DocumentViewManager",
"Ready"
)
)
self._doc_viewers = {}
self._create_menu_actions()
self.update_actions()
def __init__(self, argv):
QMainWindow.__init__(self)
#Normalize the data if true
self._normalize_data=True
if 'notnormalize' in sys.argv:
print sys.argv
self._normalize_data=False
sys.argv.remove('notnormalize')
self.opPredict = None
self.opTrain = None
self.opThreshold = None
self._colorTable16 = self._createDefault16ColorColorTable()
#self.g = Graph(7, 2048*1024**2*5)
self.g = Graph()
self.fixableOperators = []
self.featureDlg=None
#The old ilastik provided the following scale names:
#['Tiny', 'Small', 'Medium', 'Large', 'Huge', 'Megahuge', 'Gigahuge']
#The corresponding scales are:
self.featScalesList=[0.3, 0.7, 1, 1.6, 3.5, 5.0, 10.0]
self.initUic()
#if the filename was specified on command line, load it
if len(sys.argv) >= 2:
def loadFile():
self._openFile(sys.argv[1:])
QTimer.singleShot(0, loadFile)
def __init__(self, parent = None):
QMainWindow.__init__(self, parent)
self.ui = Ui_ModuleEditor()
self.ui.setupUi(self)
self.curFilename = ""
self.untouch()
self.module = None
self.ignoreUIChange = True
for domain in module.AstrophysicalDomains:
self.ui.domainCombo.addItem(domain)
numConds = 0
self.checkboxMap = {}
for condition in sorted(module.StoppingConditions, key=lambda k: module.StoppingConditions[k]):
row = numConds // STOPCOND_GRID_WIDTH
col = numConds % STOPCOND_GRID_WIDTH
numConds += 1
condBox = QCheckBox(condition, self)
self.ui.stopcondGrid.addWidget(condBox, row, col)
self.checkboxMap[condition] = condBox
self.connect(condBox, SIGNAL("stateChanged(int)"), self.stopCondChanged)
self.resetUI()
self.disableUI()
self.ignoreUIChange = False
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
# self.connect(self.xTargetSlider,
# SIGNAL("valueChanged(int)"),
# self.xTargetChanged)
self.connect(self.xValueSlider,
SIGNAL("valueChanged(int)"),
self.xValueChanged)
self.connect(self.yTargetSlider,
SIGNAL("valueChanged(int)"),
self.yTargetChanged)
self.connect(self.yValueSlider,
SIGNAL("valueChanged(int)"),
self.yValueChanged)
self.timer = QTimer()
self.timer.start(100)
self.connect(self.timer,
SIGNAL("timeout()"), self.roscb)
# self.wobbler = move_head.Wobbler()
self.valuex_publisher = rospy.Publisher("/eyeGaze/valuex/command", Int32, queue_size=10)
self.targetx_publisher = rospy.Publisher("/eyeGaze/targetx/command", Int32, queue_size=10)
self.valuey_publisher = rospy.Publisher("/eyeGaze/valuey/command", Int32, queue_size=10)
self.targety_publisher = rospy.Publisher("/eyeGaze/targety/command", Int32, queue_size=10)
def __init__(self, systray=True, debug=False, reset=False, parent=None):
"""
Constructor
Keyword arguments:
systray -- enables the system tray icon (default=True)
debug -- enable debugging output (default=False)
reset -- reset preferences (default=False)
parent -- parent QWidget (default=None)
"""
QMainWindow.__init__(self, parent)
self.ui = Ui_Qnotero()
self.ui.setupUi(self)
if not reset:
self.restoreState()
self.debug = debug
self.reInit()
self.noResults()
if systray:
self.sysTray = SysTray(self)
self.sysTray.show()
self.minimizeOnClose = True
else:
self.minimizeOnClose = False
if getConfig("firstRun"):
self.preferences(firstRun=True)
if getConfig("autoUpdateCheck"):
self.updateCheck()
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle('LCM Plotter')
self.createMenu()
self.createMainFrame()
# Each channel has data and axis associated with it.
# Dictionary key is the channel name and property.
self.data = {}
self.axes = {}
self.lastPlot = None
# Stop the program if CTRL-C is received
self._stopEvent = threading.Event()
signal.signal(signal.SIGINT, self.handleSigint)
self._lcm = lcm.LCM()
self.handlerThread = threading.Thread(target=self.pollLcm)
self.handlerThread.setDaemon(True)
self.handlerThread.start()
self.connect(self, SIGNAL('redraw()'), self.on_draw) # Create redraw signal
self.drawingThread = threading.Thread(target=self.drawLoop)
self.drawingThread.setDaemon(True)
self.drawingThread.start()
def __init__(self, parent = None):
"""
Constructor
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.tableWidget.setColumnWidth(0,320)
self.tableWidget.setColumnWidth(1,60)
self.tableWidget.setColumnWidth(2,60)
#self.tableWidget.setColumnWidth(3,200)
header = self.tableWidget.horizontalHeader()
header.setStretchLastSection(True)
label_parent = self.label_drop_url.parent()
qrect = self.label_drop_url.geometry()
#self.removeWidget(self.label_drop_url)
self.label_drop_url.deleteLater()
self.label_drop_url = DragDropLabel(parent = label_parent,ui = self)
self.label_drop_url.setGeometry(qrect)
self.horizontalLayout_10.addWidget(self.label_drop_url)
self.listWidget_process.setViewMode(QtGui.QListWidget.IconMode)
self.listWidget_process.setIconSize(QtCore.QSize(20,20))
self.listWidget_process.setGridSize (QtCore.QSize(20,20))
self.listWidget_process.setDragDropMode(QtGui.QAbstractItemView.NoDragDrop)
self.listWidget_process.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
def __init__( self, workflow = [], parent = None, flags = QtCore.Qt.WindowFlags(0) ):
QMainWindow.__init__(self, parent = parent, flags = flags )
uic.loadUi( "ui/ilastikShell.ui", self )
self._applets = []
for applet in workflow:
self.addApplet(applet)
def timerEvent(self, event):
if event.timerId() == self.m_midiInTimerId:
global jack_midi_in_data
if not jack_midi_in_data.empty():
while True:
try:
data1, data2, data3 = jack_midi_in_data.get_nowait()
except QuequeEmpty:
break
channel = (data1 & 0x0F) + 1
mode = data1 & 0xF0
if channel in self.m_channels:
if mode == 0x80:
self.keyboard.sendNoteOff(data2, False)
elif mode == 0x90:
self.keyboard.sendNoteOn(data2, False)
elif mode == 0xB0:
self.scene.handleCC(data2, data3)
jack_midi_in_data.task_done()
self.scene.updateSmooth()
QMainWindow.timerEvent(self, event)
def __init__(self, doc):
QMainWindow.__init__(self, None)
self.doc = doc
self.app = doc.app
self._setupUi()
# Create base elements
self.model = MainWindowModel(document=doc.model)
self.model2view = {}
self.apanel = AccountPanel(mainwindow=self)
self.tpanel = TransactionPanel(mainwindow=self)
self.mepanel = MassEditionPanel(mainwindow=self)
self.scpanel = SchedulePanel(mainwindow=self)
self.bpanel = BudgetPanel(mainwindow=self)
self.cdrpanel = CustomDateRangePanel(mainwindow=self)
self.arpanel = AccountReassignPanel(mainwindow=self)
self.expanel = ExportPanel(mainwindow=self)
self.alookup = Lookup(self, model=self.model.account_lookup)
self.clookup = Lookup(self, model=self.model.completion_lookup)
self.drsel = DateRangeSelector(mainwindow=self, view=self.dateRangeSelectorView)
self.sfield = SearchField(model=self.model.search_field, view=self.searchLineEdit)
self.recentDocuments = Recent(self.app, 'recentDocuments')
self.recentDocuments.addMenu(self.menuOpenRecent)
self.model.view = self
self.model.connect()
self._updateUndoActions()
self._bindSignals()
def closeEvent(self, event):
'''Catch MainWindow's close event so we can hide it instead.'''
if self.hide_window:
self.hide()
event.ignore()
else:
QMainWindow.closeEvent(self, event)
def __init__(self, directory=".", debug=False):
"""
Initialisation method, setting the directory.
:param directory:
Root directory of the git repository.
"""
QMainWindow.__init__(self)
self._ui = Ui_MainWindow()
self._ui.setupUi(self)
self._modifications_shown = True
self._directory = directory
self.current_branch = None
self._models = {}
self.set_current_directory(directory)
self.enable_modifications_buttons(False)
self.filter_main_class = FilterMainClass(self, directory, self._models)
self.rebase_main_class = RebaseMainClass(self, directory, self._models)
self.reset_history()
self._applying = False
self.connect_slots()
def __init__(self):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self._version = 0.1
# user interface configuration.
self.setupUi(self)
# Hide some stuff
self.pushButton_moreOptions.setChecked(True)
# Loads Bible
self.BibleLoader = BibleLoader("BP05FNL")
# Signal / Slots connections
self.comboBox_book.currentIndexChanged.connect(self.populatesChapter)
self.comboBox_chapter.currentIndexChanged.connect(self.populatesVerseFrom)
self.comboBox_verseFrom.currentIndexChanged.connect(self.populatesVerseTo)
self.pushButton_Start.clicked.connect(self.startGame)
# Initalisation
self.populatesBook()
self.populatesVersion()
self.setWindowTitle("Lexilogos")
# Display
self.show()
self.dockWidget_settings.setMaximumWidth(
self.dockWidget_settings.width())
def __init__(self, systray=True, debug=False, reset=False, parent=None):
"""
Constructor.
Keyword arguments:
systray -- Enables the system tray icon (default=True)
debug -- Enable debugging output (default=False)
reset -- Reset preferences (default=False)
parent -- Parent QWidget (default=None)
"""
QMainWindow.__init__(self, parent)
self.loadUi('qnotero')
if not reset:
self.restoreState()
self.debug = debug
self.reInit()
self.noResults()
if systray:
self.sysTray = SysTray(self)
self.sysTray.show()
self.minimizeOnClose = True
else:
self.minimizeOnClose = False
if getConfig(u"firstRun") or not os.path.exists(getConfig('zoteroPath')):
self.preferences(firstRun=True)
if getConfig(u"autoUpdateCheck"):
self.updateCheck()
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Init MenuViews
self.ui.actionLogView.setChecked(self.ui.logDockWidget.isVisible())
self.ui.actionToolBar.setChecked(self.ui.toolBar.isVisible())
self.bisect_runner = BisectRunner(self)
self.bisect_runner.bisector_created.connect(
self.ui.report_view.model().attach_bisector)
self.ui.report_view.step_report_changed.connect(
self.ui.build_info_browser.update_content)
self.report_delegate = ReportItemDelegate()
self.ui.report_view.setItemDelegateForColumn(0, self.report_delegate)
self.bisect_runner.running_state_changed.connect(
self.ui.actionStart_a_new_bisection.setDisabled)
self.bisect_runner.running_state_changed.connect(
self.ui.actionStop_the_bisection.setEnabled)
self.persist = mkdtemp()
self.read_settings()
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
#title2 = '我的个人防火墙'
#print title2
#title = QString(u'我的个人防火墙')
self.setWindowTitle(u'我的个人防火墙')
#self.setWindowTitle(title)
#self.setWindowIcon(QIcon(":/pics/pic.jpg"))
self.tableView.setShowGrid(False)
self.actionDisplay.triggered.connect(self.displayconnections)
self.actionList_Rules.triggered.connect(self.listrules)
self.actionAdd_Rules.triggered.connect(self.addrules)
self.actionDisconnect.triggered.connect(self.disconnection)
self.actionReconnect.triggered.connect(self.reconnection)
self.actionMessage.triggered.connect(self.message)
#self.menuRules.aboutToShow.connect(self.rulesMenuTriggered)
#self.menuRules.actions()[0].triggered.connect(self.deleteMenuTriggered)
#self.actionShow_active_only.triggered.connect(self.showActiveOnly)
#self.actionShow_all.triggered.connect(self.showAll)
self.actionExit.triggered.connect(self.realQuit)
self.askusersig.connect(self.askUser)
self.update_bytestatssig.connect(self.update_bytestats)
self.refreshmodelsig.connect(self.refreshmodel)
self.refreshconnectionssig.connect(self.refreshconnections)
self.refreshrulessig.connect(self.refreshrules)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
self.setupTable()
self.settings = Settings(self)
self.ocr_all_set = False
self.fields = [self.name, self.sell, self.buy, self.demand_num, self.demand,
self.supply_num, self.supply]
self.canvases = [self.name_img, self.sell_img, self.buy_img, self.demand_img,
self.demand_text_img, self.supply_img, self.supply_text_img]
#setup buttons
self.add_button.clicked.connect(self.addFiles)
self.remove_button.clicked.connect(self.removeFile)
self.save_button.clicked.connect(self.addItemToTable)
self.skip_button.clicked.connect(self.nextLine)
self.ocr_button.clicked.connect(self.performOCR)
self.ocr_all.clicked.connect(self.runOCRAll)
self.export_button.clicked.connect(self.exportTable)
self.clear_table.clicked.connect(self.clearTable)
QObject.connect(self.actionHow_to_use, SIGNAL('triggered()'), self.howToUse)
QObject.connect(self.actionAbout, SIGNAL('triggered()'), self.About)
QObject.connect(self.actionOpen, SIGNAL('triggered()'), self.addFiles)
QObject.connect(self.actionPreferences, SIGNAL('triggered()'), self.openSettings)
QObject.connect(self.actionCalibrate, SIGNAL('triggered()'), self.openCalibrate)
self.error_close = False
if not isfile("./tessdata/big.traineddata"):
QMessageBox.critical(self,"Error", "OCR training data not found!\n"+\
"Make sure tessdata directory exists and contains big.traineddata.")
self.error_close = True
#set up required items for nn
self.training_image_dir = self.settings.app_path +"\\nn_training_images\\"
def __init__( self ):
# Init the baseclass
QMainWindow.__init__( self )
# Load widgetGallery ui file
uic.loadUi( os.path.split( __file__ )[0] + "\UI\widgetGallery.ui", self )
# Connect disable checkbox
self.disableWidgets.toggled.connect(self.mainWidget.setDisabled)
# Connect spread sliders to the scheme spread
self.spreadSlider.sliderMoved.connect(self.spreadSliderChange)
# Connect color pickers to base- and highlight-colors
self.pickBaseColor.clicked.connect(self.slotBaseColor)
self.pickHighlightColor.clicked.connect(self.slotHighlightColor)
# Create ColorSchemer and apply to the whole app
self.ColorScheme = QColorScheme()
self.ColorScheme.loadSimpleScheme(os.path.split( __file__ )[0] + "\..\QColorScheme\Presets\SimpleNuke.ini")
# Set initial values on the colorchips and spread slider to match the loaded scheme
self.spreadSlider.setValue(self.ColorScheme.spread*1000)
self.setBackgroundColor(self.chipBaseColor, self.ColorScheme.baseColor)
self.setBackgroundColor(self.chipHighlightColor, self.ColorScheme.highlightColor)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = ui_windowSettings.Ui_windowSettings()
self.ui.setupUi(self)
# actions
self.ui.btnSave.pressed.connect(self._saveSettings)
self.ui.btnCancel.pressed.connect(self._cancel)
self.ui.openBinNES.pressed.connect(self.openBinNES)
self.ui.openBinSNES.pressed.connect(self.openBinSNES)
self.ui.openBinN64.pressed.connect(self.openBinN64)
self.ui.openBinGameCube.pressed.connect(self.openBinGameCube)
self.ui.openBinWii.pressed.connect(self.openBinWii)
self.ui.openBinPS1.pressed.connect(self.openBinPS1)
self.ui.openBinPS2.pressed.connect(self.openBinPS2)
self.ui.openBinGenesis.pressed.connect(self.openBinGenesis)
self.ui.openBinDreamcast.pressed.connect(self.openBinDreamcast)
self.ui.openBinGameBoy.pressed.connect(self.openBinGameBoy)
self.ui.openBinGBA.pressed.connect(self.openBinGBA)
self.ui.openBinNDS.pressed.connect(self.openBinNDS)
# load current saved settings
self._loadSettings()
def __init__(self):
QMainWindow.__init__(self)
self.tools = {}
self.resize(300, 700)
self.setWindowTitle('ERT')
self.__main_widget = None
self.central_widget = QWidget()
self.central_layout = QVBoxLayout()
self.central_widget.setLayout(self.central_layout)
self.setCentralWidget(self.central_widget)
self.toolbar = self.addToolBar("Tools")
self.toolbar.setObjectName("Toolbar")
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea)
self.setCorner(Qt.BottomLeftCorner, Qt.BottomDockWidgetArea)
self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
self.setCorner(Qt.BottomRightCorner, Qt.BottomDockWidgetArea)
self.__view_menu = None
self.__help_menu = None
self.__createMenu()
self.__fetchSettings()
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_DemandGraphEditor()
self.ui.setupUi(self)
self.canvas = DemandGraphCanvas(self.ui.graphArea)
self.ui.graphArea.setWidget(self.canvas)
self.basename = self.windowTitle()
def show(self, action):
QMainWindow.show(self)
if action == SPLASH_NEW:
self.newExperiment()
elif action == SPLASH_OPEN:
self.openExperiment()
def __init__(self, parent = None):
"""
Constructor
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.table_summary.setRowCount(3)
self.table_summary.setColumnCount(2)
self.table_summary.horizontalHeader().setVisible(True)
self.table_summary.horizontalHeader().setVisible(True)
self.table_summary_2.setRowCount(5)
self.table_summary_2.setColumnCount(4)
self.table_summary_2.horizontalHeader().setVisible(True)
self.table_summary_2.horizontalHeader().setVisible(True)
#hide the results widget
self.results_tab = self.tabWidget.widget(1)
self.results_iterate_tab = self.tabWidget.widget(2)
self.results_diff_tab = self.tabWidget.widget(3)
self.tabWidget.removeTab(1)
self.tabWidget.removeTab(1)
self.tabWidget.removeTab(1)
def __init__(self, parent):
QMainWindow.__init__(self, parent)
self.ui = Ui_TestsWindow()
self.ui.setupUi(self)
self.projects = {}
self.changed = True
self.algs = "acdrf"
def __init__(self, parent = None):
'''
@type parent: QWidget
'''
QMainWindow.__init__(self, parent)
self.ui = uic.loadUi(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ui/main.ui'), self)
self.__lastupdatedlabel = QLabel()
self.ui.statusbar.addWidget(self.__lastupdatedlabel, 1)
self.contextmenu = QMenu(self)
self.contextmenu.addAction("Update Shows", self.updateshows)
self.contextmenu.addSeparator()
self.contextmenu.addAction("Remove Selected", self.removeshows)
self.connect(self.ui.showlist, SIGNAL('customContextMenuRequested(const QPoint&)'), self.showcontextmenu)
self.connect(self.ui.searchbutton, SIGNAL('pressed()'), self.search)
self.connect(self.ui.addbutton, SIGNAL('pressed()'), self.add)
self.connect(self.ui.searchtext, SIGNAL('textChanged(QString)'), self.enablesearch)
self.connect(self.ui.showlist, SIGNAL('doubleClicked(QModelIndex)'), self.openshow)
self.connect(self.ui.refreshshowsbutton, SIGNAL('pressed()'), self.updateshows)
self.connect(self.ui.removeshowsbutton, SIGNAL('pressed()'), self.removeshows)
self.connect(self.ui.getshowlistbutton, SIGNAL('pressed()'), self.getshowlist)
self.connect(self.ui.settingsautoswitchshowtab, SIGNAL('stateChanged(int)'), self.settingsautoswitchshowtabvaluechanged)
self.connect(self.ui.settingsautoswitchseasontab, SIGNAL('stateChanged(int)'), self.settingsautoswitchseasontabvaluechanged)
def __init__(self, parent = None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
#self.treeWidget.setHeaderHidden(True) # qt 4.4
delegate = MyItemDelegate(self.treeWidget.itemDelegate())
self.treeWidget.setItemDelegate(delegate)
headerItem = self.treeWidget.headerItem()
headerItem.setText(0, tr("available devices"))
headerItem.setTextAlignment(0, Qt.AlignHCenter)
headerItem.setToolTip(0,
QString("%1 %2")
.arg(self.windowTitle(), "0.1")+
QString("\n%1")
.arg(u"Copyright (C) 2010 Ingo Bressler")+
QString("\n%1\n%2\n%3")
.arg("This program comes with ABSOLUTELY",
"NO WARRANTY. This is free software, use",
"and redistribute it under the terms of "+
"the GPLv3.")+
QString("\n%1\n%2")
.arg(tr("For information, feedback and "+
"contributions, please visit:"),
"http://github.com/ibressler/dfmon"))
self.treeWidget.setMouseTracking(True)
QObject.connect(self.treeWidget,
SIGNAL("contentChanged(void)"),
self.updateGeometry)
QObject.connect(self.treeWidget,
SIGNAL("contentChanged(void)"),
self.centralwidget.updateGeometry)
QObject.connect(self.treeWidget,
SIGNAL("contentChanged(void)"),
self.contentChanged)
self.treeWidget.clear() # clears and rebuilds the tree
model = DummyImageList()
cf.setImages(model)
cf.setCurrentSlide(39000)
w.setCentralWidget(cf)
w.show()
cf.setFocus(Qt.OtherFocusReason)
sys.exit(app.exec_())
def main(args=sys.argv):
return 0
if __name__ == '__main__':
from PyQt4.QtGui import QApplication, QMainWindow
app = QApplication([])
w = QMainWindow()
cf = CoverFlow()
cf.resize(int(available_width() / 1.5), available_height() - 60)
w.resize(cf.size() + QSize(30, 20))
path = sys.argv[1]
model = FileSystemImages(sys.argv[1])
cf.currentChanged[int].connect(model.currentChanged)
cf.setImages(model)
w.setCentralWidget(cf)
w.show()
cf.setFocus(Qt.OtherFocusReason)
sys.exit(app.exec_())
def __init__(self):
self.window = QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.window)
self.ui.previewLabel.setPixmap(QPixmap("ui/nopreview.jpg"))
def __init__(self):
import os # Used in Testing Script
import sys
if used_Qt_Version == 4:
#print("Compile QUI for Qt Version: " + str(used_Qt_Version))
os.system("pyuic4 -o analoggaugewidget_demo_ui.py analoggaugewidget_demo.ui")
elif used_Qt_Version == 5:
#print("Compile QUI for Qt Version: " + str(used_Qt_Version))
os.system("pyuic5 -o analoggaugewidget_demo_ui.py analoggaugewidget_demo.ui")
from analoggaugewidget_demo_ui import Ui_MainWindow
self.app = QApplication(sys.argv)
window = QMainWindow()
self.my_gauge = Ui_MainWindow()
self.my_gauge.setupUi(window)
window.show()
self.my_gauge.widget.enable_barGraph = True
self.my_gauge.widget.value_needle_snapzone = 1
self.my_gauge.widget.value_min = 0
self.my_gauge.widget.value_max = 1100
self.my_gauge.widget.scala_main_count = 11
self.my_gauge.ActualSlider.setMaximum(self.my_gauge.widget.value_max)
self.my_gauge.ActualSlider.setMinimum(self.my_gauge.widget.value_min)
self.my_gauge.AussenRadiusSlider.setValue(self.my_gauge.widget.gauge_color_outer_radius_factor * 1000)
self.my_gauge.InnenRadiusSlider.setValue(self.my_gauge.widget.gauge_color_inner_radius_factor * 1000)
self.my_gauge.GaugeStartSlider.setValue(self.my_gauge.widget.scale_angle_start_value)
self.my_gauge.GaugeSizeSlider.setValue(self.my_gauge.widget.scale_angle_size)
# set Start Value
# self.my_gauge.widget.update_value(self.my_gauge.widget.value_min)
self.my_gauge.widget.update_value(int(self.my_gauge.widget.value_max - self.my_gauge.widget.value_min)/2)
################################################################################################
# Anzeigenadel Farbe anpassen
# auf Slider Aenderung reagieren
self.my_gauge.RedSlider_Needle.valueChanged.connect(self.set_NeedleColor)
self.my_gauge.GreenSlider_Needle.valueChanged.connect(self.set_NeedleColor)
self.my_gauge.BlueSlider_Needle.valueChanged.connect(self.set_NeedleColor)
self.my_gauge.TrancSlider_Needle.valueChanged.connect(self.set_NeedleColor)
# LCD Default Werte festlegen
self.my_gauge.lcdNumber_Red_Needle.display(self.my_gauge.RedSlider_Needle.value())
self.my_gauge.lcdNumber_Green_Needle.display(self.my_gauge.GreenSlider_Needle.value())
self.my_gauge.lcdNumber_Blue_Needle.display(self.my_gauge.RedSlider_Needle.value())
self.my_gauge.lcdNumber_Trancparency_Needle.display(self.my_gauge.TrancSlider_Needle.value())
################################################################################################
# Anzeigenadel Farbe anpassen bei manueller Beswegung
# auf Slider Aenderung reagieren
self.my_gauge.RedSlider_NeedleDrag.valueChanged.connect(self.set_NeedleColorDrag)
self.my_gauge.GreenSlider_NeedleDrag.valueChanged.connect(self.set_NeedleColorDrag)
self.my_gauge.BlueSlider_NeedleDrag.valueChanged.connect(self.set_NeedleColorDrag)
self.my_gauge.TrancSlider_NeedleDrag.valueChanged.connect(self.set_NeedleColorDrag)
# LCD Default Werte festlegen
self.my_gauge.lcdNumber_Red_NeedleDrag.display(self.my_gauge.RedSlider_NeedleDrag.value())
self.my_gauge.lcdNumber_Green_NeedleDrag.display(self.my_gauge.GreenSlider_NeedleDrag.value())
self.my_gauge.lcdNumber_Blue_NeedleDrag.display(self.my_gauge.BlueSlider_NeedleDrag.value())
self.my_gauge.lcdNumber_Trancparency_NeedleDrag.display(self.my_gauge.TrancSlider_NeedleDrag.value())
################################################################################################
# Skala Text Farbe anpassen
# auf Slider Aenderung reagieren
self.my_gauge.RedSlider_Scale.valueChanged.connect(self.set_ScaleValueColor)
self.my_gauge.GreenSlider_Scale.valueChanged.connect(self.set_ScaleValueColor)
self.my_gauge.BlueSlider_Scale.valueChanged.connect(self.set_ScaleValueColor)
self.my_gauge.TrancSlider_Scale.valueChanged.connect(self.set_ScaleValueColor)
# LCD Default Werte festlegen
self.my_gauge.lcdNumber_Red_Scale.display(self.my_gauge.RedSlider_Scale.value())
self.my_gauge.lcdNumber_Green_Scale.display(self.my_gauge.GreenSlider_Scale.value())
self.my_gauge.lcdNumber_Blue_Scale.display(self.my_gauge.BlueSlider_Scale.value())
self.my_gauge.lcdNumber_Trancparency_Scale.display(self.my_gauge.TrancSlider_Scale.value())
################################################################################################
# Display Text Farbe anpassen
# auf Slider Aenderung reagieren
self.my_gauge.RedSlider_Display.valueChanged.connect(self.set_DisplayValueColor)
self.my_gauge.GreenSlider_Display.valueChanged.connect(self.set_DisplayValueColor)
self.my_gauge.BlueSlider_Display.valueChanged.connect(self.set_DisplayValueColor)
self.my_gauge.TrancSlider_Display.valueChanged.connect(self.set_DisplayValueColor)
# LCD Default Werte festlegen
self.my_gauge.lcdNumber_Red_Display.display(self.my_gauge.RedSlider_Display.value())
self.my_gauge.lcdNumber_Green_Display.display(self.my_gauge.GreenSlider_Display.value())
self.my_gauge.lcdNumber_Blue_Display.display(self.my_gauge.BlueSlider_Display.value())
self.my_gauge.lcdNumber_Trancparency_Display.display(self.my_gauge.TrancSlider_Display.value())
self.my_gauge.CB_barGraph.stateChanged.connect(self.en_disable_barGraph)
self.my_gauge.CB_ValueText.stateChanged.connect(self.en_disable_ValueText)
self.my_gauge.CB_CenterPoint.stateChanged.connect(self.en_disable_CB_CenterPoint)
self.my_gauge.CB_ScaleText.stateChanged.connect(self.en_disable_ScaleText)
self.my_gauge.CB_ShowBarGraph.stateChanged.connect(self.set_enable_filled_Polygon)
self.my_gauge.CB_Grid.stateChanged.connect(self.set_enable_Scale_Grid)
self.my_gauge.CB_fineGrid.stateChanged.connect(self.set_enable_fine_Scale_Grid)
self.my_gauge.CB_Needle.stateChanged.connect(self.en_disable_Needle)
# my_gauge.widget.set_scale_polygon_colors([[.0, Qt.transparent]])
# my_gauge.widget.set_scale_polygon_colors([[.0, Qt.yellow]])
# my_gauge.widget.set_scale_polygon_colors(None)
# my_gauge.widget.enable_filled_Polygon = False
sys.exit(self.app.exec_())
