class GoogleFinanceUrlSetupDialog(QDialog):
SETTING_GOOGLE_URL = 'googleUrl'
SETTING_GOOGLE_COUNTRY = 'googleCountry'
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prop = MaeMoneyProperties.instance()
self.urls = {}
self.urls[self.prop.GOOGLE_COUNTRY_HK] = 'www.google.com.hk'
self.urls[self.prop.GOOGLE_COUNTRY_CN] = 'www.google.com.cn'
self.urls[self.prop.GOOGLE_COUNTRY_CAN] = 'www.google.ca'
self.urls[self.prop.GOOGLE_COUNTRY_UK] = 'www.google.co.uk'
self.urls[self.prop.GOOGLE_COUNTRY_US] = 'www.google.com'
self.setupUi()
def setupUi(self):
self.setWindowModality(Qt.WindowModal)
self.buttonBox = QDialogButtonBox(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.gridLayout = QGridLayout()
self.setLayout(self.gridLayout)
self.labelGFinanceUrl = QLabel(self.tr("Google URL"))
self.gridLayout.addWidget(self.labelGFinanceUrl, 0, 1, 1, 1)
self.comboBoxGFinanceUrl = QComboBox()
for [country, url] in sorted(self.urls.iteritems()):
self.comboBoxGFinanceUrl.addItem(country, url)
googleCountry = self.prop.getGoogleCountry()
index = self.comboBoxGFinanceUrl.findText(googleCountry)
self.comboBoxGFinanceUrl.setCurrentIndex(index)
self.gridLayout.addWidget(self.comboBoxGFinanceUrl, 0, 2, 1, 1)
self.gridLayout.addWidget(QLabel(self.tr("Current setting")), 1, 1, 1, 1)
self.gridLayout.addWidget(QLabel(self.prop.getGoogleCountry()),
1, 2, 1, 1)
self.setUrlButton = QPushButton(self.tr("Set URL"))
self.gridLayout.addWidget(self.setUrlButton, 2, 1, 1, 2)
self.loginErrorMsgLabel = QLabel("")
self.gridLayout.addWidget(self.loginErrorMsgLabel, 3, 1, 1, 2)
self.setWindowTitle(self.tr("Setup"))
self.connect(self.buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.connect(self.setUrlButton, SIGNAL("clicked()"), self.setUrl)
def setUrl(self):
indexSelected = self.comboBoxGFinanceUrl.currentIndex()
country = self.comboBoxGFinanceUrl.itemText(indexSelected)
url = self.comboBoxGFinanceUrl.itemData(indexSelected).toString().toAscii()
self.prop.setGoogleCountryUrl(country, url)
self.accept()
class RunConfigDialog(BaseRunConfigDialog):
"""Run configuration dialog box: multiple file version"""
def __init__(self, parent=None):
BaseRunConfigDialog.__init__(self, parent)
self.file_to_run = None
self.combo = None
self.stack = None
def run_btn_clicked(self):
"""Run button was just clicked"""
self.file_to_run = unicode(self.combo.currentText())
def setup(self, fname):
"""Setup Run Configuration dialog with filename *fname*"""
combo_label = QLabel(_("Select a run configuration:"))
self.combo = QComboBox()
self.combo.setMaxVisibleItems(20)
self.combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.stack = QStackedWidget()
configurations = _get_run_configurations()
for index, (filename, options) in enumerate(configurations):
if fname == filename:
break
else:
# There is no run configuration for script *fname*:
# creating a temporary configuration that will be kept only if
# dialog changes are accepted by the user
configurations.insert(0, (fname, RunConfiguration(fname).get()))
index = 0
for filename, options in configurations:
widget = RunConfigOptions(self)
widget.set(options)
self.combo.addItem(filename)
self.stack.addWidget(widget)
self.connect(self.combo, SIGNAL("currentIndexChanged(int)"),
self.stack.setCurrentIndex)
self.combo.setCurrentIndex(index)
self.add_widgets(combo_label, self.combo, 10, self.stack)
self.add_button_box(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.setWindowTitle(_("Run Settings"))
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = unicode(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and\
not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append((filename, options))
_set_run_configurations(configurations)
QDialog.accept(self)
class RunConfigDialog(BaseRunConfigDialog):
"""Run configuration dialog box: multiple file version"""
def __init__(self, parent=None):
BaseRunConfigDialog.__init__(self, parent)
self.file_to_run = None
self.combo = None
self.stack = None
def run_btn_clicked(self):
"""Run button was just clicked"""
self.file_to_run = unicode(self.combo.currentText())
def setup(self, fname):
"""Setup Run Configuration dialog with filename *fname*"""
combo_label = QLabel(_("Select a run configuration:"))
self.combo = QComboBox()
self.combo.setMaxVisibleItems(20)
self.combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.combo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.stack = QStackedWidget()
configurations = _get_run_configurations()
for index, (filename, options) in enumerate(configurations):
if fname == filename:
break
else:
# There is no run configuration for script *fname*:
# creating a temporary configuration that will be kept only if
# dialog changes are accepted by the user
configurations.insert(0, (fname, RunConfiguration(fname).get()))
index = 0
for filename, options in configurations:
widget = RunConfigOptions(self)
widget.set(options)
self.combo.addItem(filename)
self.stack.addWidget(widget)
self.connect(self.combo, SIGNAL("currentIndexChanged(int)"),
self.stack.setCurrentIndex)
self.combo.setCurrentIndex(index)
self.add_widgets(combo_label, self.combo, 10, self.stack)
self.add_button_box(QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
self.setWindowTitle(_("Run Settings"))
def accept(self):
"""Reimplement Qt method"""
configurations = []
for index in range(self.stack.count()):
filename = unicode(self.combo.itemText(index))
runconfigoptions = self.stack.widget(index)
if index == self.stack.currentIndex() and\
not runconfigoptions.is_valid():
return
options = runconfigoptions.get()
configurations.append( (filename, options) )
_set_run_configurations(configurations)
QDialog.accept(self)
class LanguageDialog(QDialog):
def __init__(self):
super().__init__()
text = QLabel('Choose a language: ') # intentionally English
self._selection = QComboBox()
okButton = QPushButton(_('OK'))
layout = QVBoxLayout()
inputBox = QHBoxLayout()
buttonBox = QHBoxLayout()
self._langs = get_langs()
langs = list(self._langs.keys())
langs.sort()
self._selection.addItems([lang for lang in langs])
self._selection.currentIndexChanged.connect(self._set_lang)
self._lang = langs.index('English (United States)')
self._selection.setCurrentIndex(self._lang)
okButton.clicked.connect(self.accept)
inputBox.addWidget(text)
inputBox.addWidget(self._selection)
buttonBox.addStretch(2)
buttonBox.addWidget(okButton)
layout.addLayout(inputBox)
layout.addLayout(buttonBox)
self.setLayout(layout)
def _set_lang(self, s):
self._lang = s
@property
def lang(self):
return self._langs[self._selection.itemText(self._lang)]
class LanguageDialog(QDialog):
def __init__(self):
super().__init__()
text = QLabel('Choose a language: ') # intentionally English
self._selection = QComboBox()
okButton = QPushButton(_('OK'))
layout = QVBoxLayout()
inputBox = QHBoxLayout()
buttonBox = QHBoxLayout()
self._langs = get_langs()
langs = list(self._langs.keys())
langs.sort()
self._selection.addItems([lang for lang in langs])
self._selection.currentIndexChanged.connect(self._set_lang)
self._lang = langs.index('English (United States)')
self._selection.setCurrentIndex(self._lang)
okButton.clicked.connect(self.accept)
inputBox.addWidget(text)
inputBox.addWidget(self._selection)
buttonBox.addStretch(2)
buttonBox.addWidget(okButton)
layout.addLayout(inputBox)
layout.addLayout(buttonBox)
self.setLayout(layout)
def _set_lang(self, s):
self._lang = s
@property
def lang(self):
return self._langs[self._selection.itemText(self._lang)]
class ParamSpinBox(QAbstractSpinBox):
def __init__(self, parent):
QAbstractSpinBox.__init__(self, parent)
self.fMinimum = 0.0
self.fMaximum = 1.0
self.fDefault = 0.0
self.fValue = None
self.fStep = 0.0
self.fStepSmall = 0.0
self.fStepLarge = 0.0
self.fReadOnly = False
self.fScalePoints = None
self.fHaveScalePoints = False
self.fBar = ParamProgressBar(self)
self.fBar.setContextMenuPolicy(Qt.NoContextMenu)
self.fBar.show()
self.fName = ""
self.lineEdit().setVisible(False)
self.connect(self, SIGNAL("customContextMenuRequested(QPoint)"), SLOT("slot_showCustomMenu()"))
self.connect(self.fBar, SIGNAL("valueChanged(double)"), SLOT("slot_progressBarValueChanged(double)"))
QTimer.singleShot(0, self, SLOT("slot_updateProgressBarGeometry()"))
def setDefault(self, value):
value = fixValue(value, self.fMinimum, self.fMaximum)
self.fDefault = value
def setMinimum(self, value):
self.fMinimum = value
self.fBar.setMinimum(value)
def setMaximum(self, value):
self.fMaximum = value
self.fBar.setMaximum(value)
def setValue(self, value, send=True):
value = fixValue(value, self.fMinimum, self.fMaximum)
if self.fValue == value:
return False
self.fValue = value
self.fBar.setValue(value)
if self.fHaveScalePoints:
self._setScalePointValue(value)
if send:
self.emit(SIGNAL("valueChanged(double)"), value)
self.update()
return True
def setStep(self, value):
if value == 0.0:
self.fStep = 0.001
else:
self.fStep = value
if self.fStepSmall > value:
self.fStepSmall = value
if self.fStepLarge < value:
self.fStepLarge = value
def setStepSmall(self, value):
if value == 0.0:
self.fStepSmall = 0.0001
elif value > self.fStep:
self.fStepSmall = self.fStep
else:
self.fStepSmall = value
def setStepLarge(self, value):
if value == 0.0:
self.fStepLarge = 0.1
elif value < self.fStep:
self.fStepLarge = self.fStep
else:
self.fStepLarge = value
def setLabel(self, label):
self.fBar.setLabel(label)
def setName(self, name):
self.fName = name
def setTextCallback(self, textCall):
self.fBar.setTextCall(textCall)
def setReadOnly(self, yesNo):
self.setButtonSymbols(QAbstractSpinBox.UpDownArrows if yesNo else QAbstractSpinBox.NoButtons)
self.fReadOnly = yesNo
QAbstractSpinBox.setReadOnly(self, yesNo)
def setScalePoints(self, scalePoints, useScalePoints):
if len(scalePoints) == 0:
self.fScalePoints = None
self.fHaveScalePoints = False
return
self.fScalePoints = scalePoints
self.fHaveScalePoints = useScalePoints
if useScalePoints:
# Hide ProgressBar and create a ComboBox
self.fBar.close()
self.fBox = QComboBox(self)
self.fBox.setContextMenuPolicy(Qt.NoContextMenu)
self.fBox.show()
self.slot_updateProgressBarGeometry()
for scalePoint in scalePoints:
self.fBox.addItem("%f - %s" % (scalePoint['value'], scalePoint['label']))
if self.fValue != None:
self._setScalePointValue(self.fValue)
self.connect(self.fBox, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_comboBoxIndexChanged(QString)"))
def stepBy(self, steps):
if steps == 0 or self.fValue is None:
return
value = self.fValue + (self.fStep * steps)
if value < self.fMinimum:
value = self.fMinimum
elif value > self.fMaximum:
value = self.fMaximum
self.setValue(value)
def stepEnabled(self):
if self.fReadOnly or self.fValue is None:
return QAbstractSpinBox.StepNone
if self.fValue <= self.fMinimum:
return QAbstractSpinBox.StepUpEnabled
if self.fValue >= self.fMaximum:
return QAbstractSpinBox.StepDownEnabled
return (QAbstractSpinBox.StepUpEnabled | QAbstractSpinBox.StepDownEnabled)
def updateAll(self):
self.update()
self.fBar.update()
if self.fHaveScalePoints:
self.fBox.update()
def resizeEvent(self, event):
QTimer.singleShot(0, self, SLOT("slot_updateProgressBarGeometry()"))
QAbstractSpinBox.resizeEvent(self, event)
@pyqtSlot(str)
def slot_comboBoxIndexChanged(self, boxText):
if self.fReadOnly:
return
value = float(boxText.split(" - ", 1)[0])
lastScaleValue = self.fScalePoints[-1]["value"]
if value == lastScaleValue:
value = self.fMaximum
self.setValue(value)
@pyqtSlot(float)
def slot_progressBarValueChanged(self, value):
if self.fReadOnly:
return
step = int((value - self.fMinimum) / self.fStep + 0.5)
realValue = self.fMinimum + (step * self.fStep)
self.setValue(realValue)
@pyqtSlot()
def slot_showCustomMenu(self):
menu = QMenu(self)
actReset = menu.addAction(self.tr("Reset (%f)" % self.fDefault))
menu.addSeparator()
actCopy = menu.addAction(self.tr("Copy (%f)" % self.fValue))
clipboard = QApplication.instance().clipboard()
pasteText = clipboard.text()
pasteValue = None
if pasteText:
try:
pasteValue = float(pasteText)
except:
pass
if pasteValue is None:
actPaste = menu.addAction(self.tr("Paste"))
else:
actPaste = menu.addAction(self.tr("Paste (%s)" % pasteValue))
menu.addSeparator()
actSet = menu.addAction(self.tr("Set value..."))
if self.fReadOnly:
actReset.setEnabled(False)
actPaste.setEnabled(False)
actSet.setEnabled(False)
actSel = menu.exec_(QCursor.pos())
if actSel == actSet:
dialog = CustomInputDialog(self, self.fName, self.fValue, self.fMinimum, self.fMaximum, self.fStep, self.fScalePoints)
if dialog.exec_():
value = dialog.returnValue()
self.setValue(value)
elif actSel == actCopy:
clipboard.setText("%f" % self.fValue)
elif actSel == actPaste:
self.setValue(pasteValue)
elif actSel == actReset:
self.setValue(self.fDefault)
@pyqtSlot()
def slot_updateProgressBarGeometry(self):
self.fBar.setGeometry(self.lineEdit().geometry())
if self.fHaveScalePoints:
self.fBox.setGeometry(self.lineEdit().geometry())
def _getNearestScalePoint(self, realValue):
finalValue = 0.0
for i in range(len(self.fScalePoints)):
scaleValue = self.fScalePoints[i]["value"]
if i == 0:
finalValue = scaleValue
else:
srange1 = abs(realValue - scaleValue)
srange2 = abs(realValue - finalValue)
if srange2 > srange1:
finalValue = scaleValue
return finalValue
def _setScalePointValue(self, value):
value = self._getNearestScalePoint(value)
for i in range(self.fBox.count()):
if float(self.fBox.itemText(i).split(" - ", 1)[0]) == value:
self.fBox.setCurrentIndex(i)
break
class WFramework(QWidget, Logger.ClassLogger):
"""
Framework widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self)
self.addAction.setMinimumHeight(40)
self.addAction.setMaximumWidth(200)
self.cancelAction = QtHelper.createAction(self, "&Cancel", self.cancelStep,
icon=QIcon(":/undo.png"), tip = 'Cancel update')
self.cancelAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(self, "&", self.openOptions,
icon=QIcon(":/recorder-basic-small.png"), tip = 'Framework options')
def openOptions(self):
"""
Open options dialog
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgets(self):
"""
Create all qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
font = QFont()
font.setBold(True)
self.actionsComboBox = QComboBox(self)
self.actionsComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_FRAMEWORK_DESCR)):
if not len( GuiSteps.ACTION_FRAMEWORK_DESCR[i] ):
self.actionsComboBox.insertSeparator(i+1)
else:
el = GuiSteps.ACTION_FRAMEWORK_DESCR[i].keys()
self.actionsComboBox.addItem( list(el)[0] )
self.labelActionDescr = QLabel(self)
self.labelActionDescr.setText( "%s\n" % GuiSteps.ACTION_FRAMEWORK_DESCR[0][GuiSteps.FRAMEWORK_INFO])
self.labelActionDescr.setWordWrap(True)
self.labelActionDescr.hide()
self.descriptionLine = QLineEdit(self)
self.descriptionLine.hide()
actionLayout2 = QGridLayout()
self.createWidgetGetText()
self.createWidgetGetWait()
self.createWidgetCacheSet()
self.createWidgetCheckString()
self.createWidgetGetAsk()
actionLayout2.addWidget( self.setCacheGroup , 0, 0)
actionLayout2.addWidget( self.getCheckGroup , 1, 0)
actionLayout2.addWidget( self.getTextGroup , 2, 0)
actionLayout2.addWidget( self.getWaitGroup , 3, 0)
actionLayout2.addWidget( self.getAskGroup , 4, 0)
labelAct = QLabel( self.tr("Action: ") )
labelAct.setFont( font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutFinal = QHBoxLayout()
layoutFinal.addWidget( labelAct )
layoutFinal.addWidget(self.actionsComboBox)
layoutFinal.addWidget( self.arrowLabel )
layoutFinal.addLayout( actionLayout2 )
layoutFinal.addWidget( self.arrowLabel2 )
layoutFinal.addWidget(self.addAction)
layoutFinal.addStretch(1)
self.setLayout(layoutFinal)
def createToolbar(self):
"""
Create toolbar
"""
pass
def createWidgetCheckString(self):
"""
Create widget to check string
"""
self.getCheckGroup = QGroupBox(self.tr(""))
# check in ?
self.checkInTextLine = QLineEdit(self)
self.checkInTextLine.setMinimumWidth(300)
self.checkInTextCombo = QComboBox(self)
self.checkInTextCombo.addItems( [ "CACHE" ] )
# operator
self.checkComboBox = QComboBox(self)
self.checkComboBox.addItems( [ GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS, GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP,
GuiSteps.OP_STARTSWITH, GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH,
GuiSteps.OP_NOTENDSWITH ] )
# check what ?
self.checkOutTextLine = QLineEdit(self)
self.checkOutTextLine.setMinimumWidth(300)
self.checkOutTextCombo = QComboBox(self)
self.checkOutTextCombo.addItems( LIST_TYPES )
# final layout
mainChecklayout = QGridLayout()
mainChecklayout.addWidget( QLabel( self.tr("Checking from:") ), 0, 0 )
mainChecklayout.addWidget( self.checkInTextCombo, 0, 1 )
mainChecklayout.addWidget( self.checkInTextLine, 0, 2 )
mainChecklayout.addWidget( QLabel( self.tr("If:") ), 1, 0 )
mainChecklayout.addWidget( self.checkComboBox, 1, 1 )
mainChecklayout.addWidget( QLabel( self.tr("The Value:") ), 2, 0 )
mainChecklayout.addWidget( self.checkOutTextCombo, 2, 1 )
mainChecklayout.addWidget( self.checkOutTextLine, 2, 2 )
self.getCheckGroup.setLayout(mainChecklayout)
self.getCheckGroup.hide()
def createWidgetGetText(self):
"""
Create text widget
"""
self.getTextGroup = QGroupBox(self.tr(""))
self.basicTextLine = QLineEdit(self)
self.basicTextLine.setMinimumWidth(300)
self.basicTextCombo = QComboBox(self)
self.basicTextCombo.addItems( LIST_TYPES )
mainTextlayout = QGridLayout()
mainTextlayout.addWidget( QLabel( self.tr("Value:") ), 0, 0 )
mainTextlayout.addWidget( self.basicTextCombo, 0, 1 )
mainTextlayout.addWidget( self.basicTextLine, 0, 2 )
self.getTextGroup.setLayout(mainTextlayout)
def createWidgetGetAsk(self):
"""
Create ask widget
"""
# ask
self.getAskGroup = QGroupBox(self.tr(""))
self.askTextLine = QLineEdit(self)
self.askTextLine.setMinimumWidth(300)
self.askTextCombo = QComboBox(self)
self.askTextCombo.addItems( LIST_TYPES )
self.askTextCacheLine = QLineEdit(self)
self.askTextCacheLine.setMinimumWidth(300)
self.askTextCacheCombo = QComboBox(self)
self.askTextCacheCombo.addItems( [ "CACHE" ] )
mainAsklayout = QGridLayout()
mainAsklayout.addWidget( QLabel( self.tr("User input prompt:") ), 0, 0 )
mainAsklayout.addWidget( self.askTextCombo, 0, 1 )
mainAsklayout.addWidget( self.askTextLine, 0, 2 )
mainAsklayout.addWidget( QLabel( self.tr("And save response in:") ), 1, 0 )
mainAsklayout.addWidget( self.askTextCacheCombo, 1, 1 )
mainAsklayout.addWidget( self.askTextCacheLine, 1, 2 )
self.getAskGroup.setLayout(mainAsklayout)
self.getAskGroup.hide()
def createWidgetGetWait(self):
"""
Create wait text widget
"""
self.getWaitGroup = QGroupBox(self.tr(""))
self.valueWaitLine = QLineEdit(self)
self.valueWaitLine.setMinimumWidth(300)
self.valueWaitLine.setValidator(self.validatorInt)
self.valueWaitCombo = QComboBox(self)
self.valueWaitCombo.addItems( LIST_TYPES )
mainTextlayout = QGridLayout()
mainTextlayout.addWidget( QLabel( self.tr("Value (in seconds):") ), 0, 0 )
mainTextlayout.addWidget( self.valueWaitCombo, 0, 1 )
mainTextlayout.addWidget( self.valueWaitLine, 0, 2 )
self.getWaitGroup.setLayout(mainTextlayout)
self.getWaitGroup.hide()
def createWidgetCacheSet(self):
"""
Create cache widget
"""
self.setCacheGroup = QGroupBox(self.tr(""))
setCacheLayout = QGridLayout()
self.cacheKeyName = QLineEdit(self)
self.cacheKeyName.setMinimumWidth(300)
setCacheLayout.addWidget( QLabel( self.tr("Key name:") ) , 0, 1)
setCacheLayout.addWidget( self.cacheKeyName , 0, 2)
self.setCacheGroup.setLayout(setCacheLayout)
self.setCacheGroup.hide()
def createConnections(self):
"""
Createa qt connections
"""
self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged)
self.addAction.clicked.connect(self.addStep)
self.basicTextCombo.currentIndexChanged.connect(self.onBasicTextTypeChanged)
self.valueWaitCombo.currentIndexChanged.connect(self.onValueWaitTypeChanged)
self.checkOutTextCombo.currentIndexChanged.connect(self.onCheckOutTextTypeChanged)
self.askTextCombo.currentIndexChanged.connect(self.onAskTextTypeChanged)
def onAskTextTypeChanged(self):
"""
On ask type changed
"""
if self.askTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.askTextLine.setValidator(self.validatorAll)
if self.askTextCombo.currentText() == "ALIAS":
self.askTextLine.setText( self.askTextLine.text().upper() )
self.askTextLine.setValidator(self.validatorUpper)
def onCheckOutTextTypeChanged(self):
"""
On check out type changed
"""
if self.checkOutTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.checkOutTextLine.setValidator(self.validatorAll)
if self.checkOutTextCombo.currentText() == "ALIAS":
self.checkOutTextLine.setText( self.checkOutTextLine.text().upper() )
self.checkOutTextLine.setValidator(self.validatorUpper)
def onValueWaitTypeChanged(self):
"""
On value wait changed
"""
if self.valueWaitCombo.currentText() in [ "TEXT" ]:
self.valueWaitLine.setText( "0" )
self.valueWaitLine.setValidator(self.validatorInt)
if self.valueWaitCombo.currentText() in [ "CACHE" ]:
self.valueWaitLine.setValidator(self.validatorAll)
if self.valueWaitCombo.currentText() == "ALIAS":
self.valueWaitLine.setText( self.valueWaitLine.text().upper() )
self.valueWaitLine.setValidator(self.validatorUpper)
def onBasicTextTypeChanged(self):
"""
On basic text changed
"""
if self.basicTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.basicTextLine.setValidator(self.validatorAll)
if self.basicTextCombo.currentText() == "ALIAS":
self.basicTextLine.setText( self.basicTextLine.text().upper() )
self.basicTextLine.setValidator(self.validatorUpper)
def pluginDataAccessor(self):
"""
Return data for plugins
"""
return { "data": "" }
def onPluginImport(self, dataJson):
"""
On call from plugin
"""
pass
def onRadioAskChanged(self, button):
"""
On radio ask changed
"""
if button.text() == 'From alias parameter':
self.askTextLine.setText( self.askTextLine.text().upper() )
self.askTextLine.setValidator(self.validAskUpper)
else:
self.askTextLine.setValidator(self.validAskAll)
def onActionChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_FRAMEWORK_DESCR:
if isinstance(el, dict):
if self.actionsComboBox.currentText() in el:
descr = GuiSteps.ACTION_FRAMEWORK_DESCR[i][self.actionsComboBox.currentText()]
break
i += 1
self.labelActionDescr.setText( "%s\n" % descr )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]:
self.getTextGroup.show()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]:
self.getWaitGroup.show()
self.getTextGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
self.getTextGroup.show()
self.getWaitGroup.hide()
self.setCacheGroup.show()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
self.getCheckGroup.show()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]:
self.getCheckGroup.hide()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_USERCODE, GuiSteps.FRAMEWORK_CACHE_RESET ]:
self.getCheckGroup.hide()
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
else:
self.getTextGroup.hide()
self.getWaitGroup.hide()
self.setCacheGroup.hide()
self.getCheckGroup.hide()
self.getAskGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.hide()
def addStep(self):
"""
Add step
"""
action = self.actionsComboBox.currentText()
descr = self.descriptionLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAction.isEnabled():
signal = self.UpdateStep
if action in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ]:
fromCache = False
if self.basicTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True
newText = self.basicTextLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
parameters = { 'text': newText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_INTERACT ]:
# read text from cache, alias or not ?
fromCache = False
if self.askTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.askTextCombo.currentText() == "ALIAS": fromAlias = True
askText = self.askTextLine.text()
if not len(askText):
QMessageBox.warning(self, "Assistant" , "Please to set question to ask!")
else:
saveAskText = self.askTextCacheLine.text()
if not len(saveAskText):
QMessageBox.warning(self, "Assistant" , "Please to set key destination cache!")
else:
parameters = { 'key': saveAskText, 'value': askText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
fromCache = False
if self.checkOutTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.checkOutTextCombo.currentText() == "ALIAS": fromAlias = True
inText = self.checkInTextLine.text()
if not len(inText):
QMessageBox.warning(self, "Assistant" , "Please to set a cache key value!")
else:
outText = self.checkOutTextLine.text()
if not len(outText):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
op = self.checkComboBox.currentText()
parameters = { 'key': inText, 'value': outText, 'from-cache': fromCache,
'from-alias': fromAlias, "operator": op }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif action in [ GuiSteps.FRAMEWORK_WAIT ]:
fromCache = False
if self.valueWaitCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.valueWaitCombo.currentText() == "ALIAS": fromAlias = True
miscStr = self.valueWaitLine.text()
if not len(miscStr):
QMessageBox.warning(self, "Assistant" , "Please to set a value!")
else:
parameters = {'from-cache': fromCache, 'from-alias': fromAlias}
signal.emit( str(action), unicode(descr), miscStr, parameters )
elif action in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
fromCache = False
if self.basicTextCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.basicTextCombo.currentText() == "ALIAS": fromAlias = True
newText = self.basicTextLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant" , "Please to set a text value!")
else:
miscStr = self.cacheKeyName.text()
if not len(miscStr):
QMessageBox.warning(self, "Assistant" , "Please to set a key name!")
else:
parameters = { 'key': miscStr, 'value': newText, 'from-cache': fromCache, 'from-alias': fromAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
def cancelStep(self):
"""
Cancel step
"""
self.addAction.setText( "&Add" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize update
"""
self.addAction.setText( "&Add Action" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
def editStep(self, stepData):
"""
Edit step
"""
self.addAction.setText( "&Update" )
buttonFont = QFont()
buttonFont.setBold(True)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsComboBox.count()):
item_text = self.actionsComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionChanged()
# finally fill all fields
self.descriptionLine.setText( stepData["description"] )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INFO, GuiSteps.FRAMEWORK_WARNING ] :
self.basicTextLine.setText ( stepData["parameters"]["text"] )
if stepData["parameters"]["from-cache"]:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.basicTextLine.setValidator(self.validatorUpper)
self.basicTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_WAIT ]:
self.valueWaitLine.setText ( stepData["misc"] )
if stepData["parameters"]["from-cache"]:
self.valueWaitLine.setValidator(self.validatorAll)
self.valueWaitCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.valueWaitLine.setValidator(self.validatorUpper)
self.valueWaitCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.valueWaitLine.setValidator(self.validatorInt)
self.valueWaitCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CACHE_SET ]:
self.basicTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.basicTextLine.setValidator(self.validatorUpper)
self.basicTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.basicTextLine.setValidator(self.validatorAll)
self.basicTextCombo.setCurrentIndex(INDEX_TEXT)
self.cacheKeyName.setText( stepData["parameters"]["key"] )
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_CHECK_STRING ]:
self.checkOutTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.checkOutTextLine.setValidator(self.validatorAll)
self.checkOutTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.checkOutTextLine.setValidator(self.validatorUpper)
self.checkOutTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.checkOutTextLine.setValidator(self.validatorAll)
self.checkOutTextCombo.setCurrentIndex(INDEX_TEXT)
self.checkInTextLine.setText ( stepData["parameters"]["key"] )
for i in xrange(self.checkComboBox.count()):
item_text = self.checkComboBox.itemText(i)
if unicode(stepData["parameters"]["operator"]) == unicode(item_text):
self.checkComboBox.setCurrentIndex(i)
break
if self.actionsComboBox.currentText() in [ GuiSteps.FRAMEWORK_INTERACT ]:
self.askTextLine.setText ( stepData["parameters"]["value"] )
if stepData["parameters"]["from-cache"]:
self.askTextLine.setValidator(self.validatorAll)
self.askTextCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.askTextLine.setValidator(self.validatorUpper)
self.askTextCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.askTextLine.setValidator(self.validatorAll)
self.askTextCombo.setCurrentIndex(INDEX_TEXT)
self.askTextCacheLine.setText ( stepData["parameters"]["key"] )
def getTimeout(self):
"""
Return timeout
"""
return self.optionsDialog.timeoutLine.text()
def setTimeout(self, timeout):
"""
Set the timeout
"""
return self.optionsDialog.timeoutLine.setText(timeout)
class ResolutionSettingWidget(QWidget):
def __init__(self, app, parent = None):
super(ResolutionSettingWidget,self).__init__(parent)
self.setStyleSheet("font-size : 16px;")
self.app = app
CDLL("libjson-c.so", mode=RTLD_GLOBAL)
self.jytcapi = cdll.LoadLibrary('../lib/libjytcapi.so')
self.jytcapi.jyinittcapi()
self.resolutionLabel = QLabel(self.tr("Resolution setting"))
self.resolutionCombox = QComboBox()
self.resolutionCombox.setFixedSize(300, 30)
self.saveBtn = QPushButton(self.tr("Save"))
self.saveBtn.setStyleSheet("background: rgb(7,87,198); color: white; width: 90px; height: 30px;font-size : 16px;")
gridLayout = QGridLayout()
gridLayout.setSpacing(15)
gridLayout.setMargin(10)
gridLayout.addWidget(self.resolutionLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.resolutionCombox, 0, 1, 1, 1)
topLayout = QHBoxLayout()
topLayout.addStretch()
topLayout.addSpacing(50)
topLayout.addLayout(gridLayout)
topLayout.addStretch(1)
bottomHLayout = QHBoxLayout()
bottomHLayout.addStretch()
bottomHLayout.addWidget(self.saveBtn)
bottomHLayout.addStretch()
vLayout = QVBoxLayout()
vLayout.addStretch()
vLayout.addSpacing(50)
vLayout.addLayout(topLayout)
vLayout.addStretch(2)
vLayout.addSpacing(10)
vLayout.addLayout(bottomHLayout)
self.setLayout(vLayout)
self.updateResolutionCombox()
self.timer = QTimer()
self.timer.setSingleShot(True)
self.connect(self.timer,SIGNAL("timeout()"),self.resetScreenResolution);
self.connect(self.saveBtn, SIGNAL("clicked()"),self.slotSave)
def updateWindow(self):
self.resolutionLabel.setText(self.tr(self.tr("Resolution setting")))
self.saveBtn.setText(self.tr("Save"))
def getCmdExecValue(self, cmd):
statusOutput = commands.getstatusoutput(cmd)
monitorList = statusOutput[1].split("\n")
return monitorList
def getCmdExecValueT(self, cmd):
"""得到命令执行的结果"""
statusOutput = commands.getstatusoutput(cmd)
monitorList = statusOutput[1].split("\n")
return monitorList
def showCurrentScreenResolution(self, curResolutionValue):
"""显示当前屏幕的分辨率"""
count = self.resolutionCombox.count()
for i in range(count):
if self.resolutionCombox.itemText(i) == curResolutionValue:
self.resolutionCombox.setCurrentIndex(i)
return
self.resolutionCombox.setCurrentIndex(-1)
def getCurrentScreenResolution(self, screenName):
currentSolution = "10"
reSolution = "auto"
solutionMap = {"0":"800x600","1":"1024x768","2":"1280x720","3":"1440x900","4":"1600x1020","5":"1920x1080","6":"1280x1024","7":"1366x768","8":"1600x900","10":"auto"}
cmd = "../lib/ccr_jytcapi current_display"
value = self.getCmdExecValueT(cmd)
for i in range(len(value)):
LogRecord.instance().logger.info("#".join(value))
if len(value[i].split(":"))==2 and value[i].split(":")[0]=="res" and value[i].split(":")[1] !="auto":
currentSolution = value[i].split(":")[1]
break
if solutionMap.has_key(currentSolution):
reSolution = solutionMap[currentSolution]
return reSolution
def updateResolutionCombox(self):
"""更新分辨率下拉框的内容"""
#得到屏幕支持的分辨率
self.resolutionCombox.clear()
resolutionmMap = self.getScreenResolution()
if resolutionmMap:
screenName = resolutionmMap.keys()[0]
for resolution in resolutionmMap[screenName]:
if resolution == "800x600":
pass
else:
self.resolutionCombox.addItem(resolution)
self.resolutionCombox.setItemData(0, screenName, Qt.UserRole + 1);
#获取当前屏幕的分辨率
self.curResolutionValue = self.getCurrentScreenResolution(screenName)
#显示当前屏幕的分辨率
self.showCurrentScreenResolution(self.curResolutionValue)
def getScreenResolution(self):
"""得到屏幕支持的分辨率"""
#获得显示器名称，连接状态及行号
Monitors = self.getCmdExecValueT("../lib/ccr_jytcapi display");
#根据组合列表把显示器名称和支持的分辨率放入到一个字典中
resolutionMap = {}
resolutionList = []
count = len(Monitors)
for i in range(count):
if len(Monitors[i].split(":"))<2:
continue
valueName = Monitors[i].split(":")[0]
valueValue = Monitors[i].split(":")[1]
if valueName == "value":
resolutionList.append(valueValue)
resolutionMap["monitorName"] = resolutionList
return resolutionMap
def slotSave(self):
language = StoreInfoParser.instance().getLanguage()
m_pTranslator = QTranslator()
exePath = "./"
if language == "chinese":
QmName = "zh_CN.qm"
else:
QmName = "en_US.qm"
if(m_pTranslator.load(QmName, exePath)):
QCoreApplication.instance().installTranslator(m_pTranslator)
"""改变当前的分辨率"""
screenName = self.resolutionCombox.itemData(0, Qt.UserRole + 1).toString()
if not screenName.isEmpty() and not screenName.isNull():
self.curResolutionValue = self.getCurrentScreenResolution(str(screenName))
if self.curResolutionValue:
reScreen = self.resolutionCombox.currentText()
if reScreen == "800x600":
pass
else:
pass
#弹出提示框，默认为取消
rb = MessageBox(self.tr("making sure set the resolution to current"), self).exec_()
if rb == QDialog.Accepted:
self.jytcapi.jysetdispconf(str(reScreen))
elif rb == QDialog.Rejected:
pass
def resetScreenResolution(self):
"""还原分辨率"""
#关闭提示窗口
children = self.children()
count = len(children)
for i in range(count):
if isinstance(children[i], MessageBox):
children[i].close()
#还原之前的分辨率
if self.jytcapi.jysetdispconf(self.curResolutionValue) != 0:
# QMessageBox.information(None,u"错误",u'还原分辨率失败')
InfoHintDialog(self.tr("reserve failed")).exec_()
return
#刷新分辨率下拉框
self.updateResolutionCombox()
if QString(self.curResolutionValue).contains("x"):
width = self.curResolutionValue.split("x")[0]
height = self.curResolutionValue.split("x")[1]
self.emit(SIGNAL("resizePosition"), width, height)
#刷新屏幕
self.app.slotRefreshVMList()
def writeConfigFile(self, curResolution):
"""记录修改后的配置文件"""
StoreInfoParser.instance().setResolutionValue(curResolution)
class SettingsWidget(QWidget):
"""
Widget for setting entrys
Inherits:
QWidget
Signals:
sig_index_changed - Emitted, if the index of a combo box changes (Combo box name|str)
"""
sig_index_changed = pyqtSignal(str)
def __init__(self, content, parent=None):
"""
Initialise the layout.
Arguments:
content - Content for the widget.
parent - Parent widget (default None)
Returns:
None
"""
super(SettingsWidget, self).__init__(parent)
# Layout
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
# Global content
self.default = content[0]
self.typ = content[1]['typ']
self.values = content[1]['values']
self.name = content[1]['name']
self.dtype = content[1]['dtype']
if self.typ == 'PLAIN':
self.edit = QLineEdit(self.name, self)
self.edit.setText(self.default)
elif self.typ == 'FILE':
self.edit = QLineEdit(self.name, self)
self.edit.setText(self.default)
self.edit.setPlaceholderText('Press shift+return')
self.edit.returnPressed.connect(self._find_file)
elif self.typ == 'FILE/CHOICE':
self.edit = QLineEdit(self.name, self)
self.edit.setText(self.default)
self.edit.setPlaceholderText('Press shift+return')
self.edit.returnPressed.connect(self._find_file)
elif self.typ == 'DIR':
self.edit = QLineEdit(self.name, self)
self.edit.setText(self.default)
self.edit.setPlaceholderText('Press shift+return')
self.edit.returnPressed.connect(self._find_dir)
elif self.typ == 'COMBO':
self.edit = QComboBox(self)
self.edit.currentIndexChanged.connect(
lambda: self.sig_index_changed.emit(self.name))
self.edit.addItems(self.values)
self.edit.setCurrentIndex(self.edit.findText(self.default))
self.change_color_if_true()
else:
print('SettingsWidget:', self.typ, 'Not known! Stopping here!')
sys.exit()
self.label = QLabel(self.name, self)
self.label.setObjectName('setting')
self.edit.setObjectName('setting')
try:
self.edit.textEdited.connect(
lambda: self.edit.setStyleSheet(tu.get_style(typ='unchanged')))
except AttributeError:
pass
try:
self.edit.currentIndexChanged.connect(self.change_color_if_true)
except AttributeError:
pass
layout.addWidget(self.label)
layout.addWidget(self.edit)
def change_color_if_true(self):
"""
Change the color, if the types are all true.
Arguments:
None
Returns:
None
"""
if self.edit.currentText() == 'False':
self.edit.setStyleSheet(tu.get_style(typ='False'))
else:
self.edit.setStyleSheet(tu.get_style(typ='True'))
@pyqtSlot()
def _find_file(self):
"""
Find file with an open file dialog.
Arguments:
None
Returns:
None
"""
in_file = QFileDialog.getOpenFileName(
caption='Find file: {0}'.format(self.name),
directory=os.getcwd(),
options=QFileDialog.DontUseNativeDialog)
if QT_VERSION == 4:
in_file = in_file
elif QT_VERSION == 5:
in_file = in_file[0]
else:
raise ImportError(
'QT version unknown! Please contact the transphire authors!')
if in_file != '':
self.sender().setText(in_file)
@pyqtSlot()
def _find_dir(self):
"""
Find directory with an open directory dialog
Arguments:
None
Returns:
None
"""
in_dir = QFileDialog.getExistingDirectory(
caption='Find directory: {0}'.format(self.name),
directory=os.getcwd(),
options=QFileDialog.DontUseNativeDialog)
if in_dir != '':
self.sender().setText(in_dir)
def get_settings(self, quiet=False):
"""
Get the settings as dict.
Arguments:
quiet - True, if prints should not be shown.
Returns:
None, if an error occured.
Settings as dictionary.
"""
settings = {}
if isinstance(self.edit, QComboBox):
value = self.edit.currentText()
elif isinstance(self.edit, QLineEdit):
value = self.edit.text()
else:
message = 'Unreachable code! Please contact the TranSPHIRE authors!'
print(message)
tu.message(message)
return None
if value:
if tu.check_instance(value=value, typ=self.dtype):
self.edit.setStyleSheet(tu.get_style(typ='pass'))
else:
self.edit.setStyleSheet(tu.get_style(typ='error'))
message = '{0}: {1} needs to be {2}'.format(
self.label.text(), value, self.dtype)
if not quiet:
print(message)
tu.message(message)
else:
pass
return None
else:
pass
settings[self.name] = value
return settings
def get_combo_entries(self):
"""
Get the entries of the combo boxes.
Arguments:
None
Returns:
List containing entries.
"""
entries_list = []
for idx in range(self.edit.count()):
entries_list.append(self.edit.itemText(idx))
return entries_list
def set_settings(self, text):
"""
Set settings
text - Text to set to the widget.
Returns:
None
"""
if self.typ == 'COMBO':
index = self.edit.findText(text)
if index == -1:
index = 0
else:
pass
self.edit.setCurrentIndex(index - 1)
self.edit.setCurrentIndex(index)
else:
self.edit.setText(text)
class SessionsStartup(SettingsGroup):
def __init__(self, page):
super(SessionsStartup, self).__init__(i18n("Session to load if Frescobaldi is started without arguments"), page)
grid = QGridLayout(self)
grid.setSpacing(0)
self.sessionOptions = {}
self.customSession = QComboBox(currentIndexChanged=page.changed)
def changed(dummy):
page.changed()
self.customSession.setEnabled(self.sessionOptions["custom"].isChecked())
for title, name in (
(i18n("Start with no session"), "none"),
(i18n("Start with last used session"), "lastused"),
(i18n("Start with session:"), "custom"),
):
self.sessionOptions[name] = QRadioButton(title, toggled=changed)
self.customSession.setToolTip(i18n("Choose a session."))
self.sessionOptions["custom"].clicked.connect(lambda: self.customSession.setFocus())
grid.addWidget(self.sessionOptions["none"], 0, 0, 1, 2)
grid.addWidget(self.sessionOptions["lastused"], 1, 0, 1, 2)
grid.addWidget(self.sessionOptions["custom"], 2, 0, 1, 1)
grid.addWidget(self.customSession, 2, 1, 1, 1)
self.customSession.addItem(i18n("Choose..."))
self.customSession.addItems(page.dialog.mainwin.sessionManager().names())
def defaults(self):
current = self.page.dialog.mainwin.sessionManager().current()
if current:
for index in range(1, self.customSession.count() + 1):
if self.customSession.itemText(index) == current:
self.customSession.setCurrentIndex(index)
self.sessionOptions["none"].setChecked(True)
def loadSettings(self):
conf = config("preferences")
session = conf.readEntry("custom session", "")
if session:
for index in range(1, self.customSession.count() + 1):
if self.customSession.itemText(index) == session:
self.customSession.setCurrentIndex(index)
name = conf.readEntry("default session", "")
if name not in self.sessionOptions:
name = "none"
self.sessionOptions[name].setChecked(True)
def saveSettings(self):
conf = config("preferences")
if self.customSession.currentIndex() > 0:
session = self.customSession.currentText()
else:
session = "none"
conf.writeEntry("custom session", session)
for name, widget in self.sessionOptions.items():
if widget.isChecked():
conf.writeEntry("default session", name)
break
class ComboBoxPanel(QWidget):
def __init__(self, parent, editable=False, spacerItemMove=False):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("ComboBoxPanel" +
str(len(parent.findChildren(ComboBoxPanel))))
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(0, 0, 0, 0)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
self.comboBox = QComboBox(self.frameBoxPanel)
self.comboBox.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.comboBox.setFont(font)
self.comboBox.setObjectName(self.objectName() + "_comboBox")
self.comboBox.setMinimumWidth(70)
# self.comboBox.setMaximumWidth(70)
# self.hLayoutframeBoxPanel.addWidget(self.lineEdit)
self.hLayoutframeBoxPanel.addWidget(self.comboBox)
self.imageButton = QToolButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
if not spacerItemMove:
spacerItem = QSpacerItem(10, 10, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.hLayoutBoxPanel.addItem(spacerItem)
self.comboBox.currentIndexChanged.connect(self.comboBoxChanged)
# self.comboBox.editTextChanged.connect(self.comboBoxEditTextChanged)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.captionUnits = ""
self.hasObject = False
self.objectList = []
if editable == True:
self.lineEdit = QLineEdit(self.frameBoxPanel)
self.lineEdit.setObjectName("lineEdit")
self.hLayoutframeBoxPanel.insertWidget(1, self.lineEdit)
self.comboBox.setLineEdit(self.lineEdit)
self.lineEdit.returnPressed.connect(self.comboBoxEditTextChanged)
def FindString(self, string):
return self.comboBox.findText(string)
def comboBoxEditTextChanged(self):
self.comboBox.showPopup()
def get_Count(self):
return self.comboBox.count()
Count = property(get_Count, None, None, None)
def method_0(self):
return self.comboBox.currentIndex(
) >= 0 and self.SelectedItem != None and self.SelectedItem != ""
def method_3(self, string_0):
return self.comboBox.findText(string_0)
def method_11(self, string_0):
if (self.IsEmpty):
return "%s%s\t" % (string_0, self.Caption)
return "%s%s\t%s %s" % (string_0, self.Caption, self.Value,
self.CaptionUnits)
def comboBoxChanged(self):
self.emit(SIGNAL("Event_0"), self)
def IndexOf(self, item):
if isinstance(item, str) or isinstance(item, QString):
return self.comboBox.findText(item)
else:
return self.comboBox.findText(item.ToString())
def Contains(self, item):
compStr = None
if isinstance(item, str):
compStr = item
elif isinstance(item, float) or isinstance(item, int):
compStr = str(item)
else:
compStr = item.ToString()
for i in range(self.comboBox.count()):
comboItemstr = self.comboBox.itemText(i)
if compStr == comboItemstr:
return True
return False
def Clear(self):
self.comboBox.clear()
self.objectList = []
self.hasObject = False
def Add(self, item):
if not isinstance(item, str) and not isinstance(item, QString):
self.comboBox.addItem(item.ToString())
self.objectList.append(item)
self.hasObject = True
return
self.comboBox.addItem(item)
self.hasObject = False
def Insert(self, index, item):
if not isinstance(item, str) and not isinstance(item, QString):
self.comboBox.insertItem(index, item.ToString())
self.objectList.insert(index, item)
self.hasObject = True
return
self.comboBox.insertItem(index, item)
self.hasObject = False
def imageButtonClicked(self):
self.emit(SIGNAL("Event_3"), self)
def get_Caption(self):
caption = self.captionLabel.text()
findIndex = caption.indexOf("(")
if findIndex > 0:
val = caption.left(findIndex)
return val
return caption
def set_Caption(self, captionStr):
if captionStr == "":
self.captionLabel.setText("")
self.LabelWidth = 0
return
if self.CaptionUnits != "" and self.CaptionUnits != None:
self.captionLabel.setText(captionStr + "(" +
QString(self.CaptionUnits) + ")" + ":")
else:
self.captionLabel.setText(captionStr + ":")
Caption = property(get_Caption, set_Caption, None, None)
def get_CaptionUnits(self):
return self.captionUnits
def set_CaptionUnits(self, captionUnits):
self.captionUnits = captionUnits
CaptionUnits = property(get_CaptionUnits, set_CaptionUnits, None, None)
def set_ButtonVisible(self, bool):
self.imageButton.setVisible(bool)
ButtonVisible = property(None, set_ButtonVisible, None, None)
# def get_Value(self):
# return self.comboBox.currentIndex()
# def set_Value(self, value):
# try:
# self.comboBox.setCurrentIndex(value)
# except:
# self.textBox.setText("")
# Value = property(get_Value, set_Value, None, None)
def get_IsEmpty(self):
return self.comboBox.currentText() == "" or self.comboBox.currentIndex(
) == -1
IsEmpty = property(get_IsEmpty, None, None, None)
def get_ReadOnly(self):
return self.textBox.isReadOnly()
# def set_ReadOnly(self, bool):
# self.comboBox.setR.setReadOnly(bool)
# ReadOnly = property(get_ReadOnly, set_ReadOnly, None, None)
def set_LabelWidth(self, width):
self.captionLabel.setMinimumSize(QSize(width, 0))
self.captionLabel.setMaximumSize(QSize(width, 16777215))
LabelWidth = property(None, set_LabelWidth, None, None)
def set_Width(self, width):
self.comboBox.setMinimumSize(QSize(width, 0))
self.comboBox.setMaximumSize(QSize(width, 16777215))
Width = property(None, set_Width, None, None)
def set_Button(self, imageName):
if imageName == None or imageName == "":
self.imageButton.setVisible(False)
return
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/" + imageName)), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setVisible(True)
Button = property(None, set_Button, None, None)
def get_SelectedIndex(self):
return self.comboBox.currentIndex()
def set_SelectedIndex(self, index):
if self.comboBox.count() == 0:
return
if index > self.comboBox.count() - 1:
self.comboBox.setCurrentIndex(0)
else:
self.comboBox.setCurrentIndex(index)
SelectedIndex = property(get_SelectedIndex, set_SelectedIndex, None, None)
def get_Value(self):
return self.comboBox.currentIndex()
def set_Value(self, valueStr):
if self.comboBox.count() == 0:
return
if valueStr == None:
self.SelectedIndex = -1
return
self.comboBox.setCurrentIndex(self.comboBox.findText(str(valueStr)))
Value = property(get_Value, set_Value, None, None)
def get_Items(self):
# if self.hasObject:
# return self.objectList
itemList = []
if self.comboBox.count() > 0:
for i in range(self.comboBox.count()):
itemList.append(self.comboBox.itemText(i))
return itemList
def set_AddItems(self, strList):
self.Clear()
if len(strList) != 0 and (not isinstance(strList[0], str)
and not isinstance(strList[0], QString)):
for obj in strList:
self.comboBox.addItem(obj.ToString())
self.objectList.append(obj)
self.hasObject = True
return
self.comboBox.addItems(strList)
Items = property(get_Items, set_AddItems, None, None)
def get_Enabled(self):
return self.comboBox.isEnabled()
def set_Enabled(self, bool):
self.comboBox.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
def get_Editable(self):
return self.comboBox.isEditable()
def set_Editable(self, bool):
self.comboBox.setEditable(bool)
Editable = property(get_Editable, set_Editable, None, None)
def get_SelectedItem(self):
if self.comboBox.count() == 0:
return None
if self.hasObject:
return self.objectList[self.SelectedIndex]
return self.comboBox.currentText()
def set_SelectedItem(self, val):
index = self.comboBox.findText(val)
self.comboBox.setCurrentIndex(index)
SelectedItem = property(get_SelectedItem, set_SelectedItem, None, None)
class Window(QMainWindow):
def __init__(self,parent = None):
QMainWindow.__init__(self,parent)
self.resize(1024,768)
self.setWindowTitle("Sabel")
self.setWindowIcon(Icons.sabel)
self.centralwidget = QWidget(self)
self.horizontalLayout = QHBoxLayout(self.centralwidget)
self.horizontalLayout.setMargin(0)
self.cmdList = config.cmds()
self.paramList = config.params()
'''A.Editor TabWidget'''
'''This parent is for findbar and vertical layout'''
self.editorLayoutWidget = QWidget(self)
self.editorLayoutWidget.setMinimumWidth(800)
self.tabWidget = EditorTab(self)
self.editorLayout = QVBoxLayout(self.editorLayoutWidget)
self.editorLayout.setMargin(0)
self.editorLayout.addWidget(self.tabWidget)
"0.Style Layout"
self.styleLayoutWidget = QFrame()
self.styleLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.styleLayout = QHBoxLayout(self.styleLayoutWidget)
self.styleTest = QPushButton(self.styleLayoutWidget)
self.styleTest.setText("Change Styles")
self.styleTest.clicked.connect(self.changeStyleSheet)
self.popWidget = Popup(self.styleLayoutWidget)
self.styleLayout.addWidget(self.styleTest)
self.styleLayout.addWidget(self.popWidget)
self.styleLayout.setMargin(0)
self.editorLayout.addWidget(self.styleLayoutWidget)
self.styleLayoutWidget.hide()
"1.Find Layout"
self.findLayoutWidget = QFrame()
self.findLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.findLayout = QHBoxLayout(self.findLayoutWidget)
self.lineEdit = QLineEdit(self.findLayoutWidget)
self.lineEdit_2 = QLineEdit(self.findLayoutWidget)
self.findClose = QPushButton(self.findLayoutWidget)
self.findClose.setIcon(Icons.close_view)
self.findClose.setFlat(True)
self.findClose.clicked.connect(self.findBarShow)
self.find = QPushButton(self.findLayoutWidget)
self.find.setText("Find")
self.find.clicked.connect(self.findCurrentText)
self.replacefind = QPushButton(self.findLayoutWidget)
self.replacefind.setText("Replace/Find")
self.replacefind.clicked.connect(self.replaceFindText)
self.replace = QPushButton(self.findLayoutWidget)
self.replace.setText("Replace")
self.replace.clicked.connect(self.replaceCurrentText)
self.replaceAll = QPushButton(self.findLayoutWidget)
self.replaceAll.setText("Replace All")
self.replaceAll.clicked.connect(self.replaceAllText)
self.caseSensitive = QToolButton(self.findLayoutWidget)
self.caseSensitive.setIcon(Icons.font)
self.caseSensitive.setCheckable(True)
self.wholeWord = QToolButton(self.findLayoutWidget)
self.wholeWord.setText("ww")
self.wholeWord.setCheckable(True)
self.regex = QToolButton(self.findLayoutWidget)
self.regex.setText("re")
self.regex.setCheckable(True)
self.backward = QToolButton(self.findLayoutWidget)
self.backward.setText("bk")
self.backward.setCheckable(True)
self.backward.setDisabled(True)
self.findLayout.addWidget(self.findClose)
self.findLayout.addWidget(self.find)
self.findLayout.addWidget(self.lineEdit)
self.findLayout.addWidget(self.lineEdit_2)
self.findLayout.addWidget(self.caseSensitive)
self.findLayout.addWidget(self.wholeWord)
self.findLayout.addWidget(self.regex)
self.findLayout.addWidget(self.backward)
self.findLayout.addWidget(self.replacefind)
self.findLayout.addWidget(self.replace)
self.findLayout.addWidget(self.replaceAll)
self.findLayout.setMargin(0)
self.findLayoutWidget.setMaximumHeight(25)
self.editorLayout.addWidget(self.findLayoutWidget)
self.findLayoutWidget.hide()
'''B.Designer'''
'''This parent is for widgetsbar and design layout'''
self.designerLayoutWidget = QWidget(self)
self.designerLayoutWidget.setMinimumWidth(800)
self.designerWidget = Screen(self)
self.designerLayoutWidget.hide()
self.designerLayout = QVBoxLayout(self.designerLayoutWidget)
self.designerLayout.setMargin(0)
self.designerLayout.addWidget(self.designerWidget)
'''C.Level Editor'''
'''This parent is for spritesheets and level layout'''
self.levelLayoutWidget = QWidget(self)
self.levelLayoutWidget.setMinimumWidth(800)
self.levelWidget = Level(self)
self.levelLayoutWidget.hide()
self.levelLayout = QVBoxLayout(self.levelLayoutWidget)
self.levelLayout.setMargin(0)
self.levelLayout.addWidget(self.levelWidget)
'''D.Explorer TabWidget'''
self.explorerTabWidget = TreeTab(self)
#self.explorerTabWidget.setMaximumWidth(200)
'''1.Project Tree'''
self.tab_5 = QWidget()
#self.tab_5.setMaximumWidth(200)
self.VerticalLayout_2 = QVBoxLayout(self.tab_5)#QHBoxLayout(self.tab_5)
self.VerticalLayout_2.setMargin(0)
self.treeWidget = ProjectTree(self.tab_5)
#self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
#self.treeWidget.horizontalScrollBar().show()
self.VerticalLayout_2.addWidget(self.treeWidget)
'''2.Outline Tree'''
self.tab_2 = QWidget()
#self.tab_2.setMaximumWidth(200)
self.VerticalLayout_3 = QVBoxLayout(self.tab_2)
self.VerticalLayout_3.setMargin(0)
self.outlineWidget = OutlineTree(self.tab_2)
self.outlineWidget.itemDoubleClicked.connect(self.gotoLine)
self.VerticalLayout_3.addWidget(self.outlineWidget)
'''E.Output TabWidget'''
self.outputTabWidget = OutputTab(self)
self.tabWidget.currentChanged.connect(self.fileChanged)
self.explorerTabWidget.currentChanged.connect(self.closeExplorer)
self.outputTabWidget.currentChanged.connect(self.closeConsole)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setTabShape(0)
'''1.Output layout'''
#must check
self.tab_6 = QWidget()
self.horizontalLayout_2 = QVBoxLayout(self.tab_6)
self.horizontalLayout_2.setMargin(0)
self.textEdit = QTextEdit()
self.inputLayout = QHBoxLayout()
self.inputLayout.setMargin(0)
self.fileButton = QPushButton()
self.fileButton.setText("File")
self.fileButton.clicked.connect(self.getFile)
self.runButton = QPushButton()
self.runButton.setFlat(True)
self.runButton.setIcon(Icons.go)
self.combo = QComboBox()
self.combo.setFixedWidth(100)
self.comboAdd = QPushButton()
self.comboAdd.setIcon(Icons.add)
self.comboAdd.setFlat(True)
self.comboAdd.clicked.connect(self.addCmd)
self.comboDel = QPushButton()
self.comboDel.setIcon(Icons.close_view)
self.comboDel.setFlat(True)
self.comboDel.clicked.connect(self.delCmd)
self.combo2 = QComboBox()
self.combo2.setFixedWidth(500)
self.combo2Add = QPushButton()
self.combo2Add.setIcon(Icons.add)
self.combo2Add.setFlat(True)
self.combo2Add.clicked.connect(self.addParam)
self.combo2Del = QPushButton()
self.combo2Del.setIcon(Icons.close_view)
self.combo2Del.setFlat(True)
self.combo2Del.clicked.connect(self.delParam)
if(self.checkHasValue(self.cmdList)):
for cmd in self.cmdList:
self.combo.addItem(cmd)
else:
self.cmdList = []
if(self.checkHasValue(self.paramList)):
for param in self.paramList:
self.combo2.addItem(param)
else:
self.paramList = []
self.horizontalLayout_2.addWidget(self.textEdit)
self.inputLayout.addWidget(QLabel("<b>Command:</b>"))
self.inputLayout.addWidget(self.combo)
self.inputLayout.addWidget(self.comboAdd)
self.inputLayout.addWidget(self.comboDel)
self.inputLayout.addWidget(QLabel("<b>Parameters:</b>"))
self.inputLayout.addWidget(self.combo2)
self.inputLayout.addWidget(self.combo2Add)
self.inputLayout.addWidget(self.combo2Del)
self.inputLayout.addWidget(self.fileButton)
self.inputLayout.addWidget(self.runButton)
self.horizontalLayout_2.addLayout(self.inputLayout)
'''2.Error Layout'''
self.tab_7 = QWidget()
self.horizontalLayout_4 = QHBoxLayout(self.tab_7)
self.horizontalLayout_4.setMargin(0)
self.errorTree = ErrorTree(self.tab_7)
self.errorTree.itemDoubleClicked.connect(self.errorLine)
self.horizontalLayout_4.addWidget(self.errorTree)
'''TabWidgets tabs'''
#self.designerWidget.addTab(QWidget(self),"")
#self.designerWidget.setTabIcon(0,Icons.close_view)
#self.levelWidget.addTab(QWidget(self),"")
#self.levelWidget.setTabIcon(0,Icons.close_view)
self.explorerTabWidget.addTab(self.tab_5,"Projects")
self.explorerTabWidget.addTab(self.tab_2,"Outline")
self.explorerTabWidget.addTab(QWidget(self),"")
self.explorerTabWidget.setTabIcon(0,Icons.cprj)
self.explorerTabWidget.setTabIcon(1,Icons.envvar)
self.explorerTabWidget.setTabIcon(2,Icons.close_view)
self.outputTabWidget.addTab(self.tab_7,"Error")
self.outputTabWidget.addTab(self.tab_6,"Output")
self.outputTabWidget.addTab(QWidget(self),"")
self.outputTabWidget.setTabIcon(0,Icons.error)
self.outputTabWidget.setTabIcon(1,Icons.console_view)
self.outputTabWidget.setTabIcon(2,Icons.close_view)
'''Splitters'''
self.split1 = QSplitter(Qt.Horizontal)
self.split1.addWidget(self.explorerTabWidget)
self.split1.addWidget(self.editorLayoutWidget)
self.split1.addWidget(self.designerLayoutWidget)
self.split1.addWidget(self.levelLayoutWidget)
#self.split1.addWidget(self.tab_5)
self.split2 = QSplitter(Qt.Vertical)
self.split2.addWidget(self.split1)
self.split2.addWidget(self.outputTabWidget)
self.horizontalLayout.addWidget(self.split2)
'''Status Bar'''
self.statusbar = QStatusBar(self)
self.aboutButton = QPushButton(self)
self.aboutButton.setFlat(True)
self.aboutButton.setIcon(Icons.anchor)
self.aboutButton.clicked.connect(self.about)
self.expButton = QPushButton(self)
self.expButton.setFlat(True)
self.expButton.setIcon(Icons.prj)
self.expButton.clicked.connect(self.exp)
self.cmdButton = QPushButton(self)
self.cmdButton.setFlat(True)
self.cmdButton.setIcon(Icons.console_view)
self.cmdButton.clicked.connect(self.cmd)
self.cmdButton.setShortcut('Ctrl+D')
self.imgButton = QPushButton(self)
self.imgButton.setFlat(True)
self.imgButton.setIcon(Icons.color_palette)
self.imgButton.clicked.connect(self.design)
self.imgButton.setShortcut('Ctrl+I')
self.findButton = QPushButton(self)
self.findButton.setFlat(True)
self.findButton.setIcon(Icons.find)
self.findButton.setShortcut("Ctrl+F")
self.findButton.clicked.connect(self.findBarShow)
'''
self.zoominButton = QPushButton(self)
self.zoominButton.setFlat(True)
self.zoominButton.setIcon(Icons.zoomplus)
self.zoominButton.clicked.connect(self.zoomin)
self.zoomoutButton = QPushButton(self)
self.zoomoutButton.setFlat(True)
self.zoomoutButton.setIcon(Icons.zoomminus)
self.zoomoutButton.clicked.connect(self.zoomout)
'''
'''Status Text,Line Text, Progress Bar and Stop Button'''
self.statusText = QLabel("Writable")
#self.statusText.setAlignment(Qt.AlignCenter)
self.statusText.setFixedWidth(200)
self.lineText = QLabel("")
self.lineText.setFixedWidth(50)
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.stopButton = QPushButton(self)
self.stopButton.setFlat(True)
self.stopButton.setIcon(Icons.stop)
self.stopButton.clicked.connect(self.forceStop)
self.progressbar.hide()
self.stopButton.hide()
self.temp = False
self.progress = False
self.counter = 0
'''Adding all widgets to Status Bar'''
self.statusbar.addWidget(self.aboutButton)
self.statusbar.addWidget(self.expButton)
self.statusbar.addWidget(self.cmdButton)
self.statusbar.addWidget(self.imgButton)
self.statusbar.addWidget(self.findButton)
#self.statusbar.addWidget(QWidget(self))
#self.statusbar.addWidget(self.zoominButton)
#self.statusbar.addWidget(self.zoomoutButton)
self.statusbar.addWidget(self.statusText)
self.statusbar.addWidget(self.lineText)
self.statusbar.addWidget(self.progressbar)
self.statusbar.addWidget(self.stopButton)
#self.statusbar.setFixedHeight(18)
''''Initializing Coloring Style'''
self.initEditorStyle()
self.initStyleSheet()
'''Adding Cental Widget and Status Bar'''
self.setCentralWidget(self.centralwidget)
self.setStatusBar(self.statusbar)
self.textEdit.setReadOnly(True)
def initStyleSheet(self):
import stylesheet
self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.explorerTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.outputTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.popWidget.setStyleSheet(stylesheet.popbg)
self.popWidget.hide()
''' This is for changing the palette/window colors to Theme '''
def initEditorStyle(self):
pass
#editStyle = config.readStyle()
#print editStyle
#pal = QPalette(self.explorerTabWidget.palette())
#print pal.color(QPalette.Base).name()
#print pal.color(QPalette.Window).name()
#pal.setColor(QPalette.Base,self.colorStyle.paper)
#pal.setColor(QPalette.Text,self.colorStyle.color)
#self.explorerTabWidget.setPalette(pal)
#self.outputTabWidget.setPalette(pal)
''' This is only for testing dont know if it works for builds '''
def changeStyleSheet(self):
''' Dynamically load the changed stylesheet.py and load the modules and change
the style at runtime saves countless deploys '''
import imp
foo = imp.load_source('stletabb', workDir+"/stylesheet.py")
#print foo.stletabb
#self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(foo.stletabb)
self.popWidget.setStyleSheet(foo.popbg)
if(self.popWidget.isHidden()):
self.popWidget.showPopup()
def build_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()
if(prj != None):
self.treeWidget.build(prj)
def run_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()#current_file)
if(prj != None):
self.treeWidget.run(prj)
def forceStop(self):
self.ant.kill()
self.progressStop()
def kill(self):
self.deleteLater()
#-----------------------------------------------------------------------------------#
# Menu Actions Functions #
#-----------------------------------------------------------------------------------#
def run(self):
if(config.mode() == 0):
self.sq.run()
elif(config.mode() == 1):
self.adb.run()
elif(config.mode() == 2):
self.ios.run()
elif(config.mode() == 3):
self.c.run()
def setMode(self, action):
if(action.text() == "Squ"):
config.setMode(0)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
elif(action.text() == "Emo"):
config.setMode(1)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "Android"):
config.setMode(2)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "ios"):
config.setMode(3)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
def openCommand(self):
text, ok = QInputDialog.getText(self, 'Run Command', 'Command:')
cmd = str(text)
if ok and cmd != "":
import subprocess
subprocess.Popen(cmd)
def about(self):
form = DialogAbout(self)
def todo(self):
form = DialogTodo(self)
form.show()
def help(self):
QMessageBox.about(self,"Help","This is about all The Help that i can Give you now")
def full(self):
if not self.isFull:
self.setWindowState(Qt.WindowFullScreen)
self.isFull = True
else:
self.setWindowState(Qt.WindowMaximized)
self.isFull = False
def android(self):
form = DialogAndroid(self)
form.show()
def antt(self):
form = DialogAnt(self)
form.show()
def squirrel(self):
form = DialogSquirrel(self)
form.show()
def findBarShow(self):
if(self.findLayoutWidget.isHidden()):
self.findLayoutWidget.show()
else:
self.findLayoutWidget.hide()
def exp(self):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.hide()
def cmd(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.hide()
def editor(self):
if(self.editorLayoutWidget.isHidden()):
self.editorLayoutWidget.show()
self.levelLayoutWidget.hide()
self.designerLayoutWidget.hide()
def design(self):
if(self.designerLayoutWidget.isHidden()):
self.designerLayoutWidget.show()
self.editorLayoutWidget.hide()
self.levelLayoutWidget.hide()
else:
self.designerLayoutWidget.hide()
self.editorLayoutWidget.show()
def level(self):
if(self.levelLayoutWidget.isHidden()):
self.levelLayoutWidget.show()
self.editorLayoutWidget.hide()
self.designerLayoutWidget.hide()
else:
self.levelLayoutWidget.hide()
self.editorLayoutWidget.show()
def closeDesigner(self,no):
pass
'''
if(no == self.tiler.closeIndex()):
if(self.tiler.isHidden()):
self.tiler.show()
else:
self.tiler.setCurrentIndex(1)
self.tiler.hide()
'''
'''The current Changed idx of outputTabWidget is passed to this a param'''
def closeConsole(self,no = 2):
if(no == 2):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.setCurrentIndex(1)
self.outputTabWidget.hide()
def popOutput(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(1)
def popError(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(0)
'''The current Changed idx of explorerTabWidget is passed to this a param'''
def closeExplorer(self,no = 2):
if(no == 2):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.setCurrentIndex(0)
self.explorerTabWidget.hide()
elif(no == 1):
self.fileChanged(no)
''' This is to refresh the outline widget'''
def fileChanged(self,no):
if(self.explorerTabWidget.currentIndex() == 1):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
source = edt.text()
self.outlineWidget.parseText(source)
def statusSaving(self):
self.statusText.setText("Saving")
def statusParsing(self):
self.statusText.setText("Parsing")
def statusWriting(self):
self.statusText.setText("Writable")
def statusRunning(self):
self.statusText.setText("Running")
def statusStopping(self):
self.statusText.setText("Stopping")
def statusCommand(self):
self.statusText.setText("Command")
def statusBuilding(self):
self.statusText.setText("Building")
def statusInstalling(self):
self.statusText.setText("Installing")
def statusCleaning(self):
self.statusText.setText("Cleaning")
def statusCreating(self):
self.statusText.setText("Creating")
def progressStart(self):
self.progress == True
self.temp == True
if(self.progressbar.isHidden()):
self.progressbar.show()
if(self.stopButton.isHidden()):
self.stopButton.show()
self.progressbar.setValue(1)
def progressStop(self):
self.progress == False
self.temp == False
self.progressbar.setValue(100)
if not(self.progressbar.isHidden()):
self.progressbar.hide()
if not(self.stopButton.isHidden()):
self.stopButton.hide()
def progressUpdate(self):
if(self.progress):
if(self.temp):
self.counter += 1
self.progressbar.setValue(self.counter)
if(self.counter == 100):
self.temp = False
else:
self.counter -= 1
self.progressbar.setValue(self.counter)
if(self.counter == 0):
self.temp = True
#-----------------------------------------------------------------------------------#
# Editor Functions #
#-----------------------------------------------------------------------------------#
'''Search and Replace Functions'''
def findCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())
def replaceCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
def replaceFindText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
self.findCurrentText()
def replaceAllText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
while(edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())):
edt.replaceText(self.lineEdit_2.text())
def errorLine(self,error):
index = self.tabWidget.currentIndex()
edt = self.tabWidget.widget(index)
'''To prevent File item double clicking'''
if(error.isFile() == False):
edt.setLine(error.line)
'''Font Functions'''
def zoomin(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomin()
def zoomout(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomout()
''' Must implement Lexer '''
def setLexer(self, action):
pass
#print action.text()
def setApi(self, action):
#print action.text()
for i in range(len(self.files)): #not QString
self.tabWidget.widget(i).setApi(str(action.text()))
def setFont(self,font):
config.setFontName(str(font.family()))
for i in range(len(self.files)):
self.tabWidget.widget(i).setNewFont(font)
def setFontSize(self,idx):
fontSize = idx+1
config.setFontSize(fontSize)
for i in range(len(self.files)):
self.tabWidget.widget(i).setFontSize()
def gotoLine(self,item):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.setLine(item.line)
def updateLine(self,no,col):
self.lineText.setText(str(no)+" : "+str(col))
def setMargin(self):
mar = config.margin()
if(mar == 0):
config.setMargin(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(1)
else:
config.setMargin(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(0)
''' Toggle '''
def setIndent(self):
indent = config.indent()
if(indent == 0):
config.setIndent(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(1)
else:
config.setIndent(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(0)
''' Toggle '''
def setWhiteSpace(self):
white = config.whiteSpace()
if(white == 0):
config.setWhiteSpace(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(True)
else:
config.setWhiteSpace(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(False)
''' Toggle '''
def setEndLine(self):
for i in range(len(self.files)):
edt = self.tabWidget.widget(i)
edt.setEolVisibility(not edt.eolVisibility())
def setEncoding(self, action):
if(action.text() == "Ascii"):
config.setAscii()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(False)
elif(action.text() == "Unicode"):
config.setUnicode()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(True)
def setThreshold(self,val):
config.setThresh(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setThreshold(val)
def setTabWidth(self,val):
config.setTabWidth(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setTabWidth(val)
'''style Functions'''
#-----------------------------------------------------------------------------------#
# Command Functions #
#-----------------------------------------------------------------------------------#
def getFile(self):
self.browsedialog = DialogBrowse(self)
self.browsedialog.tree.itemDoubleClicked.connect(self.getName)
self.browsedialog.show()
def getName(self,item):
if(item.isFile()):
self.browsedialog.accept()
fname = item.getPath()
if not (fname == ""):
index = self.combo2.currentIndex()
text = str(self.combo2.itemText(index))+" "+fname
self.combo2.setItemText(index,text)
self.paramList.pop(index)
self.paramList.insert(index,text)
config.setParam(self.paramList)
def addCmd(self,index):
text, ok = QInputDialog.getText(self, 'Add Command', 'Command:')
if(ok):
if(str(text) != ''):
cmd = str(text).upper()
self.cmdList.append(cmd)
#print self.cmdList
self.combo.addItem(cmd)
config.setCmd(self.cmdList)
config.setParam(self.paramList)
def delCmd(self):
index = self.combo.currentIndex()
self.combo.removeItem(index)
self.cmdList.pop(index)
#print self.cmdList
config.setCmd(self.cmdList)
def addParam(self,index):
text, ok = QInputDialog.getText(self, 'Add Parameters', 'Params:')
if(ok):
if(str(text) != ''):
param = str(text)
self.paramList.append(param)
self.combo2.addItem(param)
config.setParam(self.paramList)
def delParam(self):
index = self.combo2.currentIndex()
self.combo2.removeItem(index)
self.paramList.pop(index)
config.setParam(self.paramList)
def checkHasValue(self,list):
if(list != None and len(list) != 0):
return True
else:
return False
class FindReplace(QWidget):
"""
Find replace widget bar
"""
NbReplaced = pyqtSignal(int)
def __init__(self, parent=None):
"""
This class provides an graphical interface to find and replace text
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.editor = None
self.styleEdit = {
False: "background-color:rgb(255, 175, 90);",
True: ""
}
self.createButton()
self.createWidgets()
self.createConnections()
def showEnhanced(self, textSelected=''):
"""
Show enhanced (focus and text selected)
"""
self.show()
if len(textSelected): self.edit.setEditText(textSelected)
self.edit.setFocus()
self.edit.lineEdit().selectAll()
def createButton(self):
"""
create qt buttons
Buttons defined:
* Previous
* Next
* Replace
"""
self.previousButton = QtHelper.createButton(
self,
text=self.tr("Find Previous"),
triggered=self.findPrevious,
icon=QIcon(":/find_previous.png"))
self.nextButton = QtHelper.createButton(self,
text=self.tr("Find Next"),
triggered=self.findNext,
icon=QIcon(":/find_next.png"))
self.replaceButton = QtHelper.createButton(self,
text=self.tr("Replace..."),
triggered=self.replaceFind,
icon=QIcon(":/replace.png"))
def createWidgets(self):
"""
QtWidgets creation
QHBoxLayout
-------------------------------------------.....
| QLabel: QLineEdit QButton QButton QCheckBox |
-------------------------------------------.....
....--------------------------------------
QLabel: QLineEdit QButton QCheckBox |
....--------------------------------------
"""
glayout = QGridLayout()
self.edit = QLineEditMore(parent=self)
self.edit.setEditable(1)
self.edit.setMaxCount(10)
self.edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.edit.lineEdit().setPlaceholderText("Search text in your test?")
self.edit.setMinimumWidth(200)
self.replaceEdit = QComboBox(self)
self.replaceEdit.setEditable(1)
self.replaceEdit.setMaxCount(10)
self.replaceEdit.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.replaceEdit.lineEdit().setPlaceholderText(
"Replace the text with?")
self.replaceEdit.setMinimumWidth(200)
self.caseCheck = QCheckBox(self.tr("Case Sensitive"))
self.caseCheck.setChecked(
QtHelper.str2bool(Settings.instance().readValue(
key='Editor/find-case-sensitive')))
self.caseWordCheck = QCheckBox(self.tr("Whole word only"))
self.caseWordCheck.setChecked(
QtHelper.str2bool(
Settings.instance().readValue(key='Editor/find-whole-word')))
self.allCheck = QCheckBox(self.tr("All occurences"))
self.allCheck.setChecked(
QtHelper.str2bool(
Settings.instance().readValue(key='Editor/replace-all')))
self.caseRegexpCheck = QCheckBox(self.tr("Regular expression"))
self.caseRegexpCheck.setChecked(
QtHelper.str2bool(
Settings.instance().readValue(key='Editor/find-regexp')))
self.caseWrapCheck = QCheckBox(self.tr("Wrap at the end"))
self.caseWrapCheck.setChecked(
QtHelper.str2bool(
Settings.instance().readValue(key='Editor/find-wrap')))
glayout.addWidget(self.edit, 0, 1)
glayout.addWidget(self.nextButton, 0, 3)
glayout.addWidget(self.previousButton, 0, 2)
glayout.addWidget(self.caseCheck, 2, 2)
glayout.addWidget(self.caseWrapCheck, 2, 3)
glayout.addWidget(self.caseWordCheck, 3, 2)
glayout.addWidget(self.caseRegexpCheck, 3, 3)
glayout.addWidget(self.replaceEdit, 1, 1)
glayout.addWidget(self.replaceButton, 1, 2)
glayout.addWidget(self.allCheck, 1, 3)
self.previousButton.setDisabled(True)
self.nextButton.setDisabled(True)
self.setLayout(glayout)
flags = Qt.WindowFlags()
flags |= Qt.Window
flags |= Qt.WindowTitleHint
flags |= Qt.WindowCloseButtonHint
flags |= Qt.MSWindowsFixedSizeDialogHint
self.setWindowFlags(flags)
self.setWindowIcon(QIcon(":/main.png"))
self.setWindowTitle("Find And Replace")
def createConnections(self):
"""
create qt connection
"""
self.edit.editTextChanged.connect(self.textHasChanged)
self.edit.EnterPressed.connect(self.returnPressed)
self.caseCheck.stateChanged.connect(self.find)
def returnPressed(self):
"""
Return key pressed
Find next in this case
"""
self.findNext()
def setEditor(self, editor):
"""
Set the target to find the text
@param editor:
@type editor:
"""
self.editor = editor
def textHasChanged(self, txt):
"""
Find text has changed
"""
text = self.edit.currentText()
if len(text) > 0:
self.previousButton.setEnabled(True)
self.nextButton.setEnabled(True)
self.find(changed=True, forward=True)
else:
self.previousButton.setDisabled(True)
self.nextButton.setDisabled(True)
def updateComboBox(self):
"""
Update combobox
"""
comboUpdated = False
for i in range(self.edit.count()):
if self.edit.itemText(i) == self.edit.currentText():
comboUpdated = True
if not comboUpdated:
self.edit.addItem(self.edit.currentText())
comboUpdated = False
for i in range(self.replaceEdit.count()):
if self.replaceEdit.itemText(i) == self.replaceEdit.currentText():
comboUpdated = True
if not comboUpdated:
self.replaceEdit.addItem(self.replaceEdit.currentText())
def clearText(self):
"""
Clear all QlineEdit
"""
self.edit.setStyleSheet("")
self.edit.clearEditText()
self.replaceEdit.clearEditText()
def findPrevious(self):
"""
Find previous occurence
"""
# update combobox
self.updateComboBox()
# find previous
self.find(changed=False, forward=False)
def findNext(self, line=-1, index=-1):
"""
Find next occurence
"""
# update combobox
self.updateComboBox()
return self.find(changed=False, forward=True, line=line, index=index)
def find(self, changed=True, forward=True, line=-1, index=-1):
"""
Call the find function
@param changed:
@type changed: boolean
@param forward:
@type forward: boolean
"""
text = self.edit.currentText()
if len(text) == 0:
self.edit.setStyleSheet("")
return None
else:
found = self.editor.findText(
text,
changed,
forward,
case=self.caseCheck.isChecked(),
words=self.caseWordCheck.isChecked(),
regexp=self.caseRegexpCheck.isChecked(),
wraps=self.caseWrapCheck.isChecked(),
line=line,
index=index)
self.edit.setStyleSheet(self.styleEdit[found])
return found
def replaceFind(self):
"""
Replace and find
"""
if (self.editor is None): return
replaceText = self.replaceEdit.currentText()
searchText = self.edit.currentText()
if not self.caseCheck.isChecked(): searchText = searchText.lower()
current = -1
nbReplaced = 0
# find the first occurence from the beginning of the doc or not
if not self.allCheck.isChecked():
detected = self.findNext()
else:
detected = self.findNext(line=0, index=0)
(line, _) = self.editor.getCursorPosition()
while detected:
previous = current
selectedText = self.editor.selectedText()
# normalize the text in lower case if the case sensitive is not activated
if not self.caseCheck.isChecked():
selectedText = selectedText.lower()
# replace the selection
if self.editor.hasSelectedText() and selectedText == searchText:
self.editor.replace(replaceText)
nbReplaced += 1
# find the next occurence of the word
detected = self.findNext()
(current, _) = self.editor.getCursorPosition()
# all doc readed ? break the loop
if previous > current: break
if current == line and previous != -1: break
# just execute one replace
if not self.allCheck.isChecked(): break
self.allCheck.setCheckState(Qt.Unchecked)
self.NbReplaced.emit(nbReplaced)
class SettingsWindow(QWidget):
def __init__(self, context, parent=None):
"""
:type context: segyviewlib.SliceViewContext
:type parent: QObject
"""
QWidget.__init__(self, parent, Qt.WindowStaysOnTopHint | Qt.Window)
self.setVisible(False)
self._context = context
self._context.context_changed.connect(self._settings_changed)
self._context.data_changed.connect(self._settings_changed)
self._context.data_source_changed.connect(self._settings_changed)
layout = QFormLayout()
self._iline_count = QLabel("")
self._xline_count = QLabel("")
self._offset_count = QLabel("")
self._sample_count = QLabel("")
self._minimum_value = QLabel("")
self._maximum_value = QLabel("")
layout.addRow("Inline Count:", self._iline_count)
layout.addRow("Crossline Count:", self._xline_count)
layout.addRow("Offset Count:", self._offset_count)
layout.addRow("Sample Count:", self._sample_count)
layout.addRow("Minimum Value:", self._minimum_value)
layout.addRow("Maximum Value:", self._maximum_value)
self.add_empty_row(layout)
self._iline = ArraySpinBox([0])
self._iline.valueChanged[int].connect(
self._index_changed_fn(SliceDirection.inline))
layout.addRow("Inline:", self._iline)
self._xline = ArraySpinBox([0])
self._xline.valueChanged[int].connect(
self._index_changed_fn(SliceDirection.crossline))
layout.addRow("Crossline:", self._xline)
# self._offset = ArraySpinBox([1])
# layout.addRow("Offset", self._offset)
self._sample = ArraySpinBox([0])
self._sample.valueChanged[int].connect(
self._index_changed_fn(SliceDirection.depth))
layout.addRow("Depth", self._sample)
self.add_empty_row(layout)
self._user_minimum_active, self._user_minimum_value, min_val_layout = self._create_user_value(
)
self._user_minimum_active.toggled.connect(self._user_value_changed)
self._user_minimum_value.valueChanged.connect(self._user_value_changed)
layout.addRow("Custom Minimum:", min_val_layout)
self._user_maximum_active, self._user_maximum_value, max_val_layout = self._create_user_value(
)
self._user_maximum_active.toggled.connect(self._user_value_changed)
self._user_maximum_value.valueChanged.connect(self._user_value_changed)
layout.addRow("Custom Maximum:", max_val_layout)
self._user_minimum_value.setMaximum(self._user_maximum_value.value())
self._user_maximum_value.setMinimum(self._user_minimum_value.value())
self._symmetric_scale = QCheckBox()
self._symmetric_scale.toggled.connect(
self._context.set_symmetric_scale)
layout.addRow("Symmetric scale:", self._symmetric_scale)
self.add_empty_row(layout)
self._indicator_visibility = QCheckBox()
self._indicator_visibility.toggled.connect(
self._context.show_indicators)
layout.addRow("Show Indicators:", self._indicator_visibility)
self._interpolation_combo = QComboBox()
self._interpolations_names = ['nearest', 'catrom', 'sinc']
self._interpolation_combo.addItems(self._interpolations_names)
self._interpolation_combo.currentIndexChanged.connect(
self._interpolation_changed)
layout.addRow("Interpolation Type:", self._interpolation_combo)
vertical_layout = QVBoxLayout()
button_layout = QHBoxLayout()
button_layout.setContentsMargins(0, 0, 0, 0)
close_button = QPushButton("Close")
close_button.clicked.connect(self.close)
button_layout.addStretch()
button_layout.addWidget(close_button)
vertical_layout.addLayout(layout)
vertical_layout.addLayout(button_layout)
self.setLayout(vertical_layout)
def _create_user_value(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
check_box = QCheckBox()
spin_box = QDoubleSpinBox()
spin_box.setDecimals(5)
spin_box.setSingleStep(0.01)
spin_box.setMinimum(-sys.float_info.max)
spin_box.setMaximum(sys.float_info.max)
spin_box.setDisabled(True)
check_box.toggled.connect(spin_box.setEnabled)
layout.addWidget(check_box)
layout.addWidget(spin_box)
return check_box, spin_box, layout
def add_empty_row(self, layout, legend=""):
layout.addRow(legend, QLabel())
def _settings_changed(self):
ctx = self._context
self._indicator_visibility.setChecked(ctx.indicators)
index = self._interpolations_names.index(ctx.interpolation)
self._interpolation_combo.setCurrentIndex(index)
self._symmetric_scale.setChecked(ctx.symmetric_scale)
ilines, xlines, offsets, samples = ctx.slice_data_source().dims()
self._iline_count.setText("%d" % ilines)
self._xline_count.setText("%d" % xlines)
self._offset_count.setText("%d" % offsets)
self._sample_count.setText("%d" % samples)
self._minimum_value.setText("%f" % ctx.global_minimum)
self._maximum_value.setText("%f" % ctx.global_maximum)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.inline).tolist()
index = ctx.index_for_direction(SliceDirection.inline)
self._iline.update_view(indexes, index)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.crossline).tolist()
index = ctx.index_for_direction(SliceDirection.crossline)
self._xline.update_view(indexes, index)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.depth).tolist()
index = ctx.index_for_direction(SliceDirection.depth)
self._sample.update_view(indexes, index)
def _interpolation_changed(self, index):
interpolation_name = str(self._interpolation_combo.itemText(index))
self._context.set_interpolation(interpolation_name)
def _index_changed_fn(self, direction):
def fn(value):
self._context.update_index_for_direction(direction, value)
return fn
def _user_value_changed(self):
min_value = None
max_value = None
if self._user_minimum_active.isChecked():
min_value = self._user_minimum_value.value()
self._user_maximum_value.setMinimum(min_value)
else:
self._user_maximum_value.setMinimum(-sys.float_info.max)
if self._user_maximum_active.isChecked():
max_value = self._user_maximum_value.value()
self._user_minimum_value.setMaximum(max_value)
else:
self._user_minimum_value.setMaximum(sys.float_info.max)
self._context.set_user_values(min_value, max_value)
class experimentersDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().prm
self.tmpPref = {}
self.tmpPref['experimenter'] = {}
self.tmpPref['experimenter'] = copy.deepcopy(self.parent().prm['experimenter'])
self.currLocale = self.parent().prm['currentLocale']
self.currLocale.setNumberOptions(self.currLocale.OmitGroupSeparator | self.currLocale.RejectGroupSeparator)
self.sizer = QGridLayout()
self.h1Sizer = QHBoxLayout()
self.v1Sizer = QVBoxLayout()
self.v2Sizer = QVBoxLayout()
n = 0
self.experimenterLabel = QLabel(self.tr("Experimenter ID:"), self)
self.sizer.addWidget(self.experimenterLabel, n, 0)
self.experimenterChooser = QComboBox()
self.experimenterChooser.addItems(self.tmpPref['experimenter']['experimenter_id'])
self.sizer.addWidget(self.experimenterChooser, n, 1)
self.experimenterChooser.activated[str].connect(self.onExperimenterChange)
self.currIdx = self.experimenterChooser.currentIndex()
n = n+1
self.experimenterNameLabel = QLabel(self.tr("Name:"), self)
self.sizer.addWidget(self.experimenterNameLabel, n, 0)
self.experimenterNameTF = QLineEdit("")
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][0])
self.sizer.addWidget(self.experimenterNameTF, n, 1)
n = n+1
self.experimenterSurnameLabel = QLabel(self.tr("Surname:"), self)
self.sizer.addWidget(self.experimenterSurnameLabel, n, 0)
self.experimenterSurnameTF = QLineEdit("")
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][0])
self.sizer.addWidget(self.experimenterSurnameTF, n, 1)
n = n+1
self.experimenterEmailLabel = QLabel(self.tr("e-mail:"), self)
self.sizer.addWidget(self.experimenterEmailLabel, n, 0)
self.experimenterEmailTF = QLineEdit("")
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][0])
self.sizer.addWidget(self.experimenterEmailTF, n, 1)
n = n+1
self.experimenterAddressLabel = QLabel(self.tr("Address (line 1):"), self)
self.sizer.addWidget(self.experimenterAddressLabel, n, 0)
self.experimenterAddressTF = QLineEdit("")
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][0])
self.sizer.addWidget(self.experimenterAddressTF, n, 1)
n = n+1
self.experimenterAddressLabel2 = QLabel(self.tr("Address (line 2):"), self)
self.sizer.addWidget(self.experimenterAddressLabel2, n, 0)
self.experimenterAddressTF2 = QLineEdit("")
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][0])
self.sizer.addWidget(self.experimenterAddressTF2, n, 1)
n = n+1
self.experimenterTelephoneLabel = QLabel(self.tr("Telephone:"), self)
self.sizer.addWidget(self.experimenterTelephoneLabel, n, 0)
self.experimenterTelephoneTF = QLineEdit("")
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][0])
self.sizer.addWidget(self.experimenterTelephoneTF, n, 1)
n = n+1
self.experimenterMobileLabel = QLabel(self.tr("Mobile:"), self)
self.sizer.addWidget(self.experimenterMobileLabel, n, 0)
self.experimenterMobileTF = QLineEdit("")
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][0])
self.sizer.addWidget(self.experimenterMobileTF, n, 1)
#ADD EXPERIMENTER BUTTON
addExpButton = QPushButton(self.tr("Add Experimenter"), self)
addExpButton.clicked.connect(self.onClickAddExpButton)
self.v2Sizer.addWidget(addExpButton)
#REMOVE EXPERIMENTER BUTTON
removeExpButton = QPushButton(self.tr("Remove Experimenter"), self)
removeExpButton.clicked.connect(self.onClickRemoveExpButton)
self.v2Sizer.addWidget(removeExpButton)
#CHANGE ID BUTTON
changeIdButton = QPushButton(self.tr("Change Identifier"), self)
changeIdButton.clicked.connect(self.onClickChangeIdButton)
self.v2Sizer.addWidget(changeIdButton)
#SET AS DEFAULT BUTTON
setAsDefaultButton = QPushButton(self.tr("Set as default"), self)
setAsDefaultButton.clicked.connect(self.onClickSetAsDefaultButton)
self.v2Sizer.addWidget(setAsDefaultButton)
self.v2Sizer.addStretch()
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply|QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
buttonBox.button(QDialogButtonBox.Apply).clicked.connect(self.onClickApplyButton)
self.h1Sizer.addLayout(self.v2Sizer)
self.sizer.setAlignment(Qt.AlignTop)
self.h1Sizer.addLayout(self.sizer)
self.v1Sizer.addLayout(self.h1Sizer)
self.v1Sizer.addWidget(buttonBox)
self.setLayout(self.v1Sizer)
def onClickApplyButton(self):
self.tryApply(self.currIdx)
self.permanentApply()
def permanentApply(self):
self.parent().prm['experimenter'] = copy.deepcopy(self.tmpPref['experimenter'])
f = open(self.parent().prm['experimenterPrefFile'], 'wb')
pickle.dump(self.parent().prm['experimenter'], f)
f.close()
for i in range(self.parent().experimenterChooser.count()):
self.parent().experimenterChooser.removeItem(0)
self.parent().experimenterChooser.addItems(self.parent().prm['experimenter']['experimenter_id'])
def tryApply(self, idx):
self.tmpPref['experimenter']['experimenter_id'][idx] = self.experimenterChooser.itemText(idx)
self.tmpPref['experimenter']['experimenter_name'][idx] = self.experimenterNameTF.text()
self.tmpPref['experimenter']['experimenter_surname'][idx] = self.experimenterSurnameTF.text()
self.tmpPref['experimenter']['experimenter_email'][idx] = self.experimenterEmailTF.text()
self.tmpPref['experimenter']['experimenter_address'][idx] = self.experimenterAddressTF.text()
self.tmpPref['experimenter']['experimenter_address2'][idx] = self.experimenterAddressTF2.text()
self.tmpPref['experimenter']['experimenter_telephone'][idx] = self.experimenterTelephoneTF.text()
self.tmpPref['experimenter']['experimenter_mobile'][idx] = self.experimenterMobileTF.text()
def revertChanges(self):
if len(self.tmpPref['experimenter']['experimenter_id']) != len(self.parent().prm['experimenter']['experimenter_id']): #experimenter was added, reverting
for i in range(self.experimenterChooser.count()):
self.experimenterChooser.removeItem(0)
self.experimenterChooser.addItems(self.parent().prm['experimenter']['experimenter_id'])
self.tmpPref['experimenter'] = copy.deepcopy(self.parent().prm['experimenter'])
def onExperimenterChange(self, experimenterSelected):
self.prevIdx = self.currIdx
self.currIdx = self.tmpPref['experimenter']['experimenter_id'].index(experimenterSelected)
self.tryApply(self.prevIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
self.experimenterNameTF.setText(self.prm['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.prm['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.prm['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.prm['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.prm['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.prm['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.prm['experimenter']['experimenter_mobile'][self.currIdx])
def onClickAddExpButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
msg = self.tr("Experimenter's Identifier:")
name, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.tmpPref['experimenter']['defaultExperimenter'].append('')
self.tmpPref['experimenter']['experimenter_id'].append(name)
self.tmpPref['experimenter']['experimenter_name'].append('')
self.tmpPref['experimenter']['experimenter_surname'].append('')
self.tmpPref['experimenter']['experimenter_email'].append('')
self.tmpPref['experimenter']['experimenter_address'].append('')
self.tmpPref['experimenter']['experimenter_address2'].append('')
self.tmpPref['experimenter']['experimenter_telephone'].append('')
self.tmpPref['experimenter']['experimenter_mobile'].append('')
self.permanentApply()
self.currIdx = self.experimenterChooser.count()
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][self.currIdx])
self.experimenterChooser.addItem(name)
self.experimenterChooser.setCurrentIndex(self.currIdx)
def onClickRemoveExpButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
if self.experimenterChooser.count() > 1:
reply = QMessageBox.warning(self, self.tr('Message'),
"Remove experimenter? This action cannot be undone!", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.tmpPref['experimenter']['defaultExperimenter'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_id'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_name'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_surname'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_email'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_address'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_address2'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_telephone'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_mobile'].pop(self.currIdx)
self.experimenterChooser.removeItem(self.currIdx)
self.currIdx = self.experimenterChooser.currentIndex()
self.permanentApply()
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][self.currIdx])
else:
QMessageBox.warning(self, self.tr('Message'),
self.tr("Only one experimenter left. Experimenter cannot be removed!"), QMessageBox.Ok)
def onClickChangeIdButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
msg = self.tr("Experimenter's Identifier:")
name, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.tmpPref['experimenter']['experimenter_id'][self.currIdx] = name
self.experimenterChooser.setItemText(self.currIdx, name)
self.permanentApply()
def onClickSetAsDefaultButton(self):
idx = self.experimenterChooser.currentIndex()
print(idx)
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
for i in range(len(self.parent().prm['experimenter']["defaultExperimenter"])):
if i == idx:
self.tmpPref['experimenter']["defaultExperimenter"][i] = "\u2713"
else:
self.tmpPref['experimenter']["defaultExperimenter"][i] = "\u2012"
print(self.tmpPref)
self.permanentApply()
class MainWindow(QWidget):
"""
the main window of the GUI.
"""
def __init__(self):
"""
constructor of the main window
"""
QWidget.__init__(self)
self.layout = QGridLayout(self)
self.setLayout(self.layout)
self.edit = QLineEdit("http://en.wikipedia.org/wiki/Homomorphism",
self)
self.layout.addWidget(self.edit, 0, 0, 1, 2)
self.queue = Queue()
self.timer = QTimer(self)
QObject.connect(self.timer, SIGNAL("timeout()"), self.tick)
self.timer.start(10)
self.combo = QComboBox(self)
self.combo.addItem("Print")
self.combo.addItem("MediaWiki")
self.combo.addItem("normal")
self.layout.addWidget(self.combo, 1, 1, 1, 1)
self.layout.addWidget(QLabel("Template Expansion"), 1, 0, 1, 1)
self.papercombo = QComboBox(self)
self.papercombo.addItem("A4")
self.papercombo.addItem("A5")
self.papercombo.addItem("B5")
self.papercombo.addItem("letter")
self.papercombo.addItem("legal")
self.papercombo.addItem("executive")
self.layout.addWidget(self.papercombo, 2, 1, 1, 1)
self.layout.addWidget(QLabel("Paper"), 2, 0, 1, 1)
self.rastercombo = QComboBox(self)
self.rastercombo.addItem("Rasterize")
self.rastercombo.addItem("Keep vector form")
self.layout.addWidget(self.rastercombo, 3, 1, 1, 1)
self.layout.addWidget(QLabel("Vector Graphics"), 3, 0, 1, 1)
self.inccombo = QComboBox(self)
if platform.system() == "Linux":
self.inccombo.addItem("Included")
self.inccombo.addItem("Excluded")
else:
self.inccombo.addItem("excluded")
self.layout.addWidget(self.inccombo, 4, 1, 1, 1)
self.layout.addWidget(QLabel("LaTeX Source"), 4, 0, 1, 1)
self.button = QPushButton("Run", self)
self.layout.addWidget(self.button, 5, 0, 1, 2)
self.counter = 0
QObject.connect(self.button, SIGNAL("clicked()"), self.callbackrun)
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.pbar.setValue(0)
self.layout.addWidget(self.pbar, 6, 0, 1, 2)
self.resize(340, -1)
self.setWindowTitle("MediaWiki to LaTeX")
def callbackrun(self):
"""
Callback function that is called when the user clicks the run button.
"""
try:
if os.path.exists("main.pdf"):
mainfile = open("main.pdf", "ab")
mainfile.close()
except:
QMessageBox.about(
self, "File still open",
"Please close your PDF viewer before pressing the run button!\n"
+ " This program need writing permission on the PDF file!")
return
self.counter = 0
self.button.setEnabled(False)
thread = threading.Thread()
thread.run = self.callbackthreadrun
thread.start()
def tick(self):
"""
callback function for the times. It is called every 10 milliseconds.
"""
got = False
try:
item = self.queue.get(False)
got = True
except:
pass
if got:
self.callbacklog(item)
self.timer.start(10)
def getSwitch(self, switch):
if switch == "MediaWiki": return " -m "
if switch == "normal": return " -i "
return ""
def getVector(self, switch):
if switch == "Rasterize": return ""
return "-g"
def callbackthreadrun(self):
"""
callback for a thread. When the used clicks the run button. The callbackrun function is
called back. This starts a thread that called this functions. So this function runs in
multithreaded context. So it cannot interact with the gui because of multithreading hazards
"""
p = subprocess.Popen([
"mediawiki2latex", "-u",
self.edit.text(), "-o", "main.pdf",
self.getSwitch(self.combo.itemText(self.combo.currentIndex())),
"-p",
self.papercombo.itemText(self.papercombo.currentIndex()),
self.getVector(
self.rastercombo.itemText(self.rastercombo.currentIndex()))
],
stdout=subprocess.PIPE)
f = (p.stdout)
r = b"X"
while r != b"":
r = f.readline()
self.queue.put(["RUN"])
self.queue.put(["Done"])
def callbacklog(self, item):
"""
called back when the logger of the main program log a message. Used to update the progress
bar. And to display the resulting pdf file in a pdf viewer if the main program has finished.
This function is called from the main GUI loop. Essentially from the timer. So here are
not multithreading problems and you can directly interact with all components of the GUI.
"""
self.counter += 1
self.pbar.setValue(int(100.0 - 100 * math.exp(-self.counter / 5000.0)))
if item[0] == "Done":
self.pbar.setValue(100)
webbrowser.open('file://%s' % os.path.abspath("main.pdf"))
self.button.setEnabled(True)
def closeEvent(self, event):
"""
callback function called when this window is closes. Disable the callback function from the
logger of the main program to this window to avoid calling callbacks on this windows in
future since it will be destroyed
"""
pass
def callbackthread(self, logmessage):
"""
callback called from the logger of the main program. This is called back from the tread of the
main program. So it can not directly interact with the GUI because of multithreading hazards
this way it just puts the message into a synchronized queue which will be polled by the timer
and essentially call the callbacklog function in the context of the GUIs main thread
"""
self.queue.put(logmessage)
class SchemeSelector(QWidget):
currentChanged = pyqtSignal()
changed = pyqtSignal()
def __init__(self, parent=None):
super(SchemeSelector, self).__init__(parent)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.label = QLabel()
self.scheme = QComboBox()
self.menuButton = QPushButton(flat=True)
menu = QMenu(self.menuButton)
self.menuButton.setMenu(menu)
layout.addWidget(self.label)
layout.addWidget(self.scheme)
layout.addWidget(self.menuButton)
layout.addStretch(1)
# action generator
def act(slot, icon=None):
a = QAction(self, triggered=slot)
self.addAction(a)
icon and a.setIcon(icons.get(icon))
return a
# add action
a = self.addAction_ = act(self.slotAdd, 'list-add')
menu.addAction(a)
# remove action
a = self.removeAction = act(self.slotRemove, 'list-remove')
menu.addAction(a)
# rename action
a = self.renameAction = act(self.slotRename, 'document-edit')
menu.addAction(a)
menu.addSeparator()
# import action
a = self.importAction = act(self.slotImport, 'document-open')
menu.addAction(a)
# export action
a = self.exportAction = act(self.slotExport, 'document-save-as')
menu.addAction(a)
self.scheme.currentIndexChanged.connect(self.slotSchemeChanged)
app.translateUI(self)
def translateUI(self):
self.label.setText(_("Scheme:"))
self.menuButton.setText(_("&Menu"))
self.addAction_.setText(_("&Add..."))
self.removeAction.setText(_("&Remove"))
self.renameAction.setText(_("Re&name..."))
self.importAction.setText(_("&Import..."))
self.exportAction.setText(_("&Export..."))
def slotSchemeChanged(self, index):
"""Called when the Scheme combobox is changed by the user."""
self.disableDefault(self.scheme.itemData(index) == 'default')
self.currentChanged.emit()
self.changed.emit()
def disableDefault(self, val):
self.removeAction.setDisabled(val)
self.renameAction.setDisabled(val)
def schemes(self):
"""Returns the list with internal names of currently available schemes."""
return [self.scheme.itemData(i) for i in range(self.scheme.count())]
def currentScheme(self):
"""Returns the internal name of the currently selected scheme"""
return self.scheme.itemData(self.scheme.currentIndex())
def insertSchemeItem(self, name, scheme):
for i in range(1, self.scheme.count()):
n = self.scheme.itemText(i)
if n.lower() > name.lower():
self.scheme.insertItem(i, name, scheme)
break
else:
self.scheme.addItem(name, scheme)
def addScheme(self, name):
num, key = 1, 'user1'
while key in self.schemes() or key in self._schemesToRemove:
num += 1
key = 'user{0}'.format(num)
self.insertSchemeItem(name, key)
self.scheme.setCurrentIndex(self.scheme.findData(key))
return key
def slotAdd(self):
name, ok = QInputDialog.getText(
self, app.caption(_("Add Scheme")),
_("Please enter a name for the new scheme:"))
if ok:
self.addScheme(name)
def slotRemove(self):
index = self.scheme.currentIndex()
scheme = self.scheme.itemData(index)
if scheme == 'default':
return # default can not be removed
self._schemesToRemove.add(scheme)
self.scheme.removeItem(index)
def slotRename(self):
index = self.scheme.currentIndex()
name = self.scheme.itemText(index)
scheme = self.scheme.itemData(index)
newName, ok = QInputDialog.getText(self,
_("Rename"),
_("New name:"),
text=name)
if ok:
self.scheme.blockSignals(True)
self.scheme.removeItem(index)
self.insertSchemeItem(newName, scheme)
self.scheme.setCurrentIndex(self.scheme.findData(scheme))
self.scheme.blockSignals(False)
self.changed.emit()
def slotImport(self):
filetypes = "{0} (*.xml);;{1} (*)".format(_("XML Files"),
_("All Files"))
caption = app.caption(_("dialog title", "Import color theme"))
filename = QFileDialog.getOpenFileName(self, caption, QDir.homePath(),
filetypes)
if filename:
self.parent().import_(filename)
def slotExport(self):
name = self.scheme.currentText()
filetypes = "{0} (*.xml);;{1} (*)".format(_("XML Files"),
_("All Files"))
caption = app.caption(
_("dialog title", "Export {name}").format(name=name))
path = os.path.join(QDir.homePath(), name + '.xml')
filename = QFileDialog.getSaveFileName(self, caption, path, filetypes)
if filename:
if os.path.splitext(filename)[1] != '.xml':
filename += '.xml'
self.parent().export(name, filename)
def loadSettings(self, currentKey, namesGroup):
# don't mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default", type(""))
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
block = self.scheme.blockSignals(True)
self.scheme.clear()
self.scheme.addItem(_("Default"), "default")
lst = [(s.value(key, key, type("")), key) for key in s.childKeys()]
for name, key in sorted(lst, key=lambda f: f[0].lower()):
self.scheme.addItem(name, key)
# find out index
index = self.scheme.findData(cur)
self.disableDefault(cur == 'default')
self.scheme.setCurrentIndex(index)
self.scheme.blockSignals(block)
self.currentChanged.emit()
def saveSettings(self, currentKey, namesGroup, removePrefix=None):
# first save new scheme names
s = QSettings()
s.beginGroup(namesGroup)
for i in range(self.scheme.count()):
if self.scheme.itemData(i) != 'default':
s.setValue(self.scheme.itemData(i), self.scheme.itemText(i))
for scheme in self._schemesToRemove:
s.remove(scheme)
s.endGroup()
if removePrefix:
for scheme in self._schemesToRemove:
s.remove("{0}/{1}".format(removePrefix, scheme))
# then save current
scheme = self.currentScheme()
s.setValue(currentKey, scheme)
# clean up
self._schemesToRemove = set()
class WSystem(QWidget, Logger.ClassLogger):
"""
System widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAction = QPushButton(QIcon(":/add_black.png"), '&Add Action',
self)
self.addAction.setMinimumHeight(40)
self.addAction.setMaximumWidth(150)
self.cancelAction = QtHelper.createAction(self,
"&Cancel",
self.cancelStep,
icon=QIcon(":/undo.png"),
tip='Cancel update')
self.cancelAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(
self,
"&",
self.openOptions,
icon=QIcon(":/system-small.png"),
tip='System options')
def openOptions(self):
"""
Open options dialog
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgets(self):
"""
Create qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
self.actionsComboBox = QComboBox(self)
self.actionsComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_SYSTEM_DESCR)):
if not len(GuiSteps.ACTION_SYSTEM_DESCR[i]):
self.actionsComboBox.insertSeparator(i + 1)
else:
el = GuiSteps.ACTION_SYSTEM_DESCR[i].keys()
self.actionsComboBox.addItem(list(el)[0])
self.labelActionDescr = QLabel(self)
self.labelActionDescr.hide()
self.descriptionLine = QLineEdit(self)
self.descriptionLine.setPlaceholderText("Step purpose description")
self.descriptionLine.hide()
actionsLayout = QHBoxLayout()
actionsLayout.addWidget(self.actionsComboBox)
actionLayout1 = QGridLayout()
actionLayout1.addLayout(actionsLayout, 0, 1)
self.createWidgetSession()
self.createWidgetText()
self.createWidgetShortcut()
self.createWidgetScreen()
actionLayout2 = QGridLayout()
actionLayout2.addWidget(self.sessionGroup, 1, 0)
actionLayout2.addWidget(self.textGroup, 1, 0)
actionLayout2.addWidget(self.shortcutGroup, 1, 0)
actionLayout2.addWidget(self.screenGroup, 1, 0)
font = QFont()
font.setBold(True)
labelAct = QLabel(self.tr("Action: "))
labelAct.setFont(font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(
QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(
QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutFinal = QHBoxLayout()
layoutFinal.addWidget(labelAct)
layoutFinal.addLayout(actionLayout1)
layoutFinal.addWidget(self.arrowLabel)
layoutFinal.addLayout(actionLayout2)
layoutFinal.addWidget(self.arrowLabel2)
layoutFinal.addWidget(self.addAction)
layoutFinal.addStretch(1)
self.setLayout(layoutFinal)
def createToolbar(self):
"""
Create toolbar
"""
pass
def createWidgetScreen(self):
"""
Create screen widget
"""
self.screenGroup = QGroupBox(self.tr(""))
# text
self.checkComboBox = QComboBox(self)
self.checkComboBox.addItems([
GuiSteps.OP_ANY, GuiSteps.OP_CONTAINS, GuiSteps.OP_NOTCONTAINS,
GuiSteps.OP_REGEXP, GuiSteps.OP_NOTREGEXP, GuiSteps.OP_STARTSWITH,
GuiSteps.OP_NOTSTARTSWITH, GuiSteps.OP_ENDSWITH,
GuiSteps.OP_NOTENDSWITH
])
self.screenLine = QLineEdit(self)
self.screenLine.setMinimumWidth(300)
self.screenLine.setEnabled(False)
self.screenLine.hide()
self.screenArea = QTextEdit(self)
self.screenArea.setMinimumWidth(300)
self.screenArea.setEnabled(False)
self.screenCombo = QComboBox(self)
self.screenCombo.addItems(LIST_TYPES)
self.screenCombo.setEnabled(False)
self.screenSaveCombo = QComboBox(self)
self.screenSaveCombo.addItems(["VARIABLE", "CACHE"])
self.screenSaveLine = QLineEdit(self)
self.screenSaveLine.setMinimumWidth(300)
self.screenSaveLine.setEnabled(False)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Checking if the screen: ")),
0, 0)
mainTextlayout.addWidget(self.checkComboBox, 0, 1)
mainTextlayout.addWidget(QLabel(self.tr("The value:")), 1, 0)
mainTextlayout.addWidget(self.screenCombo, 1, 1)
mainTextlayout.addWidget(self.screenLine, 2, 1)
mainTextlayout.addWidget(self.screenArea, 2, 1)
mainTextlayout.addWidget(QLabel(self.tr("And save the screen in:")), 0,
2)
mainTextlayout.addWidget(self.screenSaveCombo, 1, 2)
mainTextlayout.addWidget(self.screenSaveLine, 2, 2)
self.screenGroup.setLayout(mainTextlayout)
self.screenGroup.hide()
def createWidgetText(self):
"""
Create text widget
"""
self.textGroup = QGroupBox(self.tr(""))
# text
self.textLine = QLineEdit(self)
self.textLine.setMinimumWidth(300)
self.textCombo = QComboBox(self)
self.textCombo.addItems(LIST_TYPES)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Send the value:")), 0, 0)
mainTextlayout.addWidget(self.textCombo, 0, 1)
mainTextlayout.addWidget(self.textLine, 0, 2)
self.textGroup.setLayout(mainTextlayout)
self.textGroup.hide()
def createWidgetShortcut(self):
"""
Create shortcut widget
"""
self.shortcutGroup = QGroupBox(self.tr(""))
# text
self.shortcutComboBox = QComboBox()
self.shortcutComboBox.addItems([KEY_CTRLC, KEY_ENTER])
self.shortcutComboBox.setMinimumWidth(300)
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Shortcut:")), 0, 0)
mainTextlayout.addWidget(self.shortcutComboBox, 0, 1)
self.shortcutGroup.setLayout(mainTextlayout)
self.shortcutGroup.hide()
def createWidgetSession(self):
"""
Create session widget
"""
self.sessionGroup = QGroupBox(self.tr(""))
# login
self.loginLine = QLineEdit(self)
self.loginLine.setMinimumWidth(300)
self.loginCombo = QComboBox(self)
self.loginCombo.addItems(LIST_TYPES)
# password
self.pwdLine = QLineEdit(self)
self.pwdLine.setMinimumWidth(300)
self.pwdCombo = QComboBox(self)
self.pwdCombo.addItems(LIST_TYPES)
# ip
self.ipLine = QLineEdit(self)
self.ipLine.setMinimumWidth(300)
self.ipCombo = QComboBox(self)
self.ipCombo.addItems(LIST_TYPES)
# port
self.portLine = QLineEdit(self)
self.portLine.setMinimumWidth(300)
self.portLine.setText("22")
self.portLine.setValidator(self.validatorInt)
self.portCombo = QComboBox(self)
self.portCombo.addItems(LIST_TYPES)
# agent support
self.useAgent = QCheckBox("Use with agent mode")
mainTextlayout = QGridLayout()
mainTextlayout.addWidget(QLabel(self.tr("Host:")), 0, 0)
mainTextlayout.addWidget(self.ipCombo, 0, 1)
mainTextlayout.addWidget(self.ipLine, 0, 2)
mainTextlayout.addWidget(QLabel(self.tr("Port (optional):")), 1, 0)
mainTextlayout.addWidget(self.portCombo, 1, 1)
mainTextlayout.addWidget(self.portLine, 1, 2)
mainTextlayout.addWidget(QLabel(self.tr("Login:"******"Password:"******"""
Create qt connections
"""
self.actionsComboBox.currentIndexChanged.connect(self.onActionChanged)
self.addAction.clicked.connect(self.addStep)
self.ipCombo.currentIndexChanged.connect(self.onIpTypeChanged)
self.portCombo.currentIndexChanged.connect(self.onPortTypeChanged)
self.loginCombo.currentIndexChanged.connect(self.onLoginTypeChanged)
self.pwdCombo.currentIndexChanged.connect(self.onPwdTypeChanged)
self.textCombo.currentIndexChanged.connect(self.onTextTypeChanged)
self.screenCombo.currentIndexChanged.connect(self.onScreenTypeChanged)
self.checkComboBox.currentIndexChanged.connect(
self.onScreenOperatorChanged)
self.screenSaveCombo.currentIndexChanged.connect(
self.onScreenSaveChanged)
def pluginDataAccessor(self):
"""
Return data to plugin
"""
return {"data": ""}
def onPluginImport(self, dataJson):
"""
Received data from plugins
"""
if "steps" not in dataJson:
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
if not isinstance(dataJson['steps'], list):
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
if not ('ip' in dataJson and 'login' in dataJson
and 'password' in dataJson):
QMessageBox.warning(self, "Assistant Automation", "bad import")
return
# emit open session
parameters = {
'dest-ip': dataJson['ip'],
'dest-port': 22,
'login': dataJson['login'],
'password': dataJson['password'],
'from-cache-ip': False,
'from-alias-ip': False,
'from-cache-port': False,
'from-alias-port': False,
'from-cache-login': False,
'from-alias-login': False,
'from-cache-pwd': False,
'from-alias-pwd': False,
'agent-support': False
}
self.AddStep.emit(GuiSteps.SYSTEM_SESSION, EMPTY_VALUE, EMPTY_VALUE,
parameters)
for stp in dataJson['steps']:
if isinstance(stp, dict):
# new in v16
fromCache = False
fromAlias = False
if "type-value" in stp:
if stp["type-value"].lower() == "cache": fromCache = True
if stp["type-value"].lower() == "alias": fromAlias = True
# end of new
if stp["action-name"] == "SEND":
parameters = {
'text': stp["action-value"],
'from-cache': fromCache,
'from-alias': fromAlias
}
self.AddStep.emit(GuiSteps.SYSTEM_TEXT, EMPTY_VALUE,
EMPTY_VALUE, parameters)
elif stp["action-name"] == "EXPECT":
op = "Contains"
if stp["action-type"] == "REGEX":
op = "RegEx"
parameters = {
'value': stp["action-value"],
'from-cache': fromCache,
'from-alias': fromAlias,
'operator': op,
'to-cache': False,
'cache-key': ''
}
self.AddStep.emit(GuiSteps.SYSTEM_CHECK_SCREEN,
EMPTY_VALUE, EMPTY_VALUE, parameters)
else:
QMessageBox.warning(
self, "Assistant Automation",
"action not yet supported: %s" % stp["action-name"])
# close
self.AddStep.emit(GuiSteps.SYSTEM_CLOSE, EMPTY_VALUE, EMPTY_VALUE, {})
def onScreenOperatorChanged(self):
"""
On screen operator changed
"""
if self.checkComboBox.currentText() == GuiSteps.OP_ANY:
self.screenLine.setEnabled(False)
self.screenArea.setEnabled(False)
self.screenCombo.setEnabled(False)
else:
self.screenLine.setEnabled(True)
self.screenArea.setEnabled(True)
self.screenCombo.setEnabled(True)
def onScreenSaveChanged(self):
"""
On screen save changed
"""
if self.screenSaveCombo.currentText() == "VARIABLE":
self.screenSaveLine.setEnabled(False)
else:
self.screenSaveLine.setEnabled(True)
def onScreenTypeChanged(self):
"""
On screen type changed
"""
if self.screenCombo.currentText() in ["TEXT"]:
self.screenArea.show()
self.screenLine.hide()
else:
self.screenLine.show()
self.screenArea.hide()
if self.screenCombo.currentText() in ["CACHE"]:
self.screenLine.setValidator(self.validatorAll)
if self.screenCombo.currentText() == "ALIAS":
self.screenLine.setText(self.screenLine.text().upper())
self.screenLine.setValidator(self.validatorUpper)
def onTextTypeChanged(self):
"""
On text type changed
"""
if self.textCombo.currentText() in ["TEXT", "CACHE"]:
self.textLine.setValidator(self.validatorAll)
if self.textCombo.currentText() == "ALIAS":
self.textLine.setText(self.textLine.text().upper())
self.textLine.setValidator(self.validatorUpper)
def onLoginTypeChanged(self):
"""
On login type changed
"""
if self.loginCombo.currentText() in ["TEXT", "CACHE"]:
self.loginLine.setValidator(self.validatorAll)
if self.loginCombo.currentText() == "ALIAS":
self.loginLine.setText(self.loginLine.text().upper())
self.loginLine.setValidator(self.validatorUpper)
def onPwdTypeChanged(self):
"""
On password type changed
"""
if self.pwdCombo.currentText() in ["TEXT", "CACHE"]:
self.pwdLine.setValidator(self.validatorAll)
if self.pwdCombo.currentText() == "ALIAS":
self.pwdLine.setText(self.pwdLine.text().upper())
self.pwdLine.setValidator(self.validatorUpper)
def onIpTypeChanged(self):
"""
On ip type changed
"""
if self.ipCombo.currentText() in ["TEXT", "CACHE"]:
self.ipLine.setValidator(self.validatorAll)
if self.ipCombo.currentText() == "ALIAS":
self.ipLine.setText(self.ipLine.text().upper())
self.ipLine.setValidator(self.validatorUpper)
def onPortTypeChanged(self):
"""
On port type changed
"""
if self.portCombo.currentText() in ["TEXT"]:
self.portLine.setText("22")
self.portLine.setValidator(self.validatorInt)
if self.portCombo.currentText() in ["CACHE"]:
self.portLine.setValidator(self.validatorAll)
if self.portCombo.currentText() == "ALIAS":
self.portLine.setText(self.portLine.text().upper())
self.portLine.setValidator(self.validatorUpper)
def onActionChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_SYSTEM_DESCR:
if isinstance(el, dict):
if self.actionsComboBox.currentText() in el:
descr = GuiSteps.ACTION_SYSTEM_DESCR[i][
self.actionsComboBox.currentText()]
break
i += 1
self.labelActionDescr.setText("%s\n" % descr)
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]:
self.sessionGroup.show()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CLEAR_SCREEN
]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]:
self.sessionGroup.hide()
self.textGroup.show()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.show()
self.screenGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CHECK_SCREEN
]:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
else:
self.sessionGroup.hide()
self.textGroup.hide()
self.shortcutGroup.hide()
self.screenGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.hide()
def addStep(self):
"""
Add step
"""
action = self.actionsComboBox.currentText()
descr = self.descriptionLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAction.isEnabled():
signal = self.UpdateStep
if action in [GuiSteps.SYSTEM_SESSION]:
fromCacheIp = False
if self.ipCombo.currentText() == "CACHE": fromCacheIp = True
fromAliasIp = False
if self.ipCombo.currentText() == "ALIAS": fromAliasIp = True
fromCachePort = False
if self.portCombo.currentText() == "CACHE": fromCachePort = True
fromAliasPort = False
if self.portCombo.currentText() == "ALIAS": fromAliasPort = True
fromCacheLogin = False
if self.loginCombo.currentText() == "CACHE": fromCacheLogin = True
fromAliasLogin = False
if self.loginCombo.currentText() == "ALIAS": fromAliasLogin = True
fromCachePwd = False
if self.pwdCombo.currentText() == "CACHE": fromCachePwd = True
fromAliasPwd = False
if self.pwdCombo.currentText() == "ALIAS": fromAliasPwd = True
newIp = self.ipLine.text()
if not len(newIp):
QMessageBox.warning(self, "Assistant",
"Please to provide a ip!")
return
newPort = self.portLine.text()
if not len(newPort):
QMessageBox.warning(self, "Assistant",
"Please to provide a port!")
return
newLogin = self.loginLine.text()
if not len(newLogin):
QMessageBox.warning(self, "Assistant",
"Please to provide a login!")
return
newPwd = self.pwdLine.text()
agentSupport = "False"
if self.useAgent.isChecked(): agentSupport = "True"
parameters = {
'dest-ip': newIp,
'dest-port': newPort,
'login': newLogin,
'password': newPwd,
'from-cache-ip': fromCacheIp,
'from-alias-ip': fromAliasIp,
'from-cache-port': fromCachePort,
'from-alias-port': fromAliasPort,
'from-cache-login': fromCacheLogin,
'from-alias-login': fromAliasLogin,
'from-cache-pwd': fromCachePwd,
'from-alias-pwd': fromAliasPwd,
'agent-support': agentSupport
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_CLOSE]:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
elif action in [GuiSteps.SYSTEM_CLEAR_SCREEN]:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
elif action in [GuiSteps.SYSTEM_TEXT]:
fromCache = False
if self.textCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.textCombo.currentText() == "ALIAS": fromAlias = True
newText = self.textLine.text()
if not len(newText):
QMessageBox.warning(self, "Assistant",
"Please to provide text!")
return
parameters = {
'text': newText,
'from-cache': fromCache,
'from-alias': fromAlias
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_SHORTCUT]:
newShortcut = self.shortcutComboBox.currentText()
parameters = {'shortcut': newShortcut}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
elif action in [GuiSteps.SYSTEM_CHECK_SCREEN]:
op = self.checkComboBox.currentText()
fromCache = False
if self.screenCombo.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.screenCombo.currentText() == "ALIAS": fromAlias = True
toCache = False
if self.screenSaveCombo.currentText() == "CACHE": toCache = True
keyCache = self.screenSaveLine.text()
newText = ""
if op != GuiSteps.OP_ANY:
if fromCache or fromAlias:
newText = self.screenLine.text()
else:
newText = self.screenArea.toPlainText()
if not len(newText):
QMessageBox.warning(self, "Assistant",
"Please to provide value to search!")
return
parameters = {
'value': newText,
'from-cache': fromCache,
'from-alias': fromAlias,
'operator': op,
'to-cache': toCache,
'cache-key': keyCache
}
signal.emit(str(action), unicode(descr), EMPTY_VALUE, parameters)
else:
signal.emit(str(action), unicode(descr), EMPTY_VALUE, {})
def cancelStep(self):
"""
Cancel step
"""
self.addAction.setText("&Add")
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize the update of the step
"""
self.addAction.setText("&Add Action")
buttonFont = QFont()
buttonFont.setBold(False)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(False)
def editStep(self, stepData):
"""
Edit step
"""
self.addAction.setText("&Update")
buttonFont = QFont()
buttonFont.setBold(True)
self.addAction.setFont(buttonFont)
self.cancelAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsComboBox.count()):
item_text = self.actionsComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionChanged()
# finally fill all fields
self.descriptionLine.setText(stepData["description"])
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SESSION]:
self.ipLine.setText(stepData["parameters"]["dest-ip"])
self.portLine.setText("%s" % stepData["parameters"]["dest-port"])
self.loginLine.setText(stepData["parameters"]["login"])
self.pwdLine.setText(stepData["parameters"]["password"])
if stepData["parameters"]["from-cache-ip"]:
self.ipLine.setValidator(self.validatorAll)
self.ipCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-ip"]:
self.ipLine.setValidator(self.validatorUpper)
self.ipCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.ipLine.setValidator(self.validatorAll)
self.ipCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-port"]:
self.portLine.setValidator(self.validatorAll)
self.portCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-port"]:
self.portLine.setValidator(self.validatorUpper)
self.portCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.portLine.setValidator(self.validatorInt)
self.portCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-login"]:
self.loginLine.setValidator(self.validatorAll)
self.loginCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-login"]:
self.loginLine.setValidator(self.validatorUpper)
self.loginCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.loginLine.setValidator(self.validatorAll)
self.loginCombo.setCurrentIndex(INDEX_TEXT)
if stepData["parameters"]["from-cache-pwd"]:
self.pwdLine.setValidator(self.validatorAll)
self.pwdCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias-pwd"]:
self.pwdLine.setValidator(self.validatorUpper)
self.pwdCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.pwdLine.setValidator(self.validatorAll)
self.pwdCombo.setCurrentIndex(INDEX_TEXT)
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_CLOSE]:
pass
if self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CLEAR_SCREEN
]:
pass
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_TEXT]:
if stepData["parameters"]["from-cache"]:
self.textLine.setValidator(self.validatorAll)
self.textCombo.setCurrentIndex(INDEX_CACHE)
elif stepData["parameters"]["from-alias"]:
self.textLine.setValidator(self.validatorUpper)
self.textCombo.setCurrentIndex(INDEX_ALIAS)
else:
self.textLine.setValidator(self.validatorAll)
self.textCombo.setCurrentIndex(INDEX_TEXT)
self.textLine.setText(stepData["parameters"]["text"])
if self.actionsComboBox.currentText() in [GuiSteps.SYSTEM_SHORTCUT]:
for i in xrange(self.shortcutComboBox.count()):
item_text = self.shortcutComboBox.itemText(i)
if unicode(stepData["parameters"]["shortcut"]) == unicode(
item_text):
self.shortcutComboBox.setCurrentIndex(i)
break
if self.actionsComboBox.currentText() in [
GuiSteps.SYSTEM_CHECK_SCREEN
]:
if stepData["parameters"]["from-cache"]:
self.screenLine.setValidator(self.validatorAll)
self.screenCombo.setCurrentIndex(INDEX_CACHE)
self.screenLine.setText(stepData["parameters"]["value"])
elif stepData["parameters"]["from-alias"]:
self.screenLine.setValidator(self.validatorUpper)
self.screenCombo.setCurrentIndex(INDEX_ALIAS)
self.screenLine.setText(stepData["parameters"]["value"])
else:
self.screenCombo.setCurrentIndex(INDEX_TEXT)
self.screenArea.setPlainText(stepData["parameters"]["value"])
for i in xrange(self.checkComboBox.count()):
item_text = self.checkComboBox.itemText(i)
if unicode(stepData["parameters"]["operator"]) == unicode(
item_text):
self.checkComboBox.setCurrentIndex(i)
break
if stepData["parameters"]["to-cache"]:
self.screenSaveCombo.setCurrentIndex(1)
self.screenSaveLine.setText(
stepData["parameters"]["cache-key"])
else:
self.screenSaveCombo.setCurrentIndex(0)
def getTimeout(self):
"""
Return timeout value
"""
return self.optionsDialog.timeoutLine.text()
def setTimeout(self, timeout):
"""
Set the timeout
"""
return self.optionsDialog.timeoutLine.setText(timeout)
def getAgentName(self):
"""
Return the agent name
"""
return self.optionsDialog.agentNameLine.text()
def getAgentList(self):
"""
Return the agent list
"""
return self.optionsDialog.agentsList
class ShowSettingsDialog(QDialog):
"""
Dialog class for plugin settings
"""
def __init__(self, iface, configTable, uriDb, schemaDb):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param configTable: config table selected for import
"""
QDialog.__init__(self)
self.__iface = iface
self.__configTable = configTable
self.__uriDb = uriDb
self.__schemaDb = schemaDb
self.setWindowTitle(
QCoreApplication.translate("VDLNetwork", "Settings"))
self.__tables = []
self.__schemas = []
self.__dbs = DBConnector.getUsedDatabases()
self.resize(450, 200)
self.__layout = QGridLayout()
dbLabel = QLabel(
QCoreApplication.translate("VDLNetwork", "Control database : "))
dbLabel.setMinimumHeight(20)
dbLabel.setMinimumWidth(50)
self.__layout.addWidget(dbLabel, 0, 1)
self.__dbCombo = QComboBox()
self.__dbCombo.setMinimumHeight(20)
self.__dbCombo.setMinimumWidth(50)
self.__dbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__dbCombo.addItem(db)
self.__layout.addWidget(self.__dbCombo, 0, 2)
schemaLabel = QLabel(
QCoreApplication.translate("VDLNetwork", "Control schema : "))
schemaLabel.setMinimumHeight(20)
schemaLabel.setMinimumWidth(50)
self.__layout.addWidget(schemaLabel, 1, 1)
self.__schemaCombo = QComboBox()
self.__schemaCombo.setMinimumHeight(20)
self.__schemaCombo.setMinimumWidth(50)
self.__schemaCombo.addItem("")
self.__layout.addWidget(self.__schemaCombo, 1, 2)
tableLabel = QLabel(
QCoreApplication.translate("VDLNetwork", "Control table : "))
tableLabel.setMinimumHeight(20)
tableLabel.setMinimumWidth(50)
self.__layout.addWidget(tableLabel, 2, 1)
self.__tableCombo = QComboBox()
self.__tableCombo.setMinimumHeight(20)
self.__tableCombo.setMinimumWidth(50)
self.__tableCombo.addItem("")
self.__layout.addWidget(self.__tableCombo, 2, 2)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLNetwork", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLNetwork", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
self.setLayout(self.__layout)
self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged)
self.__schemaCombo.currentIndexChanged.connect(
self.__schemaComboChanged)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
if self.__uriDb is not None:
if self.__uriDb.database() in list(self.__dbs.keys()):
self.__dbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(self.__uriDb.database()) + 1)
@staticmethod
def __resetCombo(combo):
"""
To reset a combo list
:param combo: concerned combo
"""
while combo.count() > 0:
combo.removeItem(combo.count() - 1)
def __setSchemaCombo(self, uriDb):
"""
To fill the schema combo list
:param uriDb: selected database uri
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged,
self.__schemaComboChanged)
self.__resetCombo(self.__schemaCombo)
self.__schemaCombo.addItem("")
self.__schemas = []
query = db.exec_(
"""SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN
('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN
(SELECT f_table_name FROM geometry_columns)""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__schemas.append(query.value(0))
db.close()
for schema in self.__schemas:
self.__schemaCombo.addItem(schema)
self.__schemaCombo.currentIndexChanged.connect(
self.__schemaComboChanged)
if self.__schemaDb is not None:
if self.__schemaDb in self.__schemas:
self.__schemaCombo.setCurrentIndex(
self.__schemas.index(self.__schemaDb) + 1)
def __setTableCombo(self, uriDb, schema):
"""
To fill the table combo list
:param uriDb: selected database uri
:param schema: selected database schema
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged,
self.__tableComboChanged)
self.__resetCombo(self.__tableCombo)
self.__tableCombo.addItem("")
self.__tables = []
query = db.exec_(
"""SELECT table_name FROM information_schema.tables WHERE table_schema = '"""
+ schema + """' ORDER BY table_name""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__tables.append(query.value(0))
db.close()
for table in self.__tables:
if self.__tableCombo.findText(table) == -1:
self.__tableCombo.addItem(table)
self.__tableCombo.currentIndexChanged.connect(
self.__tableComboChanged)
if self.__configTable is not None:
if self.__configTable in self.__tables:
self.__tableCombo.setCurrentIndex(
self.__tables.index(self.__configTable) + 1)
def __tableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__tableCombo.itemText(0) == "":
self.__tableCombo.removeItem(0)
def __dbComboChanged(self):
"""
When the selection in db combo has changed
"""
if self.__dbCombo.itemText(0) == "":
self.__dbCombo.removeItem(0)
if self.uriDb() is not None:
self.__setSchemaCombo(self.uriDb())
def __schemaComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__schemaCombo.itemText(0) == "":
self.__schemaCombo.removeItem(0)
if self.schemaDb() is not None:
self.__setTableCombo(self.uriDb(), self.schemaDb())
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def configTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
index = self.__tableCombo.currentIndex()
if self.__tableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
def uriDb(self):
"""
To get selected import database uri
:return: import database uri
"""
index = self.__dbCombo.currentIndex()
if self.__dbCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
def schemaDb(self):
"""
To get selected import database schema
:return: import database schema
"""
index = self.__schemaCombo.currentIndex()
if self.__schemaCombo.itemText(index) == "":
return None
else:
return self.__schemas[index]
class OperatorValueDialog(QtHelper.EnhancedQDialog):
"""
Operator dialog
"""
def __init__(self, parent, currentOperator={}, liteMode=False):
"""
Operator to fill parameter description
@param dataArgs:
@type dataArgs:
@param parent:
@type parent:
"""
super(OperatorValueDialog, self).__init__(parent)
self.parentWidget = parent
self.liteMode = liteMode
self.currentOperator = currentOperator
self.createDialog()
self.createConnections()
def createDialog(self):
"""
Create qt dialog
"""
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStyleSheet("""QDialogButtonBox {
dialogbuttonbox-buttons-have-icons: 1;
dialog-ok-icon: url(:/ok.png);
dialog-cancel-icon: url(:/test-close-black.png);
}""")
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
mainLayout = QHBoxLayout()
main2Layout = QHBoxLayout()
titleLabel = QLabel(self.currentOperator['operator'])
font = QFont()
font.setBold(True)
titleLabel.setFont(font)
self.opType = QComboBox()
if not self.liteMode:
for i in xrange(len(LIST_CONDITIONS)):
self.opType.addItem(LIST_CONDITIONS[i].title())
if self.currentOperator['operator'] == LIST_CONDITIONS[
i].title():
self.opType.setCurrentIndex(i)
else:
for i in xrange(len(LIST_CONDITIONS_LITE)):
self.opType.addItem(LIST_CONDITIONS_LITE[i].title())
if self.currentOperator['operator'] == LIST_CONDITIONS_LITE[
i].title():
self.opType.setCurrentIndex(i)
main2Layout.addWidget(titleLabel)
main2Layout.addWidget(self.opType)
if not self.liteMode:
self.textValue = QTextEdit()
self.textValue.setFixedHeight(HEIGHT_TEXT_AREA)
self.textValue.setMinimumWidth(WIDTH_TEXT_AREA)
radioGroup = QButtonGroup(self)
self.strRadioButton = QRadioButton("string")
self.strRadioButton.setChecked(True)
self.inRadioButton = QRadioButton("inputs")
self.outRadioButton = QRadioButton("outputs")
self.varRadioButton = QRadioButton("variables")
radioGroup.addButton(self.strRadioButton)
radioGroup.addButton(self.inRadioButton)
radioGroup.addButton(self.outRadioButton)
radioGroup.addButton(self.varRadioButton)
self.inputsCombo = QComboBox()
for inpt in self.parentWidget.getInputs():
self.inputsCombo.addItem(inpt['name'])
self.outputsCombo = QComboBox()
for inpt in self.parentWidget.getOutputs():
self.outputsCombo.addItem(inpt['name'])
self.variablesCombo = QComboBox()
self.variablesCombo.addItems(self.parentWidget.variables)
if self.currentOperator['type'] == 'string':
self.strRadioButton.setChecked(True)
self.textValue.setText(self.currentOperator['value'])
if self.currentOperator['type'] == 'inputs':
self.inRadioButton.setChecked(True)
for x in xrange(self.inputsCombo.count()):
if self.inputsCombo.itemText(
x) == self.currentOperator['value']:
self.inputsCombo.setCurrentIndex(x)
if self.currentOperator['type'] == 'outputs':
self.outRadioButton.setChecked(True)
for x in xrange(self.outputsCombo.count()):
if self.outputsCombo.itemText(
x) == self.currentOperator['value']:
self.outputsCombo.setCurrentIndex(x)
if self.currentOperator['type'] == 'variables':
self.varRadioButton.setChecked(True)
for x in xrange(self.variablesCombo.count()):
if self.variablesCombo.itemText(
x) == self.currentOperator['value']:
self.variablesCombo.setCurrentIndex(x)
mainLayout.addWidget(self.strRadioButton)
mainLayout.addWidget(self.textValue)
mainLayout.addWidget(self.inRadioButton)
mainLayout.addWidget(self.inputsCombo)
mainLayout.addWidget(self.outRadioButton)
mainLayout.addWidget(self.outputsCombo)
mainLayout.addWidget(self.varRadioButton)
mainLayout.addWidget(self.variablesCombo)
finalLayout = QVBoxLayout()
finalLayout.addLayout(main2Layout)
finalLayout.addLayout(mainLayout)
finalLayout.addWidget(self.buttonBox)
self.setLayout(finalLayout)
self.setWindowTitle(self.tr("Operators configuration"))
self.setMinimumWidth(500)
self.center()
def createConnections(self):
"""
Create qt connections
"""
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def getValue(self):
"""
Return value
"""
self.currentOperator['operator'] = unicode(self.opType.currentText())
if not self.liteMode:
if self.currentOperator['operator'].lower() == OP_ANY:
self.currentOperator['type'] = 'string'
self.currentOperator['value'] = ''
else:
if self.strRadioButton.isChecked():
self.currentOperator['type'] = 'string'
self.currentOperator['value'] = unicode(
self.textValue.toPlainText())
if self.inRadioButton.isChecked():
self.currentOperator['type'] = 'inputs'
self.currentOperator['value'] = unicode(
self.inputsCombo.currentText())
if self.outRadioButton.isChecked():
self.currentOperator['type'] = 'outputs'
self.currentOperator['value'] = unicode(
self.outputsCombo.currentText())
if self.varRadioButton.isChecked():
self.currentOperator['type'] = 'variables'
self.currentOperator['value'] = unicode(
self.variablesCombo.currentText())
return self.currentOperator
class OutputAnalyserDialog(QDialog):
def __init__(self, iface, parent, params):
QDialog.__init__(self, parent)
self.iface = iface
self.parent = parent
self.params = params
self.output_reader = None
self.tool = None
self.element_ids_nodes = None
self.element_ids_links = None
self.nodes_lay = None
self.links_lay = None
self.setWindowTitle(Parameters.plug_in_name)
# Selection changed listeners
self.params.junctions_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.reservoirs_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.tanks_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.pipes_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.pumps_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.valves_vlay.selectionChanged.connect(
self.feature_sel_changed)
# self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
fra_main_lay = QVBoxLayout(self)
self.fra_out_file = QFrame(self)
fra_out_file_lay = QHBoxLayout(self.fra_out_file)
self.lbl_out_file = QLabel('Simulation output file:')
self.txt_out_file = QLineEdit('')
self.txt_out_file.setReadOnly(True)
self.btn_out_file = QToolButton()
self.btn_out_file.setText('...')
self.btn_out_file.clicked.connect(self.btn_out_file_clicked)
fra_out_file_lay.addWidget(self.lbl_out_file)
fra_out_file_lay.addWidget(self.txt_out_file)
fra_out_file_lay.addWidget(self.btn_out_file)
self.tab_widget = QTabWidget(self)
# Graphs tab ---------------------------------------------------------------------------------------------------
self.tab_graphs = QWidget()
tab_graphs_lay = QHBoxLayout(self.tab_graphs)
# Left frame
self.fra_graphs_left = QFrame()
self.fra_graphs_left.setMaximumWidth(100)
fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left)
self.btn_sel_element = QPushButton('Pick')
self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked)
fra_graphs_left_lay.addWidget(self.btn_sel_element)
# Nodes
self.grb_nodes = QGroupBox(u'Nodes')
lay_grb_nodes = QVBoxLayout(self.grb_nodes)
self.chk_node_demand = QCheckBox('Demand')
lay_grb_nodes.addWidget(self.chk_node_demand)
self.chk_node_head = QCheckBox('Head')
lay_grb_nodes.addWidget(self.chk_node_head)
self.chk_node_pressure = QCheckBox('Pressure')
lay_grb_nodes.addWidget(self.chk_node_pressure)
self.chk_node_quality = QCheckBox('Quality')
lay_grb_nodes.addWidget(self.chk_node_quality)
fra_graphs_left_lay.addWidget(self.grb_nodes)
# Links
self.grb_links = QGroupBox(u'Links')
lay_grb_links = QVBoxLayout(self.grb_links)
self.chk_link_flow = QCheckBox('Flow')
lay_grb_links.addWidget(self.chk_link_flow)
self.chk_link_velocity = QCheckBox('Velocity')
lay_grb_links.addWidget(self.chk_link_velocity)
self.chk_link_headloss = QCheckBox('Headloss')
lay_grb_links.addWidget(self.chk_link_headloss)
self.chk_link_quality = QCheckBox('Quality')
lay_grb_links.addWidget(self.chk_link_quality)
fra_graphs_left_lay.addWidget(self.grb_links)
self.btn_draw_graph = QPushButton('Draw')
self.btn_draw_graph.clicked.connect(self.draw_graphs)
fra_graphs_left_lay.addWidget(self.btn_draw_graph)
self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
fra_graphs_left_lay.addItem(self.spacer)
tab_graphs_lay.addWidget(self.fra_graphs_left)
# Right frame
self.fra_graphs_right = QFrame()
fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right)
fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0)
self.static_canvas = StaticMplCanvas(self.fra_graphs_right,
width=5,
height=4,
dpi=100)
fra_graphs_right_lay.addWidget(self.static_canvas)
tab_graphs_lay.addWidget(self.fra_graphs_right)
# lay.addWidget(self.button)
self.tab_widget.addTab(self.tab_graphs, 'Graphs')
# Maps tab -----------------------------------------------------------------------------------------------------
self.tab_maps = QWidget()
tab_maps_lay = QHBoxLayout(self.tab_maps)
# Left frame
self.fra_maps_left = QFrame()
self.fra_maps_left.setMaximumWidth(200)
fra_maps_left_lay = QVBoxLayout(self.fra_maps_left)
self.grb_maps = QGroupBox(u'Variable')
grb_maps_lay = QVBoxLayout(self.grb_maps)
self.rad_maps_node_demand = QRadioButton(u'Node demand')
grb_maps_lay.addWidget(self.rad_maps_node_demand)
self.rad_maps_node_head = QRadioButton(u'Node head')
grb_maps_lay.addWidget(self.rad_maps_node_head)
self.rad_maps_node_pressure = QRadioButton(u'Node pressure')
grb_maps_lay.addWidget(self.rad_maps_node_pressure)
self.rad_maps_node_quality = QRadioButton(u'Node quality')
grb_maps_lay.addWidget(self.rad_maps_node_quality)
self.rad_maps_link_flow = QRadioButton(u'Link flow')
grb_maps_lay.addWidget(self.rad_maps_link_flow)
self.rad_maps_link_velocity = QRadioButton(u'Link velocity')
grb_maps_lay.addWidget(self.rad_maps_link_velocity)
self.rad_maps_link_headloss = QRadioButton(u'Link headloss')
grb_maps_lay.addWidget(self.rad_maps_link_headloss)
self.rad_maps_link_quality = QRadioButton(u'Link quality')
grb_maps_lay.addWidget(self.rad_maps_link_quality)
fra_maps_left_lay.addWidget(self.grb_maps)
fra_maps_left_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_left)
# Right maps frame
self.fra_maps_right = QFrame()
fra_maps_right_lay = QVBoxLayout(self.fra_maps_right)
self.fra_maps_right_time = QFrame()
fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time)
self.lbl_map_times = QLabel(u'Period [h]:')
self.cbo_map_times = QComboBox()
fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times)
fra_maps_right_lay.addWidget(self.fra_maps_right_time)
self.btn_draw_map = QPushButton(u'Draw map')
self.btn_draw_map.clicked.connect(self.draw_maps)
fra_maps_right_lay.addWidget(self.btn_draw_map)
fra_maps_right_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_right)
self.tab_widget.addTab(self.tab_maps, 'Maps')
# # Add to main
fra_main_lay.addWidget(self.fra_out_file)
fra_main_lay.addWidget(self.tab_widget)
self.setup()
self.initialize()
# self.read_outputs()
# Set size
self.setMinimumWidth(self.tab_graphs.width())
self.setMinimumHeight(self.tab_graphs.height())
def setup(self):
pass
def btn_out_file_clicked(self):
config_file = ConfigFile(Parameters.config_file_path)
out_file = QFileDialog.getOpenFileName(self, 'Select out file',
config_file.get_last_out_file(),
'Out files (*.out)')
if out_file is None or out_file == '':
return
config_file.set_last_out_file(out_file)
self.txt_out_file.setText(out_file)
self.read_outputs()
if self.output_reader is None:
return
# Fill times combo
self.cbo_map_times.clear()
for period_s in self.output_reader.period_results.iterkeys():
text = self.seconds_to_string(
period_s, self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
self.cbo_map_times.addItem(text, period_s)
def initialize(self):
# Graphs
self.grb_nodes.setEnabled(False)
self.grb_links.setEnabled(False)
# Maps
self.rad_maps_node_demand.setChecked(True)
def feature_sel_changed(self):
is_nodes = False
sel_junctions = self.params.junctions_vlay.selectedFeatureCount()
sel_reservoirs = self.params.reservoirs_vlay.selectedFeatureCount()
sel_tanks = self.params.tanks_vlay.selectedFeatureCount()
if sel_junctions > 0 or sel_reservoirs > 0 or sel_tanks > 0:
is_nodes = True
self.grb_nodes.setEnabled(is_nodes)
is_links = False
sel_pipes = self.params.pipes_vlay.selectedFeatureCount()
sel_pumps = self.params.pumps_vlay.selectedFeatureCount()
sel_valves = self.params.valves_vlay.selectedFeatureCount()
if sel_pipes > 0 or sel_pumps > 0 or sel_valves > 0:
is_links = True
self.grb_links.setEnabled(is_links)
def read_outputs(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
self.output_reader = BinaryOutputReader()
self.output_reader.read(self.txt_out_file.text())
QApplication.restoreOverrideCursor()
# Check if output compatible with loaded project
compatible = True
out_nodes_nr = self.output_reader.nodes_nr
out_tanks_reservs_nr = self.output_reader.tanks_reservs_nr
out_juncts_nr = out_nodes_nr - out_tanks_reservs_nr
out_links_nr = self.output_reader.links_nr
out_pumps_nr = self.output_reader.pumps_nr
out_valves_nr = self.output_reader.valves_nr
out_pipes_nr = out_links_nr - out_pumps_nr - out_valves_nr
if out_juncts_nr != self.params.junctions_vlay.featureCount():
compatible = False
if out_tanks_reservs_nr != (
self.params.reservoirs_vlay.featureCount() +
self.params.tanks_vlay.featureCount()):
compatible = False
if out_pipes_nr != self.params.pipes_vlay.featureCount():
compatible = False
if out_valves_nr != self.params.valves_vlay.featureCount():
compatible = False
if out_pumps_nr != self.params.pumps_vlay.featureCount():
compatible = False
if not compatible:
message = 'The out file appears to incompatible with the actual project layers.'
QMessageBox.warning(self, Parameters.plug_in_name, message,
QMessageBox.Ok)
self.output_reader = None
self.txt_out_file.setText('')
else:
# Message after reading completed
message = 'Out file loaded: ' + str(
out_nodes_nr) + ' nodes, ' + str(
out_links_nr) + ' links found.'
# Clear refs to output layer
self.params.out_lay_node_demand = None
self.params.out_lay_node_head = None
self.params.out_lay_node_pressure = None
self.params.out_lay_node_quality = None
self.params.out_lay_link_flow = None
self.params.out_lay_link_velocity = None
self.params.out_lay_link_headloss = None
self.params.out_lay_link_quality = None
QMessageBox.information(self, Parameters.plug_in_name, message,
QMessageBox.Ok)
finally:
# self.iface.messageBar().pushWarning(
# Parameters.plug_in_name,
# 'Error while reading output file.') # TODO: softcode
# self.output_reader = None
# self.txt_out_file.setText('')
QApplication.restoreOverrideCursor()
def btn_sel_element_clicked(self):
if self.output_reader is None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Please select the simulation out file.',
QgsMessageBar.WARNING, 5) # TODO: softcode
return
self.tool = SelectTool(self, self.params)
self.iface.mapCanvas().setMapTool(self.tool)
cursor = QCursor()
cursor.setShape(Qt.ArrowCursor)
self.iface.mapCanvas().setCursor(cursor)
def draw_graphs(self):
# Get selected features
self.element_ids_nodes = []
for junction_feat in self.params.junctions_vlay.selectedFeatures():
self.element_ids_nodes.append(
junction_feat.attribute(Junction.field_name_eid))
for reservoir_feat in self.params.reservoirs_vlay.selectedFeatures():
self.element_ids_nodes.append(
reservoir_feat.attribute(Reservoir.field_name_eid))
for tank_feat in self.params.tanks_vlay.selectedFeatures():
self.element_ids_nodes.append(
tank_feat.attribute(Tank.field_name_eid))
self.element_ids_links = []
for pipe_feat in self.params.pipes_vlay.selectedFeatures():
self.element_ids_links.append(
pipe_feat.attribute(Pipe.field_name_eid))
for pump_feat in self.params.pumps_vlay.selectedFeatures():
self.element_ids_links.append(
pump_feat.attribute(Pump.field_name_eid))
for valve_feat in self.params.valves_vlay.selectedFeatures():
self.element_ids_links.append(
valve_feat.attribute(Valve.field_name_eid))
# Build values dictionaries
xs = self.output_reader.report_times
ys_d_d = {}
params_count = 0
# Nodes
if self.grb_nodes.isEnabled():
if self.chk_node_demand.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_demands_d[element_id],
self.params.options.flow_units
]
ys_d_d[OutputParamCodes.NODE_DEMAND] = ys_d
if self.chk_node_head.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_heads_d[element_id],
Options.units_diameter_tanks[self.params.options.units]
]
ys_d_d[OutputParamCodes.NODE_HEAD] = ys_d
if self.chk_node_pressure.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_pressures_d[element_id],
Options.units_pressure[self.params.options.units]
]
ys_d_d[OutputParamCodes.NODE_PRESSURE] = ys_d
if self.chk_node_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_qualities_d[element_id],
Quality.quality_units_text[
self.params.options.quality.mass_units]
]
ys_d_d[OutputParamCodes.NODE_QUALITY] = ys_d
# Links
if self.grb_links.isEnabled():
if self.chk_link_flow.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_flows_d[element_id],
self.params.options.flow_units
]
ys_d_d[OutputParamCodes.LINK_FLOW] = ys_d
if self.chk_link_velocity.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_velocities_d[element_id],
Options.units_velocity[self.params.options.units]
]
ys_d_d[OutputParamCodes.LINK_VELOCITY] = ys_d
if self.chk_link_headloss.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_headlosses_d[element_id],
Options.units_diameter_tanks[self.params.options.units]
]
ys_d_d[OutputParamCodes.LINK_HEADLOSS] = ys_d
if self.chk_link_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_qualities_d[element_id],
Quality.quality_units_text[
self.params.options.quality.mass_units]
]
ys_d_d[OutputParamCodes.LINK_QUALITY] = ys_d
if ys_d_d:
self.static_canvas.draw_output_line(xs, ys_d_d, params_count)
def draw_maps(self):
"""
Draws layers with all the attributes
:return:
"""
report_time = self.cbo_map_times.itemText(
self.cbo_map_times.currentIndex())
if self.rad_maps_node_demand.isChecked(
): # -------------------------------------------------------------------
lay_name = u'Node demand'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_demand_id,
lay_name, self.output_reader.node_demands_d,
report_time)
self.params.out_lay_node_demand_id = lay_id
elif self.rad_maps_node_head.isChecked():
lay_name = u'Node head'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_head_id, lay_name,
self.output_reader.node_heads_d,
report_time)
self.params.out_lay_node_head_id = lay_id
elif self.rad_maps_node_pressure.isChecked():
lay_name = u'Node pressure'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_pressure_id,
lay_name,
self.output_reader.node_pressures_d,
report_time)
self.params.out_lay_node_pressure_id = lay_id
elif self.rad_maps_node_quality.isChecked():
lay_name = u'Node quality'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_quality_id,
lay_name,
self.output_reader.node_qualities_d,
report_time)
self.params.out_lay_node_quality_id = lay_id
elif self.rad_maps_link_flow.isChecked(
): # -------------------------------------------------------------------
lay_name = u'Link flow'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_flow_id, lay_name,
self.output_reader.link_flows_d,
report_time)
self.params.out_lay_link_flow_id = lay_id
elif self.rad_maps_link_velocity.isChecked():
lay_name = u'Link velocity'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_velocity_id,
lay_name,
self.output_reader.link_velocities_d,
report_time)
self.params.out_lay_link_velocity_id = lay_id
elif self.rad_maps_link_headloss.isChecked():
lay_name = u'Link headloss'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_headloss_id,
lay_name,
self.output_reader.link_headlosses_d,
report_time)
self.params.out_lay_link_headloss_id = lay_id
elif self.rad_maps_link_quality.isChecked():
lay_name = u'Link quality'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_quality_id,
lay_name,
self.output_reader.link_qualities_d,
report_time)
self.params.out_lay_link_quality_id = lay_id
def draw_map(self, lay_type, lay_id, lay_name, dataset, report_time):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
lay_name += ' ' + report_time
lay = LayerUtils.get_lay_from_id(lay_id)
if lay is None:
if lay_type == LayerType.NODE:
lay = self.create_out_node_layer(lay_name, dataset)
ns = NodeSymbology()
lay.setRendererV2(
ns.make_graduated_sym_renderer(lay, report_time))
elif lay_type == LayerType.LINK:
lay = self.create_out_link_layer(lay_name, dataset)
ls = LinkSymbology()
lay.setRendererV2(
ls.make_flow_sym_renderer(lay, report_time))
lay_id = lay.id()
QgsMapLayerRegistry.instance().addMapLayer(lay)
self.params.out_layers.append(lay)
else:
lay.setLayerName(lay_name)
lay.triggerRepaint()
QApplication.restoreOverrideCursor()
finally:
QApplication.restoreOverrideCursor()
return lay_id
def btn_cancel_clicked(self):
self.setVisible(False)
def btn_ok_clicked(self):
pass
def create_out_node_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.NODE)
def create_out_link_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.LINK)
def create_out_layer(self, lay_name, values_d, lay_type):
field_name_vars = []
periods = self.output_reader.period_results.keys()
for period_s in periods:
text = self.seconds_to_string(
period_s, self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
field_name_vars.append(text)
if lay_type == LayerType.NODE:
new_lay = MemoryDS.create_nodes_lay(self.params, field_name_vars,
lay_name, self.params.crs)
elif lay_type == LayerType.LINK:
new_lay = MemoryDS.create_links_lay(self.params, field_name_vars,
lay_name, self.params.crs)
with edit(new_lay):
# Update attributes
for feat in new_lay.getFeatures():
fid = feat.id()
eid = feat.attribute(Node.field_name_eid)
values = values_d[eid]
for p in range(len(periods)):
new_lay.changeAttributeValue(fid, p + 1, values[p])
return new_lay
def seconds_to_string(self, period_s, duration_s, interval_s):
day = int(math.floor(period_s / 86400))
hour = period_s / 3600 - day * 24
minute = period_s / 60 - day * 24 * 60 - hour * 60
second = period_s - day * 86400 - hour * 3600 - minute * 60
text = ''
if duration_s >= 86400:
# We need days
text += str(day) + 'd'
if duration_s >= 3600:
# We need hours
text += '{:02}'.format(hour) + 'H'
text += '{:02}'.format(minute) + 'm'
if second > 0:
text += '{:02}'.format(second) + 's'
return text
class experimentersDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().prm
self.tmpPref = {}
self.tmpPref['experimenter'] = {}
self.tmpPref['experimenter'] = copy.deepcopy(self.parent().prm['experimenter'])
self.currLocale = self.parent().prm['currentLocale']
self.currLocale.setNumberOptions(self.currLocale.OmitGroupSeparator | self.currLocale.RejectGroupSeparator)
self.sizer = QGridLayout()
self.h1Sizer = QHBoxLayout()
self.v1Sizer = QVBoxLayout()
self.v2Sizer = QVBoxLayout()
n = 0
self.experimenterLabel = QLabel(self.tr("Experimenter ID:"), self)
self.sizer.addWidget(self.experimenterLabel, n, 0)
self.experimenterChooser = QComboBox()
self.experimenterChooser.addItems(self.tmpPref['experimenter']['experimenter_id'])
self.sizer.addWidget(self.experimenterChooser, n, 1)
self.experimenterChooser.activated[str].connect(self.onExperimenterChange)
self.currIdx = self.experimenterChooser.currentIndex()
n = n+1
self.experimenterNameLabel = QLabel(self.tr("Name:"), self)
self.sizer.addWidget(self.experimenterNameLabel, n, 0)
self.experimenterNameTF = QLineEdit("")
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][0])
self.sizer.addWidget(self.experimenterNameTF, n, 1)
n = n+1
self.experimenterSurnameLabel = QLabel(self.tr("Surname:"), self)
self.sizer.addWidget(self.experimenterSurnameLabel, n, 0)
self.experimenterSurnameTF = QLineEdit("")
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][0])
self.sizer.addWidget(self.experimenterSurnameTF, n, 1)
n = n+1
self.experimenterEmailLabel = QLabel(self.tr("e-mail:"), self)
self.sizer.addWidget(self.experimenterEmailLabel, n, 0)
self.experimenterEmailTF = QLineEdit("")
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][0])
self.sizer.addWidget(self.experimenterEmailTF, n, 1)
n = n+1
self.experimenterAddressLabel = QLabel(self.tr("Address (line 1):"), self)
self.sizer.addWidget(self.experimenterAddressLabel, n, 0)
self.experimenterAddressTF = QLineEdit("")
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][0])
self.sizer.addWidget(self.experimenterAddressTF, n, 1)
n = n+1
self.experimenterAddressLabel2 = QLabel(self.tr("Address (line 2):"), self)
self.sizer.addWidget(self.experimenterAddressLabel2, n, 0)
self.experimenterAddressTF2 = QLineEdit("")
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][0])
self.sizer.addWidget(self.experimenterAddressTF2, n, 1)
n = n+1
self.experimenterTelephoneLabel = QLabel(self.tr("Telephone:"), self)
self.sizer.addWidget(self.experimenterTelephoneLabel, n, 0)
self.experimenterTelephoneTF = QLineEdit("")
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][0])
self.sizer.addWidget(self.experimenterTelephoneTF, n, 1)
n = n+1
self.experimenterMobileLabel = QLabel(self.tr("Mobile:"), self)
self.sizer.addWidget(self.experimenterMobileLabel, n, 0)
self.experimenterMobileTF = QLineEdit("")
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][0])
self.sizer.addWidget(self.experimenterMobileTF, n, 1)
#ADD EXPERIMENTER BUTTON
addExpButton = QPushButton(self.tr("Add Experimenter"), self)
addExpButton.clicked.connect(self.onClickAddExpButton)
self.v2Sizer.addWidget(addExpButton)
#REMOVE EXPERIMENTER BUTTON
removeExpButton = QPushButton(self.tr("Remove Experimenter"), self)
removeExpButton.clicked.connect(self.onClickRemoveExpButton)
self.v2Sizer.addWidget(removeExpButton)
#CHANGE ID BUTTON
changeIdButton = QPushButton(self.tr("Change Identifier"), self)
changeIdButton.clicked.connect(self.onClickChangeIdButton)
self.v2Sizer.addWidget(changeIdButton)
#SET AS DEFAULT BUTTON
setAsDefaultButton = QPushButton(self.tr("Set as default"), self)
setAsDefaultButton.clicked.connect(self.onClickSetAsDefaultButton)
self.v2Sizer.addWidget(setAsDefaultButton)
self.v2Sizer.addStretch()
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply|QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
buttonBox.button(QDialogButtonBox.Apply).clicked.connect(self.onClickApplyButton)
self.h1Sizer.addLayout(self.v2Sizer)
self.sizer.setAlignment(Qt.AlignTop)
self.h1Sizer.addLayout(self.sizer)
self.v1Sizer.addLayout(self.h1Sizer)
self.v1Sizer.addWidget(buttonBox)
self.setLayout(self.v1Sizer)
def onClickApplyButton(self):
self.tryApply(self.currIdx)
self.permanentApply()
def permanentApply(self):
self.parent().prm['experimenter'] = copy.deepcopy(self.tmpPref['experimenter'])
f = open(self.parent().prm['experimenterPrefFile'], 'wb')
pickle.dump(self.parent().prm['experimenter'], f)
f.close()
for i in range(self.parent().experimenterChooser.count()):
self.parent().experimenterChooser.removeItem(0)
self.parent().experimenterChooser.addItems(self.parent().prm['experimenter']['experimenter_id'])
def tryApply(self, idx):
self.tmpPref['experimenter']['experimenter_id'][idx] = self.experimenterChooser.itemText(idx)
self.tmpPref['experimenter']['experimenter_name'][idx] = self.experimenterNameTF.text()
self.tmpPref['experimenter']['experimenter_surname'][idx] = self.experimenterSurnameTF.text()
self.tmpPref['experimenter']['experimenter_email'][idx] = self.experimenterEmailTF.text()
self.tmpPref['experimenter']['experimenter_address'][idx] = self.experimenterAddressTF.text()
self.tmpPref['experimenter']['experimenter_address2'][idx] = self.experimenterAddressTF2.text()
self.tmpPref['experimenter']['experimenter_telephone'][idx] = self.experimenterTelephoneTF.text()
self.tmpPref['experimenter']['experimenter_mobile'][idx] = self.experimenterMobileTF.text()
def revertChanges(self):
if len(self.tmpPref['experimenter']['experimenter_id']) != len(self.parent().prm['experimenter']['experimenter_id']): #experimenter was added, reverting
for i in range(self.experimenterChooser.count()):
self.experimenterChooser.removeItem(0)
self.experimenterChooser.addItems(self.parent().prm['experimenter']['experimenter_id'])
self.tmpPref['experimenter'] = copy.deepcopy(self.parent().prm['experimenter'])
def onExperimenterChange(self, experimenterSelected):
self.prevIdx = self.currIdx
self.currIdx = self.tmpPref['experimenter']['experimenter_id'].index(experimenterSelected)
self.tryApply(self.prevIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
self.experimenterNameTF.setText(self.prm['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.prm['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.prm['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.prm['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.prm['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.prm['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.prm['experimenter']['experimenter_mobile'][self.currIdx])
def onClickAddExpButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
msg = self.tr("Experimenter's Identifier:")
name, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.tmpPref['experimenter']['defaultExperimenter'].append('')
self.tmpPref['experimenter']['experimenter_id'].append(name)
self.tmpPref['experimenter']['experimenter_name'].append('')
self.tmpPref['experimenter']['experimenter_surname'].append('')
self.tmpPref['experimenter']['experimenter_email'].append('')
self.tmpPref['experimenter']['experimenter_address'].append('')
self.tmpPref['experimenter']['experimenter_address2'].append('')
self.tmpPref['experimenter']['experimenter_telephone'].append('')
self.tmpPref['experimenter']['experimenter_mobile'].append('')
self.permanentApply()
self.currIdx = self.experimenterChooser.count()
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][self.currIdx])
self.experimenterChooser.addItem(name)
self.experimenterChooser.setCurrentIndex(self.currIdx)
def onClickRemoveExpButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
if self.experimenterChooser.count() > 1:
reply = QMessageBox.warning(self, self.tr('Message'),
"Remove experimenter? This action cannot be undone!", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.tmpPref['experimenter']['defaultExperimenter'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_id'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_name'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_surname'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_email'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_address'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_address2'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_telephone'].pop(self.currIdx)
self.tmpPref['experimenter']['experimenter_mobile'].pop(self.currIdx)
self.experimenterChooser.removeItem(self.currIdx)
self.currIdx = self.experimenterChooser.currentIndex()
self.permanentApply()
self.experimenterNameTF.setText(self.tmpPref['experimenter']['experimenter_name'][self.currIdx])
self.experimenterSurnameTF.setText(self.tmpPref['experimenter']['experimenter_surname'][self.currIdx])
self.experimenterEmailTF.setText(self.tmpPref['experimenter']['experimenter_email'][self.currIdx])
self.experimenterAddressTF.setText(self.tmpPref['experimenter']['experimenter_address'][self.currIdx])
self.experimenterAddressTF2.setText(self.tmpPref['experimenter']['experimenter_address2'][self.currIdx])
self.experimenterTelephoneTF.setText(self.tmpPref['experimenter']['experimenter_telephone'][self.currIdx])
self.experimenterMobileTF.setText(self.tmpPref['experimenter']['experimenter_mobile'][self.currIdx])
else:
QMessageBox.warning(self, self.tr('Message'),
self.tr("Only one experimenter left. Experimenter cannot be removed!"), QMessageBox.Ok)
def onClickChangeIdButton(self):
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
msg = self.tr("Experimenter's Identifier:")
name, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.tmpPref['experimenter']['experimenter_id'][self.currIdx] = name
self.experimenterChooser.setItemText(self.currIdx, name)
self.permanentApply()
def onClickSetAsDefaultButton(self):
idx = self.experimenterChooser.currentIndex()
print(idx)
self.tryApply(self.currIdx)
if self.tmpPref['experimenter'] != self.parent().prm['experimenter']:
conf = applyChanges(self)
if conf.exec_():
self.permanentApply()
else:
self.revertChanges()
for i in range(len(self.parent().prm['experimenter']["defaultExperimenter"])):
if i == idx:
self.tmpPref['experimenter']["defaultExperimenter"][i] = "\u2713"
else:
self.tmpPref['experimenter']["defaultExperimenter"][i] = "\u2012"
print(self.tmpPref)
self.permanentApply()
class WAndroid(QWidget, Logger.ClassLogger):
"""
Android widget
"""
# action, description, misc, parameters
AddStep = pyqtSignal(str, str, str, dict)
UpdateStep = pyqtSignal(str, str, str, dict)
CancelEdit = pyqtSignal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self)
self.createActions()
self.createWidgets()
self.createToolbar()
self.createConnections()
def createActions(self):
"""
Create qt actions
"""
self.addAndroidAction = QPushButton(QIcon(":/add_black.png"), '&Add Action', self)
self.addAndroidAction.setMinimumHeight(40)
self.addAndroidAction.setMaximumWidth(150)
self.cancelAndroidAction = QtHelper.createAction(self, "&Cancel", self.cancelStep,
icon=None, tip = 'Cancel update')
self.cancelAndroidAction.setEnabled(False)
self.optionsAction = QtHelper.createAction(self, "&", self.openOptions,
icon=QIcon(":/recorder-mobile-small.png"), tip = 'Android options')
def createWidgets(self):
"""
Create qt widgets
"""
self.optionsDialog = OptionsDialog(self)
self.validatorUpper = ValidatorUpper(self)
self.validatorAll = ValidatorAll(self)
self.validatorInt = QIntValidator(self)
###################### android action #########################
self.actionsAndroidComboBox = QComboBox(self)
self.actionsAndroidComboBox.setMinimumHeight(40)
for i in xrange(len(GuiSteps.ACTION_ANDROID_DESCR)):
if not len( GuiSteps.ACTION_ANDROID_DESCR[i] ):
self.actionsAndroidComboBox.insertSeparator(i+1)
else:
el = GuiSteps.ACTION_ANDROID_DESCR[i].keys()
self.actionsAndroidComboBox.addItem( list(el)[0] )
self.descriptionAndroidLine = QLineEdit(self)
self.descriptionAndroidLine.setPlaceholderText("Step purpose description")
self.descriptionAndroidLine.hide()
self.labelActionAndroidDescr = QLabel( )
self.labelActionAndroidDescr.hide()
self.labelActionAndroidDescr.setText( "%s\n" % GuiSteps.ACTION_ANDROID_DESCR[0][GuiSteps.ANDROID_WAKEUP_UNLOCK])
self.labelActionAndroidDescr.setWordWrap(True)
actionsLayout = QHBoxLayout()
actionsLayout.addWidget(self.actionsAndroidComboBox)
actionLayoutAndroid = QGridLayout()
actionLayoutAndroid.addLayout(actionsLayout, 0, 1)
self.createWidgetShortcut()
self.createWidgetCode()
self.createWidgetStart()
self.createWidgetXY()
self.createWidgetEndXY()
self.createWidgetElement()
self.createWidgetTextTo()
self.createWidgetLine()
self.createWidgetLine2()
actionLayoutAndroid2 = QGridLayout()
actionLayoutAndroid2.addWidget( self.shortcutAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.codeAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.elemenAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.xyAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.startAndroidGroup , 0, 0)
actionLayoutAndroid2.addWidget( self.lineAndroidGroup , 1, 0)
actionLayoutAndroid2.addWidget( self.line2AndroidGroup , 0, 1)
actionLayoutAndroid2.addWidget( self.textToGlobalGroup , 0, 1)
actionLayoutAndroid2.addWidget( self.endXyAndroidGroup, 0, 1)
font = QFont()
font.setBold(True)
labelAct = QLabel( self.tr("Action: ") )
labelAct.setFont( font)
self.arrowLabel = QLabel("")
self.arrowLabel.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
self.arrowLabel.hide()
self.arrowLabel2 = QLabel("")
self.arrowLabel2.setPixmap(QPixmap(":/arrow-right.png").scaledToWidth(32))
layoutAndroid = QHBoxLayout()
layoutAndroid.addWidget( labelAct )
layoutAndroid.addLayout( actionLayoutAndroid )
layoutAndroid.addWidget( self.arrowLabel )
layoutAndroid.addLayout( actionLayoutAndroid2 )
layoutAndroid.addWidget( self.arrowLabel2 )
layoutAndroid.addWidget(self.addAndroidAction)
layoutAndroid.addStretch(1)
self.setLayout(layoutAndroid)
def createToolbar(self):
"""
Create qt toolbar
"""
pass
def openOptions(self):
"""
Open options
"""
if self.optionsDialog.exec_() == QDialog.Accepted:
pass
def createWidgetLine2(self):
"""
Create line widget
"""
self.valueAndroidLine2 = QLineEdit(self)
self.valueAndroidLine2.setMinimumWidth(150)
self.valueAndroidCombo2 = QComboBox(self)
self.valueAndroidCombo2.addItems( LIST_TYPES )
self.line2AndroidGroup = QGroupBox(self.tr(""))
line2Androidlayout = QGridLayout()
line2Androidlayout.addWidget( QLabel( self.tr("Text to type:") ), 0, 0 )
line2Androidlayout.addWidget( self.valueAndroidCombo2, 0, 1 )
line2Androidlayout.addWidget( self.valueAndroidLine2, 0, 2 )
self.line2AndroidGroup.setLayout(line2Androidlayout)
self.line2AndroidGroup.hide()
def createWidgetLine(self):
"""
Create line widget
"""
self.lineAndroidGroup = QGroupBox(self.tr(""))
lineAndroidlayout = QGridLayout()
self.valueAndroidLine = QLineEdit(self)
self.valueAndroidLine.setMinimumWidth(300)
lineAndroidlayout.addWidget( QLabel( self.tr("Value:") ) , 0,1)
lineAndroidlayout.addWidget( self.valueAndroidLine , 0, 2)
self.lineAndroidGroup.setLayout(lineAndroidlayout)
self.lineAndroidGroup.hide()
def createWidgetTextTo(self):
"""
Create text widget
"""
self.valueTextCacheGlobalLine = QLineEdit(self)
self.valueTextCacheGlobalLine.setMinimumWidth(150)
self.valueTextCacheGlobalCombo = QComboBox(self)
self.valueTextCacheGlobalCombo.addItems( ["CACHE"] )
self.textToGlobalGroup = QGroupBox(self.tr(""))
textToGloballayout = QGridLayout()
textToGloballayout.addWidget( QLabel( self.tr("Save text in:") ) , 0, 0)
textToGloballayout.addWidget( self.valueTextCacheGlobalCombo , 0, 1)
textToGloballayout.addWidget( self.valueTextCacheGlobalLine , 0, 2)
self.textToGlobalGroup.setLayout(textToGloballayout)
self.textToGlobalGroup.hide()
def createWidgetElement(self):
"""
Create text widget
"""
self.elemenAndroidGroup = QGroupBox(self.tr(""))
self.elementTextAndroidLine = QLineEdit(self)
self.elementTextAndroidLine.setMinimumWidth(300)
self.elementTextCombo = QComboBox(self)
self.elementTextCombo.addItems( LIST_TYPES )
self.elementDescriptionAndroidLine = QLineEdit(self)
self.elementDescriptionAndroidLine.setMinimumWidth(300)
self.elementClassAndroidLine = QLineEdit(self)
self.elementClassAndroidLine.setMinimumWidth(300)
self.elementRessourceIdAndroidLine = QLineEdit(self)
self.elementRessourceIdAndroidLine.setMinimumWidth(300)
self.elementPackageAndroidLine = QLineEdit(self)
self.elementPackageAndroidLine.setMinimumWidth(300)
# get text end
elementAndroidlayout = QGridLayout()
elementAndroidlayout.addWidget( QLabel( self.tr("Text Element:") ) , 0,1)
elementAndroidlayout.addWidget( self.elementTextCombo , 0, 2)
elementAndroidlayout.addWidget( self.elementTextAndroidLine , 0, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Description Element:") ) , 1,1)
elementAndroidlayout.addWidget( self.elementDescriptionAndroidLine , 1, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Class Name:") ) , 2,1)
elementAndroidlayout.addWidget( self.elementClassAndroidLine , 2, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Resource ID:") ) , 3,1)
elementAndroidlayout.addWidget( self.elementRessourceIdAndroidLine , 3, 3)
elementAndroidlayout.addWidget( QLabel( self.tr("Package Name:") ) , 4,1)
elementAndroidlayout.addWidget( self.elementPackageAndroidLine , 4, 3)
self.elemenAndroidGroup.setLayout(elementAndroidlayout)
self.elemenAndroidGroup.hide()
def createWidgetEndXY(self):
"""
Create widget
"""
self.endXyAndroidGroup = QGroupBox(self.tr(""))
endXyAndroidlayout = QGridLayout()
self.endxAndroidLine = QLineEdit(self)
validatorEndXAndroid = QIntValidator (self)
self.endxAndroidLine.setValidator(validatorEndXAndroid)
self.endxAndroidLine.installEventFilter(self)
self.endyAndroidLine = QLineEdit(self)
validatorEndYAndroid = QIntValidator (self)
self.endyAndroidLine.setValidator(validatorEndYAndroid)
self.endyAndroidLine.installEventFilter(self)
endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate X:") ) , 0, 0)
endXyAndroidlayout.addWidget( self.endxAndroidLine , 0, 1)
endXyAndroidlayout.addWidget( QLabel( self.tr("Destination Coordinate Y:") ) , 1,0)
endXyAndroidlayout.addWidget( self.endyAndroidLine , 1, 1)
self.endXyAndroidGroup.setLayout(endXyAndroidlayout)
self.endXyAndroidGroup.hide()
def createWidgetXY(self):
"""
Create text widget
"""
self.xyAndroidGroup = QGroupBox(self.tr(""))
xyAndroidlayout = QGridLayout()
self.xAndroidLine = QLineEdit(self)
validatorXAndroid = QIntValidator (self)
self.xAndroidLine.setValidator(validatorXAndroid)
self.xAndroidLine.installEventFilter(self)
self.yAndroidLine = QLineEdit(self)
validatorYAndroid = QIntValidator (self)
self.yAndroidLine.setValidator(validatorYAndroid)
self.yAndroidLine.installEventFilter(self)
xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate X:") ) , 0,0)
xyAndroidlayout.addWidget( self.xAndroidLine , 0, 1)
xyAndroidlayout.addWidget( QLabel( self.tr("Coordinate Y:") ) , 1,0)
xyAndroidlayout.addWidget( self.yAndroidLine , 1, 1)
self.xyAndroidGroup.setLayout(xyAndroidlayout)
self.xyAndroidGroup.hide()
def createWidgetStart(self):
"""
Create text widget
"""
self.startAndroidGroup = QGroupBox(self.tr(""))
startAndroidlayout = QGridLayout()
self.startXAndroidLine = QLineEdit(self)
validatorStartXAndroid = QIntValidator (self)
self.startXAndroidLine.setValidator(validatorStartXAndroid)
self.startXAndroidLine.installEventFilter(self)
self.startYAndroidLine = QLineEdit(self)
validatorStartYAndroid = QIntValidator (self)
self.startYAndroidLine.setValidator(validatorStartYAndroid)
self.startYAndroidLine.installEventFilter(self)
self.stopXAndroidLine = QLineEdit(self)
validatorStopXAndroid = QIntValidator (self)
self.stopXAndroidLine.setValidator(validatorStopXAndroid)
self.stopXAndroidLine.installEventFilter(self)
self.stopYAndroidLine = QLineEdit(self)
validatorStopYAndroid = QIntValidator (self)
self.stopYAndroidLine.setValidator(validatorStopYAndroid)
self.stopYAndroidLine.installEventFilter(self)
startAndroidlayout.addWidget( QLabel( self.tr("From X:") ) , 0,1)
startAndroidlayout.addWidget( self.startXAndroidLine , 0, 2)
startAndroidlayout.addWidget( QLabel( self.tr("From Y:") ) , 0,3)
startAndroidlayout.addWidget( self.startYAndroidLine , 0, 4)
startAndroidlayout.addWidget( QLabel( self.tr("To X:") ) ,1,1)
startAndroidlayout.addWidget( self.stopXAndroidLine , 1, 2)
startAndroidlayout.addWidget( QLabel( self.tr("To Y:") ) , 1,3)
startAndroidlayout.addWidget( self.stopYAndroidLine , 1 , 4)
self.startAndroidGroup.setLayout(startAndroidlayout)
self.startAndroidGroup.hide()
def createWidgetShortcut(self):
"""
Create shortcut widget
"""
self.shortcutAndroidGroup = QGroupBox(self.tr(""))
shortcutAndroidlayout = QGridLayout()
self.shortcutAndroidComboBox = QComboBox(self)
for i in xrange(len(KEYS_SHORTCUT_ANDROID)):
if len(KEYS_SHORTCUT_ANDROID[i]) == 0:
self.shortcutAndroidComboBox.insertSeparator(i + 2)
else:
self.shortcutAndroidComboBox.addItem (KEYS_SHORTCUT_ANDROID[i])
shortcutAndroidlayout.addWidget( QLabel( self.tr("Button:") ) , 0,1)
shortcutAndroidlayout.addWidget(self.shortcutAndroidComboBox, 0, 2)
self.shortcutAndroidGroup.setLayout(shortcutAndroidlayout)
self.shortcutAndroidGroup.hide()
def createWidgetCode(self):
"""
Create code widget
"""
self.codeAndroidGroup = QGroupBox(self.tr(""))
self.codeAndroidLine = QLineEdit(self)
validatorCodeAndroid = QIntValidator (self)
self.codeAndroidLine.setValidator(validatorCodeAndroid)
self.codeAndroidLine.installEventFilter(self)
codeAndroidlayout = QGridLayout()
codeAndroidlayout.addWidget( QLabel( self.tr("Code:") ) , 0,1)
codeAndroidlayout.addWidget( self.codeAndroidLine , 0, 2)
self.codeAndroidGroup.setLayout(codeAndroidlayout)
self.codeAndroidGroup.hide()
def pluginDataAccessor(self):
"""
Return data for plugin
"""
return { "data": "" }
def onPluginImport(self, dataJson):
"""
Received data from plugin
"""
pass
def createConnections(self):
"""
Create qt connections
"""
self.actionsAndroidComboBox.currentIndexChanged.connect(self.onActionAndroidChanged)
self.addAndroidAction.clicked.connect(self.addStep)
self.valueAndroidCombo2.currentIndexChanged.connect(self.onValueAndroid2TypeChanged)
self.elementTextCombo.currentIndexChanged.connect(self.onElementTextTypeChanged)
def onElementTextTypeChanged(self):
"""
On element text changed
"""
if self.elementTextCombo.currentText() in [ "TEXT", "CACHE" ]:
self.elementTextAndroidLine.setValidator(self.validatorAll)
if self.elementTextCombo.currentText() == "ALIAS":
self.elementTextAndroidLine.setText( self.elementTextAndroidLine.text().upper() )
self.elementTextAndroidLine.setValidator(self.validatorUpper)
def onValueAndroid2TypeChanged(self):
"""
On value changed
"""
if self.valueAndroidCombo2.currentText() in [ "TEXT", "CACHE" ]:
self.valueAndroidLine2.setValidator(self.validatorAll)
if self.valueAndroidCombo2.currentText() == "ALIAS":
self.valueAndroidLine2.setText( self.valueAndroidLine2.text().upper() )
self.valueAndroidLine2.setValidator(self.validatorUpper)
def addStep(self):
"""
Add step
"""
action = self.actionsAndroidComboBox.currentText()
descr = self.descriptionAndroidLine.text()
descr = unicode(descr).replace('"', '')
signal = self.AddStep
if self.cancelAndroidAction.isEnabled():
signal = self.UpdateStep
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_WAKUP, GuiSteps.ANDROID_UNLOCK, GuiSteps.ANDROID_REBOOT,
GuiSteps.ANDROID_SLEEP, GuiSteps.ANDROID_FREEZE_ROTATION, GuiSteps.ANDROID_UNFREEZE_ROTATION,
GuiSteps.ANDROID_BOOTLOADER, GuiSteps.ANDROID_RECOVERY, GuiSteps.ANDROID_NOTIFICATION,
GuiSteps.ANDROID_SETTINGS, GuiSteps.ANDROID_DEVICEINFO, GuiSteps.ANDROID_GET_LOGS,
GuiSteps.ANDROID_CLEAR_LOGS , GuiSteps.ANDROID_WAKEUP_UNLOCK, GuiSteps.ANDROID_LOCK,
GuiSteps.ANDROID_SLEEP_LOCK ]:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT]:
shorcut = self.shortcutAndroidComboBox.currentText()
signal.emit( str(action), unicode(descr), shorcut, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]:
code = self.codeAndroidLine.text()
if not len(code):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!")
else:
signal.emit( str(action), unicode(descr), code, {} )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT,
GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
textAndroid = self.elementTextAndroidLine.text()
descrAndroid = self.elementDescriptionAndroidLine.text()
classAndroid = self.elementClassAndroidLine.text()
ressourceAndroid = self.elementRessourceIdAndroidLine.text()
packageAndroid = self.elementPackageAndroidLine.text()
if not len(textAndroid) and not len(classAndroid) and not len(ressourceAndroid) and not len(packageAndroid) and not len(descrAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set one value!")
else:
# read text from cache or not ?
fromElCache = False
if self.elementTextCombo.currentText() == "CACHE": fromElCache = True
fromElAlias = False
if self.elementTextCombo.currentText() == "ALIAS": fromElAlias = True
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT:
newTextAndroid = self.valueAndroidLine2.text()
if not len(newTextAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a text value!")
else:
# read text from cache or not ?
fromCache = False
if self.valueAndroidCombo2.currentText() == "CACHE": fromCache = True
fromAlias = False
if self.valueAndroidCombo2.currentText() == "ALIAS": fromAlias = True
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid, 'new-text': newTextAndroid,
'from-cache': fromCache, 'from-alias': fromAlias,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT:
# read text from cache or not ?
cacheKey = ''
toCache = True
cacheKey = self.valueTextCacheGlobalLine.text()
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid, 'cache-key': cacheKey,
'to-cache': toCache, 'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT:
xAndroid = self.endxAndroidLine.text()
yAndroid = self.endyAndroidLine.text()
if not len(xAndroid) and not len(yAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias,
'x': xAndroid, 'y': yAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
parameters = {'text': textAndroid, 'class': classAndroid, 'ressource': ressourceAndroid,
'package': packageAndroid, 'description': descrAndroid,
'from-el-cache': fromElCache, 'from-el-alias': fromElAlias }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]:
xAndroid = self.xAndroidLine.text()
yAndroid = self.yAndroidLine.text()
if not len(xAndroid) and not len(yAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = { 'x': xAndroid, 'y': yAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT, GuiSteps.ANDROID_DRAG_POSITION,
GuiSteps.ANDROID_SWIPE_POSITION]:
startXAndroid = self.startXAndroidLine.text()
startYAndroid = self.startYAndroidLine.text()
stopXAndroid = self.stopXAndroidLine.text()
stopYAndroid = self.stopYAndroidLine.text()
if not len(startXAndroid) and not len(startYAndroid) and not len(stopXAndroid) and not len(stopYAndroid):
QMessageBox.warning(self, "Recording for Gui" , "Please to set values!")
else:
parameters = { 'start-x': startXAndroid, 'start-y': startYAndroid, 'stop-x': stopXAndroid, 'stop-y': stopYAndroid }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP,
GuiSteps.ANDROID_STOP_APP]:
miscStr = self.valueAndroidLine.text()
if not len(miscStr):
QMessageBox.warning(self, "Recording for Gui" , "Please to set a value!")
else:
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND:
parameters = { 'cmd': miscStr }
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]:
parameters = { 'pkg': miscStr }
else:
parameters = { 'sh': miscStr }
signal.emit( str(action), unicode(descr), EMPTY_VALUE, parameters )
else:
signal.emit( str(action), unicode(descr), EMPTY_VALUE, {} )
def cancelStep(self):
"""
Cancel step
"""
self.addAndroidAction.setText( "&Add" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(False)
self.CancelEdit.emit()
def finalizeUpdate(self):
"""
Finalize the update of a step
"""
self.addAndroidAction.setText( "&Add Action" )
buttonFont = QFont()
buttonFont.setBold(False)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(False)
def onActionAndroidChanged(self):
"""
On action changed
"""
descr = 'No description available!'
i = 0
for el in GuiSteps.ACTION_ANDROID_DESCR:
if isinstance(el, dict):
if self.actionsAndroidComboBox.currentText() in el:
descr = GuiSteps.ACTION_ANDROID_DESCR[i][self.actionsAndroidComboBox.currentText()]
break
i += 1
self.labelActionAndroidDescr.setText( "%s\n" % descr )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]:
self.shortcutAndroidGroup.show()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_KEYCODE ]:
self.codeAndroidGroup.show()
self.shortcutAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT, GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.show()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_GET_TEXT_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.show()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.show()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.show()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_COMMAND, GuiSteps.ANDROID_SHELL, GuiSteps.ANDROID_RESET_APP,
GuiSteps.ANDROID_STOP_APP ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.show()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
elif self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_TEXT_ELEMENT ]:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.show()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.show()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.show()
self.arrowLabel2.show()
else:
self.shortcutAndroidGroup.hide()
self.codeAndroidGroup.hide()
self.elemenAndroidGroup.hide()
self.startAndroidGroup.hide()
self.xyAndroidGroup.hide()
self.lineAndroidGroup.hide()
self.line2AndroidGroup.hide()
self.textToGlobalGroup.hide()
self.endXyAndroidGroup.hide()
self.arrowLabel.hide()
self.arrowLabel2.show()
def setTimeout(self, timeout):
"""
Set the timeout
"""
self.optionsDialog.timeoutAndroidLine.setText(timeout)
def getTimeout(self):
"""
Return the timeout
"""
return self.optionsDialog.timeoutAndroidLine.text()
def getAgentName(self):
"""
Get the agent name
"""
return self.optionsDialog.agentNameLineAndroid.text()
def getAgentList(self):
"""
Return the agent list
"""
return self.optionsDialog.agentsAndroidList
def editStep(self, stepData):
"""
Edit a step
"""
self.addAndroidAction.setText( "&Update" )
buttonFont = QFont()
buttonFont.setBold(True)
self.addAndroidAction.setFont(buttonFont)
self.cancelAndroidAction.setEnabled(True)
# set the current value for actions combo
for i in xrange(self.actionsAndroidComboBox.count()):
item_text = self.actionsAndroidComboBox.itemText(i)
if unicode(stepData["action"]) == unicode(item_text):
self.actionsAndroidComboBox.setCurrentIndex(i)
break
# and then refresh options
self.onActionAndroidChanged()
# finally fill all fields
self.descriptionAndroidLine.setText( stepData["description"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_COMMAND:
self.valueAndroidLine.setText( stepData["parameters"]["cmd"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_SHELL:
self.valueAndroidLine.setText( stepData["parameters"]["sh"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_RESET_APP, GuiSteps.ANDROID_STOP_APP ]:
self.valueAndroidLine.setText( stepData["parameters"]["pkg"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLEAR_ELEMENT, GuiSteps.ANDROID_TYPE_TEXT_ELEMENT,
GuiSteps.ANDROID_CLICK_ELEMENT, GuiSteps.ANDROID_LONG_CLICK_ELEMENT,
GuiSteps.ANDROID_EXIST_ELEMENT, GuiSteps.ANDROID_WAIT_ELEMENT,
GuiSteps.ANDROID_GET_TEXT_ELEMENT, GuiSteps.ANDROID_DRAG_ELEMENT,
GuiSteps.ANDROID_WAIT_CLICK_ELEMENT ]:
self.elementTextAndroidLine.setText( "" )
self.elementDescriptionAndroidLine.setText( "" )
self.elementClassAndroidLine.setText( "" )
self.elementRessourceIdAndroidLine.setText( "" )
self.elementPackageAndroidLine.setText( "" )
self.valueAndroidLine2.setText( "" )
if "text" in stepData["parameters"]:
if stepData["parameters"]["from-el-cache"]:
self.elementTextCombo.setCurrentIndex(INDEX_CACHE)
self.elementTextAndroidLine.setValidator(self.validatorAll)
elif stepData["parameters"]["from-el-alias"]:
self.elementTextCombo.setCurrentIndex(INDEX_ALIAS)
self.elementTextAndroidLine.setValidator(self.validatorUpper)
else:
self.elementTextCombo.setCurrentIndex(INDEX_TEXT)
self.elementTextAndroidLine.setValidator(self.validatorAll)
self.elementTextAndroidLine.setText ( stepData["parameters"]["text"] )
if "description" in stepData["parameters"]:
self.elementDescriptionAndroidLine.setText( stepData["parameters"]["description"] )
if "class" in stepData["parameters"]:
self.elementClassAndroidLine.setText( stepData["parameters"]["class"] )
if "ressource" in stepData["parameters"]:
self.elementRessourceIdAndroidLine.setText( stepData["parameters"]["ressource"] )
if "package" in stepData["parameters"]:
self.elementPackageAndroidLine.setText( stepData["parameters"]["package"] )
if "new-text" in stepData["parameters"]:
self.valueAndroidLine2.setText( stepData["parameters"]["new-text"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_DRAG_ELEMENT:
if "x" in stepData["parameters"]:
self.endxAndroidLine.setText( stepData["parameters"]["x"] )
if "y" in stepData["parameters"]:
self.endyAndroidLine.setText( stepData["parameters"]["y"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_TEXT_ELEMENT:
if stepData["parameters"]["from-cache"]:
self.valueAndroidCombo2.setCurrentIndex(INDEX_CACHE)
self.valueAndroidLine2.setValidator(self.validatorAll)
elif stepData["parameters"]["from-alias"]:
self.valueAndroidCombo2.setCurrentIndex(INDEX_ALIAS)
self.valueAndroidLine2.setValidator(self.validatorUpper)
else:
self.valueAndroidCombo2.setCurrentIndex(INDEX_TEXT)
self.valueAndroidLine2.setValidator(self.validatorAll)
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_GET_TEXT_ELEMENT:
self.valueTextCacheGlobalLine.setText ( stepData["parameters"]["cache-key"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_CLICK_POSITION]:
if "x" in stepData["parameters"]:
self.xAndroidLine.setText( stepData["parameters"]["x"] )
if "y" in stepData["parameters"]:
self.yAndroidLine.setText( stepData["parameters"]["y"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_DRAG_POSITION, GuiSteps.ANDROID_SWIPE_POSITION]:
if "start-x" in stepData["parameters"]:
self.startXAndroidLine.setText( stepData["parameters"]["start-x"] )
if "start-y" in stepData["parameters"]:
self.startYAndroidLine.setText( stepData["parameters"]["start-y"] )
if "stop-x" in stepData["parameters"]:
self.stopXAndroidLine.setText( stepData["parameters"]["stop-x"] )
if "stop-y" in stepData["parameters"]:
self.stopYAndroidLine.setText( stepData["parameters"]["stop-y"] )
if self.actionsAndroidComboBox.currentText() == GuiSteps.ANDROID_TYPE_KEYCODE:
self.codeAndroidLine.setText( stepData["misc"] )
if self.actionsAndroidComboBox.currentText() in [ GuiSteps.ANDROID_TYPE_SHORTCUT ]:
# set default
for i in xrange(self.shortcutAndroidComboBox.count()):
item_text = self.shortcutAndroidComboBox.itemText(i)
if unicode(stepData["misc"]) == unicode(item_text):
self.shortcutAndroidComboBox.setCurrentIndex(i)
break
class ParamSpinBox(QAbstractSpinBox):
def __init__(self, parent):
QAbstractSpinBox.__init__(self, parent)
self._minimum = 0.0
self._maximum = 1.0
self._default = 0.0
self._value = None
self._step = 0.0
self._step_small = 0.0
self._step_large = 0.0
self._read_only = False
self._scalepoints = None
self._have_scalepoints = False
self.bar = ParamProgressBar(self)
self.bar.setContextMenuPolicy(Qt.NoContextMenu)
self.bar.show()
self.lineEdit().setVisible(False)
self.connect(self.bar, SIGNAL("valueChangedFromBar(double)"), self.handleValueChangedFromBar)
self.connect(self, SIGNAL("customContextMenuRequested(QPoint)"), self.showCustomMenu)
QTimer.singleShot(0, self, SLOT("slot_updateBarGeometry()"))
def force_plastique_style(self):
self.setStyle(QPlastiqueStyle)
def set_minimum(self, value):
self._minimum = value
self.bar.set_minimum(value)
def set_maximum(self, value):
self._maximum = value
self.bar.set_maximum(value)
def set_default(self, value):
value = fix_value(value, self._minimum, self._maximum)
self._default = value
def set_value(self, value, send=True):
value = fix_value(value, self._minimum, self._maximum)
if self._value != value:
self._value = value
self.bar.set_value(value)
if self._have_scalepoints:
self.set_scalepoint_value(value)
if send:
self.emit(SIGNAL("valueChanged(double)"), value)
self.update()
return True
else:
return False
def set_step(self, value):
if value == 0.0:
self._step = 0.001
else:
self._step = value
def set_step_small(self, value):
if value == 0.0:
self._step_small = 0.0001
else:
self._step_small = value
def set_step_large(self, value):
if value == 0.0:
self._step_large = 0.1
else:
self._step_large = value
def set_label(self, label):
self.bar.set_label(label)
def set_text_call(self, textCall):
self.bar.set_text_call(textCall)
def set_read_only(self, yesno):
self.setButtonSymbols(QAbstractSpinBox.UpDownArrows if yesno else QAbstractSpinBox.NoButtons)
self._read_only = yesno
self.setReadOnly(yesno)
def set_scalepoints(self, scalepoints, use_scalepoints):
if len(scalepoints) > 0:
self._scalepoints = scalepoints
self._have_scalepoints = use_scalepoints
if use_scalepoints:
# Hide ProgressBar and create a ComboBox
self.bar.close()
self.box = QComboBox(self)
self.box.setContextMenuPolicy(Qt.NoContextMenu)
self.box.show()
self.slot_updateBarGeometry()
for scalepoint in scalepoints:
self.box.addItem("%f - %s" % (scalepoint['value'], scalepoint['label']))
if self._value != None:
self.set_scalepoint_value(self._value)
self.connect(self.box, SIGNAL("currentIndexChanged(QString)"), self.handleValueChangedFromBox)
else:
self._scalepoints = None
def set_scalepoint_value(self, value):
value = self.get_nearest_scalepoint(value)
for i in range(self.box.count()):
if float(self.box.itemText(i).split(" - ", 1)[0] == value):
self.box.setCurrentIndex(i)
break
def get_nearest_scalepoint(self, real_value):
final_value = 0.0
for i in range(len(self._scalepoints)):
scale_value = self._scalepoints[i]['value']
if i == 0:
final_value = scale_value
else:
srange1 = abs(real_value - scale_value)
srange2 = abs(real_value - final_value)
if srange2 > srange1:
final_value = scale_value
return final_value
def handleValueChangedFromBar(self, value):
if self._read_only:
return
step = int(0.5 + ((value - self._minimum) / self._step))
real_value = self._minimum + (step * self._step)
self.set_value(real_value)
def handleValueChangedFromBox(self, box_text):
if self._read_only:
return
value = float(box_text.split(" - ", 1)[0])
last_scale_value = self._scalepoints[len(self._scalepoints) - 1]['value']
if value == last_scale_value:
value = self._maximum
self.set_value(value)
def showCustomMenu(self, pos):
menu = QMenu(self)
act_x_reset = menu.addAction(self.tr("Reset (%f)" % self._default))
menu.addSeparator()
act_x_copy = menu.addAction(self.tr("Copy (%f)" % self._value))
if False and not self._read_only:
act_x_paste = menu.addAction(self.tr("Paste (%s)" % "TODO"))
else:
act_x_paste = menu.addAction(self.tr("Paste"))
act_x_paste.setEnabled(False)
menu.addSeparator()
act_x_set = menu.addAction(self.tr("Set value..."))
if self._read_only:
act_x_reset.setEnabled(False)
act_x_paste.setEnabled(False)
act_x_set.setEnabled(False)
# TODO - NOT IMPLEMENTED YET
act_x_copy.setEnabled(False)
act_x_sel = menu.exec_(QCursor.pos())
if act_x_sel == act_x_set:
dialog = CustomInputDialog(self, self.parent().label.text(), self._value, self._minimum, self._maximum, self._step, self._scalepoints)
if dialog.exec_():
value = dialog.ret_value
self.set_value(value)
elif act_x_sel == act_x_copy:
pass
elif act_x_sel == act_x_paste:
pass
elif act_x_sel == act_x_reset:
self.set_value(self._default)
def stepBy(self, steps):
if steps == 0 or self._value == None:
return
value = self._value + (steps * self._step)
if value < self._minimum:
value = self._minimum
elif value > self._maximum:
value = self._maximum
self.set_value(value)
def stepEnabled(self):
if self._read_only or self._value == None:
return QAbstractSpinBox.StepNone
elif self._value <= self._minimum:
return QAbstractSpinBox.StepUpEnabled
elif self._value >= self._maximum:
return QAbstractSpinBox.StepDownEnabled
else:
return QAbstractSpinBox.StepUpEnabled | QAbstractSpinBox.StepDownEnabled
def updateAll(self):
self.update()
self.bar.update()
if self._have_scalepoints:
self.box.update()
@pyqtSlot()
def slot_updateBarGeometry(self):
self.bar.setGeometry(self.lineEdit().geometry())
if self._have_scalepoints:
self.box.setGeometry(self.lineEdit().geometry())
def resizeEvent(self, event):
QTimer.singleShot(0, self, SLOT("slot_updateBarGeometry()"))
QAbstractSpinBox.resizeEvent(self, event)
class ImportJobsDialog(QDialog):
def __init__(self, jobs):
"""
Constructor
:param jobs: all the jobs available for import
"""
QDialog.__init__(self)
self.__jobs = jobs
self.setWindowTitle(
QCoreApplication.translate("VDLTools", "Choose job"))
self.resize(300, 100)
self.__layout = QGridLayout()
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
label = QLabel(QCoreApplication.translate("VDLTools", "Job : "))
label.setMinimumHeight(20)
label.setMinimumWidth(50)
self.__layout.addWidget(label, 0, 1)
self.__jobCombo = QComboBox()
self.__jobCombo.setMinimumHeight(20)
self.__jobCombo.setMinimumWidth(50)
self.__jobCombo.addItem("")
for job in self.__jobs:
self.__jobCombo.addItem(job)
self.__layout.addWidget(self.__jobCombo, 0, 2)
self.__jobCombo.currentIndexChanged.connect(self.__jobComboChanged)
self.setLayout(self.__layout)
def __jobComboChanged(self):
"""
When the selected job has changed
"""
if self.__pointCombo.itemText(0) == "":
self.__pointCombo.removeItem(0)
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def job(self):
"""
To get the selected job
:return: selected job
"""
index = self.__jobCombo.currentIndex()
if self.__jobCombo.itemText(index) == "":
return None
else:
return self.__jobs[index]
def addWidgets(self):
"""
Add widgets
"""
nbArgument = 0
layoutUsed = self.mainLayout
fontBold = QFont()
fontBold.setBold(True)
fontNormal = QFont()
fontNormal.setBold(False)
for i in xrange(len(self.actionData['data']['obj'])):
# prevent to limit the display of all arguments
# split all arguments in two tabulations if necessary
nbArgument += 1
if nbArgument > MAX_ARGUMENT_TO_DISPLAY:
layoutUsed = self.moreLayout # the second tab
self.mainTab.setTabEnabled(1, True)
if nbArgument > MAX_ARGUMENT_TO_DISPLAY2:
layoutUsed = self.more2Layout # the second tab
self.mainTab.setTabEnabled(2, True)
# extract the name of the function
varName = self.actionData['data']['obj'][i]['name']
#argNameLabel = QLabel( varName )
argNameLabel = QLabelEnhanced(
varName,
parent=self,
data=self.actionData['data']['obj'][i]['descr'])
argNameLabel.EnterLabel.connect(self.loadArgumentDescription)
argNameLabel.LeaveLabel.connect(self.clearArgumentDescription)
#argNameLabel.setToolTip(self.actionData['data']['obj'][i]['descr'])
layoutUsed.addWidget(argNameLabel, i, 0)
typeDetected = self.actionData['data']['obj'][i]['type'].split("/")
opDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'operators':
opDetected = True
break
if typeDetected[j].lower() == 'condition':
opDetected = True
break
labDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'label':
labDetected = True
break
constDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() in ['strconstant', 'intconstant']:
constDetected = True
break
dictDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'dict':
dictDetected = True
break
tplMDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'templatemessage':
tplMDetected = True
break
if tplMDetected:
typeDetected.pop(j)
tplLDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'templatelayer':
tplLDetected = True
break
if tplLDetected:
typeDetected.pop(j)
# exception for testcase parent in adapters or libraries
if self.actionData['data']['obj'][i]['type'] != "testcase":
if not self.adapterMode:
if dictDetected or tplMDetected or tplLDetected:
typeDetected.extend(['variables'])
else:
if not opDetected:
if not labDetected:
if not constDetected:
typeDetected.extend(
['inputs', 'outputs', 'variables'])
else:
if not constDetected:
typeDetected.extend(['inputs', 'outputs'])
# second exception for agent mode
if self.adapterMode and varName == "agent":
if "none" in typeDetected or "None" in typeDetected:
typeDetected = ['agents', "none"]
else:
typeDetected = ['agents']
# move none if exists on the list to the end
noneDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'none':
noneDetected = True
break
if noneDetected:
typeDetected.pop(j)
typeDetected.append("none")
# remove image type
imgDetected = False
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'image':
imgDetected = True
break
if imgDetected:
typeDetected.pop(j)
# remove string type if operators exists
strDetected = False
if opDetected:
for j in xrange(len(typeDetected)):
if typeDetected[j].lower() == 'string':
strDetected = True
break
if strDetected:
typeDetected.pop(j)
radioGroup = QButtonGroup(self)
shiftWidget = 1
deltaWidget = 0
radioSelected = shiftWidget
for j in xrange(len(typeDetected)):
#if typeDetected[j].lower() == "list":
# continue
radioButton = QRadioButton(typeDetected[j].lower())
radioButton.setFont(fontNormal)
radioGroup.addButton(radioButton)
layoutUsed.addWidget(radioButton, i,
j + shiftWidget + deltaWidget)
if typeDetected[j].lower() == "testcase":
pass
elif typeDetected[j].lower() == "none":
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
else:
if 'default-value' in self.actionData['data']['obj'][
i]:
if not len(
self.actionData['data']['obj'][i]
['selected-type']) and self.actionData['data'][
'obj'][i]['default-value'] == 'None':
radioSelected = j + shiftWidget + deltaWidget
elif typeDetected[j].lower() in [
"inputs", "outputs", "agents", "variables"
]:
paramCombo = QComboBox()
layoutUsed.addWidget(paramCombo, i,
j + shiftWidget + deltaWidget + 1)
if typeDetected[j].lower() == 'inputs':
for inpt in self.owner.getInputs():
paramCombo.addItem(inpt['name'])
if typeDetected[j].lower() == 'outputs':
for inpt in self.owner.getOutputs():
paramCombo.addItem(inpt['name'])
if typeDetected[j].lower() == 'agents':
for inpt in self.owner.getAgents():
paramCombo.addItem(inpt['name'])
if typeDetected[j].lower() == 'variables':
paramCombo.addItems(self.variables)
# set as default value or not ?
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
for x in xrange(paramCombo.count()):
if paramCombo.itemText(x) == self.actionData[
'data']['obj'][i]['value']:
paramCombo.setCurrentIndex(x)
deltaWidget += 1
elif typeDetected[j].lower() == "string":
textArea = QTextEdit()
textArea.setMinimumHeight(HEIGHT_TEXT_AREA)
textArea.setMinimumWidth(WIDTH_TEXT_AREA)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
try:
if sys.version_info > (3, ): # python 3 support
self.actionData['data']['obj'][i][
'value'] = self.actionData['data']['obj'][
i]['value']
else:
self.actionData['data']['obj'][i][
'value'] = self.actionData['data']['obj'][
i]['value'].decode('utf8')
textArea.setText(
self.actionData['data']['obj'][i]['value'])
except UnicodeDecodeError as e:
textArea.setText(
self.actionData['data']['obj'][i]['value'])
except UnicodeEncodeError as e:
textArea.setText(
self.actionData['data']['obj'][i]['value'])
else:
if 'none' not in self.actionData['data']['obj'][i][
'type'].lower():
if 'default-value' in self.actionData['data'][
'obj'][i]:
textArea.setText(self.actionData['data']['obj']
[i]['default-value'])
layoutUsed.addWidget(textArea, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() in ["integer", "float"]:
lineEdit = QLineEdit()
if typeDetected[j].lower() == "integer":
validator = QIntValidator(lineEdit)
else:
validator = QDoubleValidator(lineEdit)
validator.setNotation(
QDoubleValidator.StandardNotation)
lineEdit.setValidator(validator)
lineEdit.installEventFilter(self)
if self.actionData['data']['obj'][i]['selected-type'] in [
'integer', 'float'
]:
radioSelected = j + shiftWidget + deltaWidget
lineEdit.setText(
"%s" % self.actionData['data']['obj'][i]['value'])
else:
if 'default-value' in self.actionData['data']['obj'][
i]:
lineEdit.setText(
str(self.actionData['data']['obj'][i]
['default-value']))
layoutUsed.addWidget(lineEdit, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() in ["strconstant", "intconstant"]:
consCombo = QComboBox()
# extract values
tmpconstant = self.actionData['data']['obj'][i]['descr']
tmpvals = tmpconstant.split("|")
# extract all constant and detect the default
vals = []
defConstant = 0
defConstantVal = ''
for zz in xrange(len(tmpvals)):
if '(default)' in tmpvals[zz]:
nameConstant = tmpvals[zz].split(
'(default)')[0].strip()
vals.append(nameConstant)
defConstant = zz
defConstantVal = nameConstant
else:
vals.append(tmpvals[zz].strip())
# append all constant to the combobox
consCombo.addItems(vals)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
for x in xrange(len(vals)):
if vals[x] == str(self.actionData['data']['obj'][i]
['value']):
consCombo.setCurrentIndex(x)
else:
# set the current index for default value
consCombo.setCurrentIndex(defConstant)
layoutUsed.addWidget(consCombo, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "boolean":
boolCombo = QComboBox()
valBool = ["True", "False"]
boolCombo.addItems(valBool)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
for x in xrange(len(valBool)):
if valBool[x] == str(self.actionData['data']['obj']
[i]['value']):
boolCombo.setCurrentIndex(x)
else:
# set the default value
if 'default-value' in self.actionData['data']['obj'][
i]:
for x in xrange(len(valBool)):
if valBool[x] == str(
self.actionData['data']['obj'][i]
['default-value']):
boolCombo.setCurrentIndex(x)
layoutUsed.addWidget(boolCombo, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "dict":
dictWidget = DictWidget.DictWidget(
parent=self,
advancedMode=False,
testParams=self.testParams,
variables=self.variables)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
if not isinstance(
self.actionData['data']['obj'][i]['value'],
dict):
self.actionData['data']['obj'][i]['value'] = {
'dict': []
}
dictVal = self.actionData['data']['obj'][i]['value'][
'dict']
dictWidget.setCurrentDict(dictVal=dictVal)
layoutUsed.addWidget(dictWidget, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "dictadvanced":
dictWidget = DictWidget.DictWidget(
parent=self,
advancedMode=True,
testParams=self.testParams,
variables=self.variables)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
if not isinstance(
self.actionData['data']['obj'][i]['value'],
dict):
self.actionData['data']['obj'][i]['value'] = {
'dictadvanced': []
}
dictVal = self.actionData['data']['obj'][i]['value'][
'dictadvanced']
dictWidget.setCurrentDict(dictVal=dictVal)
layoutUsed.addWidget(dictWidget, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "operators":
opWidget = OperatorsWidget.OperatorsWidget(
self,
testParams=self.testParams,
variables=self.variables)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
opWidget.setCurrentOperator(
operatorVal=self.actionData['data']['obj'][i]
['value'])
layoutUsed.addWidget(opWidget, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "condition":
opWidget = OperatorsWidget.OperatorsWidget(
self,
testParams=self.testParams,
variables=self.variables,
liteMode=True)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
opWidget.setCurrentOperator(
operatorVal=self.actionData['data']['obj'][i]
['value'])
layoutUsed.addWidget(opWidget, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "templatelayer":
textArea = QLineEdit()
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
textArea.setText(
self.actionData['data']['obj'][i]['value'])
else:
if 'none' not in self.actionData['data']['obj'][i][
'type'].lower():
if 'default-value' in self.actionData['data'][
'obj'][i]:
textArea.setText(self.actionData['data']['obj']
[i]['default-value'])
layoutUsed.addWidget(textArea, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
elif typeDetected[j].lower() == "object":
textArea = QTextEdit()
textArea.setFixedHeight(HEIGHT_TEXT_AREA)
textArea.setMinimumWidth(WIDTH_TEXT_AREA)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
textArea.setText(
self.actionData['data']['obj'][i]['value'])
else:
# typeParam.setChecked(True) # fix bug
if 'none' not in self.actionData['data']['obj'][i][
'type'].lower():
if 'default-value' in self.actionData['data'][
'obj'][i]:
textArea.setText(self.actionData['data']['obj']
[i]['default-value'])
layoutUsed.addWidget(textArea, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
else:
textArea = QTextEdit()
textArea.setFixedHeight(HEIGHT_TEXT_AREA)
textArea.setMinimumWidth(WIDTH_TEXT_AREA)
if self.actionData['data']['obj'][i][
'selected-type'] == typeDetected[j].lower():
radioSelected = j + shiftWidget + deltaWidget
textArea.setText(
self.actionData['data']['obj'][i]['value'])
else:
if 'none' not in self.actionData['data']['obj'][i][
'type'].lower():
if 'default-value' in self.actionData['data'][
'obj'][i]:
textArea.setText(self.actionData['data']['obj']
[i]['default-value'])
layoutUsed.addWidget(textArea, i,
j + shiftWidget + deltaWidget + 1)
deltaWidget += 1
widgetRadio = layoutUsed.itemAtPosition(i, radioSelected).widget()
widgetRadio.setChecked(True)
widgetRadio.setFont(fontBold)
if nbArgument < MAX_ARGUMENT_TO_DISPLAY:
self.mainTab.setTabEnabled(1, False)
class SchemeSelector(QWidget):
currentChanged = pyqtSignal()
changed = pyqtSignal()
def __init__(self, parent=None):
super(SchemeSelector, self).__init__(parent)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.label = QLabel()
self.scheme = QComboBox()
self.menuButton = QPushButton(flat=True)
menu = QMenu(self.menuButton)
self.menuButton.setMenu(menu)
layout.addWidget(self.label)
layout.addWidget(self.scheme)
layout.addWidget(self.menuButton)
layout.addStretch(1)
# action generator
def act(slot, icon=None):
a = QAction(self, triggered=slot)
self.addAction(a)
icon and a.setIcon(icons.get(icon))
return a
# add action
a = self.addAction_ = act(self.slotAdd, 'list-add')
menu.addAction(a)
# remove action
a = self.removeAction = act(self.slotRemove, 'list-remove')
menu.addAction(a)
# rename action
a = self.renameAction = act(self.slotRename, 'document-edit')
menu.addAction(a)
menu.addSeparator()
# import action
a = self.importAction = act(self.slotImport, 'document-open')
menu.addAction(a)
# export action
a = self.exportAction = act(self.slotExport, 'document-save-as')
menu.addAction(a)
self.scheme.currentIndexChanged.connect(self.slotSchemeChanged)
app.translateUI(self)
def translateUI(self):
self.label.setText(_("Scheme:"))
self.menuButton.setText(_("&Menu"))
self.addAction_.setText(_("&Add..."))
self.removeAction.setText(_("&Remove"))
self.renameAction.setText(_("Re&name..."))
self.importAction.setText(_("&Import..."))
self.exportAction.setText(_("&Export..."))
def slotSchemeChanged(self, index):
"""Called when the Scheme combobox is changed by the user."""
self.disableDefault(self.scheme.itemData(index) == 'default')
self.currentChanged.emit()
self.changed.emit()
def disableDefault(self, val):
self.removeAction.setDisabled(val)
self.renameAction.setDisabled(val)
def schemes(self):
"""Returns the list with internal names of currently available schemes."""
return [self.scheme.itemData(i) for i in range(self.scheme.count())]
def currentScheme(self):
"""Returns the internal name of the currently selected scheme"""
return self.scheme.itemData(self.scheme.currentIndex())
def insertSchemeItem(self, name, scheme):
for i in range(1, self.scheme.count()):
n = self.scheme.itemText(i)
if n.lower() > name.lower():
self.scheme.insertItem(i, name, scheme)
break
else:
self.scheme.addItem(name, scheme)
def addScheme(self, name):
num, key = 1, 'user1'
while key in self.schemes() or key in self._schemesToRemove:
num += 1
key = 'user{0}'.format(num)
self.insertSchemeItem(name, key)
self.scheme.setCurrentIndex(self.scheme.findData(key))
return key
def slotAdd(self):
name, ok = QInputDialog.getText(self,
app.caption(_("Add Scheme")),
_("Please enter a name for the new scheme:"))
if ok:
self.addScheme(name)
def slotRemove(self):
index = self.scheme.currentIndex()
scheme = self.scheme.itemData(index)
if scheme == 'default':
return # default can not be removed
self._schemesToRemove.add(scheme)
self.scheme.removeItem(index)
def slotRename(self):
index = self.scheme.currentIndex()
name = self.scheme.itemText(index)
scheme = self.scheme.itemData(index)
newName, ok = QInputDialog.getText(self, _("Rename"), _("New name:"), text=name)
if ok:
self.scheme.blockSignals(True)
self.scheme.removeItem(index)
self.insertSchemeItem(newName, scheme)
self.scheme.setCurrentIndex(self.scheme.findData(scheme))
self.scheme.blockSignals(False)
self.changed.emit()
def slotImport(self):
filetypes = "{0} (*.xml);;{1} (*)".format(_("XML Files"), _("All Files"))
caption = app.caption(_("dialog title", "Import color theme"))
filename = QFileDialog.getOpenFileName(self, caption, os.environ['HOME'], filetypes)
if filename:
self.parent().import_(filename)
def slotExport(self):
name = self.scheme.currentText()
filetypes = "{0} (*.xml);;{1} (*)".format(_("XML Files"), _("All Files"))
caption = app.caption(_("dialog title",
"Export {name}").format(name=name))
path = os.path.join(os.environ['HOME'], name+'.xml')
filename = QFileDialog.getSaveFileName(self, caption, path, filetypes)
if filename:
if os.path.splitext(filename)[1] != '.xml':
filename += '.xml'
self.parent().export(name, filename)
def loadSettings(self, currentKey, namesGroup):
# dont mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default", type(""))
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
self.scheme.clear()
self.scheme.addItem(_("Default"), "default")
lst = [(s.value(key, key, type("")), key) for key in s.childKeys()]
for name, key in sorted(lst, key=lambda f: f[0].lower()):
self.scheme.addItem(name, key)
block = self.scheme.blockSignals(True)
# find out index
index = self.scheme.findData(cur)
self.disableDefault(cur == 'default')
self.scheme.setCurrentIndex(index)
self.scheme.blockSignals(block)
self.currentChanged.emit()
def saveSettings(self, currentKey, namesGroup, removePrefix=None):
# first save new scheme names
s = QSettings()
s.beginGroup(namesGroup)
for i in range(self.scheme.count()):
if self.scheme.itemData(i) != 'default':
s.setValue(self.scheme.itemData(i), self.scheme.itemText(i))
for scheme in self._schemesToRemove:
s.remove(scheme)
s.endGroup()
if removePrefix:
for scheme in self._schemesToRemove:
s.remove("{0}/{1}".format(removePrefix, scheme))
# then save current
scheme = self.currentScheme()
s.setValue(currentKey, scheme)
# clean up
self._schemesToRemove = set()
class ShowSettingsDialog(QDialog):
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer,
configTable):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param configTable: config table selected for import
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__configTable = configTable
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__tables = []
# dataSource = QgsDataSourceURI(self.__layer.source())
# db = DBConnector.setConnection(dataSource.database(), self.__iface)
# if db:
# query = db.exec_("""SELECT table_name FROM information_schema.tables WHERE table_schema NOT IN
# ('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN
# (SELECT f_table_name FROM geometry_columns)""")
# while query.next():
# self.__tables.append(query.value(0))
# db.close()
for layer in self.__iface.mapCanvas().layers():
if layer is not None \
and layer.type() == QgsMapLayer.VectorLayer \
and layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
self.resize(400, 200)
self.__layout = QGridLayout()
pointLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working points layer : "))
pointLabel.setMinimumHeight(20)
pointLabel.setMinimumWidth(50)
self.__layout.addWidget(pointLabel, 0, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__layout.addWidget(self.__pointCombo, 0, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(
self.__pointsLayers.index(self.__memoryPointsLayer) + 1)
lineLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working lines layer : "))
lineLabel.setMinimumHeight(20)
lineLabel.setMinimumWidth(50)
self.__layout.addWidget(lineLabel, 1, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__layout.addWidget(self.__lineCombo, 1, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(
self.__linesLayers.index(self.__memoryLinesLayer) + 1)
tableLabel = QLabel(
QCoreApplication.translate("VDLTools", "Config table : "))
tableLabel.setMinimumHeight(20)
tableLabel.setMinimumWidth(50)
self.__layout.addWidget(tableLabel, 2, 1)
self.__tableCombo = QComboBox()
self.__tableCombo.setMinimumHeight(20)
self.__tableCombo.setMinimumWidth(50)
self.__tableCombo.addItem("")
for table in self.__tables:
self.__tableCombo.addItem(table)
self.__layout.addWidget(self.__tableCombo, 2, 2)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
if self.__configTable is not None:
if self.__configTable in self.__tables:
self.__tableCombo.setCurrentIndex(
self.__tables.index(self.__configTable) + 1)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
self.setLayout(self.__layout)
def __lineComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__lineCombo.itemText(0) == "":
self.__lineCombo.removeItem(0)
def __pointComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__pointCombo.itemText(0) == "":
self.__pointCombo.removeItem(0)
def __tableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__tableCombo.itemText(0) == "":
self.__tableCombo.removeItem(0)
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def pointsLayer(self):
"""
To get the selected memory points layer
:return: selected memeory points layer, or none
"""
index = self.__pointCombo.currentIndex()
if self.__pointCombo.itemText(index) == "":
return None
else:
return self.__pointsLayers[index]
def linesLayer(self):
"""
To get the selected memory lines layer
:return: selected memory lines layer, or none
"""
index = self.__lineCombo.currentIndex()
if self.__lineCombo.itemText(index) == "":
return None
else:
return self.__linesLayers[index]
def configTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
index = self.__tableCombo.currentIndex()
if self.__tableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
class ShowSettingsDialog(QDialog):
"""
Dialog class for plugin settings
"""
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, ctllDb, configTable, uriDb, schemaDb, mntUrl,
refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer, pipeDiam, moreTools):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param configTable: config table selected for import
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__ctlDb = ctllDb
self.__configTable = configTable
self.__uriDb = uriDb
self.__schemaDb = schemaDb
self.__mntUrl = mntUrl
self.__refLayers = refLayers
self.__adjLayers = adjLayers
self.__levelAtt = levelAtt
self.__levelVal = levelVal
self.__drawdowmLayer = drawdowmLayer
self.__pipeDiam = pipeDiam
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__refAvailableLayers = []
self.__drawdownLayers = []
self.__tables = []
self.__schemas = []
self.__pipeDiamFields = []
self.__levelAttFields = []
self.__dbs = DBConnector.getUsedDatabases()
self.__refLabels = []
self.__refChecks = []
self.__adjChecks = []
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer is not None and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.LineStringZ:
self.__drawdownLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
self.__refAvailableLayers.append(layer)
# self.resize(450, 400)
self.__layout = QGridLayout()
line = 0
intersectLabel = QLabel(QCoreApplication.translate("VDLTools", "Intersect "))
self.__layout.addWidget(intersectLabel, line, 0)
line += 1
pointLabel = QLabel(QCoreApplication.translate("VDLTools", "Working points layer : "))
self.__layout.addWidget(pointLabel, line, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__layout.addWidget(self.__pointCombo, line, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(self.__pointsLayers.index(self.__memoryPointsLayer)+1)
line += 1
lineLabel = QLabel(QCoreApplication.translate("VDLTools", "Working lines layer : "))
self.__layout.addWidget(lineLabel, line, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__layout.addWidget(self.__lineCombo, line, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(self.__linesLayers.index(self.__memoryLinesLayer)+1)
line += 1
profilesLabel = QLabel(QCoreApplication.translate("VDLTools", "Profiles "))
self.__layout.addWidget(profilesLabel, line, 0)
line += 1
mntLabel = QLabel(QCoreApplication.translate("VDLTools", "Url for MNT : "))
self.__layout.addWidget(mntLabel, line, 1)
self.__mntText = QLineEdit()
if self.__mntUrl is None or self.__mntUrl == "None":
self.__mntText.insert('https://map.lausanne.ch/prod/wsgi/profile.json')
else:
self.__mntText.insert(self.__mntUrl)
self.__mntText.setMinimumHeight(20)
self.__mntText.setMinimumWidth(100)
self.__layout.addWidget(self.__mntText, line, 2)
line += 1
ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown "))
self.__layout.addWidget(ddLabel, line, 0)
line += 1
self.__layout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1)
namesLayout = QHBoxLayout()
namesWidget = QWidget()
namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Reference")))
namesLayout.addWidget(QLabel(QCoreApplication.translate("VDLTools", "Adjustable")))
namesLayout.setContentsMargins(0,0,0,0)
namesWidget.setLayout(namesLayout)
self.__layout.addWidget(namesWidget, line, 2)
line += 1
for layer in self.__refAvailableLayers:
refLabel = QLabel(" - " + layer.name())
self.__refLabels.append(refLabel)
self.__layout.addWidget(refLabel, line, 1)
checksLayout = QHBoxLayout()
checksLayout.setContentsMargins(0,0,0,0)
checksWidget = QWidget()
refCheck = QCheckBox()
self.__refChecks.append(refCheck)
refCheck.stateChanged.connect(self.__refBoxesChanged)
checksLayout.addWidget(refCheck)
adjCheck = QCheckBox()
self.__adjChecks.append(adjCheck)
checksLayout.addWidget(adjCheck)
checksWidget.setLayout(checksLayout)
self.__layout.addWidget(checksWidget, line, 2)
line += 1
levelAttLabel = QLabel(QCoreApplication.translate("VDLTools", "Code(s) on pipe : "))
self.__layout.addWidget(levelAttLabel, line, 1)
self.__levelAttCombo = QComboBox()
self.__levelAttCombo.setMinimumHeight(20)
self.__levelAttCombo.setMinimumWidth(50)
self.__levelAttCombo.addItem("")
self.__layout.addWidget(self.__levelAttCombo, line, 2)
self.__levelAttCombo.currentIndexChanged.connect(self.__levelAttComboChanged)
i = 0
for layer in self.__refAvailableLayers:
if layer in self.__refLayers:
self.__refChecks[i].setChecked(True)
if layer in self.__adjLayers:
self.__adjChecks[i].setChecked(True)
i += 1
line += 1
levelValLabel = QLabel(QCoreApplication.translate("VDLTools", "Point code attribute : "))
self.__layout.addWidget(levelValLabel, line, 1)
self.__levelValText = QLineEdit()
if self.__levelVal is not None and self.__levelVal != "None":
self.__levelValText.insert(self.__levelVal)
self.__levelValText.setMinimumHeight(20)
self.__levelValText.setMinimumWidth(100)
self.__layout.addWidget(self.__levelValText, line, 2)
line += 1
drawdownLabel = QLabel(QCoreApplication.translate("VDLTools", "drawdown layer : "))
self.__layout.addWidget(drawdownLabel, line, 1)
self.__drawdownCombo = QComboBox()
self.__drawdownCombo.setMinimumHeight(20)
self.__drawdownCombo.setMinimumWidth(50)
self.__drawdownCombo.addItem("")
for layer in self.__drawdownLayers:
self.__drawdownCombo.addItem(layer.name())
self.__layout.addWidget(self.__drawdownCombo, line, 2)
line += 1
pipeDiamLabel = QLabel(QCoreApplication.translate("VDLTools", "Pipe diameter attribute [cm] : "))
self.__layout.addWidget(pipeDiamLabel, line, 1)
self.__pipeDiamCombo = QComboBox()
self.__pipeDiamCombo.setMinimumHeight(20)
self.__pipeDiamCombo.setMinimumWidth(50)
self.__pipeDiamCombo.addItem("")
self.__layout.addWidget(self.__pipeDiamCombo, line, 2)
self.__drawdownCombo.currentIndexChanged.connect(self.__drawdownComboChanged)
self.__pipeDiamCombo.currentIndexChanged.connect(self.__pipeDiamComboChanged)
if self.__drawdowmLayer is not None:
if self.__drawdowmLayer in self.__drawdownLayers:
self.__drawdownCombo.setCurrentIndex(self.__drawdownLayers.index(self.__drawdowmLayer)+1)
if moreTools:
line += 1
importLabel = QLabel(QCoreApplication.translate("VDLTools", "Import "))
self.__layout.addWidget(importLabel, line, 0)
line += 1
dbLabel = QLabel(QCoreApplication.translate("VDLTools", "Import database : "))
self.__layout.addWidget(dbLabel, line, 1)
self.__dbCombo = QComboBox()
self.__dbCombo.setMinimumHeight(20)
self.__dbCombo.setMinimumWidth(50)
self.__dbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__dbCombo.addItem(db)
self.__layout.addWidget(self.__dbCombo, line, 2)
line += 1
schemaLabel = QLabel(QCoreApplication.translate("VDLTools", "Database schema : "))
self.__layout.addWidget(schemaLabel, line, 1)
self.__schemaCombo = QComboBox()
self.__schemaCombo.setMinimumHeight(20)
self.__schemaCombo.setMinimumWidth(50)
self.__schemaCombo.addItem("")
self.__layout.addWidget(self.__schemaCombo, line, 2)
line += 1
tableLabel = QLabel(QCoreApplication.translate("VDLTools", "Config table : "))
self.__layout.addWidget(tableLabel, line, 1)
self.__tableCombo = QComboBox()
self.__tableCombo.setMinimumHeight(20)
self.__tableCombo.setMinimumWidth(50)
self.__tableCombo.addItem("")
self.__layout.addWidget(self.__tableCombo, line, 2)
line += 1
controlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control "))
self.__layout.addWidget(controlLabel, line, 0)
line += 1
ctlLabel = QLabel(QCoreApplication.translate("VDLTools", "Control database : "))
self.__layout.addWidget(ctlLabel, line, 1)
self.__ctlCombo = QComboBox()
self.__ctlCombo.setMinimumHeight(20)
self.__ctlCombo.setMinimumWidth(50)
self.__ctlCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__ctlCombo.addItem(db)
self.__layout.addWidget(self.__ctlCombo, line, 2)
self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged)
self.__schemaCombo.currentIndexChanged.connect(self.__schemaComboChanged)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
self.__ctlCombo.currentIndexChanged.connect(self.__ctlComboChanged)
if self.__uriDb is not None:
if self.__uriDb.database() in list(self.__dbs.keys()):
self.__dbCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__uriDb.database()) + 1)
if self.__ctlDb is not None:
if self.__ctlDb.database() in list(self.__dbs.keys()):
self.__ctlCombo.setCurrentIndex(list(self.__dbs.keys()).index(self.__ctlDb.database()) + 1)
else:
self.__dbCombo = None
self.__schemaCombo = None
self.__tableCombo = None
self.__ctlCombo = None
self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
self.setLayout(self.__layout)
@staticmethod
def __resetCombo(combo):
"""
To reset a combo list
:param combo: concerned combo
"""
while combo.count() > 0:
combo.removeItem(combo.count()-1)
def __setSchemaCombo(self, uriDb):
"""
To fill the schema combo list
:param uriDb: selected database uri
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged, self.__schemaComboChanged)
self.__resetCombo(self.__schemaCombo)
self.__schemaCombo.addItem("")
self.__schemas = []
query = db.exec_("""SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN
('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN
(SELECT f_table_name FROM geometry_columns)""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0)
else:
while next(query):
self.__schemas.append(query.value(0))
db.close()
for schema in self.__schemas:
self.__schemaCombo.addItem(schema)
self.__schemaCombo.currentIndexChanged.connect(self.__schemaComboChanged)
if self.__schemaDb is not None:
if self.__schemaDb in self.__schemas:
self.__schemaCombo.setCurrentIndex(self.__schemas.index(self.__schemaDb) + 1)
def __setTableCombo(self, uriDb, schema):
"""
To fill the table combo list
:param uriDb: selected database uri
:param schema: selected database schema
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged, self.__tableComboChanged)
self.__resetCombo(self.__tableCombo)
self.__tableCombo.addItem("")
self.__tables = []
query = db.exec_("""SELECT table_name FROM information_schema.tables WHERE table_schema = '""" + schema +
"""' ORDER BY table_name""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(query.lastError().text(), level=QgsMessageBar.CRITICAL, duration=0)
else:
while next(query):
self.__tables.append(query.value(0))
db.close()
for table in self.__tables:
if self.__tableCombo.findText(table) == -1:
self.__tableCombo.addItem(table)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
if self.__configTable is not None:
if self.__configTable in self.__tables:
self.__tableCombo.setCurrentIndex(self.__tables.index(self.__configTable) + 1)
def __setPipeDiamCombo(self, drawdownLayer):
"""
To fill the pipe diameter combo list
:param drawdownLayer: choosen drawdown layer
"""
Signal.safelyDisconnect(self.__pipeDiamCombo.currentIndexChanged, self.__pipeDiamComboChanged)
self.__resetCombo(self.__pipeDiamCombo)
self.__pipeDiamCombo.addItem("")
fields = drawdownLayer.fields()
self.__pipeDiamFields = []
for field in fields:
self.__pipeDiamFields.append(field.name())
self.__pipeDiamCombo.addItem(field.name())
self.__pipeDiamCombo.currentIndexChanged.connect(self.__pipeDiamComboChanged)
if self.__pipeDiam is not None:
if self.__pipeDiam in self.__pipeDiamFields:
self.__pipeDiamCombo.setCurrentIndex(self.__pipeDiamFields.index(self.__pipeDiam) + 1)
def __setLevelAttCombo(self, refLayers):
"""
To fill the level attribute combo list
:param refLayers: choosen reference layers
"""
Signal.safelyDisconnect(self.__levelAttCombo.currentIndexChanged, self.__levelAttComboChanged)
self.__resetCombo(self.__levelAttCombo)
self.__levelAttCombo.addItem("")
self.__levelAttFields = []
num = 0
for layer in refLayers:
fields = layer.fields()
if num == 0:
for field in fields:
self.__levelAttFields.append(field.name())
num = 1
else:
names = []
for field in fields:
names.append(field.name())
news = []
for name in self.__levelAttFields:
if name in names:
news.append(name)
self.__levelAttFields = news
for name in self.__levelAttFields:
self.__levelAttCombo.addItem(name)
self.__levelAttCombo.currentIndexChanged.connect(self.__levelAttComboChanged)
if self.__levelAtt is not None:
if self.__levelAtt in self.__levelAttFields:
self.__levelAttCombo.setCurrentIndex(self.__levelAttFields.index(self.__levelAtt) + 1)
def __lineComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__lineCombo.itemText(0) == "":
self.__lineCombo.removeItem(0)
def __pointComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__pointCombo.itemText(0) == "":
self.__pointCombo.removeItem(0)
def __refBoxesChanged(self):
"""
To update level attribute combo when reference layers have changed
"""
if self.refLayers() is not None:
self.__setLevelAttCombo(self.refLayers())
def __drawdownComboChanged(self):
"""
To remove blank item when another one is selected
and update pipe diamete combo when drawdown layer has changed
"""
if self.__drawdownCombo.itemText(0) == "":
self.__drawdownCombo.removeItem(0)
if self.drawdownLayer() is not None:
self.__setPipeDiamCombo(self.drawdownLayer())
def __tableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__tableCombo.itemText(0) == "":
self.__tableCombo.removeItem(0)
def __dbComboChanged(self):
"""
When the selection in db combo has changed
"""
if self.__dbCombo.itemText(0) == "":
self.__dbCombo.removeItem(0)
if self.uriDb() is not None:
self.__setSchemaCombo(self.uriDb())
def __schemaComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__schemaCombo.itemText(0) == "":
self.__schemaCombo.removeItem(0)
if self.schemaDb() is not None:
self.__setTableCombo(self.uriDb(), self.schemaDb())
def __pipeDiamComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__pipeDiamCombo.itemText(0) == "":
self.__pipeDiamCombo.removeItem(0)
def __levelAttComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__levelAttCombo.itemText(0) == "":
self.__levelAttCombo.removeItem(0)
def __ctlComboChanged(self):
"""
When the selection in ctl combo has changed
"""
if self.__ctlCombo.itemText(0) == "":
self.__ctlCombo.removeItem(0)
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def pointsLayer(self):
"""
To get the selected memory points layer
:return: selected memory points layer, or none
"""
index = self.__pointCombo.currentIndex()
if self.__pointCombo.itemText(index) == "":
return None
else:
return self.__pointsLayers[index]
def linesLayer(self):
"""
To get the selected memory lines layer
:return: selected memory lines layer, or none
"""
index = self.__lineCombo.currentIndex()
if self.__lineCombo.itemText(index) == "":
return None
else:
return self.__linesLayers[index]
def refLayers(self):
"""
To get the selected reference layers
:return: selected reference layers, or none
"""
layers = []
i = 0
for check in self.__refChecks:
if check.isChecked():
layers.append(self.__refAvailableLayers[i])
i += 1
return layers
def adjLayers(self):
"""
To get the selected ajustable layers
:return: selected adjustable layers, or none
"""
layers = []
i = 0
for check in self.__adjChecks:
if check.isChecked():
layers.append(self.__refAvailableLayers[i])
i += 1
return layers
def levelAtt(self):
"""
To get the selected level attribute
:return: selected level attribute, or none
"""
if self.__levelAttCombo is None:
return None
index = self.__levelAttCombo.currentIndex()
if self.__levelAttCombo.itemText(index) == "":
return None
else:
return self.__levelAttFields[index]
def levelVal(self):
"""
To get the filled level value
:return: filled level value
"""
return self.__levelValText.text()
def drawdownLayer(self):
"""
To get the selected drawdown layer
:return: selected drawdown layer, or none
"""
index = self.__drawdownCombo.currentIndex()
if self.__drawdownCombo.itemText(index) == "":
return None
else:
return self.__drawdownLayers[index]
def pipeDiam(self):
"""
To get the selected pipe diameter
:return: selected pipe diameter, or none
"""
if self.__pipeDiamCombo is None:
return None
index = self.__pipeDiamCombo.currentIndex()
if self.__pipeDiamCombo.itemText(index) == "":
return None
else:
return self.__pipeDiamFields[index]
def configTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
if self.__tableCombo is None:
return None
index = self.__tableCombo.currentIndex()
if self.__tableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
def uriDb(self):
"""
To get selected import database uri
:return: import database uri
"""
if self.__dbCombo is None:
return None
index = self.__dbCombo.currentIndex()
if self.__dbCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
def schemaDb(self):
"""
To get selected import database schema
:return: import database schema
"""
if self.__schemaCombo is None:
return None
index = self.__schemaCombo.currentIndex()
if self.__schemaCombo.itemText(index) == "":
return None
else:
return self.__schemas[index]
def mntUrl(self):
"""
To get selected MN url
:return: MN url
"""
return self.__mntText.text()
def ctlDb(self):
"""
To get selected control database uri
:return: control database uri
"""
if self.__ctlCombo is None:
return None
index = self.__ctlCombo.currentIndex()
if self.__ctlCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
class RunsDialog(QtHelper.EnhancedQDialog):
"""
Runs several dialog
"""
RefreshRepository = pyqtSignal(str)
def __init__(self, dialogName, parent = None, iRepo=None, lRepo=None, rRepo=None):
"""
Constructor
"""
QtHelper.EnhancedQDialog.__init__(self, parent)
self.name = self.tr("Prepare a group of runs")
self.projectReady = False
self.iRepo = iRepo
self.lRepo = lRepo
self.rRepo = rRepo
self.createDialog()
self.createConnections()
def createDialog(self):
"""
Create qt dialog
"""
self.setWindowTitle( self.name )
mainLayout = QHBoxLayout()
layoutTests = QHBoxLayout()
layoutRepoTest = QVBoxLayout()
self.prjCombo = QComboBox(self)
self.prjCombo.setEnabled(False)
self.repoTests = QTreeWidget(self)
self.repoTests.setFrameShape(QFrame.NoFrame)
if USE_PYQT5:
self.repoTests.header().setSectionResizeMode(QHeaderView.Stretch)
else:
self.repoTests.header().setResizeMode(QHeaderView.Stretch)
self.repoTests.setHeaderHidden(True)
self.repoTests.setContextMenuPolicy(Qt.CustomContextMenu)
self.repoTests.setIndentation(10)
layoutRepoTest.addWidget(self.prjCombo)
layoutRepoTest.addWidget(self.repoTests)
self.testsList = QListWidget(self)
layoutTests.addLayout( layoutRepoTest )
layoutTests.addWidget( self.testsList )
mainLayout.addLayout( layoutTests )
buttonLayout = QVBoxLayout()
self.okButton = QPushButton(self.tr("Execute All"), self)
self.okButton.setEnabled(False)
self.cancelButton = QPushButton(self.tr("Cancel"), self)
self.upButton = QPushButton(self.tr("UP"), self)
self.upButton.setEnabled(False)
self.downButton = QPushButton(self.tr("DOWN"), self)
self.downButton.setEnabled(False)
self.clearButton = QPushButton(self.tr("Remove All"), self)
self.delButton = QPushButton(self.tr("Remove"), self)
self.delButton.setEnabled(False)
self.runSimultaneous = QCheckBox(self.tr("Simultaneous Run"))
self.schedImmed = QRadioButton(self.tr("Run Immediately"))
self.schedImmed.setChecked(True)
self.schedAt = QRadioButton(self.tr("Run At:"))
self.schedAtDateTimeEdit = QDateTimeEdit(QDateTime.currentDateTime())
self.schedAtDateTimeEdit.setEnabled(False)
buttonLayout.addWidget(self.okButton)
buttonLayout.addWidget(self.runSimultaneous)
buttonLayout.addWidget(self.schedImmed)
buttonLayout.addWidget(self.schedAt)
buttonLayout.addWidget(self.schedAtDateTimeEdit)
buttonLayout.addWidget( self.upButton )
buttonLayout.addWidget( self.downButton )
buttonLayout.addWidget( self.delButton )
buttonLayout.addWidget( self.clearButton )
buttonLayout.addWidget(self.cancelButton)
mainLayout.addLayout(buttonLayout)
self.setMinimumHeight(400)
self.setMinimumWidth(750)
self.setLayout(mainLayout)
def initProjects(self, projects=[], defaultProject=1):
"""
Initialize projects
"""
# init date and time
self.schedAtDateTimeEdit.setDateTime(QDateTime.currentDateTime())
self.projectReady = False
self.repoTests.clear()
self.prjCombo.clear()
self.testsList.clear()
self.prjCombo.setEnabled(True)
# insert data
pname = ''
for p in projects:
self.prjCombo.addItem ( p['name'] )
if defaultProject == p['project_id']:
pname = p['name']
for i in xrange(self.prjCombo.count()):
item_text = self.prjCombo.itemText(i)
if str(pname) == str(item_text):
self.prjCombo.setCurrentIndex(i)
self.projectReady = True
self.RefreshRepository.emit(pname)
def initializeTests(self, listing):
"""
Initialize tests
"""
self.repoTests.clear()
self.testRoot = self.rRepo.Item(repo = self.iRepo.remote(),
parent = self.repoTests, txt = "Root",
type = QTreeWidgetItem.UserType+10,
isRoot = True )
self.testRoot.setSelected(True)
self.createRepository(listing=listing, parent=self.testRoot,fileincluded=True)
self.repoTests.sortItems(0, Qt.AscendingOrder)
self.hideItems(hideTsx=False, hideTpx=False, hideTcx=True, hideTdx=True, hideTxt=True, hidePy=True,
hideTux=False, hidePng=True, hideTgx=False, hideTax=False)
def createRepository(self, listing, parent, fileincluded=True):
"""
Create repository
@param listing:
@type listing: list
@param parent:
@type parent:
@param fileincluded:
@type fileincluded: boolean
"""
try:
for dct in listing:
if dct["type"] == "folder":
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent,
txt = dct["name"], propertiesFile=dct )
self.createRepository( dct["content"] , item, fileincluded )
else:
if fileincluded:
if dct["type"] == "file":
pname = self.iRepo.remote().getProjectName(dct["project"])
# {'modification': 1342259500, 'type': 'file', 'name': '__init__.py', 'size': '562 }
item = self.rRepo.Item(repo = self.iRepo.remote(), parent = parent, txt = dct["name"] ,
propertiesFile=dct, type = QTreeWidgetItem.UserType+0,
projectId=dct["project"], projectName=pname )
except Exception as e:
self.error( "unable to create tree for runs: %s" % e )
def onProjectChanged(self, projectItem):
"""
Called when the project changed on the combo box
"""
if self.projectReady:
item_text = self.prjCombo.itemText(projectItem)
self.RefreshRepository.emit(item_text)
def createConnections (self):
"""
create qt connections
* ok
* cancel
"""
self.prjCombo.currentIndexChanged.connect(self.onProjectChanged)
self.okButton.clicked.connect( self.acceptClicked )
self.cancelButton.clicked.connect( self.reject )
self.upButton.clicked.connect(self.upTest)
self.downButton.clicked.connect(self.downTest)
self.clearButton.clicked.connect(self.clearList)
self.delButton.clicked.connect(self.delTest)
self.testsList.itemClicked.connect(self.onItemSelected)
self.testsList.itemSelectionChanged.connect(self.onItemSelectionChanged)
self.schedAt.toggled.connect(self.onSchedAtActivated)
self.repoTests.itemDoubleClicked.connect( self.onTestDoucleClicked )
def onSchedAtActivated(self, toggled):
"""
On sched at button activated
"""
if toggled:
self.schedAtDateTimeEdit.setEnabled(True)
else:
self.schedAtDateTimeEdit.setEnabled(False)
def onItemSelectionChanged(self):
"""
Called on item selection changed
"""
self.onItemSelected(itm=None)
def onItemSelected(self, itm):
"""
Call on item selected
"""
selectedItems = self.testsList.selectedItems()
if len(selectedItems):
self.delButton.setEnabled(True)
self.upButton.setEnabled(True)
self.downButton.setEnabled(True)
else:
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
if not self.testsList.count():
self.okButton.setEnabled(False)
def upTest(self):
"""
Up test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow - 1, currentItem)
def downTest(self):
"""
Down test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
self.testsList.insertItem(currentRow + 1, currentItem)
def delTest(self):
"""
Del test
"""
currentRow = self.testsList.currentRow()
currentItem = self.testsList.takeItem(currentRow)
def clearList(self):
"""
Clear test
"""
self.testsList.clear()
self.delButton.setEnabled(False)
self.upButton.setEnabled(False)
self.downButton.setEnabled(False)
self.okButton.setEnabled(False)
def iterateTree(self, item, hideTsx, hideTpx, hideTcx, hideTdx, hideTxt,
hidePy, hideTux, hidePng, hideTgx, hideTax):
"""
Iterate tree
"""
child_count = item.childCount()
for i in range(child_count):
subitem = item.child(i)
subchild_count = subitem.childCount()
if subchild_count > 0:
self.iterateTree(item=subitem, hideTsx=hideTsx,
hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt,
hidePy=hidePy, hideTux=hideTux,
hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
else:
if hideTux and subitem.getExtension() == self.rRepo.EXTENSION_TUX:
subitem.setHidden (True)
elif hideTpx and subitem.getExtension() == self.rRepo.EXTENSION_TPX:
subitem.setHidden (True)
elif hideTgx and subitem.getExtension() == self.rRepo.EXTENSION_TGX:
subitem.setHidden (True)
elif hideTcx and subitem.getExtension() == self.rRepo.EXTENSION_TCX:
subitem.setHidden (True)
elif hideTsx and subitem.getExtension() == self.rRepo.EXTENSION_TSX:
subitem.setHidden (True)
elif hideTdx and subitem.getExtension() == self.rRepo.EXTENSION_TDX:
subitem.setHidden (True)
elif hideTxt and subitem.getExtension() == self.rRepo.EXTENSION_TXT:
subitem.setHidden (True)
elif hidePy and subitem.getExtension() == self.rRepo.EXTENSION_PY:
subitem.setHidden (True)
elif hidePng and subitem.getExtension() == self.rRepo.EXTENSION_PNG:
subitem.setHidden (True)
elif hideTax and subitem.getExtension() == self.rRepo.EXTENSION_TAx:
subitem.setHidden (True)
else:
subitem.setHidden(False)
def hideItems(self, hideTsx=False, hideTpx=False, hideTcx=False, hideTdx=False, hideTxt=False, hidePy=False,
hideTux=False, hidePng=False, hideTgx=False, hideTax=False):
"""
Hide items
"""
root = self.repoTests.invisibleRootItem()
self.iterateTree(item=root, hideTsx=hideTsx, hideTpx=hideTpx, hideTcx=hideTcx,
hideTdx=hideTdx, hideTxt=hideTxt, hidePy=hidePy,
hideTux=hideTux, hidePng=hidePng, hideTgx=hideTgx, hideTax=hideTax)
def onTestDoucleClicked(self, testItem):
"""
On tests double clicked
"""
if testItem.type() != QTreeWidgetItem.UserType+0:
return
self.okButton.setEnabled(True)
currentProject = self.prjCombo.currentText()
testName = "%s:%s" % (str(currentProject),testItem.getPath(withFileName = True))
testItem = QListWidgetItem(testName )
if testName.endswith(self.rRepo.EXTENSION_TUX):
testItem.setIcon(QIcon(":/tux.png"))
if testName.endswith(self.rRepo.EXTENSION_TSX):
testItem.setIcon(QIcon(":/tsx.png"))
if testName.endswith(self.rRepo.EXTENSION_TPX):
testItem.setIcon(QIcon(":/tpx.png"))
if testName.endswith(self.rRepo.EXTENSION_TGX):
testItem.setIcon(QIcon(":/tgx.png"))
if testName.endswith(self.rRepo.EXTENSION_TAX):
testItem.setIcon(QIcon(":/tax.png"))
self.testsList.addItem( testItem )
def acceptClicked (self):
"""
Called on accept button
"""
self.accept()
def getTests(self):
"""
Returns all tests in the list
"""
tests = []
for i in xrange(self.testsList.count()):
testItem = self.testsList.item(i)
tests.append( str(testItem.text()) )
runSimultaneous = False
if self.runSimultaneous.isChecked(): runSimultaneous = True
if self.schedImmed.isChecked():
runAt = (0,0,0,0,0,0)
return (tests, False, runAt, runSimultaneous)
else:
pydt = self.schedAtDateTimeEdit.dateTime().toPyDateTime()
runAt = (pydt.year, pydt.month, pydt.day, pydt.hour, pydt.minute, pydt.second)
return (tests, True, runAt, runSimultaneous)
class ShowSettingsDialog(QDialog):
"""
Dialog class for plugin settings
"""
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer,
importConfigTable, importUriDb, importSchemaDb,
controlConfigTable, controlUriDb, controlSchemaDb, mntUrl,
refLayers, adjLayers, levelAtt, levelVal, drawdowmLayer,
pipeDiam, moreTools):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param importConfigTable: config table selected for import
:param importUriDb: database for import
:param importSchemaDb: db schema for import
:param controlConfigTable: config table selected for control
:param controlUriDb: database for control
:param controlSchemaDb: db schema for control
:param mntUrl: url to get mnt
:param refLayers: reference layers for drawdown
:param adjLayers: adjustement layers for drawdown
:param levelAtt: level attribute for drawdown
:param levelVal: level value for drawdown
:param drawdowmLayer: line layer for drawdown
:param pipeDiam: pipe diameter for drawdown
:param moreTools: if more tools or not
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__importConfigTable = importConfigTable
self.__importUriDb = importUriDb
self.__importSchemaDb = importSchemaDb
self.__controlConfigTable = controlConfigTable
self.__controlUriDb = controlUriDb
self.__controlSchemaDb = controlSchemaDb
self.__mntUrl = mntUrl
self.__refLayers = refLayers
self.__adjLayers = adjLayers
self.__levelAtt = levelAtt
self.__levelVal = levelVal
self.__drawdowmLayer = drawdowmLayer
self.__pipeDiam = pipeDiam
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__refAvailableLayers = []
self.__drawdownLayers = []
self.__tables = []
self.__schemas = []
self.__pipeDiamFields = []
self.__levelAttFields = []
self.__dbs = DBConnector.getUsedDatabases()
self.__refLabels = []
self.__refChecks = []
self.__adjChecks = []
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer is not None and layer.type() == QgsMapLayer.VectorLayer:
if layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
if QGis.fromOldWkbType(
layer.wkbType()) == QgsWKBTypes.LineStringZ:
self.__drawdownLayers.append(layer)
if QGis.fromOldWkbType(layer.wkbType()) == QgsWKBTypes.PointZ:
self.__refAvailableLayers.append(layer)
self.resize(600, 500)
self.__layout = QGridLayout()
self.__scrollLayout = QGridLayout()
line = 0
intersectLabel = QLabel(
QCoreApplication.translate("VDLTools", "Intersect "))
self.__scrollLayout.addWidget(intersectLabel, line, 0)
line += 1
pointLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working points layer : "))
self.__scrollLayout.addWidget(pointLabel, line, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__pointCombo, line, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(
self.__pointsLayers.index(self.__memoryPointsLayer) + 1)
line += 1
lineLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working lines layer : "))
self.__scrollLayout.addWidget(lineLabel, line, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__lineCombo, line, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(
self.__linesLayers.index(self.__memoryLinesLayer) + 1)
line += 1
profilesLabel = QLabel(
QCoreApplication.translate("VDLTools", "Profiles "))
self.__scrollLayout.addWidget(profilesLabel, line, 0)
line += 1
mntLabel = QLabel(
QCoreApplication.translate("VDLTools", "Url for MNT : "))
self.__scrollLayout.addWidget(mntLabel, line, 1)
self.__mntText = QLineEdit()
if self.__mntUrl is None or self.__mntUrl == "None":
self.__mntText.insert(
'https://map.lausanne.ch/prod/wsgi/profile.json')
else:
self.__mntText.insert(self.__mntUrl)
self.__mntText.setMinimumHeight(20)
self.__mntText.setMinimumWidth(100)
self.__scrollLayout.addWidget(self.__mntText, line, 2)
line += 1
ddLabel = QLabel(QCoreApplication.translate("VDLTools", "Drawdown "))
self.__scrollLayout.addWidget(ddLabel, line, 0)
line += 1
self.__scrollLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Layer")), line, 1)
namesLayout = QHBoxLayout()
namesWidget = QWidget()
namesLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Reference")))
namesLayout.addWidget(
QLabel(QCoreApplication.translate("VDLTools", "Adjustable")))
namesLayout.setContentsMargins(0, 0, 0, 0)
namesWidget.setLayout(namesLayout)
self.__scrollLayout.addWidget(namesWidget, line, 2)
line += 1
for layer in self.__refAvailableLayers:
refLabel = QLabel(" - " + layer.name())
self.__refLabels.append(refLabel)
self.__scrollLayout.addWidget(refLabel, line, 1)
checksLayout = QHBoxLayout()
checksLayout.setContentsMargins(0, 0, 0, 0)
checksWidget = QWidget()
refCheck = QCheckBox()
self.__refChecks.append(refCheck)
refCheck.stateChanged.connect(self.__refBoxesChanged)
checksLayout.addWidget(refCheck)
adjCheck = QCheckBox()
self.__adjChecks.append(adjCheck)
checksLayout.addWidget(adjCheck)
checksWidget.setLayout(checksLayout)
self.__scrollLayout.addWidget(checksWidget, line, 2)
line += 1
levelAttLabel = QLabel(
QCoreApplication.translate("VDLTools", "Code(s) on pipe : "))
self.__scrollLayout.addWidget(levelAttLabel, line, 1)
self.__levelAttCombo = QComboBox()
self.__levelAttCombo.setMinimumHeight(20)
self.__levelAttCombo.setMinimumWidth(50)
self.__levelAttCombo.addItem("")
self.__scrollLayout.addWidget(self.__levelAttCombo, line, 2)
self.__levelAttCombo.currentIndexChanged.connect(
self.__levelAttComboChanged)
i = 0
for layer in self.__refAvailableLayers:
if layer in self.__refLayers:
self.__refChecks[i].setChecked(True)
if layer in self.__adjLayers:
self.__adjChecks[i].setChecked(True)
i += 1
line += 1
levelValLabel = QLabel(
QCoreApplication.translate("VDLTools", "Point code attribute : "))
self.__scrollLayout.addWidget(levelValLabel, line, 1)
self.__levelValText = QLineEdit()
if self.__levelVal is not None and self.__levelVal != "None":
self.__levelValText.insert(self.__levelVal)
self.__levelValText.setMinimumHeight(20)
self.__levelValText.setMinimumWidth(100)
self.__scrollLayout.addWidget(self.__levelValText, line, 2)
line += 1
drawdownLabel = QLabel(
QCoreApplication.translate("VDLTools", "drawdown layer : "))
self.__scrollLayout.addWidget(drawdownLabel, line, 1)
self.__drawdownCombo = QComboBox()
self.__drawdownCombo.setMinimumHeight(20)
self.__drawdownCombo.setMinimumWidth(50)
self.__drawdownCombo.addItem("")
for layer in self.__drawdownLayers:
self.__drawdownCombo.addItem(layer.name())
self.__scrollLayout.addWidget(self.__drawdownCombo, line, 2)
line += 1
pipeDiamLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Pipe diameter attribute [cm] : "))
self.__scrollLayout.addWidget(pipeDiamLabel, line, 1)
self.__pipeDiamCombo = QComboBox()
self.__pipeDiamCombo.setMinimumHeight(20)
self.__pipeDiamCombo.setMinimumWidth(50)
self.__pipeDiamCombo.addItem("")
self.__scrollLayout.addWidget(self.__pipeDiamCombo, line, 2)
self.__drawdownCombo.currentIndexChanged.connect(
self.__drawdownComboChanged)
self.__pipeDiamCombo.currentIndexChanged.connect(
self.__pipeDiamComboChanged)
if self.__drawdowmLayer is not None:
if self.__drawdowmLayer in self.__drawdownLayers:
self.__drawdownCombo.setCurrentIndex(
self.__drawdownLayers.index(self.__drawdowmLayer) + 1)
line += 1
controlLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control "))
self.__scrollLayout.addWidget(controlLabel, line, 0)
line += 1
controlDbLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control database : "))
self.__scrollLayout.addWidget(controlDbLabel, line, 1)
self.__controlDbCombo = QComboBox()
self.__controlDbCombo.setMinimumHeight(20)
self.__controlDbCombo.setMinimumWidth(50)
self.__controlDbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__controlDbCombo.addItem(db)
self.__scrollLayout.addWidget(self.__controlDbCombo, line, 2)
line += 1
controlSchemaLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Control database schema : "))
self.__scrollLayout.addWidget(controlSchemaLabel, line, 1)
self.__controlSchemaCombo = QComboBox()
self.__controlSchemaCombo.setMinimumHeight(20)
self.__controlSchemaCombo.setMinimumWidth(50)
self.__controlSchemaCombo.addItem("")
self.__scrollLayout.addWidget(self.__controlSchemaCombo, line, 2)
line += 1
controlTableLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control config table : "))
self.__scrollLayout.addWidget(controlTableLabel, line, 1)
self.__controlTableCombo = QComboBox()
self.__controlTableCombo.setMinimumHeight(20)
self.__controlTableCombo.setMinimumWidth(50)
self.__controlTableCombo.addItem("")
self.__scrollLayout.addWidget(self.__controlTableCombo, line, 2)
self.__controlDbCombo.currentIndexChanged.connect(
self.__controlDbComboChanged)
self.__controlSchemaCombo.currentIndexChanged.connect(
self.__controlSchemaComboChanged)
self.__controlTableCombo.currentIndexChanged.connect(
self.__controlTableComboChanged)
if self.__controlUriDb is not None:
if self.__controlUriDb.database() in list(self.__dbs.keys()):
self.__controlDbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(
self.__controlUriDb.database()) + 1)
if moreTools:
line += 1
importLabel = QLabel(
QCoreApplication.translate("VDLTools", "Import "))
self.__scrollLayout.addWidget(importLabel, line, 0)
line += 1
importDbLabel = QLabel(
QCoreApplication.translate("VDLTools", "Import database : "))
self.__scrollLayout.addWidget(importDbLabel, line, 1)
self.__importDbCombo = QComboBox()
self.__importDbCombo.setMinimumHeight(20)
self.__importDbCombo.setMinimumWidth(50)
self.__importDbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__importDbCombo.addItem(db)
self.__scrollLayout.addWidget(self.__importDbCombo, line, 2)
line += 1
importSchemaLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Import database schema : "))
self.__scrollLayout.addWidget(importSchemaLabel, line, 1)
self.__importSchemaCombo = QComboBox()
self.__importSchemaCombo.setMinimumHeight(20)
self.__importSchemaCombo.setMinimumWidth(50)
self.__importSchemaCombo.addItem("")
self.__scrollLayout.addWidget(self.__importSchemaCombo, line, 2)
line += 1
importTableLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Import config table : "))
self.__scrollLayout.addWidget(importTableLabel, line, 1)
self.__importTableCombo = QComboBox()
self.__importTableCombo.setMinimumHeight(20)
self.__importTableCombo.setMinimumWidth(50)
self.__importTableCombo.addItem("")
self.__scrollLayout.addWidget(self.__importTableCombo, line, 2)
self.__importDbCombo.currentIndexChanged.connect(
self.__importDbComboChanged)
self.__importSchemaCombo.currentIndexChanged.connect(
self.__importSchemaComboChanged)
self.__importTableCombo.currentIndexChanged.connect(
self.__importTableComboChanged)
if self.__importUriDb is not None:
if self.__importUriDb.database() in list(self.__dbs.keys()):
self.__importDbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(
self.__importUriDb.database()) + 1)
else:
self.__importDbCombo = None
self.__importSchemaCombo = None
self.__importTableCombo = None
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 2)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 0)
self.__layout.addWidget(self.__cancelButton, 100, 1)
self.setLayout(self.__layout)
@staticmethod
def __resetCombo(combo):
"""
To reset a combo list
:param combo: concerned combo
"""
while combo.count() > 0:
combo.removeItem(combo.count() - 1)
def __setSchemaCombo(self, uriDb, schemaCombo, schemaComboChanged,
schemaDb):
"""
To fill the schema combo list
:param uriDb: selected database uri
:param schemaCombo: concerned schema combo
:param schemaComboChanged: concerned schema combo change event
:param schemaDb: selected schema db
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(schemaCombo.currentIndexChanged,
schemaComboChanged)
self.__resetCombo(schemaCombo)
schemaCombo.addItem("")
self.__schemas = []
query = db.exec_(
"""SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN
('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN
(SELECT f_table_name FROM geometry_columns)""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__schemas.append(query.value(0))
db.close()
for schema in self.__schemas:
schemaCombo.addItem(schema)
schemaCombo.currentIndexChanged.connect(schemaComboChanged)
if schemaDb is not None:
if schemaDb in self.__schemas:
schemaCombo.setCurrentIndex(
self.__schemas.index(schemaDb) + 1)
def __setTableCombo(self, uriDb, schema, tableCombo, tableComboChanged,
configTable):
"""
To fill the table combo list
:param uriDb: selected database uri
:param schema: selected database schema
:param tableCombo: concerned table combo
:param tableComboChanged: concerned table combo change event
:param configTable: selected config table
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(tableCombo.currentIndexChanged,
tableComboChanged)
self.__resetCombo(tableCombo)
tableCombo.addItem("")
self.__tables = []
query = db.exec_(
"""SELECT table_name FROM information_schema.tables WHERE table_schema = '"""
+ schema + """' ORDER BY table_name""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__tables.append(query.value(0))
db.close()
for table in self.__tables:
if tableCombo.findText(table) == -1:
tableCombo.addItem(table)
tableCombo.currentIndexChanged.connect(tableComboChanged)
if configTable is not None:
if configTable in self.__tables:
tableCombo.setCurrentIndex(
self.__tables.index(configTable) + 1)
def __setPipeDiamCombo(self, drawdownLayer):
"""
To fill the pipe diameter combo list
:param drawdownLayer: choosen drawdown layer
"""
Signal.safelyDisconnect(self.__pipeDiamCombo.currentIndexChanged,
self.__pipeDiamComboChanged)
self.__resetCombo(self.__pipeDiamCombo)
self.__pipeDiamCombo.addItem("")
fields = drawdownLayer.fields()
self.__pipeDiamFields = []
for field in fields:
self.__pipeDiamFields.append(field.name())
self.__pipeDiamCombo.addItem(field.name())
self.__pipeDiamCombo.currentIndexChanged.connect(
self.__pipeDiamComboChanged)
if self.__pipeDiam is not None:
if self.__pipeDiam in self.__pipeDiamFields:
self.__pipeDiamCombo.setCurrentIndex(
self.__pipeDiamFields.index(self.__pipeDiam) + 1)
def __setLevelAttCombo(self, refLayers):
"""
To fill the level attribute combo list
:param refLayers: choosen reference layers
"""
Signal.safelyDisconnect(self.__levelAttCombo.currentIndexChanged,
self.__levelAttComboChanged)
self.__resetCombo(self.__levelAttCombo)
self.__levelAttCombo.addItem("")
self.__levelAttFields = []
num = 0
for layer in refLayers:
fields = layer.fields()
if num == 0:
for field in fields:
self.__levelAttFields.append(field.name())
num = 1
else:
names = []
for field in fields:
names.append(field.name())
news = []
for name in self.__levelAttFields:
if name in names:
news.append(name)
self.__levelAttFields = news
for name in self.__levelAttFields:
self.__levelAttCombo.addItem(name)
self.__levelAttCombo.currentIndexChanged.connect(
self.__levelAttComboChanged)
if self.__levelAtt is not None:
if self.__levelAtt in self.__levelAttFields:
self.__levelAttCombo.setCurrentIndex(
self.__levelAttFields.index(self.__levelAtt) + 1)
def __lineComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__lineCombo.itemText(0) == "":
self.__lineCombo.removeItem(0)
def __pointComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__pointCombo.itemText(0) == "":
self.__pointCombo.removeItem(0)
def __refBoxesChanged(self):
"""
To update level attribute combo when reference layers have changed
"""
if self.refLayers() is not None:
self.__setLevelAttCombo(self.refLayers())
def __drawdownComboChanged(self):
"""
To remove blank item when another one is selected
and update pipe diamete combo when drawdown layer has changed
"""
if self.__drawdownCombo.itemText(0) == "":
self.__drawdownCombo.removeItem(0)
if self.drawdownLayer() is not None:
self.__setPipeDiamCombo(self.drawdownLayer())
def __controlTableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__controlTableCombo.itemText(0) == "":
self.__controlTableCombo.removeItem(0)
def __importTableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__importTableCombo.itemText(0) == "":
self.__importTableCombo.removeItem(0)
def __controlDbComboChanged(self):
"""
When the selection in db combo has changed
"""
if self.__controlDbCombo.itemText(0) == "":
self.__controlDbCombo.removeItem(0)
if self.controlUriDb() is not None:
self.__setSchemaCombo(self.controlUriDb(),
self.__controlSchemaCombo,
self.__controlSchemaComboChanged,
self.__controlSchemaDb)
def __importDbComboChanged(self):
"""
When the selection in db combo has changed
"""
if self.__importDbCombo.itemText(0) == "":
self.__importDbCombo.removeItem(0)
if self.importUriDb() is not None:
self.__setSchemaCombo(self.importUriDb(), self.__importSchemaCombo,
self.__importSchemaComboChanged,
self.__importSchemaDb)
def __controlSchemaComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__controlSchemaCombo.itemText(0) == "":
self.__controlSchemaCombo.removeItem(0)
if self.controlSchemaDb() is not None:
self.__setTableCombo(self.controlUriDb(), self.controlSchemaDb(),
self.__controlTableCombo,
self.__controlTableComboChanged,
self.__controlConfigTable)
def __importSchemaComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__importSchemaaCombo.itemText(0) == "":
self.__importSchemaCombo.removeItem(0)
if self.importSchemaDb() is not None:
self.__setTableCombo(self.importUriDb(), self.importSchemaDb(),
self.__importTableCombo,
self.__importTableComboChanged,
self.__importConfigTable)
def __pipeDiamComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__pipeDiamCombo.itemText(0) == "":
self.__pipeDiamCombo.removeItem(0)
def __levelAttComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__levelAttCombo.itemText(0) == "":
self.__levelAttCombo.removeItem(0)
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def pointsLayer(self):
"""
To get the selected memory points layer
:return: selected memory points layer, or none
"""
index = self.__pointCombo.currentIndex()
if self.__pointCombo.itemText(index) == "":
return None
else:
return self.__pointsLayers[index]
def linesLayer(self):
"""
To get the selected memory lines layer
:return: selected memory lines layer, or none
"""
index = self.__lineCombo.currentIndex()
if self.__lineCombo.itemText(index) == "":
return None
else:
return self.__linesLayers[index]
def refLayers(self):
"""
To get the selected reference layers
:return: selected reference layers, or none
"""
layers = []
i = 0
for check in self.__refChecks:
if check.isChecked():
layers.append(self.__refAvailableLayers[i])
i += 1
return layers
def adjLayers(self):
"""
To get the selected ajustable layers
:return: selected adjustable layers, or none
"""
layers = []
i = 0
for check in self.__adjChecks:
if check.isChecked():
layers.append(self.__refAvailableLayers[i])
i += 1
return layers
def levelAtt(self):
"""
To get the selected level attribute
:return: selected level attribute, or none
"""
if self.__levelAttCombo is None:
return None
index = self.__levelAttCombo.currentIndex()
if self.__levelAttCombo.itemText(index) == "":
return None
else:
return self.__levelAttFields[index]
def levelVal(self):
"""
To get the filled level value
:return: filled level value
"""
return self.__levelValText.text()
def drawdownLayer(self):
"""
To get the selected drawdown layer
:return: selected drawdown layer, or none
"""
index = self.__drawdownCombo.currentIndex()
if self.__drawdownCombo.itemText(index) == "":
return None
else:
return self.__drawdownLayers[index]
def pipeDiam(self):
"""
To get the selected pipe diameter
:return: selected pipe diameter, or none
"""
if self.__pipeDiamCombo is None:
return None
index = self.__pipeDiamCombo.currentIndex()
if self.__pipeDiamCombo.itemText(index) == "":
return None
else:
return self.__pipeDiamFields[index]
def controlConfigTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
if self.__controlTableCombo is None:
return None
index = self.__controlTableCombo.currentIndex()
if self.__controlTableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
def importConfigTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
if self.__importTableCombo is None:
return None
index = self.__importTableCombo.currentIndex()
if self.__importTableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
def controlUriDb(self):
"""
To get selected import database uri
:return: import database uri
"""
if self.__controlDbCombo is None:
return None
index = self.__controlDbCombo.currentIndex()
if self.__controlDbCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
def importUriDb(self):
"""
To get selected import database uri
:return: import database uri
"""
if self.__importDbCombo is None:
return None
index = self.__importDbCombo.currentIndex()
if self.__importDbCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
def controlSchemaDb(self):
"""
To get selected import database schema
:return: import database schema
"""
if self.__controlSchemaCombo is None:
return None
index = self.__controlSchemaCombo.currentIndex()
if self.__controlSchemaCombo.itemText(index) == "":
return None
else:
return self.__schemas[index]
def importSchemaDb(self):
"""
To get selected import database schema
:return: import database schema
"""
if self.__importSchemaCombo is None:
return None
index = self.__importSchemaCombo.currentIndex()
if self.__importSchemaCombo.itemText(index) == "":
return None
else:
return self.__schemas[index]
def mntUrl(self):
"""
To get selected MN url
:return: MN url
"""
return self.__mntText.text()
class AddWordWidget(QDialog):
def __init__(self, parent=None):
super(AddWordWidget, self).__init__(parent=parent)
self.setWindowTitle('Add word')
self.create_layout()
self.create_connections()
def create_layout(self):
hbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Dictionary"))
vbox.addWidget(QLabel("Original"))
vbox.addWidget(QLabel("Translation"))
vbox.addWidget(QLabel("Phoneme"))
vbox.addWidget(QLabel("Parts of Speech"))
vbox.addWidget(QLabel("Synonyms"))
vbox.addWidget(QLabel("Antonyms"))
hbox.addLayout(vbox)
vbox = QVBoxLayout()
self.dictionaries = Dictionary.objects.all()
self.dictionary = QComboBox()
self.dictionary.addItems([d.name for d in self.dictionaries])
vbox.addWidget(self.dictionary)
self.original = QLineEdit()
vbox.addWidget(self.original)
self.translation = QLineEdit()
vbox.addWidget(self.translation)
self.phoneme = QLineEdit()
vbox.addWidget(self.phoneme)
self.pos = QComboBox()
self.pos.addItems([p.strip() for p in
self.dictionaries[0].pos.split(',') if len(p) > 0])
vbox.addWidget(self.pos)
self.synonyms = QLineEdit()
vbox.addWidget(self.synonyms)
self.antonyms = QLineEdit()
vbox.addWidget(self.antonyms)
hbox.addLayout(vbox)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(QLabel("Description"))
self.description = QTextEdit()
vbox.addWidget(self.description)
self.add_button = QPushButton("&Add")
self.close_button = QPushButton("&Close")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.add_button)
hbox.addWidget(self.close_button)
vbox.addLayout(hbox)
self.status = QLabel('Add a new word to a dictionary.')
vbox.addWidget(self.status)
self.setLayout(vbox)
def create_connections(self):
self.connect(self.dictionary, SIGNAL("currentIndexChanged(int)"),
self.change_pos)
self.connect(self.close_button, SIGNAL("clicked()"), self.close)
self.connect(self.add_button, SIGNAL("clicked()"), self.add_word)
def change_pos(self, index):
current_dict = self.dictionaries[index]
self.pos.clear()
self.pos.addItems([p.strip() for p in
current_dict.pos.split(',') if len(p) > 0])
def get_texts(self):
current_dict = self.dictionaries[self.dictionary.currentIndex()].abbrev
original = unicode(self.original.text()).strip()
translation = unicode(self.translation.text()).strip()
phoneme = unicode(self.phoneme.text()).strip()
pos = unicode(self.pos.currentText()).strip()
synonyms = unicode(self.synonyms.text()).strip()
antonyms = unicode(self.antonyms.text()).strip()
description = unicode(self.description.toPlainText()).strip()
if not all([original, translation, pos]):
self.status.setText('There was an error inserting the word. Please'
' try again.')
QMessageBox.critical(self, "Error", "You must enter at least "
"'Original', 'Translation' and 'Parts of "
"Speech'.")
return None
return dict(dictionary=current_dict, original=original,
translation=translation, phoneme=phoneme, pos=pos,
synonyms=synonyms, antonyms=antonyms,
description=description)
def clear_texts(self):
self.translation.clear()
self.phoneme.clear()
self.synonyms.clear()
self.antonyms.clear()
self.description.clear()
self.original.setFocus()
def add_word(self):
self.status.clear()
texts = self.get_texts()
if not texts:
return
word = Word(**texts)
word.save()
self.clear_texts()
self.status.setText('Word %s has been added successfully.' %
word.original)
self.words_widget.load_words()
def save_word(self):
self.status.clear()
texts = self.get_texts()
if not texts:
return
word = self.word
word.dictionary = texts['dictionary']
word.original = texts['original']
word.translation = texts['translation']
word.phoneme = texts['phoneme']
word.pos = texts['pos']
word.synonyms = texts['synonyms']
word.antonyms = texts['antonyms']
word.description = texts['description']
word.save()
self.status.setText('Word %s has been saved successfully' %
word.original)
self.words_widget.load_words()
def get_word(self):
return self._word
def set_word(self, word):
self._word = word
self.setWindowTitle("Edit %s" % word.original)
self.add_button.setText("&Save")
self.disconnect(self.add_button, SIGNAL("clicked()"), self.add_word)
if word.exported:
self.add_button.setEnabled(False)
self.status.setText('This word has been exported already. '
'You cannot save the changes to it.')
else:
self.connect(self.add_button, SIGNAL("clicked()"), self.save_word)
self.status.setText('Edit this word and save to your dictionary.')
for i, d in enumerate(self.dictionaries):
if d.abbrev == word.dictionary:
self.dictionary.setCurrentIndex(i)
break
self.original.setText(word.original)
self.translation.setText(word. translation)
self.phoneme.setText(word.phoneme)
self.synonyms.setText(word.synonyms)
self.antonyms.setText(word.antonyms)
self.description.setText(word.description)
for i in range(self.pos.count()):
if self.pos.itemText(i) == word.pos:
self.pos.setCurrentIndex(i)
break
word = property(get_word, set_word)
def itemText(self, *args, **kwargs): return self.convert(QComboBox.itemText(self, *args, **kwargs))
class HydraulicsDialog(QDialog):
def __init__(self, parent, params, new_proj=False):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.new_proj = new_proj
self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
# Build dialog
self.setWindowTitle('Options - Hydraulics') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_units = QLabel('Units system:') # TODO: softocode
self.cbo_units = QComboBox()
fra_form_lay.addRow(self.lbl_units, self.cbo_units)
self.lbl_flow_units = QLabel('Flow units:') # TODO: softocode
self.cbo_flow_units = QComboBox()
fra_form_lay.addRow(self.lbl_flow_units, self.cbo_flow_units)
self.lbl_headloss = QLabel('Head loss:') # TODO: softocode
self.cbo_headloss = QComboBox()
fra_form_lay.addRow(self.lbl_headloss, self.cbo_headloss)
self.chk_hydraulics = QCheckBox('Hydraulics:') # TODO: softcode
self.cbo_hydraulics = QComboBox()
fra_form_lay.addRow(self.chk_hydraulics, self.cbo_hydraulics)
self.txt_hydraulics_file = QLineEdit()
fra_form_lay.addRow(None, self.txt_hydraulics_file)
self.btn_hydraulics_file = QPushButton('File...') # TODO: softcode
fra_form_lay.addRow(None, self.btn_hydraulics_file)
self.lbl_viscosity = QLabel('Viscosity:') # TODO: softocode
self.txt_viscosity = QLineEdit()
fra_form_lay.addRow(self.lbl_viscosity, self.txt_viscosity)
self.lbl_diffusivity = QLabel('Diffusivity:') # TODO: softocode
self.txt_diffusivity = QLineEdit()
fra_form_lay.addRow(self.lbl_diffusivity, self.txt_diffusivity)
self.lbl_spec_gravity = QLabel('Specific gravity:') # TODO: softocode
self.txt_spec_gravity = QLineEdit()
fra_form_lay.addRow(self.lbl_spec_gravity, self.txt_spec_gravity)
self.lbl_max_trials = QLabel('Max trials:') # TODO: softocode
self.txt_max_trials = QLineEdit()
fra_form_lay.addRow(self.lbl_max_trials, self.txt_max_trials)
self.lbl_accuracy = QLabel('Accuracy:') # TODO: softocode
self.txt_accuracy = QLineEdit()
fra_form_lay.addRow(self.lbl_accuracy, self.txt_accuracy)
self.lbl_unbalanced = QLabel('Unbalanced:') # TODO: softcode
self.fra_unbalanced = QFrame(self)
fra_unbalanced_lay = QHBoxLayout(self.fra_unbalanced)
fra_unbalanced_lay.setContentsMargins(0, 0, 0, 0)
self.cbo_unbalanced = QComboBox()
self.txt_unbalanced = QLineEdit()
fra_unbalanced_lay.addWidget(self.cbo_unbalanced)
fra_unbalanced_lay.addWidget(self.txt_unbalanced)
fra_form_lay.addRow(self.lbl_unbalanced, self.fra_unbalanced)
self.lbl_pattern = QLabel('Pattern:') # TODO: softocode
self.cbo_pattern = QComboBox()
fra_form_lay.addRow(self.lbl_pattern, self.cbo_pattern)
self.lbl_demand_mult = QLabel('Demand multiplier:') # TODO: softocode
self.txt_demand_mult = QLineEdit()
fra_form_lay.addRow(self.lbl_demand_mult, self.txt_demand_mult)
self.lbl_emitter_exp = QLabel('Emitter exponent:') # TODO: softocode
self.txt_emitter_exp = QLineEdit()
fra_form_lay.addRow(self.lbl_emitter_exp, self.txt_emitter_exp)
self.lbl_tolerance = QLabel('Tolerance:') # TODO: softocode
self.txt_tolerance = QLineEdit()
fra_form_lay.addRow(self.lbl_tolerance, self.txt_tolerance)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Cancel = QPushButton('Cancel')
self.btn_Ok = QPushButton('OK')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def setup(self):
# Fill units system combo box
for unit in self.params.options.units_sys:
self.cbo_units.addItem(self.params.options.units_sys_text[unit],
unit)
# Fill flow units combo box
for fu in Options.units_flow[self.params.options.units]:
self.cbo_flow_units.addItem(Options.units_flow_text[fu], fu)
self.cbo_units.activated.connect(self.cbo_units_activated)
# self.cbo_flow_units.activated.connect(self.cbo_flow_units_activated)
for key, value in self.params.options.headlosses_text.iteritems():
self.cbo_headloss.addItem(value, key)
self.cbo_headloss.activated.connect(self.cbo_headloss_activated)
self.chk_hydraulics.stateChanged.connect(self.chk_hydraulics_changed)
self.btn_hydraulics_file.clicked.connect(self.btn_hydraulics_clicked)
self.cbo_hydraulics.addItem(
self.params.options.hydraulics.action_names[
self.params.options.hydraulics.action_use],
self.params.options.hydraulics.action_use)
self.cbo_hydraulics.addItem(
self.params.options.hydraulics.action_names[
self.params.options.hydraulics.action_save],
self.params.options.hydraulics.action_save)
self.txt_hydraulics_file.setReadOnly(True)
# - Unbalanced
for id, text in self.params.options.unbalanced.unb_text.iteritems():
self.cbo_unbalanced.addItem(text, id)
self.cbo_unbalanced.activated.connect(self.cbo_unbalanced_changed)
self.txt_unbalanced.setValidator(RegExValidators.get_pos_int_no_zero())
self.txt_unbalanced.setText('1')
# - Pattern
self.cbo_pattern.addItem('None (=1.0)', None)
for pattern_id, pattern in self.params.patterns.iteritems():
self.cbo_pattern.addItem(pattern_id, pattern)
# Buttons
self.btn_Cancel.clicked.connect(self.btn_cancel_clicked)
self.btn_Ok.clicked.connect(self.btn_ok_clicked)
# Validators
self.txt_viscosity.setValidator(RegExValidators.get_pos_decimals())
self.txt_diffusivity.setValidator(RegExValidators.get_pos_decimals())
self.txt_spec_gravity.setValidator(RegExValidators.get_pos_decimals())
self.txt_max_trials.setValidator(RegExValidators.get_pos_int_no_zero())
self.txt_accuracy.setValidator(RegExValidators.get_pos_decimals())
self.txt_demand_mult.setValidator(RegExValidators.get_pos_decimals())
self.txt_emitter_exp.setValidator(RegExValidators.get_pos_decimals())
self.txt_tolerance.setValidator(RegExValidators.get_pos_decimals())
def show(self):
super(HydraulicsDialog, self).show()
self.cbo_units.setCurrentIndex(
self.cbo_units.findData(self.params.options.units))
self.cbo_flow_units.setCurrentIndex(
self.cbo_flow_units.findData(self.params.options.flow_units))
self.cbo_headloss.setCurrentIndex(
self.cbo_headloss.findData(self.params.options.headloss))
self.chk_hydraulics.setChecked(
self.params.options.hydraulics.use_hydraulics)
self.btn_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked())
self.cbo_hydraulics.setEnabled(self.chk_hydraulics.isChecked())
self.txt_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked())
if self.params.options.hydraulics.action is not None:
self.cbo_hydraulics.setCurrentIndex(
self.cbo_hydraulics.findData(
self.params.options.hydraulics.action))
if self.params.options.hydraulics.file is not None:
self.txt_hydraulics_file.setText(
self.params.options.hydraulics.file)
self.txt_viscosity.setText(str(self.params.options.viscosity))
self.txt_diffusivity.setText(str(self.params.options.diffusivity))
self.txt_spec_gravity.setText(str(self.params.options.spec_gravity))
self.txt_max_trials.setText(str(self.params.options.trials))
self.txt_accuracy.setText(str(self.params.options.accuracy))
self.cbo_unbalanced.setCurrentIndex(
self.cbo_unbalanced.findData(
self.params.options.unbalanced.unbalanced))
self.txt_unbalanced.setEnabled(self.cbo_unbalanced.currentIndex() != 0)
self.txt_unbalanced.setText(str(self.params.options.unbalanced.trials))
# Patterns
if self.params.options.pattern is not None:
if self.params.options.pattern is None:
self.cbo_pattern.setCurrentIndex(0)
else:
for i in range(self.cbo_pattern.count()):
if self.params.options.pattern.id == self.cbo_pattern.itemText(
i):
self.cbo_pattern.setCurrentIndex(i)
break
self.txt_demand_mult.setText(str(self.params.options.demand_mult))
self.txt_emitter_exp.setText(str(self.params.options.emitter_exp))
self.txt_tolerance.setText(str(self.params.options.tolerance))
def cbo_units_activated(self):
self.params.options.units = self.cbo_units.itemData(
self.cbo_units.currentIndex())
# Parameters combo box
self.cbo_flow_units.clear()
for fu in Options.units_flow[self.params.options.units]:
self.cbo_flow_units.addItem(Options.units_flow_text[fu], fu)
def cbo_headloss_activated(self):
# Warning
if not self.new_proj:
QMessageBox.warning(
self, Parameters.plug_in_name,
u'Head loss units changed: the head loss values already present might need to be reviewed.',
QMessageBox.Ok)
def chk_hydraulics_changed(self):
self.btn_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked())
self.cbo_hydraulics.setEnabled(self.chk_hydraulics.isChecked())
self.txt_hydraulics_file.setEnabled(self.chk_hydraulics.isChecked())
def btn_hydraulics_clicked(self):
file_dialog = QFileDialog(self, 'Select hydraulics file')
file_dialog.setLabelText(QFileDialog.Accept, 'Select')
file_dialog.setLabelText(QFileDialog.Reject, 'Cancel')
file_dialog.setFileMode(QFileDialog.AnyFile)
file_dialog.exec_()
hydraulics_file_path = file_dialog.selectedFiles()
if not hydraulics_file_path or hydraulics_file_path[
0] is None or hydraulics_file_path[0] == '':
return
self.txt_hydraulics_file.setText(hydraulics_file_path[0])
def cbo_unbalanced_changed(self):
self.txt_unbalanced.setEnabled(
self.cbo_unbalanced.itemData(self.cbo_unbalanced.currentIndex()) ==
self.params.options.unbalanced.unb_continue)
def btn_cancel_clicked(self):
self.setVisible(False)
def btn_ok_clicked(self):
if not self.check_params():
return
# Update parameters and options
self.params.options.units = self.cbo_units.itemData(
self.cbo_units.currentIndex())
self.params.options.flow_units = self.cbo_flow_units.itemData(
self.cbo_flow_units.currentIndex())
self.params.options.headloss = self.cbo_headloss.itemData(
self.cbo_headloss.currentIndex())
self.params.options.hydraulics.use_hydraulics = self.chk_hydraulics.isChecked(
)
if self.params.options.hydraulics.action is not None:
self.params.options.hydraulics.action = self.cbo_hydraulics.itemData(
self.cbo_hydraulics.currentIndex())
self.params.options.hydraulics.file = self.txt_hydraulics_file.text(
)
self.params.options.viscosity = float(self.txt_viscosity.text())
self.params.options.diffusivity = float(self.txt_diffusivity.text())
self.params.options.spec_gravity = float(self.txt_spec_gravity.text())
self.params.options.trials = float(self.txt_max_trials.text())
self.params.options.accuracy = float(self.txt_accuracy.text())
self.params.options.unbalanced.unbalanced = self.cbo_unbalanced.itemData(
self.cbo_unbalanced.currentIndex())
self.params.options.unbalanced.trials = int(self.txt_unbalanced.text())
self.params.options.pattern = self.cbo_pattern.itemData(
self.cbo_pattern.currentIndex())
self.params.options.demand_mult = float(self.txt_demand_mult.text())
self.params.options.emitter_exp = float(self.txt_emitter_exp.text())
self.params.options.tolerance = float(self.txt_tolerance.text())
# Junctions
self.parent.lbl_junction_demand.setText(
pre_l('Demand', Options.units_flow[self.params.options.units]
[0])) # TODO: softcode
self.parent.lbl_junction_deltaz.setText(
pre_l('Delta Z', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
# Reservoirs
self.parent.lbl_reservoir_deltaz.setText(
pre_l('Delta Z', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
self.parent.lbl_reservoir_pressure_head.setText(
pre_l('Pressure head', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
# Tanks
self.parent.lbl_tank_deltaz.setText(
pre_l('Delta Z', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
self.parent.lbl_tank_level_init.setText(
pre_l('Level init.', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
self.parent.lbl_tank_level_min.setText(
pre_l('Level min', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
self.parent.lbl_tank_level_max.setText(
pre_l('Level max', Options.units_deltaz[
self.params.options.units])) # TODO: softcode
self.parent.lbl_tank_diameter.setText(
pre_l('Diameter', Options.units_diameter_tanks[
self.params.options.units])) # TODO: softcode
self.parent.lbl_tank_vol_min.setText(
pre_l('Volume min', Options.units_volume[
self.params.options.units])) # TODO: softcode
# Pipes
self.parent.lbl_pipe_demand.setText(
pre_l('Demand', Options.units_flow[self.params.options.units]
[0])) # TODO: softcode
self.parent.lbl_pipe_diameter.setText(
pre_l('Diameter', Options.units_diameter_pipes[
self.params.options.units])) # TODO: softcode
self.parent.lbl_pipe_roughness_val.setText(
pre_l(
'Value', Options.units_roughness[self.params.options.units][
self.params.options.headloss])) # TODO: softcode
self.params.options.headloss_units = self.cbo_headloss.itemData(
self.cbo_headloss.currentIndex())
self.parent.update_roughness_params(
self.parent.cbo_pipe_roughness.itemData(
self.parent.cbo_pipe_roughness.currentIndex())[
self.params.options.headloss])
# self.parent.lbl_pipe_roughness.setText(
# pre_l(
# 'Roughness',
# self.params.options.units_roughness[self.params.options.units][self.params.options.headloss_units]))
# Pumps
self.parent.lbl_pump_head.setText(
pre_l('Head',
self.params.options.units_deltaz[self.params.options.units]))
self.parent.lbl_pump_power.setText(
pre_l('Power',
self.params.options.units_power[self.params.options.units]))
# Valves
valve_type = self.parent.cbo_valve_type.itemData(
self.parent.cbo_valve_type.currentIndex())
# Pressure valves
if valve_type == Valve.type_psv or valve_type == Valve.type_prv or valve_type == Valve.type_pbv:
self.parent.lbl_valve_setting.setText(
pre_l(
'Pressure', self.params.options.units_pressure[
self.params.options.units]))
# FCV valve: Flow
if valve_type == Valve.type_fcv:
self.parent.lbl_valve_setting.setText(
pre_l('Flow', self.params.options.flow_units))
# Throttle control valve
elif valve_type == Valve.type_tcv:
self.parent.lbl_valve_setting.setText(pre_l('Loss coeff.', '-'))
# self.parent.lbl_valve_diameter.setText(pre_l('Pressure', self.params.options.units_diameter_pipes[self.params.options.units]))
# Flow units
units = self.cbo_flow_units.itemData(
self.cbo_flow_units.currentIndex())
self.parent.lbl_junction_demand.setText(pre_l('Demand',
units)) # TODO: softcode
self.parent.lbl_pipe_demand.setText(pre_l('Demand',
units)) # TODO: softcode
self.setVisible(False)
def check_params(self):
if self.chk_hydraulics.isChecked():
if not os.path.isfile(self.txt_hydraulics_file.text()):
QMessageBox.warning(
self, Parameters.plug_in_name,
u'Hydraulics option slected, but no valid file specified.',
QMessageBox.Ok)
return False
return True
class ShowSettingsDialog(QDialog):
"""
Dialog class for plugin settings
"""
def __init__(self, iface, memoryPointsLayer, memoryLinesLayer, ctllDb,
configTable, uriDb, schemaDb, mntUrl):
"""
Constructor
:param iface: interface
:param memoryPointsLayer: working memory points layer
:param memoryLinesLayer: working memory lines layer
:param configTable: config table selected for import
"""
QDialog.__init__(self)
self.__iface = iface
self.__memoryPointsLayer = memoryPointsLayer
self.__memoryLinesLayer = memoryLinesLayer
self.__ctlDb = ctllDb
self.__configTable = configTable
self.__uriDb = uriDb
self.__schemaDb = schemaDb
self.__mntUrl = mntUrl
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Settings"))
self.__pointsLayers = []
self.__linesLayers = []
self.__tables = []
self.__schemas = []
self.__dbs = DBConnector.getUsedDatabases()
for layer in list(QgsMapLayerRegistry.instance().mapLayers().values()):
if layer is not None and layer.type(
) == QgsMapLayer.VectorLayer and layer.providerType() == "memory":
if layer.geometryType() == QGis.Point:
self.__pointsLayers.append(layer)
if layer.geometryType() == QGis.Line:
self.__linesLayers.append(layer)
self.resize(450, 200)
self.__layout = QGridLayout()
pointLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working points layer : "))
pointLabel.setMinimumHeight(20)
pointLabel.setMinimumWidth(50)
self.__layout.addWidget(pointLabel, 0, 1)
self.__pointCombo = QComboBox()
self.__pointCombo.setMinimumHeight(20)
self.__pointCombo.setMinimumWidth(50)
self.__pointCombo.addItem("")
for layer in self.__pointsLayers:
self.__pointCombo.addItem(layer.name())
self.__layout.addWidget(self.__pointCombo, 0, 2)
self.__pointCombo.currentIndexChanged.connect(self.__pointComboChanged)
if self.__memoryPointsLayer is not None:
if self.__memoryPointsLayer in self.__pointsLayers:
self.__pointCombo.setCurrentIndex(
self.__pointsLayers.index(self.__memoryPointsLayer) + 1)
lineLabel = QLabel(
QCoreApplication.translate("VDLTools", "Working lines layer : "))
lineLabel.setMinimumHeight(20)
lineLabel.setMinimumWidth(50)
self.__layout.addWidget(lineLabel, 1, 1)
self.__lineCombo = QComboBox()
self.__lineCombo.setMinimumHeight(20)
self.__lineCombo.setMinimumWidth(50)
self.__lineCombo.addItem("")
for layer in self.__linesLayers:
self.__lineCombo.addItem(layer.name())
self.__layout.addWidget(self.__lineCombo, 1, 2)
self.__lineCombo.currentIndexChanged.connect(self.__lineComboChanged)
if self.__memoryLinesLayer is not None:
if self.__memoryLinesLayer in self.__linesLayers:
self.__lineCombo.setCurrentIndex(
self.__linesLayers.index(self.__memoryLinesLayer) + 1)
dbLabel = QLabel(
QCoreApplication.translate("VDLTools", "Import database : "))
dbLabel.setMinimumHeight(20)
dbLabel.setMinimumWidth(50)
self.__layout.addWidget(dbLabel, 2, 1)
self.__dbCombo = QComboBox()
self.__dbCombo.setMinimumHeight(20)
self.__dbCombo.setMinimumWidth(50)
self.__dbCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__dbCombo.addItem(db)
self.__layout.addWidget(self.__dbCombo, 2, 2)
schemaLabel = QLabel(
QCoreApplication.translate("VDLTools", "Database schema : "))
schemaLabel.setMinimumHeight(20)
schemaLabel.setMinimumWidth(50)
self.__layout.addWidget(schemaLabel, 3, 1)
self.__schemaCombo = QComboBox()
self.__schemaCombo.setMinimumHeight(20)
self.__schemaCombo.setMinimumWidth(50)
self.__schemaCombo.addItem("")
self.__layout.addWidget(self.__schemaCombo, 3, 2)
tableLabel = QLabel(
QCoreApplication.translate("VDLTools", "Config table : "))
tableLabel.setMinimumHeight(20)
tableLabel.setMinimumWidth(50)
self.__layout.addWidget(tableLabel, 4, 1)
self.__tableCombo = QComboBox()
self.__tableCombo.setMinimumHeight(20)
self.__tableCombo.setMinimumWidth(50)
self.__tableCombo.addItem("")
self.__layout.addWidget(self.__tableCombo, 4, 2)
mntLabel = QLabel(
QCoreApplication.translate("VDLTools", "Url for MNT : "))
schemaLabel.setMinimumHeight(20)
schemaLabel.setMinimumWidth(50)
self.__layout.addWidget(mntLabel, 5, 1)
self.__mntText = QLineEdit()
if self.__mntUrl is None or self.__mntUrl == "None":
self.__mntText.insert(
'http://map.lausanne.ch/main/wsgi/profile.json')
else:
self.__mntText.insert(self.__mntUrl)
self.__mntText.setMinimumHeight(20)
self.__mntText.setMinimumWidth(100)
self.__layout.addWidget(self.__mntText, 5, 2)
ctlLabel = QLabel(
QCoreApplication.translate("VDLTools", "Control database : "))
ctlLabel.setMinimumHeight(20)
ctlLabel.setMinimumWidth(50)
self.__layout.addWidget(ctlLabel, 6, 1)
self.__ctlCombo = QComboBox()
self.__ctlCombo.setMinimumHeight(20)
self.__ctlCombo.setMinimumWidth(50)
self.__ctlCombo.addItem("")
for db in list(self.__dbs.keys()):
self.__ctlCombo.addItem(db)
self.__layout.addWidget(self.__ctlCombo, 6, 2)
self.__okButton = QPushButton(
QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 100, 1)
self.__layout.addWidget(self.__cancelButton, 100, 2)
self.setLayout(self.__layout)
self.__dbCombo.currentIndexChanged.connect(self.__dbComboChanged)
self.__schemaCombo.currentIndexChanged.connect(
self.__schemaComboChanged)
self.__tableCombo.currentIndexChanged.connect(self.__tableComboChanged)
self.__ctlCombo.currentIndexChanged.connect(self.__ctlComboChanged)
if self.__uriDb is not None:
if self.__uriDb.database() in list(self.__dbs.keys()):
self.__dbCombo.setCurrentIndex(
list(self.__dbs.keys()).index(self.__uriDb.database()) + 1)
if self.__ctlDb is not None:
if self.__ctlDb.database() in list(self.__dbs.keys()):
self.__ctlCombo.setCurrentIndex(
list(self.__dbs.keys()).index(self.__ctlDb.database()) + 1)
@staticmethod
def __resetCombo(combo):
"""
To reset a combo list
:param combo: concerned combo
"""
while combo.count() > 0:
combo.removeItem(combo.count() - 1)
def __setSchemaCombo(self, uriDb):
"""
To fill the schema combo list
:param uriDb: selected database uri
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__schemaCombo.currentIndexChanged,
self.__schemaComboChanged)
self.__resetCombo(self.__schemaCombo)
self.__schemaCombo.addItem("")
self.__schemas = []
query = db.exec_(
"""SELECT DISTINCT table_schema FROM information_schema.tables WHERE table_schema NOT IN
('pg_catalog', 'information_schema', 'topology') AND table_type = 'BASE TABLE' AND table_name NOT IN
(SELECT f_table_name FROM geometry_columns)""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__schemas.append(query.value(0))
db.close()
for schema in self.__schemas:
self.__schemaCombo.addItem(schema)
self.__schemaCombo.currentIndexChanged.connect(
self.__schemaComboChanged)
if self.__schemaDb is not None:
if self.__schemaDb in self.__schemas:
self.__schemaCombo.setCurrentIndex(
self.__schemas.index(self.__schemaDb) + 1)
def __setTableCombo(self, uriDb, schema):
"""
To fill the table combo list
:param uriDb: selected database uri
:param schema: selected database schema
"""
connector = DBConnector(uriDb, self.__iface)
db = connector.setConnection()
if db:
Signal.safelyDisconnect(self.__tableCombo.currentIndexChanged,
self.__tableComboChanged)
self.__resetCombo(self.__tableCombo)
self.__tableCombo.addItem("")
self.__tables = []
query = db.exec_(
"""SELECT table_name FROM information_schema.tables WHERE table_schema = '"""
+ schema + """' ORDER BY table_name""")
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
while next(query):
self.__tables.append(query.value(0))
db.close()
for table in self.__tables:
if self.__tableCombo.findText(table) == -1:
self.__tableCombo.addItem(table)
self.__tableCombo.currentIndexChanged.connect(
self.__tableComboChanged)
if self.__configTable is not None:
if self.__configTable in self.__tables:
self.__tableCombo.setCurrentIndex(
self.__tables.index(self.__configTable) + 1)
def __lineComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__lineCombo.itemText(0) == "":
self.__lineCombo.removeItem(0)
def __pointComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__pointCombo.itemText(0) == "":
self.__pointCombo.removeItem(0)
def __tableComboChanged(self):
"""
To remove blank item when another one is selected
"""
if self.__tableCombo.itemText(0) == "":
self.__tableCombo.removeItem(0)
def __dbComboChanged(self):
"""
When the selection in db combo has changed
"""
if self.__dbCombo.itemText(0) == "":
self.__dbCombo.removeItem(0)
if self.uriDb() is not None:
self.__setSchemaCombo(self.uriDb())
def __schemaComboChanged(self):
"""
When the selection in schema combo has changed
"""
if self.__schemaCombo.itemText(0) == "":
self.__schemaCombo.removeItem(0)
if self.schemaDb() is not None:
self.__setTableCombo(self.uriDb(), self.schemaDb())
def __ctlComboChanged(self):
"""
When the selection in ctl combo has changed
"""
if self.__ctlCombo.itemText(0) == "":
self.__ctlCombo.removeItem(0)
def okButton(self):
"""
To get the ok button instance
:return: ok button instance
"""
return self.__okButton
def cancelButton(self):
"""
To get the cancel button instance
:return: cancel button instance
"""
return self.__cancelButton
def pointsLayer(self):
"""
To get the selected memory points layer
:return: selected memeory points layer, or none
"""
index = self.__pointCombo.currentIndex()
if self.__pointCombo.itemText(index) == "":
return None
else:
return self.__pointsLayers[index]
def linesLayer(self):
"""
To get the selected memory lines layer
:return: selected memory lines layer, or none
"""
index = self.__lineCombo.currentIndex()
if self.__lineCombo.itemText(index) == "":
return None
else:
return self.__linesLayers[index]
def configTable(self):
"""
To get the selected config table
:return: selected config table, or none
"""
index = self.__tableCombo.currentIndex()
if self.__tableCombo.itemText(index) == "":
return None
else:
return self.__tables[index]
def uriDb(self):
"""
To get selected import database uri
:return: import database uri
"""
index = self.__dbCombo.currentIndex()
if self.__dbCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
def schemaDb(self):
"""
To get selected import database schema
:return: import database schema
"""
index = self.__schemaCombo.currentIndex()
if self.__schemaCombo.itemText(index) == "":
return None
else:
return self.__schemas[index]
def mntUrl(self):
"""
To get selected MN url
:return: MN url
"""
return self.__mntText.text()
def ctlDb(self):
"""
To get selected control database uri
:return: control database uri
"""
index = self.__ctlCombo.currentIndex()
if self.__ctlCombo.itemText(index) == "":
return None
else:
return self.__dbs[list(self.__dbs.keys())[index]]
class SettingsWindow(QWidget):
def __init__(self, context, parent=None):
"""
:type context: segyviewlib.SliceViewContext
:type parent: QObject
"""
QWidget.__init__(self, parent, Qt.WindowStaysOnTopHint | Qt.Window)
self.setVisible(False)
self._context = context
self._context.context_changed.connect(self._settings_changed)
self._context.data_changed.connect(self._settings_changed)
self._context.data_source_changed.connect(self._settings_changed)
f_layout = QFormLayout()
self._iline_count = QLabel("")
self._xline_count = QLabel("")
self._offset_count = QLabel("")
self._sample_count = QLabel("")
self._minimum_value = QLabel("")
self._maximum_value = QLabel("")
f_layout.addRow("Inline Count:", self._iline_count)
f_layout.addRow("Crossline Count:", self._xline_count)
f_layout.addRow("Offset Count:", self._offset_count)
f_layout.addRow("Sample Count:", self._sample_count)
f_layout.addRow("Minimum Value:", self._minimum_value)
f_layout.addRow("Maximum Value:", self._maximum_value)
# iline
self._il_ctrl = IndexController(
parent=self,
context=self._context,
slice_direction_index_source=SliceDirection.inline)
self._il_ctrl.index_changed.connect(
self._index_changed_fn(SliceDirection.inline))
self._il_ctrl.min_max_changed.connect(self.iline_limits_changed)
# xline
self._xl_ctrl = IndexController(
parent=self,
context=self._context,
slice_direction_index_source=SliceDirection.crossline)
self._xl_ctrl.index_changed.connect(
self._index_changed_fn(SliceDirection.crossline))
self._xl_ctrl.min_max_changed.connect(self.xline_limits_changed)
# depth
self._depth_ctrl = IndexController(
parent=self,
context=self._context,
slice_direction_index_source=SliceDirection.depth)
self._depth_ctrl.index_changed.connect(
self._index_changed_fn(SliceDirection.depth))
self._depth_ctrl.min_max_changed.connect(self.depth_limits_changed)
# sample
self._sample_ctrl = SampleScaleController(self)
self._sample_ctrl.min_max_changed.connect(self.sample_limits_changed)
self._symmetric_scale = QCheckBox()
self._symmetric_scale.toggled.connect(
self._context.set_symmetric_scale)
self._samples_unit = QComboBox()
self._samples_unit.addItems(['Time (ms)', 'Depth (m)'])
self._samples_unit.currentIndexChanged[str].connect(self.samples_unit)
# view
self._view_label = QLabel("")
self._view_label.setDisabled(True)
self._indicator_visibility = QCheckBox()
self._indicator_visibility.toggled.connect(
self._context.show_indicators)
self._indicator_visibility.toggled.connect(
lambda: self._set_view_label(self._indicator_visibility.isChecked(
)))
self._interpolation_combo = QComboBox()
self._interpolations_names = ['nearest', 'catrom', 'sinc']
self._interpolation_combo.addItems(self._interpolations_names)
self._interpolation_combo.currentIndexChanged.connect(
self._interpolation_changed)
# plot export settings
if self._context._has_data:
self._plt_settings_wdgt = PlotExportSettingsWidget(
self, parent._slice_view_widget, self._context)
# define tree layout
tree_def = {
"": [
{
"Inline": [{
"set_expanded": True
}, {
"":
self._align(self._il_ctrl.current_index_label)
}, {
"Inline:":
self._align(self._il_ctrl.index_widget)
}, {
"Minimum:":
self._align(self._il_ctrl.min_spinbox,
self._il_ctrl.min_checkbox)
}, {
"Maximum:":
self._align(self._il_ctrl.max_spinbox,
self._il_ctrl.max_checkbox)
}]
},
{
"Crossline": [{
"set_expanded": True
}, {
"":
self._align(self._xl_ctrl.current_index_label)
}, {
"Crossline:":
self._align(self._xl_ctrl.index_widget)
}, {
"Minimum:":
self._align(self._xl_ctrl.min_spinbox,
self._xl_ctrl.min_checkbox)
}, {
"Maximum:":
self._align(self._xl_ctrl.max_spinbox,
self._xl_ctrl.max_checkbox)
}]
},
{
"Depth": [{
"set_expanded": True
}, {
"":
self._align(self._depth_ctrl.current_index_label)
}, {
"Depth:":
self._align(self._depth_ctrl.index_widget)
}, {
"Minimum:":
self._align(self._depth_ctrl.min_spinbox,
self._depth_ctrl.min_checkbox)
}, {
"Maximum:":
self._align(self._depth_ctrl.max_spinbox,
self._depth_ctrl.max_checkbox)
}, {
"Type": self._align(self._samples_unit)
}]
},
{
"Sample": [{
"Custom min.:":
self._align(self._sample_ctrl.min_spinbox,
self._sample_ctrl.min_checkbox)
}, {
"Custom max.:":
self._align(self._sample_ctrl.max_spinbox,
self._sample_ctrl.max_checkbox)
}, {
"Symmetric scale:":
self._align(self._symmetric_scale)
}]
},
{
"View": [{
"": self._align(self._view_label)
}, {
"Show Indicators:":
self._align(self._indicator_visibility)
}, {
"Interpolation Type:":
self._align(self._interpolation_combo)
}]
},
]
}
if self._context._has_data:
tree_def[''].append({
"Plot export dimensions": [{
"":
self._align(self._plt_settings_wdgt.label)
}, {
"Fixed size":
self._align(self._plt_settings_wdgt.checkbox)
}, {
"Width:":
self._align(self._plt_settings_wdgt.width_spinbox)
}, {
"Height:":
self._align(self._plt_settings_wdgt.height_spinbox)
}, {
"Units:":
self._align(self._plt_settings_wdgt.units_combobox)
}]
})
# setup the menu/navigation tree widget
tre = QTreeWidget(self)
tre.setHeaderHidden(True)
tre.setColumnCount(2)
tre.setColumnWidth(0, 140)
tre.setColumnWidth(1, 180)
self._build_tree(tre, tree_def, tre.invisibleRootItem())
# layout
vertical_layout = QVBoxLayout()
button_layout = QHBoxLayout()
button_layout.setContentsMargins(0, 0, 0, 0)
close_button = QPushButton("Close")
close_button.clicked.connect(self.close)
button_layout.addStretch()
button_layout.addWidget(close_button)
vertical_layout.addLayout(f_layout, 0)
vertical_layout.addStretch()
vertical_layout.addWidget(tre, 1)
vertical_layout.addStretch()
vertical_layout.addLayout(button_layout, 0)
self.setLayout(vertical_layout)
self.setMinimumSize(390, 740)
@staticmethod
def _align(widget, checkbox=None):
l = QHBoxLayout()
if checkbox is not None:
checkbox.setMaximumWidth(23)
l.addWidget(checkbox, 0)
else:
l.addSpacing(25)
l.addStretch(0.5)
if widget is not None:
widget.setMinimumWidth(180)
widget.setMaximumWidth(180)
l.addWidget(widget)
else:
l.addSpacing(180)
l.setContentsMargins(0, 0, 0, 0)
l.addStretch(1)
w = QWidget()
w.setContentsMargins(0, 2, 0, 2)
w.setLayout(l)
return w
def samples_unit(self, val):
self._context.samples_unit = val
def _create_user_value(self):
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
def _build_tree(self, tree_wdgt, tree_def, root):
parent, children = tree_def.items()[0]
# empty label /parent is a special case: either inline with the previous, or skip
if parent == "":
if isinstance(children, QWidget):
item = root
tree_wdgt.setItemWidget(item, 1, children)
elif isinstance(children, list):
for c in children:
self._build_tree(tree_wdgt, c, root)
elif parent == "set_expanded": # a configuration item for the current root
root.setExpanded(children)
else:
item = QTreeWidgetItem(root)
item.setText(0, parent)
if isinstance(children, list):
for c in children:
self._build_tree(tree_wdgt, c, item)
else:
tree_wdgt.setItemWidget(item, 1, children)
def add_empty_row(self, layout, legend=""):
layout.addRow(legend, QLabel())
def _settings_changed(self):
ctx = self._context
self._indicator_visibility.setChecked(ctx.indicators)
index = self._interpolations_names.index(ctx.interpolation)
self._interpolation_combo.setCurrentIndex(index)
self._symmetric_scale.setChecked(ctx.symmetric_scale)
ilines, xlines, offsets, samples = ctx.slice_data_source().dims()
self._iline_count.setText("%d" % ilines)
self._xline_count.setText("%d" % xlines)
self._offset_count.setText("%d" % offsets)
self._sample_count.setText("%d" % samples)
if ctx._has_data:
self._minimum_value.setText("%f" % ctx.global_minimum)
self._maximum_value.setText("%f" % ctx.global_maximum)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.inline).tolist()
index = ctx.index_for_direction(SliceDirection.inline)
self._il_ctrl.update_view(indexes, index)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.crossline).tolist()
index = ctx.index_for_direction(SliceDirection.crossline)
self._xl_ctrl.update_view(indexes, index)
indexes = ctx.slice_data_source().indexes_for_direction(
SliceDirection.depth).tolist()
index = ctx.index_for_direction(SliceDirection.depth)
self._depth_ctrl.update_view(indexes, index)
index = self._samples_unit.findText(ctx.samples_unit)
if index != -1:
self._samples_unit.setCurrentIndex(index)
def _set_view_label(self, indicator_on):
self._view_label.setText(
"indicators {0}".format("on" if indicator_on else "off"))
def _interpolation_changed(self, index):
interpolation_name = str(self._interpolation_combo.itemText(index))
self._context.set_interpolation(interpolation_name)
def _index_changed_fn(self, direction):
def fn(value):
self._context.update_index_for_direction(direction, value)
return fn
def sample_limits_changed(self, values):
self._context.set_user_values(*values)
def depth_limits_changed(self, values):
min, max = values
self._context.set_y_view_limits(SliceDirection.crossline, min, max)
self._context.set_y_view_limits(SliceDirection.inline, min, max)
def iline_limits_changed(self, values):
min, max = values
self._context.set_x_view_limits(SliceDirection.crossline, min, max)
self._context.set_x_view_limits(SliceDirection.depth, min, max)
def xline_limits_changed(self, values):
min, max = values
self._context.set_x_view_limits(SliceDirection.inline, min, max)
self._context.set_y_view_limits(SliceDirection.depth, min, max)
class ComboBoxDelegate(QItemDelegate):
def __init__(self, parent, itemslist=["a", "b", "c"]):
QItemDelegate.__init__(self, parent)
# itemslist = ["a", "b", "c"]
self.itemslist = itemslist
self.parent = parent
# def paint(self, painter, option, index):
# # Get Item Data
# value = index.data(Qt.DisplayRole).toInt()[0]
# # value = self.itemslist[index.data(QtCore.Qt.DisplayRole).toInt()[0]]
# # fill style options with item data
# style = QApplication.style()
# opt = QStyleOptionComboBox()
# opt.currentText = str(self.itemslist[value])
# opt.rect = option.rect
# # draw item data as ComboBox
# style.drawComplexControl(QStyle.CC_ComboBox, opt, painter)
# self.parent.openPersistentEditor(index)
def createEditor(self, parent, option, index):
##get the "check" value of the row
# for row in range(self.parent.model.rowCount(self.parent)):
# print row
self.editor = QComboBox(parent)
self.editor.addItems(self.itemslist)
self.editor.setCurrentIndex(0)
self.editor.installEventFilter(self)
# self.connect(self.editor, SIGNAL("currentIndexChanged(int)"), self.editorChanged)
return self.editor
# def setEditorData(self, editor, index):
# value = index.data(QtCore.Qt.DisplayRole).toInt()[0]
# editor.setCurrentIndex(value)
def setEditorData(self, editor, index):
curtxt = index.data(Qt.DisplayRole)
# print(type(curtxt)== QPyNullVariant )
if type(curtxt) == type(1):
curindx = int(index.data(Qt.DisplayRole))
curtxt = self.itemslist[curindx]
elif type(curtxt)== QPyNullVariant:
curtxt = ""
pos = self.editor.findText(curtxt)
if pos == -1:
pos = 0
self.editor.setCurrentIndex(pos)
def setModelData(self,editor,model,index):
curindx = self.editor.currentIndex()
text = self.itemslist[curindx]
model.setData(index, text)
def updateEditorGeometry(self, editor, option, index):
self.editor.setGeometry(option.rect)
def editorChanged(self, index):
check = self.editor.itemText(index)
id_seq = self.parent.selectedIndexes[0][0]
update.updateCheckSeq(self.parent.db, id_seq, check)
