class KeywordConfigurationWidget(ConfigurationWidget):
def __init__(self):
ConfigurationWidget.__init__(self)
self.keyIndexCombo = QComboBox()
self.addRow("Key index:", self.keyIndexCombo)
self.connect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration)
def setKeyIndexList(self, list):
self.disconnect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration)
self.keyIndexCombo.clear()
self.keyIndexCombo.addItems(list)
self.connect(self.keyIndexCombo, SIGNAL("currentIndexChanged(QString)"), self.applyConfiguration)
def setParameter(self, parameter):
self.parameter = parameter
self.applyConfiguration(False)
def applyConfiguration(self, emit=True):
user_data = {"state": self.getState(), "key_index": self.getKeyIndex()}
self.parameter.setUserData(user_data)
self.emitConfigurationChanged(emit)
def getKeyIndex(self):
return str(self.keyIndexCombo.currentText())
class StartSession(preferences.Group):
def __init__(self, page):
super(StartSession, self).__init__(page)
grid = QGridLayout()
self.setLayout(grid)
def changed():
self.changed.emit()
self.combo.setEnabled(self.custom.isChecked())
self.none = QRadioButton(toggled=changed)
self.lastused = QRadioButton(toggled=changed)
self.custom = QRadioButton(toggled=changed)
self.combo = QComboBox(currentIndexChanged=changed)
grid.addWidget(self.none, 0, 0, 1, 2)
grid.addWidget(self.lastused, 1, 0, 1, 2)
grid.addWidget(self.custom, 2, 0, 1, 1)
grid.addWidget(self.combo, 2, 1, 1, 1)
app.translateUI(self)
def translateUI(self):
self.setTitle(
_("Session to load if Frescobaldi is started without arguments"))
self.none.setText(_("Start with no session"))
self.lastused.setText(_("Start with last used session"))
self.custom.setText(_("Start with session:"))
def loadSettings(self):
s = QSettings()
s.beginGroup("session")
startup = s.value("startup", "none", type(""))
if startup == "lastused":
self.lastused.setChecked(True)
elif startup == "custom":
self.custom.setChecked(True)
else:
self.none.setChecked(True)
sessionNames = sessions.sessionNames()
self.combo.clear()
self.combo.addItems(sessionNames)
custom = s.value("custom", "", type(""))
if custom in sessionNames:
self.combo.setCurrentIndex(sessionNames.index(custom))
def saveSettings(self):
s = QSettings()
s.beginGroup("session")
s.setValue("custom", self.combo.currentText())
if self.custom.isChecked():
startup = "custom"
elif self.lastused.isChecked():
startup = "lastused"
else:
startup = "none"
s.setValue("startup", startup)
class StartSession(preferences.Group):
def __init__(self, page):
super(StartSession, self).__init__(page)
grid = QGridLayout()
self.setLayout(grid)
def changed():
self.changed.emit()
self.combo.setEnabled(self.custom.isChecked())
self.none = QRadioButton(toggled=changed)
self.lastused = QRadioButton(toggled=changed)
self.custom = QRadioButton(toggled=changed)
self.combo = QComboBox(currentIndexChanged=changed)
grid.addWidget(self.none, 0, 0, 1, 2)
grid.addWidget(self.lastused, 1, 0, 1, 2)
grid.addWidget(self.custom, 2, 0, 1, 1)
grid.addWidget(self.combo, 2, 1, 1, 1)
app.translateUI(self)
def translateUI(self):
self.setTitle(_("Session to load if Frescobaldi is started without arguments"))
self.none.setText(_("Start with no session"))
self.lastused.setText(_("Start with last used session"))
self.custom.setText(_("Start with session:"))
def loadSettings(self):
s = QSettings()
s.beginGroup("session")
startup = s.value("startup", "none", type(""))
if startup == "lastused":
self.lastused.setChecked(True)
elif startup == "custom":
self.custom.setChecked(True)
else:
self.none.setChecked(True)
sessionNames = sessions.sessionNames()
self.combo.clear()
self.combo.addItems(sessionNames)
custom = s.value("custom", "", type(""))
if custom in sessionNames:
self.combo.setCurrentIndex(sessionNames.index(custom))
def saveSettings(self):
s = QSettings()
s.beginGroup("session")
s.setValue("custom", self.combo.currentText())
if self.custom.isChecked():
startup = "custom"
elif self.lastused.isChecked():
startup = "lastused"
else:
startup = "none"
s.setValue("startup", startup)
class DropDownRadioBooleanFilter(QWidget, Control):
"""Container for multiple boolean filters
"""
def __init__(self, tree, dataset, master, parent=None):
QWidget.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.setLayout(QHBoxLayout())
self.cb = QComboBox(self)
self.layout().addWidget(self.cb)
rblayout = QVBoxLayout()
self.radioButtons = [QRadioButton("Only", self),
QRadioButton("Excluded", self)
]
for b in self.radioButtons:
rblayout.addWidget(b)
self.radioButtons[0].setChecked(True)
self.layout().addLayout(rblayout)
self.options = []
self.setOptions(tree.subelements_top("Option"))
def setOptions(self, options):
self.cb.clear()
self.options = []
for option in options:
self.cb.addItem(option.displayName)
self.options.append(option)
for op, rb in zip(self.options[0].subelements_top("Option"),
self.radioButtons):
rb.setText(op.displayName)
rb.setChecked(getattr(op, "default", "false") == "true")
def value(self):
return {"excluded": "0" if self.radioButtons[0].isChecked() else "1"}
def query(self):
filter = self.options[self.cb.currentIndex()]
filter = biomart.FilterDescription(
self.tree.registry, "FilterDescription",
filter.attributes, filter.children)
return [("Filter", filter, self.value())]
def setControlValue(self, name, value):
for i, option in enumerate(self.options):
if option.internalName == name:
self.cb.setCurrentIndex(i)
if value == "Only":
self.radioButtons[0].setChecked(True)
class DropDownIdListFilter(QWidget, Control):
"""Container for multiple id list filters
"""
def __init__(self, tree, dataset, master, parent=None):
QWidget.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.setLayout(QVBoxLayout())
self.setContentsMargins(0, 0, 0, 0)
self.cb = QComboBox()
self.idsEdit = QPlainTextEdit()
self.layout().addWidget(self.cb)
self.layout().addWidget(self.idsEdit)
self.options = []
self.setOptions(tree.subelements_top("Option"))
def setOptions(self, options):
self.cb.clear()
self.options = []
for option in options:
self.cb.addItem(option.displayName)
self.options.append(option)
def value(self):
return str(self.idsEdit.toPlainText()).split()
def query(self):
filter = self.options[self.cb.currentIndex()]
filter = biomart.FilterDescription(
self.tree.registry, "FilterDescription",
filter.attributes, filter.children)
return [("Filter", filter, self.value())]
def setControlValue(self, name, value):
if isinstance(value, list):
value = "\n".join(value)
for i, op in enumerate(self.options):
if name == op.internalName:
self.cb.setCurrentIndex(i)
self.idsEdit.setPlainText(value)
class RecentPathsWComboMixin(RecentPathsWidgetMixin):
"""
Adds file combo handling to :obj:`RecentPathsWidgetMixin`.
The mixin constructs a combo box `self.file_combo` and provides a method
`set_file_list` for updating its content. The mixin also overloads the
inherited `add_path` and `select_file` to call `set_file_list`.
"""
def __init__(self):
super().__init__()
self.file_combo = \
QComboBox(self, sizeAdjustPolicy=QComboBox.AdjustToContents)
def add_path(self, filename):
"""Add (or move) a file name to the top of recent paths"""
super().add_path(filename)
self.set_file_list()
def select_file(self, n):
"""Move the n-th file to the top of the list"""
super().select_file(n)
self.set_file_list()
def set_file_list(self):
"""
Sets the items in the file list combo
"""
self._check_init()
self.file_combo.clear()
if not self.recent_paths:
self.file_combo.addItem("(none)")
self.file_combo.model().item(0).setEnabled(False)
else:
for i, recent in enumerate(self.recent_paths):
self.file_combo.addItem(recent.basename)
self.file_combo.model().item(i).setToolTip(recent.abspath)
def workflowEnvChanged(self, key, value, oldvalue):
super().workflowEnvChanged(key, value, oldvalue)
if key == "basedir":
self.set_file_list()
class RecentPathsWComboMixin(RecentPathsWidgetMixin):
"""
Adds file combo handling to :obj:`RecentPathsWidgetMixin`.
The mixin constructs a combo box `self.file_combo` and provides a method
`set_file_list` for updating its content. The mixin also overloads the
inherited `add_path` and `select_file` to call `set_file_list`.
"""
def __init__(self):
super().__init__()
self.file_combo = \
QComboBox(self, sizeAdjustPolicy=QComboBox.AdjustToContents)
def add_path(self, filename):
"""Add (or move) a file name to the top of recent paths"""
super().add_path(filename)
self.set_file_list()
def select_file(self, n):
"""Move the n-th file to the top of the list"""
super().select_file(n)
self.set_file_list()
def set_file_list(self):
"""
Sets the items in the file list combo
"""
self._check_init()
self.file_combo.clear()
if not self.recent_paths:
self.file_combo.addItem("(none)")
self.file_combo.model().item(0).setEnabled(False)
else:
for i, recent in enumerate(self.recent_paths):
self.file_combo.addItem(recent.basename)
self.file_combo.model().item(i).setToolTip(recent.abspath)
def workflowEnvChanged(self, key, value, oldvalue):
super().workflowEnvChanged(key, value, oldvalue)
if key == "basedir":
self.set_file_list()
class ConnectedComponentParamEditorWidget(QWidget):
def __init__(self, parent=None):
super(ConnectedComponentParamEditorWidget, self).__init__(parent)
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Scene : '))
self._sceneQCB = QComboBox(self)
self._sceneQCB.setMaxVisibleItems(5)
hbox.addWidget(self._sceneQCB)
self._sceneQCB.clear()
self.setLayout(hbox)
def initSceneQCB(self):
try:
self._sceneQCB.currentIndexChanged.disconnect(self.changeScene)
except TypeError:
pass
sceneOfCC = self._selectedConnectedComponent.scene()
self._sceneQCB.clear()
i = 0
for scene in self.parent().parent().scenes():
self._sceneQCB.addItem(scene.getName())
if scene == sceneOfCC:
self._sceneQCB.setCurrentIndex(i)
i += 1
self._sceneQCB.currentIndexChanged.connect(self.changeScene)
def setSelectedConnectedComponent(self, cc):
self._selectedConnectedComponent = cc
self.initSceneQCB()
def changeScene(self, sceneIndex):
self._sceneQCB.clear()
self._selectedConnectedComponent.scene().changeConnectedComponentSceneByIndex(
self._selectedConnectedComponent, sceneIndex)
class LayerSelectionPage(QFrame):
#TODO. Filtering, (visible) row selection, multi selection
colparams = ((0,65,'Name'), (1,235,'Title'), (2,350,'Keywords'))
XFER_BW = 40
def __init__(self, parent=None):
super(LayerSelectionPage, self).__init__(parent)
self.parent = parent
#convenience link
self.confconn_link = self.parent.parent.confconn
#flag top prevent read read action on keyword delete. New logic makes this redundant
#self.keywordbypass = False
QToolTip.setFont(QFont('SansSerif', 10))
#label
filterlabel = QLabel('Filter')
availablelabel = QLabel('Available Layers')
selectionlabel = QLabel('Layer Selections')
keywordlabel = QLabel('Keyword')
explainlabel = QLabel("Edit Group assignments using this dialog or to simply initialise the Layer-Config just click 'Finish'")
#selection buttons
chooseallbutton = QPushButton('>>')
chooseallbutton.setFixedWidth(self.XFER_BW)
chooseallbutton.clicked.connect(self.doChooseAllClickAction)
choosebutton = QPushButton('>')
choosebutton.setFixedWidth(self.XFER_BW)
choosebutton.clicked.connect(self.doChooseClickAction)
rejectbutton = QPushButton('<')
rejectbutton.setFixedWidth(self.XFER_BW)
rejectbutton.clicked.connect(self.doRejectClickAction)
rejectallbutton = QPushButton('<<')
rejectallbutton.setFixedWidth(self.XFER_BW)
rejectallbutton.clicked.connect(self.doRejectAllClickAction)
#operation buttons
finishbutton = QPushButton('Finish')
finishbutton.setToolTip('Finish and Close layer selection dialog')
finishbutton.clicked.connect(self.parent.close)
resetbutton = QPushButton('Reset')
resetbutton.font()
resetbutton.setToolTip('Read Layer from LDS GetCapabilities request. Overwrites current Layer Config')
resetbutton.clicked.connect(self.doResetClickAction)
self.available_sfpm = LDSSFPAvailableModel(self)
self.selection_sfpm = LDSSFPSelectionModel(self)
self.available_sfpm.setSourceModel(self.parent.available_model)
self.selection_sfpm.setSourceModel(self.parent.selection_model)
#textedits
filteredit = QLineEdit('')
filteredit.setToolTip('Filter Available-Layers pane (filter operates across Name and Title fields and accepts Regex expressions)')
filteredit.textChanged.connect(self.available_sfpm.setActiveFilter)
self.keywordcombo = QComboBox()
self.keywordcombo.setToolTip('Select or Add a unique identifier to be saved in layer config (keyword)')
self.keywordcombo.addItems(list(self.confconn_link.assigned))
self.keywordcombo.setEditable(True)
self.keywordcombo.activated.connect(self.doKeyComboChangeAction)
lgindex = self.confconn_link.getLayerGroupIndex(self.confconn_link.lgval,col=1)
lgentry = self.confconn_link.lglist[lgindex] if LU.assessNone(lgindex) else None
#keywordedit = self.keywordcombo.lineEdit().text().toUtf8().data().decode('utf8')# for writing
#if no entry or layer indicated then blank
self.keywordcombo.lineEdit().setText('' if lgentry is None or lgentry[0]==LORG.LAYER else lgentry[1])#self.confconn_link.lgval)#TODO. group only
#header
headmodel = QStandardItemModel()
headmodel.setHorizontalHeaderLabels([i[2] for i in self.colparams][:self.parent.available_model.columnCount()])
headview1 = QHeaderView(Qt.Horizontal)
headview1.setModel(headmodel)
headview1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
headview2 = QHeaderView(Qt.Horizontal)
headview2.setModel(headmodel)
headview2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
#table
self.available = QTableView()
self.available.setSelectionBehavior(QAbstractItemView.SelectRows)
self.available.setSelectionMode(QAbstractItemView.MultiSelection)
self.selection = QTableView()
self.selection.setSelectionBehavior(QAbstractItemView.SelectRows)
self.selection.setSelectionMode(QAbstractItemView.MultiSelection)
#interesting, must set model after selection attributes but before headers else row selections/headers don't work properly
self.available.setModel(self.available_sfpm)
self.selection.setModel(self.selection_sfpm)
self.available.setSortingEnabled(True)
self.available.setHorizontalHeader(headview1)
self.selection.setSortingEnabled(True)
self.selection.setHorizontalHeader(headview2)
for cp in self.colparams:
self.available.setColumnWidth(cp[0],cp[1])
self.selection.setColumnWidth(cp[0],cp[1])
self.available.verticalHeader().setVisible(False)
self.available.horizontalHeader().setVisible(True)
self.selection.verticalHeader().setVisible(False)
self.selection.horizontalHeader().setVisible(True)
#layout
vbox00 = QVBoxLayout()
vbox00.addWidget(availablelabel)
vbox00.addWidget(self.available)
vbox01 = QVBoxLayout()
vbox01.addWidget(chooseallbutton)
vbox01.addWidget(choosebutton)
vbox01.addWidget(rejectbutton)
vbox01.addWidget(rejectallbutton)
vbox02 = QVBoxLayout()
vbox02.addWidget(selectionlabel)
vbox02.addWidget(self.selection)
vbox10 = QVBoxLayout()
vbox10.addWidget(filterlabel)
vbox10.addWidget(filteredit)
hbox12 = QHBoxLayout()
hbox12.addWidget(keywordlabel)
hbox12.addStretch(1)
#hbox12.addWidget(inspbutton)
#hbox12.addWidget(addbutton)
#hbox12.addWidget(delbutton)
vbox12 = QVBoxLayout()
vbox12.addLayout(hbox12)
vbox12.addWidget(self.keywordcombo)
#00|01|02
#10|11|12
grid0 = QGridLayout()
grid0.addLayout(vbox00,1,0)
grid0.addLayout(vbox01,1,1)
grid0.addLayout(vbox02,1,2)
grid0.addLayout(vbox10,0,0)
grid0.addLayout(vbox12,0,2)
hbox2 = QHBoxLayout()
hbox2.addWidget(resetbutton)
hbox2.addStretch(1)
hbox2.addWidget(explainlabel)
hbox2.addWidget(finishbutton)
#gbox1.setLayout(hbox2)
vbox3 = QVBoxLayout()
vbox3.addLayout(grid0)
#vbox3.addLayout(hbox3)
#vbox3.addWidget(line0)
vbox3.addLayout(hbox2)
self.setLayout(vbox3)
def doChooseAllClickAction(self):
'''Moves the lot to Selected'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
self.parent.signalModels(self.parent.STEP.PRE)
#self.parent.selection_model.mdata += self.parent.available_model.mdata
self.parent.selection_model.initData(self.confconn_link.complete)
self.parent.available_model.initData([])
self.parent.signalModels(self.parent.STEP.POST)
#------------------------------
self.parent.writeKeysToLayerConfig(ktext)
#self.confconn_link.setupAssignedLayerList()
if self.keywordcombo.findText(ktext) == -1:
self.keywordcombo.addItem(ktext)
def doChooseClickAction(self):
'''Takes available selected and moves to selection'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
#ktext = str(self.keywordcombo.lineEdit().text())
if not self.checkKeyword(ktext): return
#------------------------------
select = self.available.selectionModel()
if select.hasSelection():
self.transferSelectedRows(select.selectedRows(),self.available_sfpm,self.selection_sfpm)
#------------------------------
self.parent.writeKeysToLayerConfig(ktext)
#self.confconn_link.assigned = self.confconn_link.setupAssignedLayerList()
# -1 to indicate no index since 0,1,... are valid
if self.keywordcombo.findText(ktext) == -1:
self.keywordcombo.addItem(ktext)
else:
ldslog.warn('L2R > Transfer action without selection')
#TRACE#
#pdb.set_trace()
self.available.clearSelection()
def transferSelectedRows(self,indices,from_model,to_model):
tlist = []
for proxymodelindex in indices:
transfer = from_model.getData(proxymodelindex)
tlist.append((proxymodelindex,transfer),)
to_model.addData([t[1] for t in tlist])
from_model.delData([t[0] for t in tlist])
return tlist
def doRejectClickAction(self):
'''Takes available selected and moves to selection'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
select = self.selection.selectionModel()
if select.hasSelection():
tlist = self.transferSelectedRows(select.selectedRows(),self.selection_sfpm,self.available_sfpm)
#------------------------------
kindex = self.keywordcombo.findText(ktext)
remainder = self.parent.deleteKeysFromLayerConfig([ll[1][0] for ll in tlist],ktext)
if remainder > 0 and kindex == -1:
#items+newkey -> add
self.parent.writeKeysToLayerConfig(ktext)
self.keywordcombo.addItem(ktext)
elif remainder == 0 and kindex > -1:
#empty+oldkey -> del
self.keywordcombo.removeItem(kindex)
self.keywordcombo.clearEditText()
else:
ldslog.warn('R2L < Transfer action without selection')
#TRACE#
#pdb.set_trace()
self.selection.clearSelection()
def doRejectAllClickAction(self):
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
self.parent.deleteKeysFromLayerConfig([ll[0] for ll in self.parent.selection_model.mdata],ktext)
#------------------------------
self.parent.signalModels(self.parent.STEP.PRE)
#self.parent.available_model.mdata += self.parent.selection_model.mdata
self.parent.available_model.initData(self.confconn_link.complete)
self.parent.selection_model.initData([])
self.parent.signalModels(self.parent.STEP.POST)
#------------------------------
#self.confconn_link.setupAssignedLayerList()
#self.keywordbypass = True
self.keywordcombo.removeItem(self.keywordcombo.findText(ktext))
self.keywordcombo.clearEditText()
def doKeyComboChangeAction(self):
'''Reset the available pane and if there is anything in the keyword box use this to init the selection pane'''
#HACK
#if self.keywordbypass:
# self.keywordbypass = False
# return
#------------------------------
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
#------------------------------
av_sl = self.parent.splitData(ktext,self.confconn_link.complete)
#av_sl = self.parent.splitData(ktext,self.confconn_link.complete)
self.parent.signalModels(self.parent.STEP.PRE)
self.parent.available_model.initData(av_sl[0])
self.parent.selection_model.initData(av_sl[1])
self.parent.signalModels(self.parent.STEP.POST)
def doResetClickAction(self):
'''Dumps the LC and rebuilds from a fresh read of the caps doc'''
#int warning (QWidget parent, QString title, QString text, QString button0Text, QString button1Text = QString(), QString button2Text = QString(), int defaultButtonNumber = 0, int escapeButtonNumber = -1)
ans = QMessageBox.warning(self, "Reset","This action will overwrite your Layer Configuration using the current LDS settings (potentially adding new or removing layers). Continue?","Continue","Cancel")
if ans:
#Cancel
ldslog.warn('Cancelling Reset operation')
return
#Continue
ldslog.warn('Reset Layer Config')
self.parent.resetLayers()
self.keywordcombo.clear()
def checkKeyword(self,ktext):
'''Checks keyword isn't null and isn't part of the LDS supplied keywords'''
if LU.assessNone(ktext) is None:
QMessageBox.about(self, "Keyword Required","Please enter a Keyword to assign Layer(s) to")
return False
if ktext in self.confconn_link.reserved:
QMessageBox.about(self, "Reserved Keyword","'{}' is a reserved keyword, please select again".format(ktext))
return False
return True
class AdvancedVisualizationForm(QWidget):
def __init__(self, mainwindow, result_manager):
QWidget.__init__(self, mainwindow)
#mainwindow is an OpusGui
self.mainwindow = mainwindow
self.result_manager = result_manager
self.toolboxBase = self.result_manager.mainwindow.toolboxBase
self.inGui = False
self.logFileKey = 0
self.xml_helper = ResultsManagerXMLHelper(toolboxBase=self.toolboxBase)
self.result_generator = OpusResultGenerator(
toolboxBase=self.toolboxBase)
self.result_generator.guiElement = self
self.tabIcon = QIcon(':/Images/Images/cog.png')
self.tabLabel = 'Advanced Visualization'
self.widgetLayout = QVBoxLayout(self)
self.widgetLayout.setAlignment(Qt.AlignTop)
self.resultsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.resultsGroupBox)
self.dataGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.dataGroupBox)
self.optionsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.optionsGroupBox)
self._setup_definition_widget()
self._setup_buttons()
self._setup_tabs()
def _setup_buttons(self):
# Add Generate button...
self.pbn_go = QPushButton(self.resultsGroupBox)
self.pbn_go.setObjectName('pbn_go')
self.pbn_go.setText(QString('Go!'))
QObject.connect(self.pbn_go, SIGNAL('released()'),
self.on_pbn_go_released)
self.widgetLayout.addWidget(self.pbn_go)
self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox)
self.pbn_set_esri_storage_location.setObjectName(
'pbn_set_esri_storage_location')
self.pbn_set_esri_storage_location.setText(QString('...'))
self.pbn_set_esri_storage_location.hide()
QObject.connect(self.pbn_set_esri_storage_location,
SIGNAL('released()'),
self.on_pbn_set_esri_storage_location_released)
def _setup_tabs(self):
# Add a tab widget and layer in a tree view and log panel
self.tabWidget = QTabWidget(self.resultsGroupBox)
# Log panel
self.logText = QTextEdit(self.resultsGroupBox)
self.logText.setReadOnly(True)
self.logText.setLineWidth(0)
self.tabWidget.addTab(self.logText, 'Log')
# Finally add the tab to the model page
self.widgetLayout.addWidget(self.tabWidget)
#
def _setup_definition_widget(self):
#### setup results group box ####
self.gridlayout = QGridLayout(self.resultsGroupBox)
self.gridlayout.setObjectName('gridlayout')
self.lbl_results = QLabel(self.resultsGroupBox)
self.lbl_results.setObjectName('lbl_results')
self.lbl_results.setText(QString('Results'))
self.gridlayout.addWidget(self.lbl_results, 0, 0, 1, 3)
self._setup_co_results()
self.gridlayout.addWidget(self.co_results, 0, 3, 1, 10)
self.pbn_add = QPushButton(self.resultsGroupBox)
self.pbn_add.setObjectName('pbn_add')
self.pbn_add.setText(QString('+'))
QObject.connect(self.pbn_add, SIGNAL('released()'),
self.on_pbn_add_released)
self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1)
self.lw_indicators = QListWidget(self.resultsGroupBox)
self.lw_indicators.setObjectName('lw_indicators')
self.gridlayout.addWidget(self.lw_indicators, 1, 1, 1, 13)
self.pbn_remove = QPushButton(self.resultsGroupBox)
self.pbn_remove.setObjectName('pbn_remove')
self.pbn_remove.setText(QString('-'))
QObject.connect(self.pbn_remove, SIGNAL('released()'),
self.on_pbn_remove_released)
self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1)
#### setup data group box ####
self.gridlayout2 = QGridLayout(self.dataGroupBox)
self.gridlayout2.setObjectName('gridlayout2')
self._setup_co_result_style()
self.gridlayout2.addWidget(self.co_result_style, 1, 0, 1, 2)
self.lbl_result_style_sep = QLabel(self.resultsGroupBox)
self.lbl_result_style_sep.setObjectName('lbl_result_style_sep')
self.lbl_result_style_sep.setText(QString('<center>as</center>'))
self.gridlayout2.addWidget(self.lbl_result_style_sep, 1, 2, 1, 1)
self._setup_co_result_type()
self.gridlayout2.addWidget(self.co_result_type, 1, 3, 1, 2)
##### setup options group box ####
self.gridlayout3 = QGridLayout(self.optionsGroupBox)
self.gridlayout3.setObjectName('gridlayout3')
self.le_esri_storage_location = QLineEdit(self.optionsGroupBox)
self.le_esri_storage_location.setObjectName('le_esri_storage_location')
self.le_esri_storage_location.setText('[set path]')
self.le_esri_storage_location.hide()
self.optionsGroupBox.hide()
QObject.connect(self.co_result_style,
SIGNAL('currentIndexChanged(int)'),
self.on_co_result_style_changed)
QObject.connect(self.co_result_type,
SIGNAL('currentIndexChanged(int)'),
self.on_co_result_type_changed)
def _setup_co_results(self):
self.co_results = QComboBox(self.resultsGroupBox)
self.co_results.setObjectName('co_results')
self.co_results.addItem(QString('[select]'))
results = self.xml_helper.get_available_results()
for result in results:
name = '%i.%s' % (result['run_id'], result['indicator_name'])
self.co_results.addItem(QString(name))
def _setup_co_result_style(self):
available_styles = [
'visualize',
'export',
]
self.co_result_style = QComboBox(self.dataGroupBox)
self.co_result_style.setObjectName('co_result_style')
for dataset in available_styles:
self.co_result_style.addItem(QString(dataset))
def _setup_co_result_type(self):
available_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
self.co_result_type = QComboBox(self.dataGroupBox)
self.co_result_type.setObjectName('co_result_type')
for dataset in available_types:
self.co_result_type.addItem(QString(dataset))
def on_pbnRemoveModel_released(self):
self.result_manager.removeTab(self)
self.result_manager.updateGuiElements()
def on_pbn_add_released(self):
cur_selected = self.co_results.currentText()
for i in range(self.lw_indicators.count()):
if self.lw_indicators.item(i).text() == cur_selected:
return
self.lw_indicators.addItem(cur_selected)
def on_pbn_remove_released(self):
selected_idxs = self.lw_indicators.selectedIndexes()
for idx in selected_idxs:
self.lw_indicators.takeItem(idx.row())
def on_co_result_style_changed(self, ind):
available_viz_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
available_export_types = ['ESRI table (for loading in ArcGIS)']
txt = self.co_result_style.currentText()
if txt == 'visualize':
available_types = available_viz_types
else:
available_types = available_export_types
self.co_result_type.clear()
for result_type in available_types:
r_type = QString(result_type)
self.co_result_type.addItem(r_type)
def on_co_result_type_changed(self, ind):
self.gridlayout3.removeWidget(self.le_esri_storage_location)
self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location)
self.optionsGroupBox.hide()
self.pbn_set_esri_storage_location.hide()
self.le_esri_storage_location.hide()
txt = self.co_result_type.currentText()
print txt
if txt == 'ESRI table (for loading in ArcGIS)':
self.pbn_set_esri_storage_location.show()
self.le_esri_storage_location.show()
self.gridlayout3.addWidget(self.le_esri_storage_location, 0, 1, 1,
6)
self.gridlayout3.addWidget(self.pbn_set_esri_storage_location, 0,
7, 1, 1)
self.optionsGroupBox.show()
def on_pbn_set_esri_storage_location_released(self):
print 'pbn_set_esri_storage_location released'
from opus_core.misc import directory_path_from_opus_path
start_dir = directory_path_from_opus_path('opus_gui.projects')
configDialog = QFileDialog()
filter_str = QString("*.gdb")
fd = configDialog.getExistingDirectory(
self,
QString("Please select an ESRI geodatabase (*.gdb)..."
), #, *.sde, *.mdb)..."),
QString(start_dir),
QFileDialog.ShowDirsOnly)
if len(fd) != 0:
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameBaseName = fileNameInfo.completeBaseName()
self.le_esri_storage_location.setText(fileName)
def on_pbn_go_released(self):
# Fire up a new thread and run the model
print 'Go button pressed'
# References to the GUI elements for status for this run...
#self.statusLabel = self.runStatusLabel
#self.statusLabel.setText(QString('Model initializing...'))
indicator_names = []
for i in range(self.lw_indicators.count()):
indicator_names.append(str(self.lw_indicators.item(i).text()))
if indicator_names == []:
print 'no indicators selected'
return
indicator_type = str(self.co_result_type.currentText())
indicator_type = {
#'Map (per indicator per year)':'matplotlib_map',
'Map (per indicator per year)': 'mapnik_map',
'Chart (per indicator, spans years)': 'matplotlib_chart',
'Table (per indicator, spans years)': 'table_per_attribute',
'Table (per year, spans indicators)': 'table_per_year',
'ESRI table (for loading in ArcGIS)': 'table_esri'
}[indicator_type]
kwargs = {}
if indicator_type == 'table_esri':
storage_location = str(self.le_esri_storage_location.text())
if not os.path.exists(storage_location):
print 'Warning: %s does not exist!!' % storage_location
kwargs['storage_location'] = storage_location
self.result_manager.addIndicatorForm(indicator_type=indicator_type,
indicator_names=indicator_names,
kwargs=kwargs)
def runUpdateLog(self):
self.logFileKey = self.result_generator._get_current_log(
self.logFileKey)
def runErrorFromThread(self, errorMessage):
QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class SimulationPanel(QWidget):
def __init__(self):
QWidget.__init__(self)
layout = QVBoxLayout()
self._simulation_mode_combo = QComboBox()
addHelpToWidget(self._simulation_mode_combo, "run/simulation_mode")
self._simulation_mode_combo.currentIndexChanged.connect(self.toggleSimulationMode)
simulation_mode_layout = QHBoxLayout()
simulation_mode_layout.addSpacing(10)
simulation_mode_layout.addWidget(QLabel("Simulation mode:"), 0, Qt.AlignVCenter)
simulation_mode_layout.addWidget(self._simulation_mode_combo, 0, Qt.AlignVCenter)
simulation_mode_layout.addSpacing(20)
self.run_button = QToolButton()
self.run_button.setIconSize(QSize(32, 32))
self.run_button.setText("Start Simulation")
self.run_button.setIcon(resourceIcon("ide/gear_in_play"))
self.run_button.clicked.connect(self.runSimulation)
self.run_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
addHelpToWidget(self.run_button, "run/start_simulation")
simulation_mode_layout.addWidget(self.run_button)
simulation_mode_layout.addStretch(1)
layout.addSpacing(5)
layout.addLayout(simulation_mode_layout)
layout.addSpacing(10)
self._simulation_stack = QStackedWidget()
self._simulation_stack.setLineWidth(1)
self._simulation_stack.setFrameStyle(QFrame.StyledPanel)
layout.addWidget(self._simulation_stack)
self._simulation_widgets = OrderedDict()
""" :type: OrderedDict[BaseRunModel,SimulationConfigPanel]"""
self.addSimulationConfigPanel(EnsembleExperimentPanel())
self.addSimulationConfigPanel(EnsembleSmootherPanel())
self.addSimulationConfigPanel(IteratedEnsembleSmootherPanel(advanced_option=True))
self.addSimulationConfigPanel(MultipleDataAssimilationPanel())
self.setLayout(layout)
def addSimulationConfigPanel(self, panel):
assert isinstance(panel, SimulationConfigPanel)
panel.toggleAdvancedOptions(False)
self._simulation_stack.addWidget(panel)
simulation_model = panel.getSimulationModel()
self._simulation_widgets[simulation_model] = panel
if not panel.is_advanced_option:
self._simulation_mode_combo.addItem(str(simulation_model), simulation_model)
panel.simulationConfigurationChanged.connect(self.validationStatusChanged)
def getActions(self):
return []
def toggleAdvancedOptions(self, show_advanced):
current_model = self.getCurrentSimulationModel()
self._simulation_mode_combo.clear()
for model, panel in self._simulation_widgets.iteritems():
if show_advanced or not panel.is_advanced_option:
self._simulation_mode_combo.addItem(str(model), model)
old_index = self._simulation_mode_combo.findText(str(current_model))
self._simulation_mode_combo.setCurrentIndex(old_index if old_index > -1 else 0)
def toggleAdvancedMode(self, show_advanced):
for panel in self._simulation_widgets.values():
panel.toggleAdvancedOptions(show_advanced)
self.toggleAdvancedOptions(show_advanced)
def getCurrentSimulationModel(self):
data = self._simulation_mode_combo.itemData(self._simulation_mode_combo.currentIndex(), Qt.UserRole)
return data.toPyObject()
def getSimulationArguments(self):
""" @rtype: dict[str,object]"""
simulation_widget = self._simulation_widgets[self.getCurrentSimulationModel()]
return simulation_widget.getSimulationArguments()
def runSimulation(self):
case_name = getCurrentCaseName()
message = "Are you sure you want to use case '%s' for initialization of the initial ensemble when running the simulations?" % case_name
start_simulations = QMessageBox.question(self, "Start simulations?", message, QMessageBox.Yes | QMessageBox.No )
if start_simulations == QMessageBox.Yes:
run_model = self.getCurrentSimulationModel()
arguments = self.getSimulationArguments()
dialog = RunDialog(run_model, arguments, self)
dialog.startSimulation()
dialog.exec_()
ERT.emitErtChange() # simulations may have added new cases.
def toggleSimulationMode(self):
current_model = self.getCurrentSimulationModel()
if current_model is not None:
widget = self._simulation_widgets[self.getCurrentSimulationModel()]
self._simulation_stack.setCurrentWidget(widget)
self.validationStatusChanged()
def validationStatusChanged(self):
widget = self._simulation_widgets[self.getCurrentSimulationModel()]
self.run_button.setEnabled(widget.isConfigurationValid())
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 Widget(QWidget):
def __init__(self, dockwidget):
super(Widget, self).__init__(dockwidget)
self._document = None
self._fileSelector = QComboBox(editable=True,
insertPolicy=QComboBox.NoInsert)
widgets.drag.ComboDrag(self._fileSelector).role = Qt.UserRole
self._fileSelector.lineEdit().setReadOnly(True)
self._fileSelector.lineEdit().setFocusPolicy(Qt.NoFocus)
self._stopButton = QToolButton()
self._playButton = QToolButton()
self._timeSlider = QSlider(Qt.Horizontal,
tracking=False,
singleStep=500,
pageStep=5000,
invertedControls=True)
self._display = Display()
self._tempoFactor = QSlider(Qt.Vertical,
minimum=-50,
maximum=50,
singleStep=1,
pageStep=5)
grid = QGridLayout(spacing=0)
self.setLayout(grid)
grid.addWidget(self._fileSelector, 0, 0, 1, 3)
grid.addWidget(self._stopButton, 1, 0)
grid.addWidget(self._playButton, 1, 1)
grid.addWidget(self._timeSlider, 1, 2)
grid.addWidget(self._display, 2, 0, 1, 3)
grid.addWidget(self._tempoFactor, 0, 3, 3, 1)
# size policy of combo
p = self._fileSelector.sizePolicy()
p.setHorizontalPolicy(QSizePolicy.Ignored)
self._fileSelector.setSizePolicy(p)
# size policy of combo popup
p = self._fileSelector.view().sizePolicy()
p.setHorizontalPolicy(QSizePolicy.MinimumExpanding)
self._fileSelector.view().setSizePolicy(p)
self._player = player.Player()
self._outputCloseTimer = QTimer(interval=60000,
singleShot=True,
timeout=self.closeOutput)
self._timeSliderTicker = QTimer(interval=200,
timeout=self.updateTimeSlider)
self._fileSelector.activated[int].connect(self.slotFileSelected)
self._tempoFactor.valueChanged.connect(self.slotTempoChanged)
self._timeSlider.valueChanged.connect(self.slotTimeSliderChanged)
self._timeSlider.sliderMoved.connect(self.slotTimeSliderMoved)
self._player.beat.connect(self.updateDisplayBeat)
self._player.time.connect(self.updateDisplayTime)
self._player.stateChanged.connect(self.slotPlayerStateChanged)
self.slotPlayerStateChanged(False)
dockwidget.mainwindow().currentDocumentChanged.connect(
self.loadResults)
app.documentLoaded.connect(self.slotUpdatedFiles)
app.jobFinished.connect(self.slotUpdatedFiles)
app.aboutToQuit.connect(self.stop)
midihub.aboutToRestart.connect(self.slotAboutToRestart)
midihub.settingsChanged.connect(self.clearMidiSettings, -100)
midihub.settingsChanged.connect(self.readMidiSettings)
app.documentClosed.connect(self.slotDocumentClosed)
app.translateUI(self)
self.readMidiSettings()
d = dockwidget.mainwindow().currentDocument()
if d:
self.loadResults(d)
def translateUI(self):
self._tempoFactor.setToolTip(_("Tempo"))
def slotAboutToRestart(self):
self.stop()
self._player.set_output(None)
def clearMidiSettings(self):
"""Called first when settings are changed."""
self.stop()
self._outputCloseTimer.stop()
self._player.set_output(None)
def readMidiSettings(self):
"""Called after clearMidiSettings(), and on first init."""
pass
def openOutput(self):
"""Called when playing starts. Ensures an output port is opened."""
self._outputCloseTimer.stop()
if not self._player.output():
p = QSettings().value("midi/player/output_port",
midihub.default_output(), type(""))
o = midihub.output_by_name(p)
if o:
self._player.set_output(output.Output(o))
def closeOutput(self):
"""Called when the output close timer fires. Closes the output."""
self._player.set_output(None)
def slotPlayerStateChanged(self, playing):
ac = self.parentWidget().actionCollection
# setDefaultAction also adds the action
for b in self._stopButton, self._playButton:
while b.actions():
b.removeAction(b.actions()[0])
if playing:
self._timeSliderTicker.start()
self._stopButton.setDefaultAction(ac.midi_stop)
self._playButton.setDefaultAction(ac.midi_pause)
else:
self._timeSliderTicker.stop()
self.updateTimeSlider()
self._stopButton.setDefaultAction(ac.midi_restart)
self._playButton.setDefaultAction(ac.midi_play)
# close the output if the preference is set
if QSettings().value("midi/close_outputs", False, bool):
self._outputCloseTimer.start()
def play(self):
"""Starts the MIDI player, opening an output if necessary."""
if not self._player.is_playing() and not self._player.has_events():
self.restart()
self.openOutput()
if not self._player.output():
self._display.statusMessage(_("No output found!"))
self._player.start()
def stop(self):
"""Stops the MIDI player."""
self._player.stop()
def restart(self):
"""Restarts the MIDI player.
If another file is in the file selector, or the file was updated,
the new file is loaded.
"""
self._player.seek(0)
self.updateTimeSlider()
self._display.reset()
if self._document:
files = midifiles.MidiFiles.instance(self._document)
index = self._fileSelector.currentIndex()
if files and (files.song(index) is not self._player.song()):
self.loadSong(index)
def slotTempoChanged(self, value):
"""Called when the user drags the tempo."""
# convert -50 to 50 to 0.5 to 2.0
factor = 2**(value / 50.0)
self._player.set_tempo_factor(factor)
self._display.setTempo("{0}%".format(int(factor * 100)))
def slotTimeSliderChanged(self, value):
self._player.seek(value)
self._display.setTime(value)
if self._player.song():
self._display.setBeat(*self._player.song().beat(value)[1:])
def slotTimeSliderMoved(self, value):
self._display.setTime(value)
if self._player.song():
self._display.setBeat(*self._player.song().beat(value)[1:])
def updateTimeSlider(self):
if not self._timeSlider.isSliderDown():
with qutil.signalsBlocked(self._timeSlider):
self._timeSlider.setMaximum(self._player.total_time())
self._timeSlider.setValue(self._player.current_time())
def updateDisplayBeat(self, measnum, beat, num, den):
if not self._timeSlider.isSliderDown():
self._display.setBeat(measnum, beat, num, den)
def updateDisplayTime(self, time):
if not self._timeSlider.isSliderDown():
self._display.setTime(time)
def slotUpdatedFiles(self, document):
"""Called when there are new MIDI files."""
if document == self.parentWidget().mainwindow().currentDocument():
self.loadResults(document)
def loadResults(self, document):
self._document = document
files = midifiles.MidiFiles.instance(document)
self._fileSelector.setModel(files.model())
if files:
self._fileSelector.setCurrentIndex(files.current)
if not self._player.is_playing():
self.loadSong(files.current)
def loadSong(self, index):
files = midifiles.MidiFiles.instance(self._document)
self._player.set_song(files.song(index))
m, s = divmod(self._player.total_time() // 1000, 60)
name = self._fileSelector.currentText()
self.updateTimeSlider()
self._display.reset()
self._display.statusMessage(_("midi lcd screen", "LOADED"), name,
_("midi lcd screen", "TOTAL"),
"{0}:{1:02}".format(m, s))
def slotFileSelected(self, index):
if self._document:
self._player.stop()
files = midifiles.MidiFiles.instance(self._document)
if files:
files.current = index
self.restart()
def slotDocumentClosed(self, document):
if document == self._document:
self._document = None
self._fileSelector.clear()
self._player.stop()
self._player.clear()
self.updateTimeSlider()
self._display.reset()
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 MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setWindowTitle('Address Book')
self.resize(704, 459)
self.db_file = self.database_file()
self.db = database.Database(self.db_file)
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
else:
self.close()
self.categComboBox = QComboBox()
self.cont_numLabel = QLabel()
self.contactsListWidget = QListWidget()
self.searchLineEdit = QLineEdit()
widgets = ((QLabel('Category:'), self.categComboBox),
(self.cont_numLabel, None),
(self.contactsListWidget,),
(QLabel('Search:'), self.searchLineEdit))
vlayout1 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout1.addLayout(hlayout)
addToolButton = QToolButton()
addToolButton.setIcon(QIcon(':addcontact.jpeg'))
addToolButton.setIconSize(QSize(45, 45))
self.showLabel = QLabel()
self.showLabel.setFrameShape(QFrame.StyledPanel)
self.showLabel.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignTop)
self.editButton = QPushButton('Edit')
self.delButton = QPushButton('Delete')
widgets = ((None, addToolButton, None),
(self.showLabel,),
(None, self.editButton, self.delButton))
vlayout2 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout2.addLayout(hlayout)
f_layout = pyqttools.add_to_layout(QHBoxLayout(), (vlayout1, vlayout2))
Widget = QWidget()
Widget.setLayout(f_layout)
self.setCentralWidget(Widget)
self.statusBar = self.statusBar()
self.userLabel = QLabel()
self.statusBar.addPermanentWidget(self.userLabel)
c_action = pyqttools.create_action
panelAction = c_action(self, 'User panel', triggered=self.user_panel)
quitAction = c_action(self, 'Quit', 'Ctrl+Q',triggered=self.close)
add_contactAction = c_action(self, 'Add contact', 'Ctrl+N',
triggered=self.add_contact)
delete_allAction = c_action(self, 'Delete all contacts',
triggered=self.delete_all)
delete_categAction = c_action(self, 'Delete categories',
triggered=self.delete_categories)
backupAction = c_action(self, 'Backup', triggered=self.backup)
restoreAction = c_action(self, 'Restore', triggered=self.restore)
aboutAction = c_action(self, 'About', 'Ctrl+?', triggered=self.about)
fileMenu = self.menuBar().addMenu('File')
contactsMenu = self.menuBar().addMenu('Contacts')
deleteMenu = self.menuBar().addMenu(self.tr('Delete'))
backupMenu = self.menuBar().addMenu(self.tr('Backup'))
helpMenu = self.menuBar().addMenu('Help')
pyqttools.add_actions(fileMenu, [panelAction, None, quitAction])
pyqttools.add_actions(contactsMenu, [add_contactAction])
pyqttools.add_actions(deleteMenu,[delete_allAction,delete_categAction])
pyqttools.add_actions(backupMenu, [backupAction, restoreAction])
pyqttools.add_actions(helpMenu, [aboutAction])
addToolButton.clicked.connect(self.add_contact)
self.editButton.clicked.connect(self.edit_contact)
self.delButton.clicked.connect(self.delete_contact)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.contactsListWidget.currentRowChanged.connect(self.show_contact)
self.searchLineEdit.textEdited.connect(self.search)
self.fill_categComboBox()
self.refresh_userLabel()
def fill_categComboBox(self):
categories = ['All']
categories.extend([i[1] for i in self.db.get_categories(self.user)])
self.categComboBox.currentIndexChanged.disconnect(self.fill_ListWidget)
self.categComboBox.clear()
self.categComboBox.addItems(categories)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.fill_ListWidget()
def fill_ListWidget(self):
self.showLabel.clear()
self.contactsListWidget.clear()
if self.categComboBox.currentIndex() != 0: self.searchLineEdit.clear()
category = self.categComboBox.currentText()
if category == 'All':
contacts = self.db.get_all_contacts(self.user)
else:
categ_id = self.db.get_category_id(category, self.user)
if categ_id is None: return
contacts = self.db.get_contacts(categ_id)
for i in contacts:
self.contactsListWidget.addItem(MyListItem(i[1]+' '+i[2], i[0]))
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def refresh_userLabel(self):
self.userLabel.setText('User: '******'Contacts Numer: {0}'.format(self.contactsListWidget.count())
self.cont_numLabel.setText(text)
def set_buttons_enabled(self):
enable = bool(self.contactsListWidget)
self.editButton.setEnabled(enable)
self.delButton.setEnabled(enable)
def user_panel(self):
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
self.fill_categComboBox()
self.refresh_userLabel()
def show_contact(self):
try:
_id = self.contactsListWidget.currentItem()._id
except AttributeError:
return
_id, name, surname, mail, address, tel, categ_id = \
self.db.get_contact_from_id(_id)[0]
category = self.db.get_category_from_id(categ_id)
text = ''
data = (name, surname, mail, address, tel, category)
labs = ('Name', 'Surname', 'e-mail', 'Address', 'Telephone', 'Category')
for i, y in zip(labs, data):
text += '''<p style=\' margin-top:0px; margin-bottom:0px; \'>
<span style=\' font-weight:600;\'>{0}:</span> {1} </p>\n'''\
.format(i, y)
self.showLabel.setText(text)
def add_contact(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories)
if dialog.exec_():
data = dialog.values
if data[-1] not in categories:
self.db.addto_categories(data[-1], self.user)
categ_id = self.db.get_category_id(data[-1], self.user)
data[-1] = categ_id
self.db.addto_contacts(data)
self.fill_categComboBox()
def edit_contact(self):
_id = self.contactsListWidget.currentItem()._id
data = list(self.db.get_contact_from_id(_id)[0])
categ = self.db.get_category_from_id(data[-1])
data[-1] = categ
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories, True, data)
if dialog.exec_():
new_data = dialog.values
if new_data[-1] not in categories:
self.db.addto_categories(new_data[-1], self.user)
categ_id = self.db.get_category_id(new_data[-1], self.user)
new_data[-1] = categ_id
self.db.edit_contact(new_data, _id)
self.fill_categComboBox()
def delete_contact(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete this contact?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
_id = self.contactsListWidget.currentItem()._id
self.db.delete_contact(_id)
self.fill_ListWidget()
def delete_all(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete all contacts?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.db.delete_all_contacts()
self.fill_ListWidget()
def delete_categories(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialogs.DelCategoriesDlg(categories, self).exec_()
self.fill_categComboBox()
def search(self):
self.categComboBox.setCurrentIndex(0)
self.showLabel.clear()
self.contactsListWidget.clear()
txt = self.searchLineEdit.text()
if all(i == ' ' for i in txt):
self.fill_ListWidget()
return
must_appear = []
contacts = self.db.get_all_contacts(self.user)
if not ' ' in txt:
for i in contacts:
if txt.lower() in i[1].lower() or txt.lower() in i[2].lower():
must_appear.append(i)
else:
try:
first, last = txt.split()
except ValueError:
return
for i in contacts:
_bool = bool(first.lower() in i[1].lower() or first.lower() in
i[2].lower() or last.lower() in i[1].lower() or
last.lower() in i[2].lower())
if _bool: must_appear.append(i)
for i in must_appear:
item = MyListItem(i[1] + ' ' + i[2], i[0])
self.contactsListWidget.addItem(item)
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def backup(self):
fname = QFileDialog.getSaveFileName(self,'Address Book - Backup','.db')
if fname:
try:
shutil.copy(self.db_file, fname)
except IOError:
pass
def restore(self):
reply = QMessageBox.question(self, 'Address Book - Restore',
'All current contacts will be deleted.\nAre you sure that you want'
' to continue?', QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
fname = QFileDialog.getOpenFileName(self, 'Address Book - Restore')
if fname:
msg = 'Succesful restore!'
try:
os.remove(self.db_file)
shutil.copy(fname, self.db_file)
except (OSError, IOError):
msg = 'Restore failed!'
QMessageBox.information(self, 'Addess Book - Restore', msg)
self.db = database.Database(self.db_file)
self.fill_categComboBox()
def database_file(self):
_file = 'addressbook.db'
if not platform.platform().startswith('Windows'):
folder = os.getenv('HOME') + os.sep + '.addressbook'
if not os.path.exists(folder): os.mkdir(folder)
_file = folder + os.sep + _file
return _file
def about(self):
link = 'http://wiki.ubuntu-gr.org/Address%20Book'
QMessageBox.about(self, self.tr('About') + ' FF Multi Converter',
'''<b> Address Book {0} </b>
<p>Gui application to organize your contacts!
<p>Copyright © 2012 Ilias Stamatis
<br>License: GNU GPL3
<p><a href='{1}'>http://wiki.ubuntu-gr.org/Address Book</a>
<p>Python {2} - Qt {3} - PyQt {4} on {5}'''
.format(__version__, link, platform.python_version()[:5],
QT_VERSION_STR, PYQT_VERSION_STR, platform.system()))
def close(self):
self.db.close()
sys.exit()
class MainWindowStart(QMainWindow, MainWindow_Pro.Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindowStart, self).__init__(parent)
# Mappers for connecting buttons and labels
self.myMapper = QSignalMapper(self)
self.myMapper_StyleSheet = QSignalMapper(self)
# Load UI
self.setupUi(self)
self.regex_edits = QRegExp(r"(^[0]+$|^$)")
self._filter = Filter()
self.filename = QString()
self.edit1_delayh.installEventFilter(self._filter)
self.sizeLabel = QLabel()
self.sizeLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.statusBar1.addPermanentWidget(self.sizeLabel)
self.statusBar1.setSizeGripEnabled(False)
self.create_connections()
self.assign_shortcuts()
self.create_tool_bar()
self.update_devices_list()
# self.button_stop.clicked.connect(self.stop_all)
# List of valve pushbuttons
self.valve_list = [
self.valve1, self.valve2, self.valve3, self.valve4, self.valve5,
self.valve6, self.valve7, self.valve8
]
# GroupBoxes for grouping labels and buttons on each row, used for applying StyleSheets
self.group_boxes = [
self.groupbox1, self.groupbox2, self.groupbox3, self.groupbox4,
self.groupbox5, self.groupbox6, self.groupbox7, self.groupbox8
]
# List of lineEdits
self.lineEdits_list = [
(self.edit1_delayh, self.edit1_delaym, self.edit1_delays,
self.edit1_onh, self.edit1_onm, self.edit1_ons, self.edit1_offh,
self.edit1_offm, self.edit1_offs, self.edit1_totalh,
self.edit1_totalm, self.edit1_totals),
(self.edit2_delayh, self.edit2_delaym, self.edit2_delays,
self.edit2_onh, self.edit2_onm, self.edit2_ons, self.edit2_offh,
self.edit2_offm, self.edit2_offs, self.edit2_totalh,
self.edit2_totalm, self.edit2_totals),
(self.edit3_delayh, self.edit3_delaym, self.edit3_delays,
self.edit3_onh, self.edit3_onm, self.edit3_ons, self.edit3_offh,
self.edit3_offm, self.edit3_offs, self.edit3_totalh,
self.edit3_totalm, self.edit3_totals),
(self.edit4_delayh, self.edit4_delaym, self.edit4_delays,
self.edit4_onh, self.edit4_onm, self.edit4_ons, self.edit4_offh,
self.edit4_offm, self.edit4_offs, self.edit4_totalh,
self.edit4_totalm, self.edit4_totals),
(self.edit5_delayh, self.edit5_delaym, self.edit5_delays,
self.edit5_onh, self.edit5_onm, self.edit5_ons, self.edit5_offh,
self.edit5_offm, self.edit5_offs, self.edit5_totalh,
self.edit5_totalm, self.edit5_totals),
(self.edit6_delayh, self.edit6_delaym, self.edit6_delays,
self.edit6_onh, self.edit6_onm, self.edit6_ons, self.edit6_offh,
self.edit6_offm, self.edit6_offs, self.edit6_totalh,
self.edit6_totalm, self.edit6_totals),
(self.edit7_delayh, self.edit7_delaym, self.edit7_delays,
self.edit7_onh, self.edit7_onm, self.edit7_ons, self.edit7_offh,
self.edit7_offm, self.edit7_offs, self.edit7_totalh,
self.edit7_totalm, self.edit7_totals),
(self.edit8_delayh, self.edit8_delaym, self.edit8_delays,
self.edit8_onh, self.edit8_onm, self.edit8_ons, self.edit8_offh,
self.edit8_offm, self.edit8_offs, self.edit8_totalh,
self.edit8_totalm, self.edit8_totals)
]
for index, editLabels in enumerate(self.lineEdits_list, 1):
for index2, lineedits in enumerate(editLabels, 0):
# Apply mapper (GUIObject, objectIndex)
self.myMapper_StyleSheet.setMapping(
self.lineEdits_list[index - 1][index2], index - 1)
# Connect mapper to signal
(self.lineEdits_list[index - 1][index2]).textChanged.connect(
self.myMapper_StyleSheet.map)
# Set event Filter, for detecting when Focus changes
self.lineEdits_list[index - 1][index2].installEventFilter(
self._filter)
# Set Mappers for buttons (1..8)
self.myMapper.setMapping(self.valve_list[index - 1], index)
# Connect mapper to signal for detecting clicks on buttons
(self.valve_list[index - 1]).clicked.connect(self.myMapper.map)
# Connect to signal for enabling labelEdits
self.myMapper.mapped['int'].connect(self.enable_fields)
# Connect to signal for changing color of groupbox used for visual indication
self.myMapper_StyleSheet.mapped['int'].connect(self.valve_color_status)
# Create Keyboard Shortcuts
def assign_shortcuts(self):
self.actionArchivo_Nuevo.setShortcut(QKeySequence.New)
self.action_Abrir.setShortcut(QKeySequence.Open)
self.action_Guardar.setShortcut(QKeySequence.Save)
self.actionGuardar_Como.setShortcut(QKeySequence.SaveAs)
self.action_Limpiar.setShortcut('Ctrl+L')
self.actionVAL_508_Ayuda.setShortcut(QKeySequence.HelpContents)
self.action_Salir.setShortcut(QKeySequence.Close)
# self.actionPreferencias.setShortcut(QKeySequence.Preferences)
self.action_Detener_USB.setShortcut('Ctrl+Shift+C')
self.action_Ejecutar.setShortcut('Ctrl+Shift+X')
self.action_Para_Valvulas.setShortcut('Ctrl+Shift+P')
# Create connections to signals
def create_connections(self):
self.actionArchivo_Nuevo.triggered.connect(self.new_file)
self.action_Abrir.triggered.connect(self.open_file)
self.action_Guardar.triggered.connect(self.save_file)
self.actionGuardar_Como.triggered.connect(self.save_file_as)
self.action_Limpiar.triggered.connect(self.clean_fields)
self.action_Salir.triggered.connect(self.close)
self.actionVAL_508_Ayuda.triggered.connect(self.show_help)
self.actionAcerca_de_VAL_508.triggered.connect(self.show_about)
self.action_Detener_USB.triggered.connect(self.stop_usb)
self.action_Ejecutar.triggered.connect(self.execute)
self.action_Para_Valvulas.triggered.connect(self.stop_all)
# Creation of About Dialog
def show_about(self):
about = aboutdialog.AboutDialog(self)
about.show()
# Creation of Help Form
def show_help(self):
form = helpform.HelpForm('Help.html', self)
form.show()
def new_file(self):
self.filename = QString()
self.clean_fields()
# Close connection to arduino before closing Program
def closeEvent(self, QCloseEvent):
try:
self.thread_connection.serial_connection.close()
logging.debug("Thread running and killed at closing program")
except AttributeError:
logging.debug("Thread was not running when closing program OK")
def clean_fields(self):
for index, editLabels in enumerate(self.lineEdits_list, 1):
for index2, lineedits in enumerate(editLabels, 0):
self.lineEdits_list[index - 1][index2].setText('0')
def save_file_as(self):
filename_copy = self.filename
logging.info("Current filename: %s" % self.filename)
my_home = os.path.expanduser('~')
self.filename = QFileDialog.getSaveFileName(
self, self.tr('Guardar como'),
os.path.join(my_home, "archivo.txt"), "", "",
QFileDialog.DontUseNativeDialog)
logging.info("Filename to save: %s" % self.filename)
if not self.filename.isNull():
if self.filename.endsWith(QString('.txt')):
self.write_data_to_file('w')
else:
self.filename.append(QString('.txt'))
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Advertencia'))
messageBox.setText(
self.tr(u"El archivo ya existe, ¿Reemplazar?"))
messageBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
messageBox.setIconPixmap(QPixmap(':/broken_file.png'))
if messageBox.exec_() == QMessageBox.Yes:
self.write_data_to_file('w')
else:
try:
while True:
self.filename = QFileDialog.getSaveFileName(
self, self.tr('Guardar como'),
os.path.join(my_home, "archivo.txt"), "", "",
QFileDialog.DontUseNativeDialog)
if self.filename.isNull():
raise Saved_Canceled()
else:
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}'
)
messageBox.setWindowTitle(
self.tr('Advertencia'))
messageBox.setText(
self.tr(
u"El archivo ya existe, ¿Reemplazar?"))
messageBox.setStandardButtons(QMessageBox.Yes
| QMessageBox.No)
messageBox.setIconPixmap(
QPixmap(':/broken_file.png'))
if messageBox.exec_() == QMessageBox.Yes:
self.write_data_to_file('w')
raise Saved_Accepted()
except Saved_Canceled:
self.filename = filename_copy
except Saved_Accepted:
pass
logging.info("Current filename after operation: %s" % self.filename)
def save_file(self):
if self.filename.isNull():
self.save_file_as()
else:
self.write_data_to_file('w')
# Colect data for arduino
def execute(self):
string_data = ''
list_strings = []
if str(self.arduino_combobox.currentText()):
self.statusBar1.showMessage(self.tr('Conectando...'))
# Gather all the contents of each row of valves and create a list of lists with them
for elem_edit in self.lineEdits_list:
# delay
string_data = string_data + str(
((int(elem_edit[0].text()) * 3600) +
(int(elem_edit[1].text()) * 60) +
(int(elem_edit[2].text()))) * 1000) + ';'
# ON
string_data = string_data + str(
((int(elem_edit[3].text()) * 3600) +
(int(elem_edit[4].text()) * 60) +
(int(elem_edit[5].text()))) * 1000) + ';'
# OFF
string_data = string_data + str(
((int(elem_edit[6].text()) * 3600) +
(int(elem_edit[7].text()) * 60) +
(int(elem_edit[8].text()))) * 1000) + ';'
# Total
string_data = string_data + str(
((int(elem_edit[9].text()) * 3600) +
(int(elem_edit[10].text()) * 60) +
(int(elem_edit[11].text()))) * 1000) + ';'
list_strings.append(string_data)
string_data = ''
# Start QThread for communicating with arduino
self.thread_connection = Arduino_Communication(
str(self.arduino_combobox.currentText()), list_strings)
self.thread_connection.start()
self.action_Ejecutar.setEnabled(False)
self.action_Para_Valvulas.setEnabled(False)
# Connect to current QThread instance in order to know the status of it's termination
# This line used only when stopping current task
self.thread_connection.finished.connect(self.finished_thread)
self.thread_connection.connection_exit_status.connect(
self.finished_thread)
else:
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Advertencia'))
messageBox.setText(self.tr("Arduino no seleccionado"))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/usb_error.png'))
messageBox.exec_()
# Inform QThread to stop sending data to arduino
def stop_usb(self):
if str(self.arduino_combobox.currentText()):
try:
self.statusBar1.showMessage(self.tr(u'Conexión detenida'))
if self.thread_connection.isRunning():
mutex.lock()
self.thread_connection.kill_serial = True
mutex.unlock()
except AttributeError:
logging.debug("Thread not running \'disconnected! \'")
else:
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Advertencia'))
messageBox.setText(self.tr("Arduino no seleccionado"))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/usb_error.png'))
messageBox.exec_()
def enable_fields(self, index):
hours_reg = QRegExp(r"0*[0-9]{1,3}")
sec_reg = QRegExp(r"(0*[0-9])|(0*[0-5][0-9])")
for counter, line_edit in enumerate(self.lineEdits_list[index - 1]):
line_edit.setEnabled(self.valve_list[index - 1].isChecked())
if counter % 3 == 0:
line_edit.setValidator(QRegExpValidator(hours_reg, self))
else:
line_edit.setValidator(QRegExpValidator(sec_reg, self))
def valve_color_status(self, index):
logging.info("Checking color from valve button")
for edit in self.lineEdits_list[index]:
if edit.text().contains(self.regex_edits):
self.group_boxes[index].setStyleSheet('''QGroupBox {
border: 2px solid;
border-color: rgba(255, 255, 255, 0);}'''
)
else:
self.group_boxes[index].setStyleSheet(
'''QGroupBox {background-color: rgba(103, 255, 126, 150);
border: 2px solid;
border-color: rgba(255, 255, 255, 255);}'''
)
break
def create_tool_bar(self):
self.label_arduino = QLabel(self.tr('Dispositivos: '))
self.toolBar.addWidget(self.label_arduino)
self.arduino_combobox = QComboBox()
self.arduino_combobox.setToolTip(self.tr('Seleccionar Arduino'))
self.arduino_combobox.setFocusPolicy(Qt.NoFocus)
# Update List of Arduino devices
self.reload = QAction(QIcon(":/reload.png"), self.tr("&Refrescar"),
self)
self.reload.setShortcut(QKeySequence.Refresh)
self.reload.setToolTip(self.tr('Refrescar Dispositivos'))
self.reload.triggered.connect(self.update_devices_list)
self.toolBar.addWidget(self.arduino_combobox)
self.toolBar.addAction(self.reload)
# Update current usb devices connected to PC
def update_devices_list(self):
device_list = serial.tools.list_ports.comports()
current_arduino = self.arduino_combobox.currentText()
self.arduino_combobox.clear()
for device_index, device in enumerate(sorted(device_list)):
self.arduino_combobox.addItem(device.device)
if device.device == current_arduino:
self.arduino_combobox.setCurrentIndex(device_index)
# Stop current arduino task
def stop_all(self):
if str(self.arduino_combobox.currentText()):
self.thread_connection = Arduino_Communication(
str(self.arduino_combobox.currentText()))
self.thread_connection.start()
self.action_Ejecutar.setEnabled(False)
self.action_Para_Valvulas.setEnabled(False)
self.action_Detener_USB.setEnabled(False)
self.thread_connection.finished.connect(self.finished_thread)
self.thread_connection.connection_exit_status.connect(
self.finished_thread)
else:
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Advertencia'))
messageBox.setText(self.tr("Arduino no seleccionado"))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/usb_error.png'))
messageBox.exec_()
def open_file(self):
try:
my_home = os.path.expanduser('~')
file_name = QFileDialog.getOpenFileName(
self, self.tr('Abrir archivo'), my_home, '*.txt', '*.txt',
QFileDialog.DontUseNativeDialog)
logging.warning("file_name type: %s" % type(file_name))
list_values = []
if not file_name.isNull():
with open(file_name) as fp:
for line in fp:
list_values.extend([line.replace('\n', '')])
logging.info("List Content: %s" % list_values)
count = 0
for elems in self.lineEdits_list:
for inner_elem in elems:
if not unicode(list_values[count]).isdigit():
raise Uncompatible_Data()
inner_elem.setText(list_values[count])
count = count + 1
self.filename = file_name
except (IOError, OSError):
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Error'))
messageBox.setText(self.tr('No se pudo abrir el archivo'))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/broken_file.png'))
messageBox.exec_()
except (IndexError, Uncompatible_Data):
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Error'))
messageBox.setText(self.tr('Formato Incompatible'))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/broken_file.png'))
messageBox.exec_()
# Inform the user if we were able to send data successfully to arduino
def finished_thread(self, error=None, message=''):
if error == 'error':
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Error'))
messageBox.setText(message)
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/usb_error.png'))
messageBox.exec_()
return
elif error == 'success':
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr(u'Éxito'))
messageBox.setText(message)
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/usb_success.png'))
messageBox.exec_()
return
elif error == 'stopped':
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr(u'Éxito'))
messageBox.setText(message)
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIconPixmap(QPixmap(':/success_general.png'))
messageBox.exec_()
return
self.action_Ejecutar.setEnabled(True)
self.action_Para_Valvulas.setEnabled(True)
self.action_Detener_USB.setEnabled(True)
self.statusBar1.showMessage(self.tr('Finalizado'))
# Save data to disk
def write_data_to_file(self, open_mode):
progressDialog = QProgressDialog()
progressDialog.setModal(True)
progressDialog.setLabelText(self.tr('Guardando...'))
progressDialog.setMaximum(8)
progressDialog.setCancelButton(None)
progressDialog.show()
try:
# File is closed automatically even on error
with open(unicode(self.filename), open_mode) as file_obj:
for count, elem_edit in enumerate(self.lineEdits_list, 1):
file_obj.write(''.join([str(elem_edit[0].text()), '\n']))
file_obj.write(''.join([str(elem_edit[1].text()), '\n']))
file_obj.write(''.join([str(elem_edit[2].text()), '\n']))
file_obj.write(''.join([str(elem_edit[3].text()), '\n']))
file_obj.write(''.join([str(elem_edit[4].text()), '\n']))
file_obj.write(''.join([str(elem_edit[5].text()), '\n']))
file_obj.write(''.join([str(elem_edit[6].text()), '\n']))
file_obj.write(''.join([str(elem_edit[7].text()), '\n']))
file_obj.write(''.join([str(elem_edit[8].text()), '\n']))
file_obj.write(''.join([str(elem_edit[9].text()), '\n']))
file_obj.write(''.join([str(elem_edit[10].text()), '\n']))
file_obj.write(''.join([str(elem_edit[11].text()), '\n']))
progressDialog.setValue(count)
except (IOError, OSError):
progressDialog.close()
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Error'))
messageBox.setText(self.tr('Error al guardar'))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIcon(QMessageBox.Critical)
messageBox.exec_()
else:
self.statusBar1.showMessage(self.tr('Guardado'), 3000)
class MusicPreviewWidget(QWidget):
def __init__(self, parent=None):
super(MusicPreviewWidget, self).__init__(parent)
self._lastbuildtime = 10.0
self._running = None
self._current = None
self._chooserLabel = QLabel()
self._chooser = QComboBox(self, activated=self.selectDocument)
self._log = log.Log()
self._view = popplerview.View()
self._progress = widgets.progressbar.TimedProgressBar()
self._stack = QStackedLayout()
self._top = QWidget()
layout = QVBoxLayout()
self.setLayout(layout)
layout.addWidget(self._top)
layout.addLayout(self._stack)
layout.addWidget(self._progress)
top = QHBoxLayout()
top.setContentsMargins(0, 0, 0, 0)
top.setSpacing(2)
self._top.setLayout(top)
top.addWidget(self._chooserLabel)
top.addWidget(self._chooser)
top.addStretch(1)
self._stack.addWidget(self._log)
self._stack.addWidget(self._view)
self._top.hide()
app.aboutToQuit.connect(self.cleanup)
app.translateUI(self)
def translateUI(self):
self._chooserLabel.setText(_("Document:"))
def preview(self, text, title=None):
"""Runs LilyPond on the given text and shows the resulting PDF."""
j = self._running = MusicPreviewJob(text, title)
j.done.connect(self._done)
self._log.clear()
self._log.connectJob(j)
j.start()
self._progress.start(self._lastbuildtime)
def _done(self, success):
self._progress.stop(False)
pdfs = self._running.resultfiles()
self.setDocuments(pdfs)
if not pdfs:
self._stack.setCurrentWidget(self._log)
return
self._lastbuildtime = self._running.elapsed_time()
self._stack.setCurrentWidget(self._view)
if self._current:
self._current.cleanup()
self._current = self._running # keep the tempdir
self._running = None
def setDocuments(self, pdfs):
"""Loads the given PDF path names in the UI."""
self._documents = [popplertools.Document(name) for name in pdfs]
self._chooser.clear()
self._chooser.addItems([d.name() for d in self._documents])
self._top.setVisible(len(self._documents) > 1)
if pdfs:
self._chooser.setCurrentIndex(0)
self.selectDocument(0)
else:
self._view.clear()
def selectDocument(self, index):
doc = self._documents[index].document()
if doc:
self._view.load(doc)
def cleanup(self):
if self._running:
self._running.abort()
self._running.cleanup()
self._running = None
if self._current:
self._current.cleanup()
self._current = None
self._stack.setCurrentWidget(self._log)
self._top.hide()
self._view.clear()
def print_(self):
"""Prints the currently displayed document."""
if self._documents:
doc = self._documents[self._chooser.currentIndex()]
import popplerprint
popplerprint.printDocument(doc, self)
class FilteringModule(PreprocessorModule):
DEFAULT_SETTINGS = {
'is_enabled': True,
'methods': [True, False, False],
'recent_sw_files': [],
'min_df': None,
'max_df': None,
}
English, Custom, DocumentFrequency = 0, 1, 2
filtering_values = {
English: 'english',
Custom: [],
DocumentFrequency: (None, None),
}
filter_names = {
English: 'English stop words',
Custom: 'Custom stop words',
DocumentFrequency: 'Filter by token frequency',
}
filtering_methods = [True, False, False]
dlgFormats = 'Only text files (*.txt)'
recent_sw_files = []
def __init__(self, data):
data = data or self.DEFAULT_SETTINGS
PreprocessorModule.__init__(self, 'Token filtering', True,
data.get('is_enabled'))
self.group = QButtonGroup(self, exclusive=False)
# --- English ---
cb = QCheckBox(self, text=self.filter_names[self.English])
self.add_to_content_area(cb)
self.group.addButton(cb, self.English)
# --- Custom ---
cb = QCheckBox(self, text=self.filter_names[self.Custom])
self.add_to_content_area(cb)
self.group.addButton(cb, self.Custom)
# File browser.
file_browser_layout = QHBoxLayout()
file_browser_layout.setContentsMargins(20, 0, 0, 0)
self.sw_file_combo = QComboBox()
self.sw_file_combo.setMinimumWidth(200)
file_browser_layout.addWidget(self.sw_file_combo)
self.sw_file_combo.activated[int].connect(self.select_file)
self.browse_button = QPushButton(self)
self.browse_button.clicked.connect(self.browse_file)
self.browse_button.setIcon(self.style().standardIcon(
QStyle.SP_DirOpenIcon))
self.browse_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
file_browser_layout.addWidget(self.browse_button)
# Reload button
self.reload_button = QPushButton(self)
self.reload_button.clicked.connect(self.on_reload_button_clicked)
self.reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
self.reload_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
file_browser_layout.addWidget(self.reload_button)
self.add_layout_to_content_area(file_browser_layout)
# --- DF ---
df_info_text = """
Remove all tokens that appear in less than 'min-df' documents.
Remove all tokens that appear in more than 'max-df' documents.
Values can be either integers or floats (ratio of documents).
"""
cb = QCheckBox(self, text=self.filter_names[self.DocumentFrequency])
self.add_to_content_area(cb)
self.group.addButton(cb, self.DocumentFrequency)
df_info_text = QLabel(df_info_text)
df_info_text.setContentsMargins(0, 0, 0, 0)
df_info_text.setStyleSheet("""
font-size: 11px;
font-style: italic;
""")
self.add_to_content_area(df_info_text)
# Min/Max-Df setter.
df_setter_layout = QHBoxLayout()
df_setter_layout.setContentsMargins(20, 0, 0, 0)
self.min_df_input = QLineEdit()
self.min_df_input.textChanged.connect(self.update_df_parameters)
self.max_df_input = QLineEdit()
self.max_df_input.textChanged.connect(self.update_df_parameters)
df_setter_layout.addWidget(QLabel('Min-df:'))
df_setter_layout.addWidget(self.min_df_input)
df_setter_layout.addWidget(QLabel('Max-df:'))
df_setter_layout.addWidget(self.max_df_input)
self.add_layout_to_content_area(df_setter_layout)
self.group.buttonClicked.connect(self.group_button_clicked)
# Restore the widget to its previous state.
self.restore_data(data)
def str_to_num(self, s):
if not s:
return None
try:
return int(s)
except ValueError:
pass # Not an int. Continue.
try:
return float(s)
except ValueError: # Not a float either.
self.send_message(
'Input "{}" cannot be cast into a number.'.format(s))
return None
def send_message(self, message):
# Sends a message with the "message" signal, to the main widget.
self.error_signal.emit(message)
# --- File selection.
def select_file(self, n):
if n < len(self.recent_sw_files):
name = self.recent_sw_files[n]
del self.recent_sw_files[n]
self.recent_sw_files.insert(0, name)
if len(self.recent_sw_files) > 0:
self.set_file_list()
self.open_file(self.recent_sw_files[0])
def set_file_list(self):
self.sw_file_combo.clear()
if not self.recent_sw_files:
self.sw_file_combo.addItem('(none)')
else:
for file in self.recent_sw_files:
self.sw_file_combo.addItem(os.path.split(file)[1])
def browse_file(self):
# Opens the file browser, starting at the home directory.
start_file = os.path.expanduser('~/')
# Get the file path from the browser window.
path = QFileDialog.getOpenFileName(self, 'Open a stop words source',
start_file, self.dlgFormats)
if not path:
return
if path in self.recent_sw_files:
self.recent_sw_files.remove(path)
self.recent_sw_files.insert(0, path)
self.set_file_list()
self.open_file(path)
def update_df_parameters(self):
min_df = None if not self.min_df_input.text(
) else self.min_df_input.text()
max_df = None if not self.max_df_input.text(
) else self.max_df_input.text()
self.filtering_values[self.DocumentFrequency] = (min_df, max_df)
self.notify_on_change()
def open_file(self, path):
try:
with open(path) as f: # Read most recent.
self.filtering_values[self.Custom] = [
sw.strip() for sw in f.read().splitlines()
]
self.notify_on_change()
except Exception: # Raise an exception otherwise.
self.send_message('Could not open "{}".'.format(path))
def on_reload_button_clicked(self):
if self.recent_sw_files:
self.select_file(0)
# END File selection.
def group_button_clicked(self):
self.filtering_methods = [
ch_box.isChecked() for ch_box in self.group.buttons()
]
self.enable_choice_settings()
# Emit the signal.
self.notify_on_change()
def enable_choice_settings(self):
self.sw_file_combo.setEnabled(self.filtering_methods[1])
self.browse_button.setEnabled(self.filtering_methods[1])
self.reload_button.setEnabled(self.filtering_methods[1])
self.min_df_input.setEnabled(self.filtering_methods[2])
self.max_df_input.setEnabled(self.filtering_methods[2])
def get_pp_setting(self):
flag_english = self.filtering_methods[0]
flag_custom = self.filtering_methods[1]
flag_df = self.filtering_methods[2]
if flag_english and flag_custom: # Use custom.
stop_words = {
'stop_words':
stopwords.words('english') + self.filtering_values[self.Custom]
}
elif flag_english and not flag_custom:
stop_words = {'stop_words': 'english'}
elif flag_custom:
stop_words = {'stop_words': self.filtering_values[self.Custom]}
else:
stop_words = {}
if flag_df:
stop_words.update({
'min_df':
self.str_to_num(self.min_df_input.text()),
'max_df':
self.str_to_num(self.max_df_input.text()),
})
return stop_words
def restore_data(self, data):
self.recent_sw_files = data.get('recent_sw_files')
self.min_df_input.setText(data.get('min_df'))
self.max_df_input.setText(data.get('max_df'))
self.filtering_methods = data.get('methods')
for flag, ch_box in zip(self.filtering_methods, self.group.buttons()):
ch_box.setChecked(flag)
self.enable_choice_settings() # Enable the settings if set.
self.set_file_list() # Fill the combo box with the recent sw files.
self.select_file(0) # Select the first file.
def export_data(self):
return {
'is_enabled': self.enabled,
'methods': self.filtering_methods,
'recent_sw_files': self.recent_sw_files,
'min_df': self.min_df_input.text(),
'max_df': self.max_df_input.text(),
}
class Dialog(QDialog):
def __init__(self, mainwindow):
super(Dialog, self).__init__(mainwindow)
self._document = None
layout = QGridLayout()
self.setLayout(layout)
self.versionLabel = QLabel()
self.versionCombo = QComboBox()
self.outputLabel = QLabel()
self.outputCombo = QComboBox()
self.resolutionLabel = QLabel()
self.resolutionCombo = QComboBox(editable=True)
self.antialiasLabel = QLabel()
self.antialiasSpin = QSpinBox(minimum=1, maximum=128, value=1)
self.modeLabel = QLabel()
self.modeCombo = QComboBox()
self.englishCheck = QCheckBox()
self.deleteCheck = QCheckBox()
self.commandLineLabel = QLabel()
self.commandLine = QTextEdit(acceptRichText=False)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).setIcon(icons.get("lilypond-run"))
userguide.addButton(self.buttons, "engrave_custom")
self.resolutionCombo.addItems(['100', '200', '300', '600', '1200'])
self.resolutionCombo.setCurrentIndex(2)
self.modeCombo.addItems(['preview', 'publish', 'debug'])
layout.addWidget(self.versionLabel, 0, 0)
layout.addWidget(self.versionCombo, 0, 1, 1, 3)
layout.addWidget(self.outputLabel, 1, 0)
layout.addWidget(self.outputCombo, 1, 1, 1, 3)
layout.addWidget(self.resolutionLabel, 2, 0)
layout.addWidget(self.resolutionCombo, 2, 1)
layout.addWidget(self.antialiasLabel, 2, 2, Qt.AlignRight)
layout.addWidget(self.antialiasSpin, 2, 3)
layout.addWidget(self.modeLabel, 3, 0)
layout.addWidget(self.modeCombo, 3, 1, 1, 3)
layout.addWidget(self.englishCheck, 4, 0, 1, 4)
layout.addWidget(self.deleteCheck, 5, 0, 1, 4)
layout.addWidget(self.commandLineLabel, 6, 0, 1, 4)
layout.addWidget(self.commandLine, 7, 0, 1, 4)
layout.addWidget(widgets.Separator(), 8, 0, 1, 4)
layout.addWidget(self.buttons, 9, 0, 1, 4)
app.translateUI(self)
qutil.saveDialogSize(self, "engrave/custom/dialog/size", QSize(480, 260))
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
model = listmodel.ListModel(formats, display=lambda f: f.title(),
icon=lambda f: icons.file_type(f.type))
self.outputCombo.setModel(model)
s = QSettings()
s.beginGroup("lilypond_settings")
self.englishCheck.setChecked(
s.value("no_translation", False, bool))
self.deleteCheck.setChecked(
s.value("delete_intermediate_files", True, bool))
if s.value("default_output_target", "pdf", type("")) == "svg":
self.outputCombo.setCurrentIndex(3)
self.loadLilyPondVersions()
self.selectLilyPondInfo(lilypondinfo.preferred())
app.settingsChanged.connect(self.loadLilyPondVersions)
app.jobFinished.connect(self.slotJobFinished)
self.outputCombo.currentIndexChanged.connect(self.makeCommandLine)
self.modeCombo.currentIndexChanged.connect(self.makeCommandLine)
self.deleteCheck.toggled.connect(self.makeCommandLine)
self.resolutionCombo.editTextChanged.connect(self.makeCommandLine)
self.antialiasSpin.valueChanged.connect(self.makeCommandLine)
self.makeCommandLine()
panelmanager.manager(mainwindow).layoutcontrol.widget().optionsChanged.connect(self.makeCommandLine)
def translateUI(self):
self.setWindowTitle(app.caption(_("Engrave custom")))
self.versionLabel.setText(_("LilyPond Version:"))
self.outputLabel.setText(_("Output Format:"))
self.resolutionLabel.setText(_("Resolution:"))
self.antialiasLabel.setText(_("Antialias Factor:"))
self.modeLabel.setText(_("Engraving mode:"))
self.modeCombo.setItemText(0, _("Preview"))
self.modeCombo.setItemText(1, _("Publish"))
self.modeCombo.setItemText(2, _("Layout Control"))
self.englishCheck.setText(_("Run LilyPond with English messages"))
self.deleteCheck.setText(_("Delete intermediate output files"))
self.commandLineLabel.setText(_("Command line:"))
self.buttons.button(QDialogButtonBox.Ok).setText(_("Run LilyPond"))
self.outputCombo.update()
def slotJobFinished(self, doc):
if doc == self._document:
self.buttons.button(QDialogButtonBox.Ok).setEnabled(True)
self._document = None
def setDocument(self, doc):
self.selectLilyPondInfo(command.info(doc))
if jobmanager.isRunning(doc):
self._document = doc
self.buttons.button(QDialogButtonBox.Ok).setEnabled(False)
def loadLilyPondVersions(self):
infos = lilypondinfo.infos() or [lilypondinfo.default()]
infos.sort(key = lambda i: i.version() or (999,))
self._infos = infos
index = self.versionCombo.currentIndex()
self.versionCombo.clear()
for i in infos:
icon = 'lilypond-run' if i.version() else 'dialog-error'
self.versionCombo.addItem(icons.get(icon), i.prettyName())
self.versionCombo.setCurrentIndex(index)
def selectLilyPondInfo(self, info):
if info in self._infos:
self.versionCombo.setCurrentIndex(self._infos.index(info))
def makeCommandLine(self):
"""Reads the widgets and builds a command line."""
f = formats[self.outputCombo.currentIndex()]
self.resolutionCombo.setEnabled('resolution' in f.widgets)
self.antialiasSpin.setEnabled('antialias' in f.widgets)
cmd = ["$lilypond"]
if self.modeCombo.currentIndex() == 0: # preview mode
cmd.append('-dpoint-and-click')
elif self.modeCombo.currentIndex() == 1: # publish mode
cmd.append('-dno-point-and-click')
else: # debug mode
args = panelmanager.manager(self.parent()).layoutcontrol.widget().preview_options()
cmd.extend(args)
if self.deleteCheck.isChecked():
cmd.append('-ddelete-intermediate-files')
else:
cmd.append('-dno-delete-intermediate-files')
d = {
'version': self._infos[self.versionCombo.currentIndex()].version,
'resolution': self.resolutionCombo.currentText(),
'antialias': self.antialiasSpin.value(),
}
cmd.append("$include")
cmd.extend(f.options(d))
cmd.append("$filename")
self.commandLine.setText(' '.join(cmd))
def getJob(self, document):
"""Returns a Job to start."""
filename, includepath = documentinfo.info(document).jobinfo(True)
i = self._infos[self.versionCombo.currentIndex()]
cmd = []
for t in self.commandLine.toPlainText().split():
if t == '$lilypond':
cmd.append(i.abscommand() or i.command)
elif t == '$filename':
cmd.append(filename)
elif t == '$include':
cmd.extend('-I' + path for path in includepath)
else:
cmd.append(t)
j = job.Job()
j.directory = os.path.dirname(filename)
j.command = cmd
if self.englishCheck.isChecked():
j.environment['LANG'] = 'C'
j.setTitle("{0} {1} [{2}]".format(
os.path.basename(i.command), i.versionString(), document.documentName()))
return j
class ItemEntriesFrame(QFrame):
read_block = pyqtSignal(int, int) # start_addr, num_bytes
poke_block = pyqtSignal(int, QByteArray,
bool) # start_addr, raw_bytes, is_ascii
log = pyqtSignal(str, str) # msg, color
MISSING_ITEM_NAME = '[NOT IN DB]'
def __init__(self,
type_val,
addr_start,
addr_end,
label,
id2name,
idx2id,
names,
parent=None):
super(ItemEntriesFrame, self).__init__(parent)
self.type_val = type_val
self.code_offset = 0
self.addr_start = addr_start
self.addr_end = addr_end
self.max_num_slots = (addr_end - addr_start) / 3 / 4 + 1
self.label = label
self.id2name = id2name
self.idx2id = idx2id
self.names = names
self.slots_cache = [
] # tuple: (addr_hex, addr_val, slot_number, cur_val)
self.cur_slot_idx = -1
self.lbl_label = QLabel(self.label, self)
self.btn_read_slots = QPushButton(' Cache Slots', self)
self.btn_read_slots.setIcon(QIcon('img/flaticon/data110.png'))
self.btn_read_slots.setStyleSheet('background-color: white')
self.btn_read_slots.clicked.connect(self.onReadSlots)
self.btn_search_cache = QPushButton(' Search ID', self)
self.btn_search_cache.setIcon(QIcon('img/flaticon/magnifier13.png'))
self.btn_search_cache.setToolTip(
'Find slot in cache with specified item ID')
self.btn_search_cache.setStyleSheet('background-color: white')
self.btn_search_cache.clicked.connect(self.onSearchCacheForID)
self.btn_read = QPushButton(self)
self.btn_read.setIcon(QIcon('img/flaticon/open135.png'))
self.btn_read.setToolTip('Read item slot value from memory')
self.btn_read.setStyleSheet('background-color: white')
self.btn_read.clicked.connect(self.onReadSlot)
self.cmb_slots = QComboBox(self)
self.cmb_slots.setStyleSheet('background-color: white')
self.cmb_slots.currentIndexChanged[int].connect(self.onChangeSlot)
self.cmb_slots.setDisabled(True)
self.cmb_names = QComboBox(self)
self.cmb_names.setEditable(True)
self.cmb_names.addItems(self.names)
self.cmb_names.lineEdit().setText(ItemEntriesFrame.MISSING_ITEM_NAME)
self.cmb_names.currentIndexChanged[int].connect(self.fetchID)
self.txt_id = QLineEdit(self)
self.txt_id.setPlaceholderText('ID (hex)')
self.txt_id.setMaxLength(3)
self.txt_id.textChanged.connect(self.fetchName)
self.btn_rename = QPushButton(' Fix Name', self)
self.btn_rename.setIcon(QIcon('img/flaticon/cloud-storage3.png'))
self.btn_rename.setToolTip(
'Add/Correct Item Name for %s (type: %02X)' %
(self.label, type_val))
self.btn_rename.setStyleSheet('background-color: white')
self.btn_rename.clicked.connect(self.onRename)
self.txt_amount = QLineEdit(self)
self.txt_amount.setPlaceholderText('Amount')
self.txt_amount.setMaxLength(3)
self.btn_poke = QPushButton(self)
self.btn_poke.setIcon(QIcon('img/flaticon/draw39.png'))
self.btn_poke.setToolTip('Poke new value for item slot')
self.btn_poke.setStyleSheet('background-color: white')
self.btn_poke.clicked.connect(self.onPokeSlot)
self.layout = QGridLayout(self)
self.layout.addWidget(self.lbl_label, 0, 0)
self.layout.addWidget(self.btn_read_slots, 0, 1)
self.layout.addWidget(self.btn_search_cache, 0, 2)
self.layout.addWidget(self.cmb_slots, 0, 3)
self.layout.addWidget(self.btn_read, 0, 4)
self.layout.addWidget(self.cmb_names, 1, 0)
self.layout.addWidget(self.txt_id, 1, 1)
self.layout.addWidget(self.btn_rename, 1, 2)
self.layout.addWidget(self.txt_amount, 1, 3)
self.layout.addWidget(self.btn_poke, 1, 4)
self.layout.setColumnStretch(0, 7)
self.layout.setColumnStretch(1, 3)
self.layout.setColumnStretch(2, 3)
self.layout.setColumnStretch(3, 3)
self.layout.setColumnStretch(4, 1)
self.layout.setContentsMargins(0, 2, 0, 2)
icon_height = self.lbl_label.height() * 8 / 15
icon_size = QSize(icon_height, icon_height)
self.btn_read_slots.setIconSize(icon_size)
self.btn_search_cache.setIconSize(icon_size)
self.btn_rename.setIconSize(icon_size)
self.btn_read.setIconSize(icon_size)
self.btn_poke.setIconSize(icon_size)
btn_size = QSize(icon_height * 1.5, icon_height * 1.5)
self.btn_read.setFixedSize(btn_size)
self.btn_poke.setFixedSize(btn_size)
self.updateUI()
def updateUI(self):
# Disable editing if cache missing
if not (0 <= self.cur_slot_idx < len(self.slots_cache)):
self.cmb_names.lineEdit().setText(
ItemEntriesFrame.MISSING_ITEM_NAME)
self.cmb_names.setDisabled(True)
self.txt_id.setText('')
self.txt_id.setDisabled(True)
return
# Validate current value
cur_val = self.slots_cache[self.cur_slot_idx][3]
(type_val, id_val, amount) = parse_item_word(cur_val)
if type_val != self.type_val and type_val != 0:
cur_addr = self.slots_cache[
self.cur_slot_idx][1] + self.code_offset
self.log.emit(
'Cache error: val(0x%08X)=%08X, type (%02X) != expected (%02X)'
% (cur_addr, cur_val, type_val, self.type_val), 'red')
return
# Update UI
self.txt_id.setDisabled(False)
self.txt_id.setText('%03X' % id_val)
self.cmb_names.setDisabled(False)
self.fetchName()
self.txt_amount.setText(str(amount))
def setAlternateBGColor(self):
self.setStyleSheet(
'ItemEntriesFrame { background-color:rgb(248,248,248) }')
@pyqtSlot(int)
def onSetCodeOffset(self, signed_offset):
self.code_offset = signed_offset
@pyqtSlot()
def onRename(self):
id_txt = str(self.txt_id.text())
if len(id_txt) != 3:
return
dialog = FixItemNameDialog('%02X' % self.type_val, id_txt, self)
dialog.log.connect(self.log)
dialog.exec_()
@pyqtSlot()
def onReadSlots(self):
self.read_block.emit(self.addr_start + self.code_offset,
self.max_num_slots * 4 * 3)
@pyqtSlot(int, int, QByteArray)
def onBlockRead(self, addr_start_w_code_offset, num_bytes, raw_bytes):
# Determine whether block has cache or single slot
if (addr_start_w_code_offset == (self.addr_start + self.code_offset)
) and (num_bytes == self.max_num_slots * 4 * 3):
self.onCacheRead(addr_start_w_code_offset, raw_bytes)
elif num_bytes == 4: # Assume read slot
# Ignore if no cache
if not (0 <= self.cur_slot_idx < len(self.slots_cache)):
return
self.onSlotRead(addr_start_w_code_offset, raw_bytes)
def onCacheRead(self, addr_start_w_code_offset, raw_bytes):
slot_bytes = str(raw_bytes)
self.slots_cache = []
slots_txt = []
for slot_i in xrange(self.max_num_slots):
byte_offset = slot_i * 3 * 4
cur_slot_bytes = slot_bytes[byte_offset:(byte_offset + 4)]
if len(cur_slot_bytes) != 4:
continue
cur_slot_val = struct.unpack('>I', cur_slot_bytes)[0]
(type_val, id_val, amount) = parse_item_word(cur_slot_val)
if type_val == 0 or amount == 0:
continue
elif type_val != self.type_val:
self.log.emit(
'val(%08X)=%08X, type_val(%02X) unexpected(%02X)' %
(addr_start_w_code_offset + byte_offset, cur_slot_val,
type_val, self.type_val), 'red')
continue
else:
addr_val = addr_start_w_code_offset + byte_offset - self.code_offset # remove code_offset since it may change later
addr_hex = '%08X' % addr_val
slot_number = slot_i + 1
self.slots_cache.append(
(addr_hex, addr_val, slot_number, cur_slot_val))
slots_txt.append('Slot %03d' % slot_number)
# Update UI
self.log.emit(
'Found %d %s slots in memory' %
(len(self.slots_cache), self.label), 'black')
self.cmb_slots.clear()
if len(self.slots_cache) <= 0:
self.cmb_slots.setDisabled(True)
self.cur_slot_idx = -1
else:
self.cmb_slots.setDisabled(False)
self.cmb_slots.addItems(slots_txt)
self.cur_slot_idx = 0
self.updateUI()
def onSlotRead(self, addr_word_w_code_offset, raw_bytes):
addr_cur_slot = self.slots_cache[
self.cur_slot_idx][1] + self.code_offset
if addr_word_w_code_offset == addr_cur_slot:
cur_cache = self.slots_cache[self.cur_slot_idx]
new_val = struct.unpack('>I', str(raw_bytes))[0]
new_cache = (cur_cache[0], cur_cache[1], cur_cache[2], new_val)
self.slots_cache[self.cur_slot_idx] = new_cache
self.updateUI()
else: # Update cached value of other slots
addr_first_slot = self.slots_cache[0][1] + self.code_offset
addr_last_slot = self.slots_cache[-1][1] + self.code_offset
if (addr_first_slot <= addr_word_w_code_offset <= addr_last_slot) and \
((addr_word_w_code_offset - addr_first_slot) % 12 == 0):
for slot_i in xrange(len(self.slots_cache)):
addr_cur_slot = self.slots_cache[slot_i][
1] + self.code_offset
if addr_word_w_code_offset == addr_cur_slot:
cur_cache = self.slots_cache[slot_i]
new_val = struct.unpack('>I', str(raw_bytes))[0]
new_cache = (cur_cache[0], cur_cache[1], cur_cache[2],
new_val)
self.slots_cache[slot_i] = new_cache
return
@pyqtSlot()
def onSearchCacheForID(self):
# Stop if no cache
if not (0 <= self.cur_slot_idx < len(self.slots_cache)):
self.log.emit('Must cache slots before searching', 'red')
return
# Fetch and validate target ID
try:
target_id_val = int(str(self.txt_id.text()), 16)
if target_id_val < 0 or target_id_val > Item.MAX_ID_VAL:
self.log.emit('Item ID out of [0, 0x%03X] range' %
Item.MAX_ID_VAL)
return
except ValueError:
self.log.emit('Failed to parse item ID, expecting XXX', 'red')
return
# Search ID in cache
for cand_slot_idx in xrange(len(self.slots_cache)):
(type_val, id_val,
amount) = parse_item_word(self.slots_cache[cand_slot_idx][3])
if id_val == target_id_val and type_val == self.type_val:
self.cur_slot_idx = cand_slot_idx
self.cmb_slots.setCurrentIndex(self.cur_slot_idx)
self.updateUI()
return
self.log.emit(
'Did not find ID=%03X in %d cached %s slots' %
(target_id_val, len(self.slots_cache), self.label), 'red')
@pyqtSlot(int)
def onChangeSlot(self, new_slot_idx):
# Validate new_slot_idx
if not (0 <= new_slot_idx < len(self.slots_cache)):
return
# Update slot idx and read value from memory
self.cur_slot_idx = new_slot_idx
self.cmb_names.lineEdit().setText(ItemEntriesFrame.MISSING_ITEM_NAME)
self.cmb_names.setDisabled(True)
self.txt_id.setText('')
self.txt_id.setDisabled(True)
self.onReadSlot()
@pyqtSlot()
def fetchName(self):
try:
id_val = int(str(self.txt_id.text()), 16)
except ValueError:
return
name = self.MISSING_ITEM_NAME
if id_val in self.id2name:
name = self.id2name[id_val]
self.cmb_names.lineEdit().setText(name)
@pyqtSlot(int)
def fetchID(self, cmb_idx):
if cmb_idx < 0 or cmb_idx >= len(self.idx2id):
self.txt_id.setText('')
else:
self.txt_id.setText(self.idx2id[cmb_idx])
@pyqtSlot()
def onReadSlot(self):
try:
if not (0 <= self.cur_slot_idx < len(self.slots_cache)):
raise ValueError('must cache slots before reading')
addr_cur_slot = self.slots_cache[
self.cur_slot_idx][1] + self.code_offset
self.read_block.emit(addr_cur_slot, 4)
except ValueError, e:
cur_slot_num = self.slots_cache[self.cur_slot_idx][2]
self.log.emit(
'READ %s Slot %03d failed: %s' %
(self.label, cur_slot_num, str(e)), 'red')
except BaseException, e:
cur_slot_num = self.slots_cache[self.cur_slot_idx][2]
self.log.emit(
'READ %s Slot %03d failed: %s' %
(self.label, cur_slot_num, str(e)), 'red')
traceback.print_exc()
class MusicPreviewWidget(QWidget):
def __init__(self, parent=None):
super(MusicPreviewWidget, self).__init__(parent)
self._lastbuildtime = 10.0
self._running = None
self._current = None
self._chooserLabel = QLabel()
self._chooser = QComboBox(self, activated=self.selectDocument)
self._log = log.Log()
self._view = popplerview.View()
self._progress = widgets.progressbar.TimedProgressBar()
self._stack = QStackedLayout()
self._top = QWidget()
layout = QVBoxLayout()
self.setLayout(layout)
layout.addWidget(self._top)
layout.addLayout(self._stack)
layout.addWidget(self._progress)
top = QHBoxLayout()
top.setContentsMargins(0, 0, 0, 0)
top.setSpacing(2)
self._top.setLayout(top)
top.addWidget(self._chooserLabel)
top.addWidget(self._chooser)
top.addStretch(1)
self._stack.addWidget(self._log)
self._stack.addWidget(self._view)
self._top.hide()
app.aboutToQuit.connect(self.cleanup)
app.translateUI(self)
def translateUI(self):
self._chooserLabel.setText(_("Document:"))
def preview(self, text, title=None):
"""Runs LilyPond on the given text and shows the resulting PDF."""
j = self._running = MusicPreviewJob(text, title)
j.done.connect(self._done)
self._log.clear()
self._log.connectJob(j)
j.start()
self._progress.start(self._lastbuildtime)
def _done(self, success):
self._progress.stop(False)
pdfs = self._running.resultfiles()
self.setDocuments(pdfs)
if not pdfs:
self._stack.setCurrentWidget(self._log)
return
self._lastbuildtime = self._running.elapsed_time()
self._stack.setCurrentWidget(self._view)
if self._current:
self._current.cleanup()
self._current = self._running # keep the tempdir
self._running = None
def setDocuments(self, pdfs):
"""Loads the given PDF path names in the UI."""
self._documents = [popplertools.Document(name) for name in pdfs]
self._chooser.clear()
self._chooser.addItems([d.name() for d in self._documents])
self._top.setVisible(len(self._documents) > 1)
if pdfs:
self._chooser.setCurrentIndex(0)
self.selectDocument(0)
else:
self._view.clear()
def selectDocument(self, index):
doc = self._documents[index].document()
if doc:
self._view.load(doc)
def cleanup(self):
if self._running:
self._running.abort()
self._running.cleanup()
self._running = None
if self._current:
self._current.cleanup()
self._current = None
self._stack.setCurrentWidget(self._log)
self._top.hide()
self._view.clear()
def print_(self):
"""Prints the currently displayed document."""
if self._documents:
doc = self._documents[self._chooser.currentIndex()]
import popplerprint
popplerprint.printDocument(doc, self)
class ImportWindow(QWidget):
def __init__(self, parent, doc):
QWidget.__init__(self, parent, Qt.Window)
self._setupUi()
self.doc = doc
self.model = ImportWindowModel(document=doc.model)
self.swapOptionsComboBox = ComboboxModel(model=self.model.swap_type_list, view=self.swapOptionsComboBoxView)
self.table = ImportTable(model=self.model.import_table, view=self.tableView)
self.model.view = self
self._setupColumns() # Can only be done after the model has been connected
self.tabView.tabCloseRequested.connect(self.tabCloseRequested)
self.tabView.currentChanged.connect(self.currentTabChanged)
self.targetAccountComboBox.currentIndexChanged.connect(self.targetAccountChanged)
self.importButton.clicked.connect(self.importClicked)
self.swapButton.clicked.connect(self.swapClicked)
def _setupUi(self):
self.setWindowTitle(tr("Import"))
self.resize(557, 407)
self.verticalLayout = QtGui.QVBoxLayout(self)
self.tabView = QTabBar(self)
self.tabView.setMinimumSize(QtCore.QSize(0, 20))
self.verticalLayout.addWidget(self.tabView)
self.targetAccountLayout = QtGui.QHBoxLayout()
self.targetAccountLabel = QtGui.QLabel(tr("Target Account:"))
self.targetAccountLayout.addWidget(self.targetAccountLabel)
self.targetAccountComboBox = QComboBox(self)
self.targetAccountComboBox.setMinimumSize(QtCore.QSize(150, 0))
self.targetAccountLayout.addWidget(self.targetAccountComboBox)
spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
self.targetAccountLayout.addItem(spacerItem)
self.groupBox = QGroupBox(tr("Are some fields wrong? Fix them!"))
self.gridLayout = QtGui.QGridLayout(self.groupBox)
self.swapOptionsComboBoxView = QComboBox(self.groupBox)
self.gridLayout.addWidget(self.swapOptionsComboBoxView, 0, 0, 1, 2)
self.applyToAllCheckBox = QtGui.QCheckBox(tr("Apply to all accounts"))
self.gridLayout.addWidget(self.applyToAllCheckBox, 1, 0, 1, 1)
self.swapButton = QPushButton(tr("Fix"))
self.gridLayout.addWidget(self.swapButton, 1, 1, 1, 1)
self.targetAccountLayout.addWidget(self.groupBox)
self.verticalLayout.addLayout(self.targetAccountLayout)
self.tableView = TableView(self)
self.tableView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.tableView.setDragEnabled(True)
self.tableView.setDragDropMode(QtGui.QAbstractItemView.InternalMove)
self.tableView.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
self.tableView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.tableView.horizontalHeader().setHighlightSections(False)
self.tableView.horizontalHeader().setMinimumSectionSize(18)
self.tableView.verticalHeader().setVisible(False)
self.tableView.verticalHeader().setDefaultSectionSize(18)
self.verticalLayout.addWidget(self.tableView)
self.horizontalLayout = QtGui.QHBoxLayout()
spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem1)
self.importButton = QPushButton(tr("Import"))
self.horizontalLayout.addWidget(self.importButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.tabView.setTabsClosable(True)
self.tabView.setDrawBase(False)
self.tabView.setDocumentMode(True)
self.tabView.setUsesScrollButtons(True)
def _setupColumns(self):
# Can't set widget alignment in a layout in the Designer
l = self.targetAccountLayout
l.setAlignment(self.targetAccountLabel, Qt.AlignTop)
l.setAlignment(self.targetAccountComboBox, Qt.AlignTop)
#--- Event Handlers
def currentTabChanged(self, index):
self.model.selected_pane_index = index
def importClicked(self):
self.model.import_selected_pane()
def swapClicked(self):
applyToAll = self.applyToAllCheckBox.isChecked()
self.model.perform_swap(applyToAll)
def tabCloseRequested(self, index):
self.model.close_pane(index)
self.tabView.removeTab(index)
def targetAccountChanged(self, index):
self.model.selected_target_account_index = index
self.table.updateColumnsVisibility()
#--- model --> view
def close(self):
self.hide()
def close_selected_tab(self):
self.tabView.removeTab(self.tabView.currentIndex())
def refresh_target_accounts(self):
# We disconnect the combobox because we don't want the clear() call to set the selected
# target index in the model.
self.targetAccountComboBox.currentIndexChanged.disconnect(self.targetAccountChanged)
self.targetAccountComboBox.clear()
self.targetAccountComboBox.addItems(self.model.target_account_names)
self.targetAccountComboBox.currentIndexChanged.connect(self.targetAccountChanged)
def refresh_tabs(self):
while self.tabView.count():
self.tabView.removeTab(0)
for pane in self.model.panes:
self.tabView.addTab(pane.name)
def set_swap_button_enabled(self, enabled):
self.swapButton.setEnabled(enabled)
def show(self):
# For non-modal dialogs, show() is not enough to bring the window at the forefront, we have
# to call raise() as well
QWidget.show(self)
self.raise_()
def update_selected_pane(self):
index = self.model.selected_pane_index
if index != self.tabView.currentIndex(): # this prevents infinite loops
self.tabView.setCurrentIndex(index)
self.targetAccountComboBox.setCurrentIndex(self.model.selected_target_account_index)
self.table.updateColumnsVisibility()
class FindInFilesDialog(QDialog):
"""Dialog to configure and trigger the search in the files."""
def __init__(self, result_widget, parent):
super(FindInFilesDialog, self).__init__(parent)
self._find_thread = FindInFilesThread()
self.setWindowTitle(translations.TR_FIND_IN_FILES)
self.resize(400, 300)
#MAIN LAYOUT
main_vbox = QVBoxLayout(self)
self.pattern_line_edit = QLineEdit()
self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...")
self.dir_name_root = None
self.user_home = os.path.expanduser('~')
self.dir_combo = QComboBox()
self.dir_combo.addItem(self.user_home)
self.dir_combo.setEditable(True)
self.open_button = QPushButton(QIcon(":img/find"),
translations.TR_OPEN)
self.filters_line_edit = QLineEdit("*.py")
self.filters_line_edit.setPlaceholderText("*.py")
self.filters_line_edit.setCompleter(
QCompleter([
"*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS
]))
self.replace_line = QLineEdit()
self.replace_line.setEnabled(False)
self.replace_line.setPlaceholderText(translations.TR_TEXT_FOR_REPLACE +
"...")
self.check_replace = QCheckBox(translations.TR_REPLACE)
self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE)
self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION)
self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE)
self.recursive_checkbox.setCheckState(Qt.Checked)
self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE)
self.phrase_radio.setChecked(True)
self.words_radio = QRadioButton(
translations.TR_SEARCH_FOR_ALL_THE_WORDS)
self.find_button = QPushButton(translations.TR_FIND + "!")
self.find_button.setMaximumWidth(150)
self.cancel_button = QPushButton(translations.TR_CANCEL)
self.cancel_button.setMaximumWidth(150)
self.result_widget = result_widget
hbox = QHBoxLayout()
hbox.addWidget(self.find_button)
hbox.addWidget(self.cancel_button)
#main section
find_group_box = QGroupBox(translations.TR_MAIN)
grid = QGridLayout()
grid.addWidget(QLabel(translations.TR_TEXT), 0, 0)
grid.addWidget(self.pattern_line_edit, 0, 1)
grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0)
grid.addWidget(self.dir_combo, 1, 1)
grid.addWidget(self.open_button, 1, 2)
grid.addWidget(QLabel(translations.TR_FILTER), 2, 0)
grid.addWidget(self.filters_line_edit, 2, 1)
grid.addWidget(self.check_replace, 3, 0)
grid.addWidget(self.replace_line, 3, 1)
find_group_box.setLayout(grid)
#add main section to MAIN LAYOUT
main_vbox.addWidget(find_group_box)
#options sections
options_group_box = QGroupBox(translations.TR_OPTIONS)
gridOptions = QGridLayout()
gridOptions.addWidget(self.case_checkbox, 0, 0)
gridOptions.addWidget(self.type_checkbox, 1, 0)
gridOptions.addWidget(self.recursive_checkbox, 2, 0)
gridOptions.addWidget(self.phrase_radio, 0, 1)
gridOptions.addWidget(self.words_radio, 1, 1)
options_group_box.setLayout(gridOptions)
#add options sections to MAIN LAYOUT
main_vbox.addWidget(options_group_box)
#add buttons to MAIN LAYOUT
main_vbox.addLayout(hbox)
#Focus
self.pattern_line_edit.setFocus()
self.open_button.setFocusPolicy(Qt.NoFocus)
#signal
self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
self.connect(self.find_button, SIGNAL("clicked()"),
self._find_in_files)
self.connect(self.cancel_button, SIGNAL("clicked()"),
self._kill_thread)
self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
self._found_match)
self.connect(self._find_thread, SIGNAL("finished()"),
self._find_thread_finished)
self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
self._change_radio_enabled)
self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
self._replace_activated)
self.connect(self.words_radio, SIGNAL("clicked(bool)"),
self._words_radio_pressed)
def _replace_activated(self):
"""If replace is activated, display the replace widgets."""
self.replace_line.setEnabled(self.check_replace.isChecked())
self.phrase_radio.setChecked(True)
def _words_radio_pressed(self, value):
"""If search by independent words is activated, replace is not."""
self.replace_line.setEnabled(not value)
self.check_replace.setChecked(not value)
self.words_radio.setChecked(True)
def _change_radio_enabled(self, val):
"""Control the state of the radio buttons."""
enabled = not self.type_checkbox.isChecked()
self.phrase_radio.setEnabled(enabled)
self.words_radio.setEnabled(enabled)
def show(self, actual_project=None, actual=None):
"""Display the dialog and load the projects."""
self.dir_combo.clear()
self.dir_name_root = actual_project if \
actual_project else [self.user_home]
self.dir_combo.addItems(self.dir_name_root)
if actual:
index = self.dir_combo.findText(actual)
self.dir_combo.setCurrentIndex(index)
super(FindInFilesDialog, self).show()
self.pattern_line_edit.setFocus()
def reject(self):
"""Close the dialog and hide the tools dock."""
self._kill_thread()
tools_dock = IDE.get_service('tools_dock')
if tools_dock:
tools_dock.hide()
super(FindInFilesDialog, self).reject()
def _find_thread_finished(self):
"""Wait on thread finished."""
self.emit(SIGNAL("finished()"))
self._find_thread.wait()
def _select_dir(self):
"""When a new folder is selected, add to the combo if needed."""
dir_name = QFileDialog.getExistingDirectory(
self, translations.TR_OPEN, self.dir_combo.currentText(),
QFileDialog.ShowDirsOnly)
index = self.dir_combo.findText(dir_name)
if index >= 0:
self.dir_combo.setCurrentIndex(index)
else:
self.dir_combo.insertItem(0, dir_name)
self.dir_combo.setCurrentIndex(0)
def _found_match(self, result):
"""Update the tree for each match found."""
file_name = result[0]
items = result[1]
self.result_widget.update_result(self.dir_combo.currentText(),
file_name, items)
def _kill_thread(self):
"""Kill the thread."""
if self._find_thread.isRunning():
self._find_thread.cancel()
self.accept()
def _find_in_files(self):
"""Trigger the search on the files."""
self.emit(SIGNAL("findStarted()"))
self._kill_thread()
self.result_widget.clear()
pattern = self.pattern_line_edit.text()
dir_name = self.dir_combo.currentText()
filters = re.split("[,;]", self.filters_line_edit.text())
#remove the spaces in the words Ex. (" *.foo"--> "*.foo")
filters = [f.strip() for f in filters]
case_sensitive = self.case_checkbox.isChecked()
type_ = QRegExp.RegExp if \
self.type_checkbox.isChecked() else QRegExp.FixedString
recursive = self.recursive_checkbox.isChecked()
by_phrase = True
if self.phrase_radio.isChecked() or self.type_checkbox.isChecked():
regExp = QRegExp(pattern, case_sensitive, type_)
elif self.words_radio.isChecked():
by_phrase = False
type_ = QRegExp.RegExp
pattern = '|'.join([word.strip() for word in pattern.split()])
regExp = QRegExp(pattern, case_sensitive, type_)
#save a reference to the root directory where we find
self.dir_name_root = dir_name
self._find_thread.find_in_files(dir_name, filters, regExp, recursive,
by_phrase)
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(_("Scheme:"))
self.scheme = QComboBox()
self.label.setBuddy(self.scheme)
self.add = QPushButton(icons.get('list-add'), '')
self.remove = QPushButton(icons.get('list-remove'), '')
layout.addWidget(self.label)
layout.addWidget(self.scheme)
layout.addWidget(self.add)
layout.addWidget(self.remove)
self.scheme.currentIndexChanged.connect(self.slotSchemeChanged)
self.add.clicked.connect(self.addClicked)
self.remove.clicked.connect(self.removeClicked)
app.translateUI(self)
def translateUI(self):
self.label.setText(_("Scheme:"))
self.add.setText(_("New Scheme", "&New..."))
self.remove.setText(_("&Remove"))
def slotSchemeChanged(self, index):
"""Called when the Scheme combobox is changed by the user."""
self.remove.setEnabled(bool(index))
self.currentChanged.emit()
self.changed.emit()
def schemes(self):
"""Returns the list with internal names of currently available schemes."""
return self._schemes
def currentScheme(self):
"""Returns the internal name of the currently selected scheme"""
return self._schemes[self.scheme.currentIndex()]
def removeClicked(self):
index = self.scheme.currentIndex()
if index == 0:
return # default can not be removed
self._schemesToRemove.add(self._schemes[index])
del self._schemes[index]
del self._schemeNames[index]
self.scheme.removeItem(index)
def addClicked(self):
name, ok = QInputDialog.getText(self,
app.caption("Add Scheme"),
_("Please enter a name for the new scheme:"))
if not ok:
return
num, key = 1, 'user1'
while key in self._schemes or key in self._schemesToRemove:
num += 1
key = 'user{0}'.format(num)
self._schemes.append(key)
self._schemeNames.append(name)
self.scheme.addItem(name)
self.scheme.setCurrentIndex(self.scheme.count() - 1)
def loadSettings(self, currentKey, namesGroup):
# dont mark schemes for removal anymore
self._schemesToRemove = set()
s = QSettings()
cur = s.value(currentKey, "default")
# load the names for the shortcut schemes
s.beginGroup(namesGroup)
self._schemes = ["default"]
self._schemeNames = [_("Default")]
for key in s.childKeys():
self._schemes.append(key)
self._schemeNames.append(s.value(key, key))
block = self.scheme.blockSignals(True)
self.scheme.clear()
self.scheme.addItems(self._schemeNames)
# find out index
index = self._schemes.index(cur) if cur in self._schemes else 0
self.remove.setEnabled(bool(index))
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 scheme, name in zip(self._schemes, self._schemeNames)[1:]:
s.setValue(scheme, name)
# then remove removed schemes
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 IdeaBonus(QWidget):
costChanged = pyqtSignal()
def __init__(self, initialIndex=0, allowNone=True, parent=None):
super().__init__(parent=parent)
self.allowNone = allowNone
layout = QHBoxLayout()
self.bonusTypeSelect = QComboBox()
if allowNone:
self.bonusTypeSelect.addItems(eu4cd.ideaoptions.bonusTypes)
else:
self.bonusTypeSelect.addItems(eu4cd.ideaoptions.bonusTypes[1:])
layout.addWidget(self.bonusTypeSelect)
self.bonusValueSelect = QComboBox()
layout.addWidget(self.bonusValueSelect)
self.setLayout(layout)
self.bonusTypeSelect.currentIndexChanged.connect(self.resetBonusValue)
self.bonusValueSelect.currentIndexChanged.connect(
self.handleCostChanged)
# TODO: clean this up
self.resetBonusValue(0)
self.setBonusTypeIndex(initialIndex)
def resetBonusValue(self, selectIndex):
if self.allowNone:
index = selectIndex
else:
index = selectIndex + 1
options, self.values, self.costs = eu4cd.ideaoptions.generateOptions(
index)
defaultIndex = eu4cd.ideaoptions.getClosestValueIndex(
self.values, eu4cd.ideaoptions.bonusNormalValues[index])
self.bonusValueSelect.clear()
self.bonusValueSelect.addItems(options)
self.bonusValueSelect.setCurrentIndex(defaultIndex)
def getBonusTypeIndex(self):
if self.allowNone:
return self.bonusTypeSelect.currentIndex()
else:
return self.bonusTypeSelect.currentIndex() + 1
def setBonusTypeIndex(self, index):
if self.allowNone:
self.bonusTypeSelect.setCurrentIndex(index)
else:
self.bonusTypeSelect.setCurrentIndex(max(index - 1, 0))
def getType(self):
return eu4cd.ideaoptions.bonusTypes[self.getBonusTypeIndex()]
def getValue(self):
return self.values[self.bonusValueSelect.currentIndex()]
def getCost(self):
return self.costs[self.bonusValueSelect.currentIndex()]
def handleCostChanged(self):
self.costChanged.emit()
class OWImpute(OWWidget):
name = "Impute"
description = "Imputes missing values in the data table."
icon = "icons/Impute.svg"
priority = 2130
inputs = [("Data", Orange.data.Table, "set_data"),
("Learner", Orange.classification.Learner, "set_learner")]
outputs = [("Data", Orange.data.Table)]
METHODS = METHODS
settingsHandler = settings.DomainContextHandler()
default_method = settings.Setting(1)
variable_methods = settings.ContextSetting({})
autocommit = settings.Setting(True)
want_main_area = False
def __init__(self, parent=None):
super().__init__(parent)
self.modified = False
box = group_box(self.tr("Default method"),
layout=layout(Qt.Vertical))
self.controlArea.layout().addWidget(box)
bgroup = QButtonGroup()
for i, m in enumerate(self.METHODS[1:-1], 1):
b = radio_button(m.name, checked=i == self.default_method,
group=bgroup, group_id=i)
box.layout().addWidget(b)
self.defbggroup = bgroup
bgroup.buttonClicked[int].connect(self.set_default_method)
box = group_box(self.tr("Individual attribute settings"),
layout=layout(Qt.Horizontal))
self.controlArea.layout().addWidget(box)
self.varview = QtGui.QListView(
selectionMode=QtGui.QListView.ExtendedSelection
)
self.varview.setItemDelegate(DisplayFormatDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._on_var_selection_changed
)
self.selection = self.varview.selectionModel()
box.layout().addWidget(self.varview)
method_layout = layout(Qt.Vertical, margins=0)
box.layout().addLayout(method_layout)
methodbox = group_box(layout=layout(Qt.Vertical))
bgroup = QButtonGroup()
for i, m in enumerate(self.METHODS):
b = radio_button(m.name, group=bgroup, group_id=i)
methodbox.layout().addWidget(b)
assert self.METHODS[-1].short == "value"
self.value_stack = value_stack = QStackedLayout()
self.value_combo = QComboBox(activated=self._on_value_changed)
self.value_line = QLineEdit(editingFinished=self._on_value_changed)
self.value_line.setValidator(QDoubleValidator())
value_stack.addWidget(self.value_combo)
value_stack.addWidget(self.value_line)
methodbox.layout().addLayout(value_stack)
bgroup.buttonClicked[int].connect(
self.set_method_for_current_selection
)
reset_button = push_button("Restore all to default",
clicked=self.reset_var_methods,
default=False, autoDefault=False)
method_layout.addWidget(methodbox)
method_layout.addStretch(2)
method_layout.addWidget(reset_button)
self.varmethodbox = methodbox
self.varbgroup = bgroup
commitbox = group_box("Commit", layout=layout(margins=0))
cwidget = commit_widget(
button_text="Commit",
button_default=True,
check_text="Commit on any change",
checked=self.autocommit,
clicked=self.commit
)
def toggle_auto_commit(b):
self.autocommit = b
if self.modified:
self.commit()
cwidget.auto_commit_check.toggled[bool].connect(toggle_auto_commit)
commitbox.layout().addWidget(cwidget)
self.addAction(cwidget.commit_action)
self.controlArea.layout().addWidget(commitbox)
self.data = None
self.learner = None
def set_default_method(self, index):
"""
Set the current selected default imputation method.
"""
if self.default_method != index:
self.default_method = index
self.defbggroup.button(index).setChecked(True)
self._invalidate()
def set_data(self, data):
self.closeContext()
self.clear()
self.data = data
if data is not None:
self.varmodel[:] = data.domain.variables
self.openContext(data.domain)
self.restore_state(self.variable_methods)
itemmodels.select_row(self.varview, 0)
self.commit()
def set_learner(self, learner):
self.learner = learner
if self.data is not None and \
any(state.model.short == "model" for state in
map(self.state_for_column, range(len(self.data.domain)))):
self.commit()
def restore_state(self, state):
for i, var in enumerate(self.varmodel):
key = variable_key(var)
if key in state:
index = self.varmodel.index(i)
self.varmodel.setData(index, state[key], Qt.UserRole)
def clear(self):
self.varmodel[:] = []
self.variable_methods = {}
self.data = None
self.modified = False
def state_for_column(self, column):
"""
#:: int -> State
Return the effective imputation state for `column`.
:param int column:
:rtype State:
"""
var = self.varmodel[column]
state = self.variable_methods.get(variable_key(var), None)
if state is None or state.method == METHODS[0]:
state = State(METHODS[self.default_method], ())
return state
def imputer_for_column(self, column):
state = self.state_for_column(column)
data = self.data
var = data.domain[column]
method, params = state
if method.short == "leave":
return None
elif method.short == "avg":
return column_imputer_average(var, data)
elif method.short == "model":
learner = self.learner if self.learner is not None else MeanLearner()
return column_imputer_by_model(var, data, learner=learner)
elif method.short == "random":
return column_imputer_random(var, data)
elif method.short == "value":
return column_imputer_defaults(var, data, float(params[0]))
elif method.short == "as_value":
return column_imputer_as_value(var, data)
else:
assert False
def commit(self):
if self.data is not None:
states = [self.state_for_column(i)
for i in range(len(self.varmodel))]
# Columns to filter unknowns by dropping rows.
filter_columns = [i for i, state in enumerate(states)
if state.method.short == "drop"]
impute_columns = [i for i, state in enumerate(states)
if state.method.short not in ["drop", "leave"]]
imputers = [(self.varmodel[i], self.imputer_for_column(i))
for i in impute_columns]
data = self.data
if imputers:
table_imputer = ImputerModel(data.domain, dict(imputers))
data = table_imputer(data)
if filter_columns:
filter_ = data_filter.IsDefined(filter_columns)
data = filter_(data)
else:
data = None
self.send("Data", data)
self.modified = False
def _invalidate(self):
self.modified = True
if self.autocommit:
self.commit()
def _on_var_selection_changed(self):
indexes = self.selection.selectedIndexes()
vars = [self.varmodel[index.row()] for index in indexes]
defstate = State(METHODS[0], ())
states = [self.variable_methods.get(variable_key(var), defstate)
for var in vars]
all_cont = all(isinstance(var, Orange.data.ContinuousVariable)
for var in vars)
states = list(unique(states))
method = None
params = ()
state = None
if len(states) == 1:
state = states[0]
method, params = state
mindex = METHODS.index(method)
self.varbgroup.button(mindex).setChecked(True)
elif self.varbgroup.checkedButton() is not None:
self.varbgroup.setExclusive(False)
self.varbgroup.checkedButton().setChecked(False)
self.varbgroup.setExclusive(True)
values, enabled, stack_index = [], False, 0
value, value_index = "0.0", 0
if all_cont:
enabled, stack_index = True, 1
if method is not None and method.short == "value":
value = params[0]
elif len(vars) == 1 and \
isinstance(vars[0], Orange.data.DiscreteVariable):
values, enabled, stack_index = vars[0].values, True, 0
if method is not None and method.short == "value":
try:
value_index = values.index(params[0])
except IndexError:
pass
self.value_stack.setCurrentIndex(stack_index)
self.value_stack.setEnabled(enabled)
if stack_index == 0:
self.value_combo.clear()
self.value_combo.addItems(values)
self.value_combo.setCurrentIndex(value_index)
else:
self.value_line.setText(value)
def _on_value_changed(self):
# The "fixed" value in the widget has been changed by the user.
index = self.varbgroup.checkedId()
self.set_method_for_current_selection(index)
def set_method_for_current_selection(self, methodindex):
indexes = self.selection.selectedIndexes()
self.set_method_for_indexes(indexes, methodindex)
def set_method_for_indexes(self, indexes, methodindex):
method = METHODS[methodindex]
params = (None,)
if method.short == "value":
if self.value_stack.currentIndex() == 0:
value = self.value_combo.currentIndex()
else:
value = self.value_line.text()
params = (value, )
elif method.short == "model":
params = ("model", )
state = State(method, params)
for index in indexes:
self.varmodel.setData(index, state, Qt.UserRole)
var = self.varmodel[index.row()]
self.variable_methods[variable_key(var)] = state
self._invalidate()
def reset_var_methods(self):
indexes = map(self.varmodel.index, range(len(self.varmodel)))
self.set_method_for_indexes(indexes, 0)
class ExportPanel(QWidget):
updateExportButton = pyqtSignal(str, bool)
runExport = pyqtSignal(dict)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setMinimumWidth(500)
self.setMinimumHeight(200)
self._dynamic = False
self.setWindowTitle("Export data")
self.activateWindow()
layout = QFormLayout()
current_case = getCurrentCaseName()
self._case_model = AllCasesModel()
self._case_combo = QComboBox()
self._case_combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self._case_combo.setMinimumContentsLength(20)
self._case_combo.setModel(self._case_model)
self._case_combo.setCurrentIndex(self._case_model.indexOf(current_case))
layout.addRow("Select case:", self._case_combo)
self._export_keyword_model = ExportKeywordModel()
self._kw_model = self._export_keyword_model.getKeyWords()
self._keywords = QComboBox()
self._keywords.addItems(self._kw_model)
layout.addRow("Select keyword:", self._keywords)
self._active_realizations_model = ActiveRealizationsModel()
self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations")
self._active_realizations_field.setValidator(RangeStringArgument())
self._active_realizations_field.getValidationSupport().validationChanged.connect(self.validateExportDialog)
layout.addRow("Active realizations:", self._active_realizations_field)
file_name_button = QToolButton()
file_name_button.setText("Browse")
file_name_button.clicked.connect(self.selectFileDirectory)
self._defaultPath = QDir.currentPath() + "/export"
self._file_name = QLineEdit()
self._file_name.setEnabled(False)
self._file_name.setText(self._defaultPath)
self._file_name.textChanged.connect(self.validateExportDialog)
self._file_name.setMinimumWidth(250)
file_name_layout = QHBoxLayout()
file_name_layout.addWidget(self._file_name)
file_name_layout.addWidget(file_name_button)
layout.addRow("Select directory to save files to:", file_name_layout)
self._gen_kw_file_types = ["Parameter list", "Template based"]
self._field_kw_file_types = ["Eclipse GRDECL", "RMS roff"]
self._gen_data_file_types = ["Gen data"]
self._file_type_model = self._field_kw_file_types
self._file_type_combo = QComboBox()
self._file_type_combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self._file_type_combo.addItems(self._file_type_model)
layout.addRow("Select file format:", self._file_type_combo)
self._report_step = QLineEdit()
layout.addRow("Report step:", self._report_step)
self._gen_data_report_step_model = []
self._gen_data_report_step = QComboBox()
layout.addRow("Report step:", self._gen_data_report_step)
self.setLayout(layout)
self._keywords.currentIndexChanged.connect(self.keywordSelected)
self.keywordSelected()
def selectFileDirectory(self):
directory = QFileDialog().getExistingDirectory(self, "Directory", self._file_name.text(), QFileDialog.ShowDirsOnly)
if str(directory).__len__() > 0:
self._file_name.setText(str(directory))
def updateFileExportType(self, keyword):
self._file_type_combo.clear()
if self._export_keyword_model.isGenKw(keyword):
self._file_type_model = self._gen_kw_file_types
elif self._export_keyword_model.isGenParamKw(keyword):
self._file_type_model = self._gen_data_file_types
elif self._export_keyword_model.isGenDataKw(keyword):
self._file_type_model = self._gen_data_file_types
else:
self._file_type_model = self._field_kw_file_types
self._file_type_combo.addItems(self._file_type_model)
def export(self):
keyword = self._kw_model[self._keywords.currentIndex()]
try:
report_step = self.getReportStep(keyword)
except IndexError as e:
QMessageBox.question(self, 'Error', e.args[0], QMessageBox.NoButton)
return
all_cases = self._case_model.getAllItems()
selected_case = all_cases[self._case_combo.currentIndex()]
path = self._file_name.text()
iactive = self._active_realizations_model.getActiveRealizationsMask()
file_type_key = self._file_type_model[self._file_type_combo.currentIndex()]
values = {"keyword": keyword,
"report_step": report_step,
"iactive": iactive,
"file_type_key": file_type_key,
"path": path,
"selected_case": selected_case}
self.runExport.emit(values)
def getReportStep(self, key):
report_step = 0
if self._dynamic:
report_step = self._report_step.text()
if self._export_keyword_model.isGenParamKw(key):
return report_step
if self._export_keyword_model.isGenDataKw(key):
lst = self._gen_data_report_step_model
idx = self._gen_data_report_step.currentIndex()
if lst and len(lst) > idx:
report_step = lst[idx]
else:
raise IndexError('No such model step: %d. Valid range: [0, %d)' % (idx, len(lst)))
return report_step
def keywordSelected(self):
key = self._kw_model[self._keywords.currentIndex()]
self.updateFileExportType(key)
self._dynamic = False
if self._export_keyword_model.isFieldKw(key):
self._dynamic = self._export_keyword_model.isDynamicField(key)
self._report_step.setVisible(self._dynamic)
self.layout().labelForField(self._report_step).setVisible(self._dynamic)
self._gen_data_report_step.setVisible(self._export_keyword_model.isGenDataKw(key))
self.layout().labelForField(self._gen_data_report_step).setVisible(self._export_keyword_model.isGenDataKw(key))
if self._export_keyword_model.isGenDataKw(key):
data = self._export_keyword_model.getGenDataReportSteps(key)
self._gen_data_report_step_model = data
self._gen_data_report_step.clear()
self._gen_data_report_step.addItems(self._gen_data_report_step_model)
def setSelectedCase(self, selected_case):
self._case_combo.setCurrentIndex(self._case_model.indexOf(selected_case))
def validateExportDialog(self):
validRealizations = False
if self._active_realizations_field.isValid():
validRealizations = True
path = str(self._file_name.text())
validPath = len(path) > 0
if validRealizations and validPath:
self.updateExportButton.emit("export", True)
else:
self.updateExportButton.emit("export", False)
class LDSControls(QFrame):
STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png')
ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif')
IMG_SPEED = 100
IMG_WIDTH = 64
IMG_HEIGHT = 64
MAX_WD = 450
GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data'))
STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN')
def __init__(self,parent):
super(LDSControls, self).__init__()
self.parent = parent
self.initConf()
self.initEPSG()
self.initUI()
def initConf(self):
'''Read files in conf dir ending in conf'''
self.cflist = ConfigInitialiser.getConfFiles()
#self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
#self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf)
self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME)
def initEPSG(self):
'''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld'''
gcsf = gdal.FindFile('gdal','gcs.csv')
if not gcsf:
gcsf = os.path.join(self.GD_PATH,'gcs.csv')
pcsf = gdal.FindFile('gdal','pcs.csv')
if not pcsf:
pcsf = os.path.join(self.GD_PATH,'pcs.csv')
gcs = ConfigInitialiser.readCSV(gcsf)
pcs = ConfigInitialiser.readCSV(pcsf)
self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]]
self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]]
def initUI(self):
# 0 1 2 3 4 5 6 7 8
#'destname','lgselect','layer','uconf','group','epsg','fd','td','int'
#self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist
QToolTip.setFont(QFont('SansSerif', 10))
#labels
destLabel = QLabel('Destination')
lgLabel = QLabel('Group/Layer')
epsgLabel = QLabel('EPSG')
fromDateLabel = QLabel('From Date')
toDateLabel = QLabel('To Date')
confLabel = QLabel('User Config')
self.view = QLabel()
self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.view.setAlignment(Qt.AlignCenter)
self.confcombo = QComboBox(self)
self.confcombo.setToolTip('Enter your user config name (file) here')
self.confcombo.addItems(self.cflist)
self.confcombo.setEditable(False)
#self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate)
#combos
self.lgcombo = QComboBox(self)
self.lgcombo.setMaximumWidth(self.MAX_WD)
self.lgcombo.setDuplicatesEnabled(False)
#self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work
self.lgcombo.setToolTip('Select either Layer or Group entry')
self.lgcombo.setEditable(False)
self.sepindex = None
#self.updateLGValues()
self.epsgcombo = QComboBox(self)
self.epsgcombo.setMaximumWidth(self.MAX_WD)
self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer')
self.epsgcombo.addItems([i[1] for i in self.nzlsr])
self.epsgcombo.insertSeparator(len(self.nzlsr))
self.epsgcombo.addItems([i[1] for i in self.rowsr])
self.epsgcombo.setEditable(True)
self.epsgcombo.setEnabled(False)
self.destlist = self.getConfiguredDestinations()
self.destcombo = QComboBox(self)
self.destcombo.setToolTip('Choose the desired output type')
self.destcombo.setEditable(False)
self.destcombo.addItems(self.destlist)
#date selection
self.fromdateedit = QDateEdit()
self.fromdateedit.setCalendarPopup(True)
self.fromdateedit.setEnabled(False)
self.todateedit = QDateEdit()
self.todateedit.setCalendarPopup(True)
self.todateedit.setEnabled(False)
#check boxes
self.epsgenable = QCheckBox()
self.epsgenable.setCheckState(False)
self.epsgenable.clicked.connect(self.doEPSGEnable)
self.fromdateenable = QCheckBox()
self.fromdateenable.setCheckState(False)
self.fromdateenable.clicked.connect(self.doFromDateEnable)
self.todateenable = QCheckBox()
self.todateenable.setCheckState(False)
self.todateenable.clicked.connect(self.doToDateEnable)
self.progressbar = QProgressBar()
self.progressbar.setRange(0,100)
self.progressbar.setVisible(True)
self.progressbar.setMinimumWidth(self.MAX_WD)
#buttons
self.initbutton = QPushButton("waiting")
self.initbutton.setToolTip('Initialise the Layer Configuration')
self.initbutton.clicked.connect(self.doInitClickAction)
self.cleanbutton = QPushButton("Clean")
self.cleanbutton.setToolTip('Clean the selected layer/group from local storage')
self.cleanbutton.clicked.connect(self.doCleanClickAction)
self.replicatebutton = QPushButton("Replicate")
self.replicatebutton.setToolTip('Execute selected replication')
self.replicatebutton.clicked.connect(self.doReplicateClickAction)
self.cancelbutton = QPushButton("Close")
self.cancelbutton.setToolTip('Close the LDS Replicate application')
self.cancelbutton.clicked.connect(self.parent.close)
#set dialog values using GPR
self.updateGUIValues(self.parent.gvs)
#set onchange here otherwise we get circular initialisation
self.destcombo.currentIndexChanged.connect(self.doDestChanged)
self.confcombo.currentIndexChanged.connect(self.doConfChanged)
self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged)
self.setStatus(self.STATUS.IDLE)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#placement section ------------------------------------
#---------+---------+--------+---------+--------
# dest LB | | dest DD
# grp LB | | grp DD
# conf LB | | conf DD
# epsg L | epsg CB | epsg DD
# f dt L | f dt CB | f dt DD
# t td L | t td CB | t td DD
# icon | <- progress ->
# layer B | <- . -> |repl B | clean B | close B
#---------+---------+--------+---------+--------
grid.addWidget(destLabel, 1, 0)
grid.addWidget(self.destcombo, 1, 2)
#grid.addWidget(layerLabel, 2, 0)
grid.addWidget(lgLabel, 2, 0)
grid.addWidget(self.lgcombo, 2, 2)
grid.addWidget(confLabel, 3, 0)
grid.addWidget(self.confcombo, 3, 2)
#grid.addWidget(groupLabel, 4, 0)
#grid.addWidget(self.groupEdit, 4, 2)
grid.addWidget(epsgLabel, 5, 0)
grid.addWidget(self.epsgenable, 5, 1)
grid.addWidget(self.epsgcombo, 5, 2)
grid.addWidget(fromDateLabel, 6, 0)
grid.addWidget(self.fromdateenable, 6, 1)
grid.addWidget(self.fromdateedit, 6, 2)
grid.addWidget(toDateLabel, 7, 0)
grid.addWidget(self.todateenable, 7, 1)
grid.addWidget(self.todateedit, 7, 2)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.view)
hbox3.addStretch(1)
hbox3.addWidget(self.progressbar)
#hbox3.addLayout(vbox2)
#hbox3.addLayout(vbox3)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.initbutton)
hbox4.addStretch(1)
hbox4.addWidget(self.replicatebutton)
hbox4.addWidget(self.cleanbutton)
hbox4.addWidget(self.cancelbutton)
vbox = QVBoxLayout()
#vbox.addStretch(1)
vbox.addLayout(grid)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#def setProgress(self,pct):
# self.progressbar.setValue(pct)
def setStatus(self,status,message='',tooltip=None):
'''Sets indicator icon and statusbar message'''
self.parent.statusbar.showMessage(message)
self.parent.statusbar.setToolTip(tooltip if tooltip else '')
#progress
loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status]))
#loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status]))
self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN))
#icon
anim = QMovie(loc, QByteArray(), self)
anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT))
anim.setCacheMode(QMovie.CacheAll)
anim.setSpeed(self.IMG_SPEED)
self.view.clear()
self.view.setMovie(anim)
anim.start()
self.view.repaint()
QApplication.processEvents(QEventLoop.AllEvents)
def mainWindowEnable(self,enable=True):
cons = (self.lgcombo, self.confcombo, self.destcombo,
self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton,
self.epsgenable,self.fromdateenable,self.todateenable,
self.parent.menubar)
for c in cons:
c.setEnabled(enable)
if enable:
self.epsgcombo.setEnabled(self.epsgenable.checkState())
self.fromdateedit.setEnabled(self.fromdateenable.checkState())
self.todateedit.setEnabled(self.todateenable.checkState())
else:
self.epsgcombo.setEnabled(False)
self.fromdateedit.setEnabled(False)
self.todateedit.setEnabled(False)
QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
def refreshLGCombo(self):
'''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups'''
self.lgcombo.clear()
self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist])
#NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l)
#if self.sepindex:
# self.lgcombo.removeItem(self.sepindex)
self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP)
self.lgcombo.insertSeparator(self.sepindex)
def updateLGValues(self,uconf,lgval,dest):
'''Sets the values displayed in the Layer/Group combo'''
#because we cant seem to sort combobox entries and want groups at the top, clear and re-add
#TRACE#
#pdb.set_trace()
sf = None
try:
self.parent.confconn.initConnections(uconf,lgval,dest)
except Exception as e:
sf=1
ldslog.error('Error Updating UC Values. '+str(e))
if sf:
self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e))
else:
self.setStatus(self.STATUS.IDLE)
self.refreshLGCombo()
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def gprParameters(self,rdest):
'''Zip default and GPR values'''
return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])]
def getLCE(self,ln):
'''Read layer parameters'''
dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
#sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf)
self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False)
lce = dep.getLayerConf().readLayerParameters(ln)
#self.parent.confconn.reg.closeEndPoint('WFS')
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
sep,dep = None,None
return lce
def doDestChanged(self):
'''Read the destname parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rvals = self.gprParameters(rdest)
self.updateGUIValues([rdest]+rvals)
def doConfChanged(self):
'''Read the user conf parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rlg,_,rep,rfd,rtd = self.gprParameters(rdest)
ruc = str(self.cflist[self.confcombo.currentIndex()])
self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd))
def doLGComboChanged(self):
'''Read the layer/group value and change epsg to layer or gpr match'''
#get a matching LG entry and test whether its a layer or group
#lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#lgi can be none if we init a new group, in which case we use the GPR value
if lgi:
lge = self.parent.confconn.lglist[lgi]
lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None
else:
lce = None
#look for filled layer conf epsg OR use prefs stored in gpr
if lce and LU.assessNone(lce.epsg):
epsgval = lce.epsg
else:
rdest = str(self.destlist[self.destcombo.currentIndex()])
_,_,epsgval,_,_ = self.gprParameters(rdest)
epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(int(epsgindex))
def updateGUIValues(self,readlist):
'''Fill dialog values from provided list'''
#TODO. Remove circular references when setCurrentIndex() triggers do###Changed()
#Read user input
rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist
#--------------------------------------------------------------------
#Destination Menu
selecteddest = LU.standardiseDriverNames(rdest)
if selecteddest not in self.destlist:
self.destlist = self.getConfiguredDestinations()
self.destcombo.addItem(selecteddest)
destindex = self.destlist.index(selecteddest) if selecteddest else 0
if self.destcombo.currentIndex() != destindex:
self.destcombo.setCurrentIndex(destindex)
#InitButton
self.initbutton.setText('Layer Select')
#Config File
confindex = 0
if LU.assessNone(ruconf):
ruconf = ruconf.split('.')[0]
if ruconf not in self.cflist:
self.cflist += [ruconf,]
self.confcombo.addItem(ruconf)
confindex = self.cflist.index(ruconf)
if self.confcombo.currentIndex() != confindex:
self.confcombo.setCurrentIndex(confindex)
#self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '')
#Layer/Group Selection
self.updateLGValues(ruconf,self.rlgval,rdest)
lgindex = None
if LU.assessNone(self.rlgval):
#index of list value
lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1)
if LU.assessNone(lgindex):
#advance by 1 for sep
lgindex += 1 if lgindex>self.sepindex else 0
else:
#using the separator index sets the combo to blank
lgindex = self.sepindex
if self.lgcombo.currentIndex() != lgindex:
self.lgcombo.setCurrentIndex(lgindex)
#self.doLGEditUpdate()
#EPSG
# user > layerconf
#useepsg = LU.precedence(repsg, lce.epsg if lce else None, None)
epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(epsgindex)
#epsgedit = self.epsgcombo.lineEdit()
#epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0])
#epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0])
#To/From Dates
if LU.assessNone(rfd):
self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10])))
else:
early = DataStore.EARLIEST_INIT_DATE
self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10])))
if LU.assessNone(rtd):
self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10])))
else:
today = DataStore.getCurrent()
self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10])))
#Internal/External CheckBox
# if LU.assessNone(rint):
# self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT)
# else:
# self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT)
def getConfiguredDestinations(self):
defml = ['',]+DataStore.DRIVER_NAMES.values()
return [d for d in self.parent.gpr.getDestinations() if d in defml]
def doEPSGEnable(self):
self.epsgcombo.setEnabled(self.epsgenable.isChecked())
def doFromDateEnable(self):
self.fromdateedit.setEnabled(self.fromdateenable.isChecked())
def doToDateEnable(self):
self.todateedit.setEnabled(self.todateenable.isChecked())
def readParameters(self):
'''Read values out of dialogs'''
destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()]))
#lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#NB need to test for None explicitly since zero is a valid index
lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None
#uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text()))
#uconf = str(self.confcombo.lineEdit().text())
uconf = str(self.cflist[self.confcombo.currentIndex()])
ee = self.epsgenable.isChecked()
epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1)
fe = self.fromdateenable.isChecked()
te = self.todateenable.isChecked()
fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd'))
td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd'))
return destination,lgval,uconf,epsg,fe,te,fd,td
def doInitClickAction(self):
'''Initialise the LC on LC-button-click, action'''
try:
try:
self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor')
self.progressbar.setValue(0)
self.parent.runLayerConfigAction()
finally:
self.setStatus(self.STATUS.IDLE,'Ready')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e))
def doCleanClickAction(self):
'''Set clean anim and run clean'''
#lgo = self.lgcombo.currentText().toUtf8().data()
lgo = LQ.readWidgetText(self.lgcombo.currentText())
try:
self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(True)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e))
def doReplicateClickAction(self):
'''Set busy anim and run repl'''
lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages
try:
self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(False)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e))
def runReplicationScript(self,clean=False):
'''Run the layer/group repliction script'''
destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters()
uconf_path = LU.standardiseUserConfigName(uconf)
destination_path = LU.standardiseLayerConfigName(destination)
destination_driver = LU.standardiseDriverNames(destination)
if not os.path.exists(uconf_path):
self.userConfMessage(uconf_path)
return
elif not MainFileReader(uconf_path).hasSection(destination_driver):
self.userConfMessage(uconf_path,destination_driver)
return
#-----------------------------------------------------
#'destname','layer','uconf','group','epsg','fd','td','int'
self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td))
ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg))
ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te))
lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1)
#lorg = self.parent.confconn.lglist[lgindex][0]
#----------don't need lorg in TP anymore but it is useful for sorting/counting groups
#self.parent.confconn.tp.setLayerOrGroup(lorg)
self.parent.confconn.tp.setLayerGroupValue(lgval)
if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd)
if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td)
self.parent.confconn.tp.setUserConf(uconf)
if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg)
#because clean state persists in TP
if clean:
self.parent.confconn.tp.setCleanConfig()
else:
self.parent.confconn.tp.clearCleanConfig()
#(re)initialise the data source since uconf may have changed
#>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper()
#--------------------------
###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
###ep = None
#Open ProcessRunner and run with TP(proc)/self(gui) instances
#HACK temp add of dest_drv to PR call
try:
#TODO. Test for valid LC first
self.tpr = ProcessRunner(self,destination_driver)
except Exception as e:
ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path))
self.layerConfMessage(destination_path)
return
#If PR has been successfully created we must vave a valid dst
self.tpr.start()
def quitProcessRunner(self):
self.tpr.join()
self.tpr.quit()
self.trp = None
def userConfMessage(self,uconf,secname=None):
ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete',
'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section',
'Back','Initialise User Config')
if not ucans:
#Retry
ldslog.warn('Retry specifying UC')
#self.confcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset User Config Wizard')
self.parent.runWizardAction()
def layerConfMessage(self,dest):
lcans = QMessageBox.warning(self, 'Layer Config Missing',
'Required Layer-Config file, '+str(dest)+' does not exist',
'Back','Run Layer Select')
if not lcans:
#Retry
ldslog.warn('Retry specifying LC')
#self.destcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset Layer Config')
self.doInitClickAction()
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 Mplayer(QDialog):
REVENIR, PAS_PRECEDENT_SUIVANT, PRECEDENT_SUIVANT, CURSEUR_SUR_UNE_LIGNE,\
CURSEUR_A_PART, PARCOURIR, PAS_PARCOURIR, LIST, RATIO = range(9)
HAUTEUR, LARGEUR = range(2)
def __init__(self, cheminVideo=[], taille=(250,225),
choixWidget=(RATIO, REVENIR, PAS_PRECEDENT_SUIVANT,CURSEUR_SUR_UNE_LIGNE,PAS_PARCOURIR,LIST),
debutFin=(0,0), cheminMPlayer=None, barreTaches=None, facteurLimitant=HAUTEUR,
cheminParcourir=None, parent=None):
"""widget mplayer"""
QDialog.__init__(self, parent)
#=== Paramètres généraux ===#
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_(u"Player vidéo"))
#On réduit la marge pour gagner de l'espace
self.setContentsMargins(0,0,0,0)
self.systeme = os.name
### Quand EKD windows est installé, le chemin des dépendances sont ###########
### positionnées dans les variables d'environnement donc pas besoin de #######
### collecter le chemin des ces dépendances ##################################
self.cheminMPlayer = "mplayer"
##############################################################################
# liste de chemins vidéos
if type(cheminVideo) != list :
self.listeVideos=[cheminVideo]
else :
self.listeVideos = cheminVideo
# est-ce que la vidéo est lue?
self.estLue=False
# est-ce que la vidéo est en pause?
self.estEnPause=False
self.debutFin = debutFin
# Nom du fichier courant (le self n'est pas encore utile)
txtParDefaut = u"Pas de fichier lu"
if self.listeVideos.__len__()!=0:
self.fichierCourant = [txtParDefaut, self.listeVideos[0]]
else: self.fichierCourant = [txtParDefaut, ""]
# Barre des tâches de la fenêtre
self.barreTaches = barreTaches
# Taille de la vidéo
self.tailleLargeur=taille[0]
self.tailleHauteur=taille[1]
# paramètres des boutons-icones
iconTaille=22
flat=1
# Pour récupérer le temps courant depuis certains cadre
self.temps = 0
self.dureeTimer = 10 # temps en ms
###############################################################################################################################
#Pour être plus précis lors de la lecture, on prend comme unité la miliseconde. ######################
## Il faut donc utiliser une echelle 1000 fois plus grande pour les unités du slider
self.echelle=1000
###############################################################################################################################
# Permet de récupérer la durée de la vidéo depuis une instance de la classe
# Sert dans certains cadres
self.dureeVideo = 0
# Chemin sur lequel peut s'ouvrir la boite de dialogue de fichier
# associée au bouton parcourir
self.cheminPourBoutonParcourir = cheminParcourir
self.taille = taille
debug("self.taille avant lecture : %s %s" % (self.taille, type(self.taille)))
#=== Widgets ===#
self.icone_lire=QIcon("Icones" + os.sep + "player_play.png")
self.icone_pause=QIcon("Icones" + os.sep + "player_pause.png")
self.icone_arret=QIcon("Icones" + os.sep + "player_stop.png")
if Mplayer.REVENIR in choixWidget:
self.bout_revenir = QPushButton(u"Revenir")
self.bout_revenir.setIcon(QIcon("Icones" + os.sep + "revenir.png"))
if Mplayer.PARCOURIR in choixWidget:
self.bout_ouvVideo = QPushButton(u"Parcourir...")
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
self.bout_prec = QPushButton(QIcon("Icones" + os.sep + "player_rew.png"),"")
self.bout_prec.setIconSize(QSize(iconTaille, iconTaille))
self.bout_prec.setFlat(flat)
self.bout_suivant = QPushButton(QIcon("Icones" + os.sep + "player_fwd.png"),"")
self.bout_suivant.setIconSize(QSize(iconTaille, iconTaille))
self.bout_suivant.setFlat(flat)
self.LISTW=False
if Mplayer.LIST in choixWidget :
self.LISTW = True
self.listFichiers = QComboBox()
self.listFichiers.hide()
self.setListeVideo()
self.bout_LectPause = QPushButton(self.icone_lire,"")
self.bout_LectPause.setIconSize(QSize(iconTaille, iconTaille))
self.bout_LectPause.setFlat(flat)
self.bout_Arret = QPushButton(self.icone_arret,"")
self.bout_Arret.setIconSize(QSize(iconTaille, iconTaille))
self.bout_Arret.setFlat(flat)
# widget qui contiendra la vidéo
self.cibleVideo = DisplayVid(self)
# par défaut le widget-cible est noir
color = QColor(0, 0, 0)
self.cibleVideo.setAutoFillBackground(True)
self.cibleVideo.setPalette(QPalette(color))
self.cibleVideo.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.cibleVideo.setFixedHeight(self.taille[1])
self.cibleVideo.setToolTip(self.fichierCourant[0])
#Choix de l'aspect ratio de la vidéo
if Mplayer.RATIO in choixWidget :
self.conf = QGroupBox()
self.conf.setContentsMargins(0,0,0,0)
self.conf.setMinimumSize(QSize(self.tailleLargeur, 0))
self.conf.setObjectName("conf")
self.verticalLayout = QHBoxLayout(self.conf)
self.verticalLayout.setObjectName("verticalLayout")
self.choicenorm = QRadioButton(self.conf)
self.choicenorm.setObjectName("choicenorm")
self.verticalLayout.addWidget(self.choicenorm)
self.choicewide = QRadioButton(self.conf)
self.choicewide.setObjectName("choicewide")
self.verticalLayout.addWidget(self.choicewide)
self.choiceone = QRadioButton(self.conf)
self.choiceone.setObjectName("choiceone")
self.verticalLayout.addWidget(self.choiceone)
self.choicenorm.setText("4:3")
self.choicewide.setText("16:9")
self.choiceone.setText("w:h")
# Checked le ratio de la vidéo
if self.listeVideos.__len__()!=0:
self.changeRatio(self.listeVideos[0])
else :
self.setRatio(4.0/3.0)
if Mplayer.RATIO in choixWidget :
self.choicenorm.setChecked(True)
self.slider = QSlider(Qt.Horizontal)
self.slider.setEnabled(True)
self.mplayerProcess = QProcess(self)
self.timer = QTimer(self)
self.tempsChrono = TracerChrono()
#=== mise-en-page/plan ===#
mhbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(self.cibleVideo)
if Mplayer.RATIO in choixWidget :
vbox.addWidget(self.conf)
hbox = QHBoxLayout()
if Mplayer.REVENIR in choixWidget:
hbox.addWidget(self.bout_revenir)
if Mplayer.PARCOURIR in choixWidget:
hbox.addWidget(self.bout_ouvVideo)
hbox.addWidget(self.bout_LectPause)
hbox.addWidget(self.bout_Arret)
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
hbox.addWidget(self.bout_prec)
hbox.addWidget(self.bout_suivant)
hbox.addWidget(self.tempsChrono)
if Mplayer.CURSEUR_A_PART not in choixWidget:
hbox.addWidget(self.slider)
vbox.addLayout(hbox)
if Mplayer.CURSEUR_A_PART in choixWidget:
hbox.setAlignment(Qt.AlignLeft)
hbox = QHBoxLayout()
hbox.addWidget(self.slider)
vbox.addLayout(hbox)
# Liste fichier dans combobox
if self.LISTW :
hbox = QHBoxLayout()
hbox.addWidget(self.listFichiers)
vbox.addLayout(hbox)
mhbox.addLayout(vbox)
self.setLayout(mhbox)
#=== connexion des widgets à des fonctions ===#
if Mplayer.REVENIR in choixWidget:
self.connect(self.bout_revenir, SIGNAL('clicked()'), SLOT('close()'))
if Mplayer.PARCOURIR in choixWidget:
self.connect(self.bout_ouvVideo, SIGNAL('clicked()'), self.ouvrirVideo)
if Mplayer.PRECEDENT_SUIVANT in choixWidget:
self.connect(self.bout_prec, SIGNAL('clicked()'), self.precedent)
self.connect(self.bout_suivant, SIGNAL('clicked()'), self.suivant)
#Ajouté le 08/11/2009 - Liste des fichiers dans une combobox
if self.LISTW :
self.connect(self.listFichiers, SIGNAL('currentIndexChanged(int)'), self.changeVideo)
self.connect(self.bout_LectPause, SIGNAL('clicked()'), self.lectPause)
self.connect(self.bout_Arret, SIGNAL('clicked()'), self.arretMPlayer)
self.connect(self.mplayerProcess, SIGNAL('readyReadStandardOutput()'), self.recupSortie)
self.connect(self.mplayerProcess, SIGNAL('finished(int,QProcess::ExitStatus)'), self.finVideo)
self.connect(self.timer, SIGNAL('timeout()'), self.sonderTempsActuel)
self.connect(self.slider, SIGNAL('sliderMoved(int)'), self.changerTempsCurseur)
self.connect(self.cibleVideo, SIGNAL('changeSize'), self.sizeMplayer)
if Mplayer.RATIO in choixWidget :
self.connect(self.choicenorm, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choicewide, SIGNAL("clicked(bool)"), self.defRatio)
self.connect(self.choiceone, SIGNAL("clicked(bool)"), self.defRatio)
def setListeVideo(self) :
self.referenceVideo = []
self.listFichiers.clear()
for vid in self.listeVideos :
self.referenceVideo.append(vid)
self.listFichiers.addItem(os.path.basename(vid))
if self.listeVideos.__len__() > 1 :
self.listFichiers.show()
def setAudio(self,au) :
if au :
self.cibleVideo.hide()
if "conf" in self.__dict__ :
self.conf.hide()
else :
self.cibleVideo.show()
if "conf" in self.__dict__ :
self.conf.show()
def changeVideo(self, index) :
self.arretMPlayer()
if index >= 0 : # Condition ajoutée pour éviter une erreure de dépassement de range dans la liste.
self.listeVideos = self.referenceVideo[index]
self.listFichiers.setCurrentIndex(index)
def defRatio(self, state=0) :
if state :
if self.choicenorm.isChecked() :
self.setRatio(4.0/3.0)
if self.choicewide.isChecked() :
self.setRatio(16.0/9.0)
if self.choiceone.isChecked() :
try :
dim=getVideoSize(unicode(self.listeVideos[0]))
self.setRatio(dim[0]/dim[1])
except :
None
self.defRatio()
else :
self.adjustSize()
def setRatio(self,ratio) :
self.ratio = ratio
self.sizeMplayer()
def changeRatio(self,video) :
rv = getVideoRatio(video)
if rv[0]==0.0 and type(rv[1])==float :
rat = rv[1]
else :
rat = rv[0]
if rat > 1.7 :
if "choicewide" in self.__dict__ :
self.choicewide.setChecked(True)
self.setRatio(16.0/9.0)
elif rat > 1.3 and rat <= 1.7 :
if "choicenorm" in self.__dict__ :
self.choicenorm.setChecked(True)
self.setRatio(4.0/3.0)
elif rat < 1.3 and rat != 0.0 :
if "choiceone" in self.__dict__ :
self.choiceone.setChecked(True)
dim=getVideoSize(video)
self.setRatio(dim[0]/dim[1])
else :
if "choicenorm" in self.__dict__ :
self.choicenorm.setChecked(True)
self.setRatio(4.0/3.0)
def sizeMplayer(self) :
self.cibleVideo.setFixedHeight(int(self.cibleVideo.width()/self.ratio))
def ouvrirVideo(self):
"""Ouverture de la boîte de dialogue de fichiers"""
txt = u"Fichiers vidéo"
if self.cheminPourBoutonParcourir:
chemin = self.cheminPourBoutonParcourir
else:
try:
chemin = EkdConfig.get('general','video_input_path').decode("UTF8")
except:
chemin = os.path.expanduser('~')
liste=QFileDialog.getOpenFileNames(None, u"Ouvrir", chemin, "%s (*.avi *.mpg *.mpeg *.mjpeg *.flv *.mp4 *.ogg *.vob *.mov *.wmv *.3gp *.h264)\n*" %txt)
if not liste: return
self.listeVideos = liste
self.changeRatio(unicode(self.listeVideos[0]))
chemin = unicode(self.listeVideos[0])
EkdConfig.set('general','video_input_path',os.path.dirname(chemin).encode("UTF8"))
def setVideos(self, videos) :
'''Définie proprement la liste des vidéos à jouer'''
if type(videos) != list :
self.listeVideos = [videos]
else :
self.listeVideos = videos
if self.LISTW and videos.__len__() > 1 :
self.setListeVideo()
elif self.LISTW :
self.listFichiers.hide()
def demarrerMPlayer(self):
"""démarrage de mplayer avec les arguments choisis"""
if self.estLue:
return True
args = QStringList() # Liste Qt qui contiendra les options de mplayer
# Ajout d'options à liste: args << "-option"
# mplayer fonctionnera comme un terminal dans ce script
args << "-slave"
# on ne veut pas avoir des commentaires sans grand intérêt
args << "-quiet"
# Sous linux, aucun driver n'a été nécessaire et pas de manip pour Wid :)
if self.systeme=='posix':
# try - except?
# la fenêtre de mplayer restera attaché à la fenêtre
# wid prend en valeur le nombre identifiant le widget (celui qui contiendra la vidéo)
args << "-wid" << QString.number(self.cibleVideo.winId()) # Objet QString car args est une liste de ch de caractères
settings = QSettings()
videoOutput = settings.value("vo", QVariant('')).toString()
if videoOutput:
args << '-vo' << videoOutput
# Sous windows
else:
# reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;)
args << "-wid" << self.cibleVideo.winId().__hex__()
args << "-vo" << "directx:noaccel"
#args << "-vo" << "gl" # alternative
# chemin de la vidéo
args << self.listeVideos
if PYQT_VERSION_STR >= "4.1.0":
# mode de canal: on fusionne le canal de sortie normal (stdout) et celui des erreurs (stderr)
self.mplayerProcess.setProcessChannelMode(QProcess.MergedChannels)
# démarrage de mplayer (en tenant compte des arguments définis ci-dessus)
# comme un nouveau processus
self.mplayerProcess.start(self.cheminMPlayer, args)
# au cas où mplayer ne démarrerait pas au bout de 3 sec (ex. problème de codec)
if not self.mplayerProcess.waitForStarted(3000):
QMessageBox.critical(self, u"Avertissement", u"Bogue au lancement de la vidéo avec mplayer")
return False
# donne le temps toutes les x secondes
self.timer.start(self.dureeTimer)
self.estLue = True
return True
def recupSortie(self):
"""récupère les lignes d'information émises par QProcess (mplayerProcess) et en tire les conséquences"""
while self.mplayerProcess.canReadLine(): # renvoie True si une ligne complète peut être lue à partir du système
# stocker l'ensemble des bits d'une ligne
tampon=QByteArray(self.mplayerProcess.readLine()) # readline: lit une ligne ascii à partir du système
# On vérifie si on a eu des réponses
if tampon.startsWith("Playing"):
# On récupère les infos de base ('$ mplayer -input cmdlist' pour avoir la liste complète - file:///usr/share/doc/mplayer-doc/tech/slave.txt.gz pour plus de détails)
self.mplayerProcess.write("get_video_resolution\n") # récupère la résolution de la vidéo
self.mplayerProcess.write("get_time_length\n")
# Nouveau fichier chargé -> on récupère son nom
ind = tampon.length() - 2 # suppression du '.' à la fin
tampon.remove(ind,ind)
tampon.remove(0, 8) # vire Playing
tampon.replace(QByteArray("\n"), QByteArray(""))
tampon.replace(QByteArray("\r"), QByteArray(""))
try:
# Tour de passe-passe pour ne pas avoir de problème d'accents
# Condition pour détection windows
if os.name == 'nt':
self.fichierCourant[1]=unicode(QString(tampon))
# Condition pour détection Linux ou MacOSX
elif os.name in ['posix', 'mac']:
self.fichierCourant[1]=unicode(QString(tampon)).encode("Latin1").decode("UTF8")
except UnicodeEncodeError, e:
debug(e)
self.fichierCourant[1]="?"
self.cibleVideo.setToolTip(self.fichierCourant[1])
if self.barreTaches is not None:
self.barreTaches.showMessage(self.fichierCourant[1])
# réponse à get_video_resolution : ANS_VIDEO_RESOLUTION='<width> x <height>'
if tampon.startsWith("ANS_VIDEO_RESOLUTION"): # retourne True si l'ensemble de bits démarre avec "..."
debug("tampon : %s" % tampon) # ex. -> ANS_VIDEO_RESOLUTION='352 x 288'
tampon.remove(0, 21) # suppression des 21 1er caract -> '352 x 288'
tampon.replace(QByteArray("'"), QByteArray("")) # -> 352 x 288
tampon.replace(QByteArray(" "), QByteArray("")) # -> 352x288
tampon.replace(QByteArray("\n"), QByteArray("")) # -> 352x288 # retour chariot unix
tampon.replace(QByteArray("\r"), QByteArray("")) # -> 352x288 # retour chariot windows
#print "-----tampon.indexOf('x') :", tampon.indexOf('x'), type(tampon.indexOf('x'))
sepIndex = tampon.indexOf('x') # récupère la position de 'x' # 3 <type 'int'>
#print "-----tampon.left(sepIndex).toInt():", tampon.left(sepIndex).toInt(), type(tampon.left(sepIndex).toInt())
resX = tampon.left(sepIndex).toInt()[0] # -> 352 # (352, True) <type 'tuple'>
#print "-----tampon.mid(sepIndex+1).toInt() :", tampon.mid(sepIndex+1).toInt(), type(tampon.mid(sepIndex+1).toInt())
resY = tampon.mid(sepIndex+1).toInt()[0] # -> 288 # (288, True) <type 'tuple'>
# on définit les nouvelles dimensions de l'image du widget-mplayer.
# try pour éviter les bogues sur les fichiers audio (sans dimension d'image)!!!
#try:
if resX!=0 or resY!=0:
debug( "ratio : %s - %s" % (self.ratio, type(self.ratio)))
else:
debug("fichier audio")
# réponse à get_time_length : ANS_LENGTH=xx.yy
elif tampon.startsWith("ANS_LENGTH"):
debug("tampon : %s" % tampon) # -> ANS_LENGTH=279.38
tampon.remove(0, 11) # vire ANS_LENGTH=
tampon.replace(QByteArray("'"), QByteArray(""))
tampon.replace(QByteArray(" "), QByteArray(""))
tampon.replace(QByteArray("\n"), QByteArray(""))
tampon.replace(QByteArray("\r"), QByteArray("")) # -> 279.38
#print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat())
tempsMax = tampon.toFloat()[0] # (279.3800048828125, True) <type 'tuple'>
self.dureeVideo = tempsMax
## Modifié le 28/05/2009 : On augmente la précision du slider
#self.slider.setMaximum(tempsMax) # déf du domaine de valeur du curseur
self.slider.setMaximum(tempsMax*self.echelle)
# ATTENTION J'AI COMMENTE CETTE LIGNE !!!
#self.slider.setMaximum(tempsMax)
# réponse à get_time_pos : ANS_TIME_POSITION=xx.y
elif tampon.startsWith("ANS_TIME_POSITION"):
#print "tampon :",tampon # -> ANS_TIME_POSITION=1.4 (temps courant)
tampon.remove(0, 18) # vire ANS_TIME_POSITION=
tampon.replace(QByteArray("'"), QByteArray(""))
tampon.replace(QByteArray(" "), QByteArray(""))
tampon.replace(QByteArray("\n"), QByteArray(""))
tampon.replace(QByteArray("\r"), QByteArray(""))
#print "-----tampon.toFloat() :", tampon.toFloat(), type(tampon.toFloat())
tempsCourant = tampon.toFloat()[0] # (1.3999999761581421, True) <type 'tuple'>
# récupération du temps courant: utile dans certains cadres
self.temps = tempsCourant
# Programmer un arrêt. Utile pour les aperçus
temps = float("%.1f" %self.temps)
if self.debutFin!=(0,0) and self.debutFin[1]==temps:
self.arretMPlayer()
return
self.slider.setValue(tempsCourant*self.echelle)
#############################################################################
self.changerTempsChrono(tempsCourant) # modifier le chrono du bouton
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 QuantOSLoginEngine(QWidget):
"""风控引擎的管理组件"""
#----------------------------------------------------------------------
def __init__(self, gateway, setting, parent=None):
"""Constructor"""
super(QuantOSLoginEngine, self).__init__(parent)
self.setting = setting
self.gateway = gateway
self.connectionMap = {}
self.initUi()
#----------------------------------------------------------------------
def initUi(self):
"""初始化界面"""
self.setWindowTitle(u'登录')
# 设置界面
self.userName = QLineEdit()
self.password = QTextEdit()
self.comboStrategy = QComboBox()
grid = QGridLayout()
grid.addWidget(LoginLine(), 1, 0, 1, 2)
grid.addWidget(QLabel(u'用户名'), 2, 0)
grid.addWidget(self.userName, 2, 1)
grid.addWidget(QLabel(u'令牌'), 3, 0)
grid.addWidget(self.password, 3, 1)
grid.addWidget(LoginLine(), 4, 0, 1, 2)
grid.addWidget(QLabel(u'策略'), 5, 0)
grid.addWidget(self.comboStrategy, 5, 1)
grid.addWidget(LoginLine(), 6, 0, 1, 2)
self.buttonCancel = QPushButton(u'取消')
self.buttonConfirm = QPushButton(u'确认')
hbox = QHBoxLayout()
hbox.addWidget(self.buttonConfirm)
hbox.addWidget(self.buttonCancel)
self.buttonConfirm.setDefault(True)
vbox = QVBoxLayout()
vbox.addLayout(grid)
vbox.addLayout(hbox)
self.setLayout(vbox)
# 设为固定大小
self.setFixedSize(self.sizeHint())
self.buttonCancel.clicked.connect(self.close)
self.buttonConfirm.clicked.connect(self.login)
self.userName.returnPressed.connect(self.password.setFocus)
# init username & token
username = self.setting['username']
token = self.setting['token']
self.userName.setText(username)
self.password.setText(token)
def login(self):
selectedStrat = self.comboStrategy.currentText()
if selectedStrat is not None and len(selectedStrat) > 0:
username = str(self.userName.text()).strip()
password = str(self.password.toPlainText()).strip()
if len(username) <= 0 or len(password) <= 0:
QMessageBox.warning(self, u'登录', u'输入用户名和密码')
else:
self.close()
self.gateway.login(username, password, selectedStrat)
else:
self.connect()
def connect(self):
userName = str(self.userName.text()).strip()
password = str(self.password.toPlainText()).strip()
if len(userName) <= 0 or len(password) <= 0:
QMessageBox.warning(self, u'获取策略', u'输入用户名和密码')
else:
strategyList = self.gateway.getStrategyList(userName, password)
if strategyList is not None and len(strategyList) > 0:
self.comboStrategy.clear()
strategyList_sl = []
for strategy in strategyList:
strategyList_sl.append(str(strategy))
strategyList_sl.sort()
self.comboStrategy.addItems(strategyList_sl)
self.userName.setEnabled(False)
self.password.setEnabled(False)
else:
QMessageBox.warning(self, u'获取策略', u'无法获取相关策略')
self.comboStrategy.clear()
self.comboStrategy.setFocus()
class Plugin(QObject):
def __init__(self, iface):
QObject.__init__(self)
self.__iface = iface
self.__shortcuts = []
self.__current_section = QComboBox()
self.__current_section.setMinimumWidth(150)
self.__current_graph = QComboBox()
self.__current_graph.setMinimumWidth(150)
self.__toolbar = None
self.__axis_layer = None
self.__menu = None
self.__log_strati = None
def initGui(self):
for keyseq, slot in (
(Qt.CTRL + Qt.ALT + Qt.Key_K, self.__create_group),
(Qt.CTRL + Qt.ALT + Qt.Key_S, self.__select_next_group),
(Qt.CTRL + Qt.ALT + Qt.Key_N, self.__next_section),
(Qt.CTRL + Qt.ALT + Qt.Key_B, self.__previous_section)
):
short = QShortcut(QKeySequence(keyseq), self.__iface.mainWindow())
short.setContext(Qt.ApplicationShortcut)
short.activated.connect(slot)
self.__shortcuts.append(short)
self.__menu = QMenu("Albion")
self.__menu.aboutToShow.connect(self.__create_menu_entries)
self.__iface.mainWindow().menuBar().addMenu(self.__menu)
self.__toolbar = QToolBar('Albion')
self.__iface.addToolBar(self.__toolbar)
self.__toolbar.addAction(icon('log_strati.svg'), 'stratigraphic log').triggered.connect(self.__log_strati_clicked)
self.__toolbar.addWidget(self.__current_graph)
self.__current_graph.currentIndexChanged[unicode].connect(self.__current_graph_changed)
self.__toolbar.addWidget(self.__current_section)
self.__current_section.currentIndexChanged[unicode].connect(self.__current_section_changed)
self.__toolbar.addAction(icon('previous_line.svg'), 'previous section (Ctrl+Alt+b)').triggered.connect(self.__previous_section)
self.__toolbar.addAction(icon('next_line.svg'), 'next section (Ctrl+Alt+n)').triggered.connect(self.__next_section)
self.__toolbar.addAction(icon('line_from_selected.svg'), 'create temporary section').triggered.connect(self.__section_from_selection)
self.__viewer3d = QDockWidget('3D')
self.__viewer3d.setWidget(Viewer3d())
self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__viewer3d)
self.__iface.mainWindow().tabifyDockWidget(
self.__iface.mainWindow().findChild(QDockWidget, "Layers"),
self.__viewer3d)
self.__viewer3d_ctrl = QToolBar('3D controls')
self.__viewer3d_ctrl.addWidget(ViewerControls(self.__viewer3d.widget()))
self.__iface.addToolBar(self.__viewer3d_ctrl)
QgsProject.instance().readProject.connect(self.__qgis__project__loaded)
self.__qgis__project__loaded() # case of reload
def unload(self):
for s in self.__shortcuts:
s.setParent(None)
self.__toolbar and self.__toolbar.setParent(None)
self.__menu and self.__menu.setParent(None)
self.__viewer3d and self.__viewer3d.setParent(None)
self.__viewer3d_ctrl and self.__viewer3d_ctrl.setParent(None)
def __add_menu_entry(self, name, callback, enabled=True, help_str=''):
act = self.__menu.addAction(name)
if callback is not None:
act.triggered.connect(callback)
act.setEnabled(enabled)
act.setToolTip(help_str)
else:
act.setEnabled(False)
act.setToolTip("NOT INMPLEMENTED "+help_str)
return act
def __create_menu_entries(self):
self.__menu.clear()
self.__add_menu_entry('New &Project', self.__new_project)
self.__add_menu_entry('Import Project', self.__import_project)
self.__add_menu_entry('Upgrade Project', self.__upgrade_project)
self.__menu.addSeparator()
self.__add_menu_entry('&Import Data', self.__import_data,
self.project is not None,
"Import data from directory. The data files are in ")
self.__menu.addSeparator()
self.__add_menu_entry('Create cells', self.__create_cells,
self.project is not None and self.project.has_collar,
"Create Delaunay triangulation of collar layer.")
self.__add_menu_entry('Refresh all edges', self.__refresh_all_edge,
self.project is not None and self.project.has_cell,
"Refresh materialized view of all cell edges used by graph possible edges.")
self.__menu.addSeparator()
#self.__add_menu_entry(u'Create section views 0° and 90°', self.__create_section_view_0_90,
# False and self.project is not None and self.project.has_hole,
# "Create section views (i.e. cut directions) to work West-East and South-North for this project")
#self.__add_menu_entry(u'Create section views -45° and 45°', None,
# False and self.project is not None and self.project.has_hole,
# "Create section views (i.e. cut directions) to work SE-NW and SW-NE for this project")
#
#self.__menu.addSeparator()
self.__add_menu_entry('Create sections', self.__create_sections,
self.project is not None and self.project.has_group_cell,
"Once cell groups have been defined, create section lines.")
self.__menu.addSeparator()
self.__add_menu_entry('Compute &Mineralization', self.__compute_mineralization,
self.project is not None and self.project.has_radiometry,
"")
self.__menu.addSeparator()
self.__add_menu_entry('New &Graph', self.__new_graph,
self.project is not None,
"Create a new grap.h")
self.__add_menu_entry('Delete Graph', self.__delete_graph,
self.project is not None)
self.__menu.addSeparator()
self.__add_menu_entry('Create volumes', self.__create_volumes,
self.project is not None and bool(self.__current_graph.currentText()),
"Create volumes associated with current graph.")
self.__menu.addSeparator()
self.__add_menu_entry('Create terminations', self.__create_terminations,
self.project is not None and bool(self.__current_graph.currentText()),
"Create terminations associated with current graph.")
self.__menu.addSeparator()
self.__add_menu_entry('Toggle axis', self.__toggle_axis)
self.__menu.addSeparator()
self.__add_menu_entry('Export Project', self.__export_project,
self.project is not None)
self.__add_menu_entry('Export Sections', None,
self.project is not None and self.project.has_section,
"Export triangulated section in .obj or .dxf format")
self.__add_menu_entry('Export Volume', self.__export_volume,
self.project is not None and bool(self.__current_graph.currentText()),
"Export volume of current graph in .obj or .dxf format")
self.__menu.addSeparator()
self.__menu.addAction('Help').triggered.connect(self.open_help)
def __current_graph_changed(self, graph_id):
if self.project is None:
return
self.__viewer3d.widget().set_graph(graph_id)
def __getattr__(self, name):
if name == "project":
project_name = QgsProject.instance().readEntry("albion", "project_name", "")[0]
return Project(project_name) if project_name else None
else:
raise AttributeError(name)
def __refresh_all_edge(self):
if self.project is None:
return
self.project.refresh_all_edge()
def __create_terminations(self):
if self.project is None:
return
self.project.create_terminations(self.__current_graph.currentText())
self.__viewer3d.widget().refresh_data()
self.__refresh_layers('section')
def __create_volumes(self):
if self.project is None:
return
self.project.create_volumes(self.__current_graph.currentText())
self.__viewer3d.widget().refresh_data()
def __next_section(self):
if self.project is None:
return
self.project.next_section(self.__current_section.currentText())
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def __previous_section(self):
if self.project is None:
return
self.project.previous_section(self.__current_section.currentText())
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def __refresh_layers(self, name=None):
for layer in self.__iface.mapCanvas().layers():
if name is None or layer.name().find(name) != -1:
layer.triggerRepaint()
def __current_section_changed(self, section_id):
layers = QgsMapLayerRegistry.instance().mapLayersByName(u"group_cell")
if len(layers):
layers[0].setSubsetString("section_id='{}'".format(section_id))
self.__refresh_layers('section')
def __select_next_group(self):
if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell":
self.__iface.activeLayer().removeSelection()
self.__iface.activeLayer().selectByExpression(
"id in ({})".format(",".join(project.next_group_ids())))
def __create_group(self):
if self.project and self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"cell":
if self.__iface.activeLayer().selectedFeatureCount():
section = self.__current_section.currentText()
self.project.create_group(section,
[f['id'] for f in self.__iface.activeLayer().selectedFeatures()])
self.__iface.activeLayer().removeSelection()
self.__refresh_layers('group_cell')
def __qgis__project__loaded(self):
if self.project is None:
return
self.__current_graph.clear()
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
self.__current_graph.addItems(self.project.graphs())
layers = QgsMapLayerRegistry.instance().mapLayersByName('section.anchor')
if len(layers):
layers[0].editingStopped.connect(self.__update_section_list)
self.__viewer3d.widget().resetScene(self.project)
def __update_section_list(self):
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
def __upgrade_project(self):
project_name, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Database name", "Database name:", QLineEdit.Normal, '')
if not ok:
return
Project(project_name).update()
def __new_project(self):
# @todo open dialog to configure project name and srid
fil = QFileDialog.getSaveFileName(None,
u"New project name (no space, plain ascii)",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"QGIS poject file (*.qgs)")
if not fil:
return
fil = fil if len(fil)>4 and fil[-4:]=='.qgs' else fil+'.qgs'
fil = fil.replace(' ','_')
try:
fil.decode('ascii')
except UnicodeDecodeError:
self.__iface.messageBar().pushError('Albion:', "project name may only contain asci character (no accent)")
return
srid, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Project SRID", "Project SRID EPSG:", QLineEdit.Normal, '32632')
if not ok:
return
srid = int(srid)
project_name = str(os.path.split(fil)[1][:-4])
if Project.exists(project_name):
if QMessageBox.Yes != QMessageBox(QMessageBox.Information,
"Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name),
QMessageBox.Yes|QMessageBox.No).exec_():
return
Project.delete(project_name)
self.__iface.messageBar().pushInfo('Albion:', "creating project...")
Project.create(project_name, srid)
# load template
open(fil, 'w').write(
open(resource('template_project.qgs')).read().replace('template_project', project_name))
self.__iface.newProject()
QgsProject.instance().setFileName(fil)
QgsProject.instance().read()
QgsProject.instance().writeEntry("albion", "project_name", project_name)
QgsProject.instance().writeEntry("albion", "srid", srid)
QgsProject.instance().write()
self.__qgis__project__loaded()
def __import_data(self):
if self.project is None:
return
if not QgsProject.instance().readEntry("albion", "conn_info", "")[0]:
return
dir_ = QFileDialog.getExistingDirectory(None,
u"Data directory",
QgsProject.instance().readEntry("albion", "last_dir", "")[0])
if not dir_:
return
QgsProject.instance().writeEntry("albion", "last_dir", dir_),
progressMessageBar = self.__iface.messageBar().createMessage("Loading {}...".format(dir_))
progress = QProgressBar()
progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.__iface.messageBar().pushWidget(progressMessageBar, self.__iface.messageBar().INFO)
self.project.import_data(dir_, ProgressBar(progress))
self.project.triangulate()
self.project.create_section_view_0_90(4)
self.__iface.messageBar().clearWidgets()
collar = QgsMapLayerRegistry.instance().mapLayersByName('collar')[0]
collar.reload()
collar.updateExtents()
self.__iface.setActiveLayer(collar)
QApplication.instance().processEvents()
while self.__iface.mapCanvas().isDrawing():
QApplication.instance().processEvents()
self.__iface.zoomToActiveLayer()
self.__iface.actionSaveProject().trigger()
self.__viewer3d.widget().resetScene(self.project)
self.__current_section.clear()
self.__current_section.addItems(self.project.sections())
def __new_graph(self):
if self.project is None:
return
graph, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Graph", "Graph name:", QLineEdit.Normal, 'test_graph')
if not ok:
return
parent, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Parent Graph", "Parent Graph name:", QLineEdit.Normal, '')
if not ok:
return
self.project.new_graph(graph, parent)
self.__current_graph.addItem(graph)
self.__current_graph.setCurrentIndex(self.__current_graph.findText(graph))
def __delete_graph(self):
if self.project is None:
return
graph, ok = QInputDialog.getText(self.__iface.mainWindow(),
"Graph", "Graph name:", QLineEdit.Normal, self.__current_graph.currentText())
if not ok:
return
self.__current_graph.removeItem(self.__current_graph.findText(graph))
def __toggle_axis(self):
if self.__axis_layer:
pass
QgsMapLayerRegistry.instance().removeMapLayer(self.__axis_layer.id())
self.__axis_layer = None
else:
self.__axis_layer = AxisLayer(self.__iface.mapCanvas().mapSettings().destinationCrs())
QgsMapLayerRegistry.instance().addMapLayer(self.__axis_layer)
self.__refresh_layers()
def __create_cells(self):
if self.project is None:
return
self.project.triangulate()
self.__refresh_layers('cells')
def __create_sections(self):
if self.project is None:
return
self.project.create_sections()
def __compute_mineralization(self):
MineralizationDialog(self.project).exec_()
def __export_volume(self):
if self.project is None:
return
fil = QFileDialog.getSaveFileName(None,
u"Export volume for current graph",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"File formats (*.dxf *.obj)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if fil[-4:] == '.obj':
self.project.export_obj(self.__current_graph.currentText(), fil)
elif fil[-4:] == '.dxf':
self.project.export_dxf(self.__current_graph.currentText(), fil)
else:
self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for volume export')
def __import_project(self):
fil = QFileDialog.getOpenFileName(None,
u"Import project from file",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"File formats (*.zip)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if fil[-4:] != '.zip':
self.__iface.messageBar().pushWarning('Albion', 'unsupported extension for import')
project_name = os.path.split(fil)[1][:-4]
dir_ = tempfile.gettempdir()
with zipfile.ZipFile(fil, "r") as z:
z.extractall(dir_)
dump = find_in_dir(dir_, '.dump')
prj = find_in_dir(dir_, '.qgs')
self.__iface.messageBar().pushInfo('Albion', 'loading {} from {}'.format(project_name, dump))
if Project.exists(project_name):
if QMessageBox.Yes != QMessageBox(QMessageBox.Information,
"Delete existing DB", "Database {} exits, to you want to delete it ?".format(project_name),
QMessageBox.Yes|QMessageBox.No).exec_():
return
Project.delete(project_name)
project = Project.import_(project_name, dump)
QgsProject.instance().read(QFileInfo(prj))
def __export_project(self):
if self.project is None:
return
fil = QFileDialog.getSaveFileName(None,
u"Export project",
QgsProject.instance().readEntry("albion", "last_dir", "")[0],
"Data files(*.zip)")
if not fil:
return
QgsProject.instance().writeEntry("albion", "last_dir", os.path.dirname(fil)),
if os.path.exists(fil):
os.remove(fil)
with zipfile.ZipFile(fil, 'w') as project:
dump = tempfile.mkstemp()[1]
self.project.export(dump)
project.write(dump, self.project.name+'.dump')
project.write(QgsProject.instance().fileName(), os.path.split(QgsProject.instance().fileName())[1])
def __create_section_view_0_90(self):
if self.project is None:
return
self.project.create_section_view_0_90()
def __log_strati_clicked(self):
#@todo switch behavior when in section view -> ortho
self.__click_tool = QgsMapToolEmitPoint(self.__iface.mapCanvas())
self.__iface.mapCanvas().setMapTool(self.__click_tool)
self.__click_tool.canvasClicked.connect(self.__map_log_clicked)
def __map_log_clicked(self, point, button):
self.__click_tool.setParent(None)
self.__click_tool = None
if self.project is None:
self.__log_strati and self.__log_strati.setParent(None)
self.__log_strati = None
return
if self.__log_strati is None:
self.__log_strati = QDockWidget('Stratigraphic Log')
self.__log_strati.setWidget(BoreHoleWindow(self.project))
self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__log_strati)
self.__iface.mainWindow().tabifyDockWidget(
self.__iface.mainWindow().findChild(QDockWidget, "Layers"),
self.__log_strati)
res = self.project.closest_hole_id(point.x(), point.y())
if res:
self.__log_strati.widget().scene.set_current_id(res)
self.__log_strati.show()
self.__log_strati.raise_()
def __section_from_selection(self):
if self.project is None:
return
if self.__iface.activeLayer() and self.__iface.activeLayer().name() == u"collar" \
and self.__iface.activeLayer().selectedFeatures():
collar = self.__iface.activeLayer()
selection = collar.selectedFeatures()
if len(selection) < 2:
return
def align(l):
assert len(l) >= 2
res = numpy.array(l[:2])
for p in l[2:]:
u, v = res[0] - res[1], p - res[1]
if numpy.dot(u,v) < 0:
res[1] = p
elif numpy.dot(u, u) < numpy.dot(v,v):
res[0] = p
# align with ref direction
sqrt2 = math.sqrt(2.)/2
l = l[numpy.argsort(numpy.dot(l-res[0], res[1]-res[0]))]
d = numpy.array(l[-1] - l[0])
dr = numpy.array([(0,1),(sqrt2, sqrt2),(1,0), (sqrt2, -sqrt2)])
i = numpy.argmax(numpy.abs(dr.dot(d)))
return l if (dr.dot(d))[i] > 0 else l[::-1]
line = LineString(align(numpy.array([f.geometry().asPoint() for f in selection])))
collar.removeSelection()
self.project.set_section_geom(self.__current_section.currentText(), line)
self.__refresh_layers('section')
self.__viewer3d.widget().scene.update('section')
self.__viewer3d.widget().update()
def open_help(self):
QDesktopServices.openUrl(QUrl.fromLocalFile(os.path.join(os.path.dirname(__file__), 'doc', 'build', 'html', 'index.html')))
class OWImpute(OWWidget):
name = "Impute"
description = "Imputes missing values in the data table."
icon = "icons/Impute.svg"
priority = 2130
inputs = [("Data", Orange.data.Table, "set_data"),
("Learner", Orange.classification.Fitter, "set_fitter")]
outputs = [("Data", Orange.data.Table)]
METHODS = METHODS
settingsHandler = settings.DomainContextHandler()
default_method = settings.Setting(1)
variable_methods = settings.ContextSetting({})
autocommit = settings.Setting(False)
want_main_area = False
def __init__(self, parent=None):
super().__init__(parent)
self.modified = False
box = group_box(self.tr("Default method"),
layout=layout(Qt.Vertical))
self.controlArea.layout().addWidget(box)
bgroup = QButtonGroup()
for i, m in enumerate(self.METHODS[1:-1], 1):
b = radio_button(m.name, checked=i == self.default_method,
group=bgroup, group_id=i)
box.layout().addWidget(b)
self.defbggroup = bgroup
bgroup.buttonClicked[int].connect(self.set_default_method)
box = group_box(self.tr("Individual attribute settings"),
layout=layout(Qt.Horizontal))
self.controlArea.layout().addWidget(box)
self.varview = QtGui.QListView(
selectionMode=QtGui.QListView.ExtendedSelection
)
self.varview.setItemDelegate(DisplayFormatDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._on_var_selection_changed
)
self.selection = self.varview.selectionModel()
box.layout().addWidget(self.varview)
method_layout = layout(Qt.Vertical, margins=0)
box.layout().addLayout(method_layout)
methodbox = group_box(layout=layout(Qt.Vertical))
bgroup = QButtonGroup()
for i, m in enumerate(self.METHODS):
b = radio_button(m.name, group=bgroup, group_id=i)
methodbox.layout().addWidget(b)
assert self.METHODS[-1].short == "value"
self.value_stack = value_stack = QStackedLayout()
self.value_combo = QComboBox(activated=self._on_value_changed)
self.value_line = QLineEdit(editingFinished=self._on_value_changed)
self.value_line.setValidator(QDoubleValidator())
value_stack.addWidget(self.value_combo)
value_stack.addWidget(self.value_line)
methodbox.layout().addLayout(value_stack)
bgroup.buttonClicked[int].connect(
self.set_method_for_current_selection
)
reset_button = push_button("Restore all to default",
clicked=self.reset_var_methods,
default=False, autoDefault=False)
method_layout.addWidget(methodbox)
method_layout.addStretch(2)
method_layout.addWidget(reset_button)
self.varmethodbox = methodbox
self.varbgroup = bgroup
commitbox = group_box("Commit", layout=layout(margins=0))
cwidget = commit_widget(
button_text="Commit",
button_default=True,
check_text="Commit on any change",
checked=self.autocommit,
clicked=self.commit
)
def toggle_auto_commit(b):
self.autocommit = b
if self.modified:
self.commit()
cwidget.auto_commit_check.toggled[bool].connect(toggle_auto_commit)
commitbox.layout().addWidget(cwidget)
self.addAction(cwidget.commit_action)
self.controlArea.layout().addWidget(commitbox)
self.data = None
self.fitter = None
def set_default_method(self, index):
"""
Set the current selected default imputation method.
"""
if self.default_method != index:
self.default_method = index
self.defbggroup.button(index).setChecked(True)
self._invalidate()
def set_data(self, data):
self.closeContext()
self.clear()
self.data = data
if data is not None:
self.varmodel[:] = data.domain.variables
self.openContext(data.domain)
self.restore_state(self.variable_methods)
itemmodels.select_row(self.varview, 0)
self.commit()
def set_fitter(self, fitter):
self.fitter = fitter
if self.data is not None and \
any(state.model.short == "model" for state in
map(self.state_for_column, range(len(self.data.domain)))):
self.commit()
def restore_state(self, state):
for i, var in enumerate(self.varmodel):
key = variable_key(var)
if key in state:
index = self.varmodel.index(i)
self.varmodel.setData(index, state[key], Qt.UserRole)
def clear(self):
self.varmodel[:] = []
self.variable_methods = {}
self.data = None
self.modified = False
def state_for_column(self, column):
"""
#:: int -> State
Return the effective imputation state for `column`.
:param int column:
:rtype State:
"""
var = self.varmodel[column]
state = self.variable_methods.get(variable_key(var), None)
if state is None or state.method == METHODS[0]:
state = State(METHODS[self.default_method], ())
return state
def imputer_for_column(self, column):
state = self.state_for_column(column)
data = self.data
var = data.domain[column]
method, params = state
if method.short == "leave":
return None
elif method.short == "avg":
return column_imputer_average(var, data)
elif method.short == "model":
fitter = self.fitter if self.fitter is not None else MeanFitter()
return column_imputer_by_model(var, data, fitter=fitter)
elif method.short == "random":
return column_imputer_random(var, data)
elif method.short == "value":
return column_imputer_defaults(var, data, float(params[0]))
elif method.short == "as_value":
return column_imputer_as_value(var, data)
else:
assert False
def commit(self):
if self.data is not None:
states = [self.state_for_column(i)
for i in range(len(self.varmodel))]
# Columns to filter unknowns by dropping rows.
filter_columns = [i for i, state in enumerate(states)
if state.method.short == "drop"]
impute_columns = [i for i, state in enumerate(states)
if state.method.short not in ["drop", "leave"]]
imputers = [(self.varmodel[i], self.imputer_for_column(i))
for i in impute_columns]
data = self.data
if imputers:
table_imputer = ImputerModel(data.domain, dict(imputers))
data = table_imputer(data)
if filter_columns:
filter_ = data_filter.IsDefined(filter_columns)
data = filter_(data)
else:
data = None
self.send("Data", data)
self.modified = False
def _invalidate(self):
self.modified = True
if self.autocommit:
self.commit()
def _on_var_selection_changed(self):
indexes = self.selection.selectedIndexes()
vars = [self.varmodel[index.row()] for index in indexes]
defstate = State(METHODS[0], ())
states = [self.variable_methods.get(variable_key(var), defstate)
for var in vars]
all_cont = all(isinstance(var, Orange.data.ContinuousVariable)
for var in vars)
states = list(unique(states))
method = None
params = ()
state = None
if len(states) == 1:
state = states[0]
method, params = state
mindex = METHODS.index(method)
self.varbgroup.button(mindex).setChecked(True)
elif self.varbgroup.checkedButton() is not None:
self.varbgroup.setExclusive(False)
self.varbgroup.checkedButton().setChecked(False)
self.varbgroup.setExclusive(True)
values, enabled, stack_index = [], False, 0
value, value_index = "0.0", 0
if all_cont:
enabled, stack_index = True, 1
if method is not None and method.short == "value":
value = params[0]
elif len(vars) == 1 and \
isinstance(vars[0], Orange.data.DiscreteVariable):
values, enabled, stack_index = vars[0].values, True, 0
if method is not None and method.short == "value":
try:
value_index = values.index(params[0])
except IndexError:
pass
self.value_stack.setCurrentIndex(stack_index)
self.value_stack.setEnabled(enabled)
if stack_index == 0:
self.value_combo.clear()
self.value_combo.addItems(values)
self.value_combo.setCurrentIndex(value_index)
else:
self.value_line.setText(value)
def _on_value_changed(self):
# The "fixed" value in the widget has been changed by the user.
index = self.varbgroup.checkedId()
self.set_method_for_current_selection(index)
def set_method_for_current_selection(self, methodindex):
indexes = self.selection.selectedIndexes()
self.set_method_for_indexes(indexes, methodindex)
def set_method_for_indexes(self, indexes, methodindex):
method = METHODS[methodindex]
params = (None,)
if method.short == "value":
if self.value_stack.currentIndex() == 0:
value = self.value_combo.currentIndex()
else:
value = self.value_line.text()
params = (value, )
elif method.short == "model":
params = ("model", )
state = State(method, params)
for index in indexes:
self.varmodel.setData(index, state, Qt.UserRole)
var = self.varmodel[index.row()]
self.variable_methods[variable_key(var)] = state
self._invalidate()
def reset_var_methods(self):
indexes = map(self.varmodel.index, range(len(self.varmodel)))
self.set_method_for_indexes(indexes, 0)
class FindInFilesDialog(QDialog, object):
""" find in files dialog implementation """
inProject = 0
inDirectory = 1
inOpenFiles = 2
def __init__(self, where, what="", dirPath="", filters=[], parent=None):
QDialog.__init__(self, parent)
mainWindow = GlobalData().mainWindow
self.editorsManager = mainWindow.editorsManagerWidget.editorsManager
self.__cancelRequest = False
self.__inProgress = False
self.searchRegexp = None
self.searchResults = []
# Avoid pylint complains
self.findCombo = None
self.caseCheckBox = None
self.wordCheckBox = None
self.regexpCheckBox = None
self.projectRButton = None
self.openFilesRButton = None
self.dirRButton = None
self.dirEditCombo = None
self.dirSelectButton = None
self.filterCombo = None
self.fileLabel = None
self.progressBar = None
self.findButton = None
self.__createLayout()
self.setWindowTitle("Find in files")
# Restore the combo box values
project = GlobalData().project
if project.fileName != "":
self.findFilesWhat = project.findFilesWhat
self.findFilesDirs = project.findFilesDirs
self.findFilesMasks = project.findFilesMasks
else:
settings = Settings()
self.findFilesWhat = settings.findFilesWhat
self.findFilesDirs = settings.findFilesDirs
self.findFilesMasks = settings.findFilesMasks
self.findCombo.addItems(self.findFilesWhat)
self.findCombo.setEditText("")
self.dirEditCombo.addItems(self.findFilesDirs)
self.dirEditCombo.setEditText("")
self.filterCombo.addItems(self.findFilesMasks)
self.filterCombo.setEditText("")
if where == self.inProject:
self.setSearchInProject(what, filters)
elif where == self.inDirectory:
self.setSearchInDirectory(what, dirPath, filters)
else:
self.setSearchInOpenFiles(what, filters)
return
def __createLayout(self):
""" Creates the dialog layout """
self.resize(600, 300)
self.setSizeGripEnabled(True)
verticalLayout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Combo box for the text to search
findLabel = QLabel(self)
findLabel.setText("Find text:")
self.findCombo = QComboBox(self)
self.__tuneCombo(self.findCombo)
self.findCombo.lineEdit().setToolTip(
"Regular expression to search for")
self.findCombo.editTextChanged.connect(self.__someTextChanged)
gridLayout.addWidget(findLabel, 0, 0, 1, 1)
gridLayout.addWidget(self.findCombo, 0, 1, 1, 1)
verticalLayout.addLayout(gridLayout)
# Check boxes
horizontalCBLayout = QHBoxLayout()
self.caseCheckBox = QCheckBox(self)
self.caseCheckBox.setText("Match &case")
horizontalCBLayout.addWidget(self.caseCheckBox)
self.wordCheckBox = QCheckBox(self)
self.wordCheckBox.setText("Match whole &word")
horizontalCBLayout.addWidget(self.wordCheckBox)
self.regexpCheckBox = QCheckBox(self)
self.regexpCheckBox.setText("Regular &expression")
horizontalCBLayout.addWidget(self.regexpCheckBox)
verticalLayout.addLayout(horizontalCBLayout)
# Files groupbox
filesGroupbox = QGroupBox(self)
filesGroupbox.setTitle("Find in")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
filesGroupbox.sizePolicy().hasHeightForWidth())
filesGroupbox.setSizePolicy(sizePolicy)
gridLayoutFG = QGridLayout(filesGroupbox)
self.projectRButton = QRadioButton(filesGroupbox)
self.projectRButton.setText("&Project")
gridLayoutFG.addWidget(self.projectRButton, 0, 0)
self.projectRButton.clicked.connect(self.__projectClicked)
self.openFilesRButton = QRadioButton(filesGroupbox)
self.openFilesRButton.setText("&Opened files only")
gridLayoutFG.addWidget(self.openFilesRButton, 1, 0)
self.openFilesRButton.clicked.connect(self.__openFilesOnlyClicked)
self.dirRButton = QRadioButton(filesGroupbox)
self.dirRButton.setText("&Directory tree")
gridLayoutFG.addWidget(self.dirRButton, 2, 0)
self.dirRButton.clicked.connect(self.__dirClicked)
self.dirEditCombo = QComboBox(filesGroupbox)
self.__tuneCombo(self.dirEditCombo)
self.dirEditCombo.lineEdit().setToolTip("Directory to search in")
gridLayoutFG.addWidget(self.dirEditCombo, 2, 1)
self.dirEditCombo.editTextChanged.connect(self.__someTextChanged)
self.dirSelectButton = QPushButton(filesGroupbox)
self.dirSelectButton.setText("...")
gridLayoutFG.addWidget(self.dirSelectButton, 2, 2)
self.dirSelectButton.clicked.connect(self.__selectDirClicked)
filterLabel = QLabel(filesGroupbox)
filterLabel.setText("Files filter:")
gridLayoutFG.addWidget(filterLabel, 3, 0)
self.filterCombo = QComboBox(filesGroupbox)
self.__tuneCombo(self.filterCombo)
self.filterCombo.lineEdit().setToolTip("File names regular expression")
gridLayoutFG.addWidget(self.filterCombo, 3, 1)
self.filterCombo.editTextChanged.connect(self.__someTextChanged)
verticalLayout.addWidget(filesGroupbox)
# File label
self.fileLabel = FitPathLabel(self)
self.fileLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
verticalLayout.addWidget(self.fileLabel)
# Progress bar
self.progressBar = QProgressBar(self)
self.progressBar.setValue(0)
self.progressBar.setOrientation(Qt.Horizontal)
verticalLayout.addWidget(self.progressBar)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.findButton = buttonBox.addButton("Find",
QDialogButtonBox.AcceptRole)
self.findButton.setDefault(True)
self.findButton.clicked.connect(self.__process)
verticalLayout.addWidget(buttonBox)
buttonBox.rejected.connect(self.__onClose)
return
@staticmethod
def __tuneCombo(comboBox):
" Sets the common settings for a combo box "
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth( \
comboBox.sizePolicy().hasHeightForWidth() )
comboBox.setSizePolicy(sizePolicy)
comboBox.setEditable(True)
comboBox.setInsertPolicy(QComboBox.InsertAtTop)
comboBox.setAutoCompletion(False)
comboBox.setDuplicatesEnabled(False)
return
def __onClose(self):
" Triggered when the close button is clicked "
self.__cancelRequest = True
if not self.__inProgress:
self.close()
return
def setSearchInProject(self, what="", filters=[]):
" Set search ready for the whole project "
if GlobalData().project.fileName == "":
# No project loaded, fallback to opened files
self.setSearchInOpenFiles(what, filters)
return
# Select the project radio button
self.projectRButton.setEnabled(True)
self.projectRButton.setChecked(True)
self.dirEditCombo.setEnabled(False)
self.dirSelectButton.setEnabled(False)
openedFiles = self.editorsManager.getTextEditors()
self.openFilesRButton.setEnabled(len(openedFiles) != 0)
self.setFilters(filters)
self.findCombo.setEditText(what)
self.findCombo.lineEdit().selectAll()
self.findCombo.setFocus()
# Check searchability
self.__testSearchability()
return
def setSearchInOpenFiles(self, what="", filters=[]):
" Sets search ready for the opened files "
openedFiles = self.editorsManager.getTextEditors()
if len(openedFiles) == 0:
# No opened files, fallback to search in dir
self.setSearchInDirectory(what, "", filters)
return
# Select the radio buttons
self.projectRButton.setEnabled(GlobalData().project.fileName != "")
self.openFilesRButton.setEnabled(True)
self.openFilesRButton.setChecked(True)
self.dirEditCombo.setEnabled(False)
self.dirSelectButton.setEnabled(False)
self.setFilters(filters)
self.findCombo.setEditText(what)
self.findCombo.lineEdit().selectAll()
self.findCombo.setFocus()
# Check searchability
self.__testSearchability()
return
def setSearchInDirectory(self, what="", dirPath="", filters=[]):
" Sets search ready for the given directory "
# Select radio buttons
self.projectRButton.setEnabled(GlobalData().project.fileName != "")
openedFiles = self.editorsManager.getTextEditors()
self.openFilesRButton.setEnabled(len(openedFiles) != 0)
self.dirRButton.setEnabled(True)
self.dirRButton.setChecked(True)
self.dirEditCombo.setEnabled(True)
self.dirSelectButton.setEnabled(True)
self.dirEditCombo.setEditText(dirPath)
self.setFilters(filters)
self.findCombo.setEditText(what)
self.findCombo.lineEdit().selectAll()
self.findCombo.setFocus()
# Check searchability
self.__testSearchability()
return
def setFilters(self, filters):
" Sets up the filters "
# Set filters if provided
if filters:
self.filterCombo.setEditText(";".join(filters))
else:
self.filterCombo.setEditText("")
return
def __testSearchability(self):
" Tests the searchability and sets the Find button status "
startTime = time.time()
if self.findCombo.currentText().strip() == "":
self.findButton.setEnabled(False)
self.findButton.setToolTip("No text to search")
return
if self.dirRButton.isChecked():
dirname = self.dirEditCombo.currentText().strip()
if dirname == "":
self.findButton.setEnabled(False)
self.findButton.setToolTip("No directory path")
return
if not os.path.isdir(dirname):
self.findButton.setEnabled(False)
self.findButton.setToolTip("Path is not a directory")
return
# Now we need to match file names if there is a filter
filtersText = self.filterCombo.currentText().strip()
if filtersText == "":
self.findButton.setEnabled(True)
self.findButton.setToolTip("Find in files")
return
# Need to check the files match
try:
filterRe = re.compile(filtersText, re.IGNORECASE)
except:
self.findButton.setEnabled(False)
self.findButton.setToolTip( "Incorrect files " \
"filter regular expression" )
return
matched = False
tooLong = False
if self.projectRButton.isChecked():
# Whole project
for fname in GlobalData().project.filesList:
if fname.endswith(sep):
continue
matched = filterRe.match(fname)
if matched:
break
# Check the time, it might took too long
if time.time() - startTime > 0.1:
tooLong = True
break
elif self.openFilesRButton.isChecked():
# Opened files
openedFiles = self.editorsManager.getTextEditors()
for record in openedFiles:
matched = filterRe.match(record[1])
if matched:
break
# Check the time, it might took too long
if time.time() - startTime > 0.1:
tooLong = True
break
else:
# Search in the dir
if not dirname.endswith(sep):
dirname += sep
matched, tooLong = self.__matchInDir(dirname, filterRe, startTime)
if matched:
self.findButton.setEnabled(True)
self.findButton.setToolTip("Find in files")
else:
if tooLong:
self.findButton.setEnabled(True)
self.findButton.setToolTip("Find in files")
else:
self.findButton.setEnabled(False)
self.findButton.setToolTip("No files matched to search in")
return
@staticmethod
def __matchInDir(path, filterRe, startTime):
" Provides the 'match' and 'too long' statuses "
matched = False
tooLong = False
for item in os.listdir(path):
if time.time() - startTime > 0.1:
tooLong = True
return matched, tooLong
if os.path.isdir(path + item):
dname = path + item + sep
matched, tooLong = FindInFilesDialog.__matchInDir(
dname, filterRe, startTime)
if matched or tooLong:
return matched, tooLong
continue
if filterRe.match(path + item):
matched = True
return matched, tooLong
return matched, tooLong
def __projectClicked(self):
" project radio button clicked "
self.dirEditCombo.setEnabled(False)
self.dirSelectButton.setEnabled(False)
self.__testSearchability()
return
def __openFilesOnlyClicked(self):
" open files only radio button clicked "
self.dirEditCombo.setEnabled(False)
self.dirSelectButton.setEnabled(False)
self.__testSearchability()
return
def __dirClicked(self):
" dir radio button clicked "
self.dirEditCombo.setEnabled(True)
self.dirSelectButton.setEnabled(True)
self.dirEditCombo.setFocus()
self.__testSearchability()
return
def __someTextChanged(self, text):
" Text to search, filter or dir name has been changed "
self.__testSearchability()
return
def __selectDirClicked(self):
" The user selects a directory "
dirName = QFileDialog.getExistingDirectory(
self, "Select directory to search in",
self.dirEditCombo.currentText(),
QFileDialog.Options(QFileDialog.ShowDirsOnly))
if dirName:
self.dirEditCombo.setEditText(os.path.normpath(dirName))
self.__testSearchability()
return
def __projectFiles(self, filterRe):
" Project files list respecting the mask "
mainWindow = GlobalData().mainWindow
files = []
for fname in GlobalData().project.filesList:
if fname.endswith(sep):
continue
if filterRe is None or filterRe.match(fname):
widget = mainWindow.getWidgetForFileName(fname)
if widget is None:
# Do not check for broken symlinks
if isFileSearchable(fname, False):
files.append(ItemToSearchIn(fname, ""))
else:
if widget.getType() in \
[ MainWindowTabWidgetBase.PlainTextEditor ]:
files.append(ItemToSearchIn(fname, widget.getUUID()))
QApplication.processEvents()
if self.__cancelRequest:
raise Exception("Cancel request")
return files
def __openedFiles(self, filterRe):
" Currently opened editor buffers "
files = []
openedFiles = self.editorsManager.getTextEditors()
for record in openedFiles:
uuid = record[0]
fname = record[1]
if filterRe is None or filterRe.match(fname):
files.append(ItemToSearchIn(fname, uuid))
QApplication.processEvents()
if self.__cancelRequest:
raise Exception("Cancel request")
return files
def __dirFiles(self, path, filterRe, files):
" Files recursively for the dir "
for item in os.listdir(path):
QApplication.processEvents()
if self.__cancelRequest:
raise Exception("Cancel request")
if os.path.isdir(path + item):
if item in [".svn", ".cvs"]:
# It does not make sense to search in revision control dirs
continue
anotherDir, isLoop = resolveLink(path + item)
if not isLoop:
self.__dirFiles(anotherDir + sep, filterRe, files)
continue
if not os.path.isfile(path + item):
continue
realItem, isLoop = resolveLink(path + item)
if isLoop:
continue
if filterRe is None or filterRe.match(realItem):
found = False
for itm in files:
if itm.fileName == realItem:
found = True
break
if not found:
mainWindow = GlobalData().mainWindow
widget = mainWindow.getWidgetForFileName(realItem)
if widget is None:
if isFileSearchable(realItem):
files.append(ItemToSearchIn(realItem, ""))
else:
if widget.getType() in \
[ MainWindowTabWidgetBase.PlainTextEditor ]:
files.append(
ItemToSearchIn(realItem, widget.getUUID()))
return
def __buildFilesList(self):
" Builds the list of files to search in "
filtersText = self.filterCombo.currentText().strip()
if filtersText != "":
filterRe = re.compile(filtersText, re.IGNORECASE)
else:
filterRe = None
if self.projectRButton.isChecked():
return self.__projectFiles(filterRe)
if self.openFilesRButton.isChecked():
return self.__openedFiles(filterRe)
dirname = os.path.realpath(self.dirEditCombo.currentText().strip())
files = []
self.__dirFiles(dirname + sep, filterRe, files)
return files
def __process(self):
" Search process "
# Add entries to the combo box if required
regexpText = self.findCombo.currentText()
if regexpText in self.findFilesWhat:
self.findFilesWhat.remove(regexpText)
self.findFilesWhat.insert(0, regexpText)
if len(self.findFilesWhat) > 32:
self.findFilesWhat = self.findFilesWhat[:32]
self.findCombo.clear()
self.findCombo.addItems(self.findFilesWhat)
filtersText = self.filterCombo.currentText().strip()
if filtersText in self.findFilesMasks:
self.findFilesMasks.remove(filtersText)
self.findFilesMasks.insert(0, filtersText)
if len(self.findFilesMasks) > 32:
self.findFilesMasks = self.findFilesMasks[:32]
self.filterCombo.clear()
self.filterCombo.addItems(self.findFilesMasks)
if self.dirRButton.isChecked():
dirText = self.dirEditCombo.currentText().strip()
if dirText in self.findFilesDirs:
self.findFilesDirs.remove(dirText)
self.findFilesDirs.insert(0, dirText)
if len(self.findFilesDirs) > 32:
self.findFilesDirs = self.findFilesDirs[:32]
self.dirEditCombo.clear()
self.dirEditCombo.addItems(self.findFilesDirs)
# Save the combo values for further usage
if GlobalData().project.fileName != "":
GlobalData().project.setFindInFilesHistory(self.findFilesWhat,
self.findFilesDirs,
self.findFilesMasks)
else:
Settings().findFilesWhat = self.findFilesWhat
Settings().findFilesDirs = self.findFilesDirs
Settings().findFilesMasks = self.findFilesMasks
self.__inProgress = True
numberOfMatches = 0
self.searchResults = []
self.searchRegexp = None
# Form the regexp to search
if not self.regexpCheckBox.isChecked():
regexpText = re.escape(regexpText)
if self.wordCheckBox.isChecked():
regexpText = "\\b%s\\b" % regexpText
flags = re.UNICODE | re.LOCALE
if not self.caseCheckBox.isChecked():
flags |= re.IGNORECASE
try:
self.searchRegexp = re.compile(regexpText, flags)
except:
logging.error("Invalid search expression")
self.close()
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.fileLabel.setPath('Building list of files to search in...')
QApplication.processEvents()
try:
files = self.__buildFilesList()
except Exception, exc:
if "Cancel request" in str(exc):
QApplication.restoreOverrideCursor()
self.close()
return
else:
QApplication.restoreOverrideCursor()
logging.error(str(exc))
self.close()
return
QApplication.restoreOverrideCursor()
QApplication.processEvents()
if len(files) == 0:
self.fileLabel.setPath('No files to search in')
return
self.progressBar.setRange(0, len(files))
index = 1
for item in files:
if self.__cancelRequest:
self.__inProgress = False
self.close()
return
self.fileLabel.setPath( 'Matches: ' + str( numberOfMatches ) + \
' Processing: ' + item.fileName )
item.search(self.searchRegexp)
found = len(item.matches)
if found > 0:
numberOfMatches += found
self.searchResults.append(item)
self.progressBar.setValue(index)
index += 1
QApplication.processEvents()
if numberOfMatches == 0:
if len(files) == 1:
self.fileLabel.setPath("No matches in 1 file.")
else:
self.fileLabel.setPath( "No matches in " + \
str( len( files ) ) + " files." )
self.__inProgress = False
else:
self.close()
return
class ComboChoice(HelpedWidget):
"""
A combo box widget for choices.
List of objects retrieved from model
str(item) is used for presentation
getValue and setValue uses the same object as from the list
"""
def __init__(self, model, combo_label="Choice", help_link=""):
HelpedWidget.__init__(self, combo_label, help_link)
assert model is not None and isinstance(model, ChoiceModelMixin)
self.model = model
model.observable().attach(ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT, self.getCurrentFromModel)
model.observable().attach(ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT, self.updateChoicesFromModel)
self.combo = QComboBox()
self.combo.addItem("Fail!")
self.addWidget(self.combo)
self.addStretch()
self.choice_list = None
""" @type: list """
self.connect(self.combo, SIGNAL('currentIndexChanged(int)'), self.selectionChanged)
self.updateChoicesFromModel()
self.getCurrentFromModel()
def selectionChanged(self, index):
assert 0 <= index < len(self.choice_list), "Should not happen! Index out of range: 0 <= %i < %i" % (index, len(self.choice_list))
item = self.choice_list[index]
self.model.setCurrentChoice(item)
def getCurrentFromModel(self):
new_value = self.model.getCurrentChoice()
if self.choice_list is None:
self.updateChoicesFromModel()
if new_value in self.choice_list:
index = self.choice_list.index(new_value)
if not index == self.combo.currentIndex():
self.combo.setCurrentIndex(index)
else:
self.combo.setCurrentIndex(0)
#sys.stderr.write("AssertionError: ComboBox can not be set to: " + str(new_value) + "\n")
# raise AssertionError("ComboBox can not be set to: " + str(new_value))
def updateChoicesFromModel(self):
block = self.combo.signalsBlocked()
self.combo.blockSignals(True)
self.choice_list = self.model.getChoices()
self.combo.clear()
for choice in self.choice_list:
self.combo.addItem(str(choice))
self.combo.blockSignals(block)
class ProfileWizard(StandaloneWizardPage):
"""Wizard for the creation of a new database
profile.
.. attribute:: languages
.. attribute:: dialects
A list of languages allowed in the profile selection, an empty list will
allow all languages
"""
languages = []
dialects = []
def __init__(self, profiles, parent=None):
super(ProfileWizard, self).__init__(parent)
self._connection_valid = False
self.network_reply = None
self.profiles = profiles
self.setWindowTitle(_('Profile Wizard'))
self.set_banner_logo_pixmap(art.Icon('tango/22x22/categories/preferences-system.png').getQPixmap())
self.set_banner_title(_('Create New/Edit Profile'))
self.set_banner_subtitle(_('Please enter the database settings'))
self.banner_widget().setStyleSheet('background-color: white;')
self.manager = QtNetwork.QNetworkAccessManager( self )
self.manager.finished.connect( self.update_network_status )
#self.manager.networkAccessibleChanged.connect( self.network_accessible_changed )
self.manager.proxyAuthenticationRequired.connect( self.proxy_authentication_required )
self.create_labels_and_widgets()
self.create_buttons()
self.set_tab_order()
self.set_widgets_values()
# note: connections come after labels and widgets are created
# and have default values
self.connect_widgets()
self.connect_buttons()
timer = QtCore.QTimer(self)
timer.timeout.connect( self.new_network_request )
timer.setInterval( 3000 )
timer.start()
self.new_network_request()
def create_labels_and_widgets(self):
assert object_thread( self )
self.profile_label = QLabel(_('Profile Name:'))
self.dialect_label = QLabel(_('Driver:'))
self.host_label = QLabel(_('Server Host:'))
self.port_label = QLabel(_('Port:'))
self.database_name_label = QLabel(_('Database Name:'))
self.username_label = QLabel(_('Username:'******'Password:'******'Media Location:'))
self.language_label = QLabel(_('Language:'))
self.proxy_host_label = QLabel(_('Proxy Host:'))
self.proxy_port_label = QLabel(_('Port:'))
self.proxy_username_label = QLabel(_('Proxy Username:'******'Proxy Password:'******'Media location path '\
'is not accessible.'))
self.not_accessible_media_path_label.setStyleSheet('color: red')
self.not_writable_media_path_label = QLabel(_('Media location path '\
'is not writable.'))
self.not_writable_media_path_label.setStyleSheet('color: red')
layout = QGridLayout()
layout.addWidget(self.profile_label, 0, 0, Qt.AlignRight)
layout.addWidget(self.dialect_label, 1, 0, Qt.AlignRight)
layout.addWidget(self.host_label, 2, 0, Qt.AlignRight)
layout.addWidget(self.port_label, 2, 3, Qt.AlignRight)
layout.addWidget(self.database_name_label, 3, 0, Qt.AlignRight)
layout.addWidget(self.username_label, 4, 0, Qt.AlignRight)
layout.addWidget(self.password_label, 5, 0, Qt.AlignRight)
layout.addWidget(self.media_location_label, 7, 0, Qt.AlignRight)
layout.addWidget(self.language_label, 8, 0, Qt.AlignRight)
layout.addWidget(self.proxy_host_label, 10, 0, Qt.AlignRight)
layout.addWidget(self.proxy_port_label, 10, 3, Qt.AlignRight)
layout.addWidget(self.proxy_username_label, 11, 0, Qt.AlignRight)
layout.addWidget(self.proxy_password_label, 12, 0, Qt.AlignRight)
self.profile_editor = QComboBox(self)
self.profile_editor.setEditable(True)
# 32767 is Qt max length for string
# should be more than enough for folders
# http://doc.qt.nokia.com/latest/qlineedit.html#maxLength-prop
self.dialect_editor = ChoicesEditor(parent=self)
self.host_editor = TextLineEditor(self, length=32767)
self.host_editor.set_value('')
self.port_editor = TextLineEditor(self)
self.port_editor.setFixedWidth(60)
self.port_editor.set_value('')
self.database_name_editor = TextLineEditor(self, length=32767)
self.database_name_editor.set_value('')
self.username_editor = TextLineEditor(self)
self.username_editor.set_value('')
self.password_editor = TextLineEditor(self)
self.password_editor.setEchoMode(QLineEdit.Password)
self.password_editor.set_value('')
self.media_location_editor = TextLineEditor(self, length=32767)
self.media_location_editor.set_value('')
self.language_editor = LanguageEditor(languages=self.languages,
parent=self)
#
# try to find a default language
#
system_language = QtCore.QLocale.system().name()
if self.languages:
if system_language in self.languages:
self.language_editor.set_value( system_language )
else:
self.language_editor.set_value( self.languages[0] )
else:
self.language_editor.set_value( system_language )
self.proxy_host_editor = TextLineEditor(self, length=32767)
self.proxy_host_editor.set_value('')
self.proxy_port_editor = TextLineEditor(self)
self.proxy_port_editor.setFixedWidth(60)
self.proxy_port_editor.set_value('')
self.proxy_username_editor = TextLineEditor(self)
self.proxy_username_editor.set_value('')
self.proxy_password_editor = TextLineEditor(self)
self.proxy_password_editor.set_value('')
self.proxy_password_editor.setEchoMode(QLineEdit.Password)
layout.addWidget(self.profile_editor, 0, 1, 1, 1)
layout.addWidget(self.dialect_editor, 1, 1, 1, 1)
layout.addWidget(self.host_editor, 2, 1, 1, 1)
layout.addWidget(self.port_editor, 2, 4, 1, 1)
layout.addWidget(self.database_name_editor, 3, 1, 1, 1)
layout.addWidget(self.username_editor, 4, 1, 1, 1)
layout.addWidget(self.password_editor, 5, 1, 1, 1)
layout.addWidget(HSeparator(), 6, 0, 1, 5)
layout.addWidget(self.media_location_editor, 7, 1, 1, 1)
layout.addWidget(self.language_editor, 8, 1, 1, 1)
layout.addWidget(HSeparator(), 9, 0, 1, 5)
layout.addWidget(self.proxy_host_editor, 10, 1, 1, 1)
layout.addWidget(self.proxy_port_editor, 10, 4, 1, 1)
layout.addWidget(self.proxy_username_editor, 11, 1, 1, 1)
layout.addWidget(self.proxy_password_editor, 12, 1, 1, 1)
layout.addWidget(self.network_status_label, 13, 1, 1, 4)
self.main_widget().setLayout(layout)
def set_widgets_values(self):
self.dialect_editor.clear()
self.profile_editor.clear()
if self.dialects:
dialects = self.dialects
else:
import sqlalchemy.dialects
dialects = [name for _importer, name, is_package in \
pkgutil.iter_modules(sqlalchemy.dialects.__path__) \
if is_package]
self.dialect_editor.set_choices([(dialect, dialect.capitalize()) \
for dialect in dialects])
self.profile_editor.insertItems(1, [''] + \
[item for item in fetch_profiles()])
self.profile_editor.setFocus()
self.update_wizard_values()
def connect_widgets(self):
self.profile_editor.editTextChanged.connect(self.update_wizard_values)
# self.dialect_editor.currentIndexChanged.connect(self.update_wizard_values)
def create_buttons(self):
self.more_button = QPushButton(_('More'))
self.more_button.setCheckable(True)
self.more_button.setAutoDefault(False)
self.cancel_button = QPushButton(_('Cancel'))
self.ok_button = QPushButton(_('OK'))
layout = QHBoxLayout()
layout.setDirection(QBoxLayout.RightToLeft)
layout.addWidget(self.cancel_button)
layout.addWidget(self.ok_button)
layout.addStretch()
layout.addWidget(self.more_button)
self.buttons_widget().setLayout(layout)
self.browse_button = QPushButton(_('Browse'))
self.main_widget().layout().addWidget(self.browse_button, 7, 2, 1, 3)
self.setup_extension()
def setup_extension(self):
self.extension = QWidget()
self.load_button = QPushButton(_('Load profiles'))
self.save_button = QPushButton(_('Save profiles'))
extension_buttons_layout = QHBoxLayout()
extension_buttons_layout.setContentsMargins(0, 0, 0, 0)
extension_buttons_layout.addWidget(self.load_button)
extension_buttons_layout.addWidget(self.save_button)
extension_buttons_layout.addStretch()
extension_layout = QVBoxLayout()
extension_layout.setContentsMargins(0, 0, 0, 0)
extension_layout.addWidget(HSeparator())
extension_layout.addLayout(extension_buttons_layout)
self.extension.setLayout(extension_layout)
self.main_widget().layout().addWidget(self.extension, 15, 0, 1, 5)
self.extension.hide()
def set_tab_order(self):
all_widgets = [self.profile_editor, self.dialect_editor,
self.host_editor, self.port_editor, self.database_name_editor,
self.username_editor, self.password_editor,
self.media_location_editor, self.browse_button,
self.language_editor,
self.proxy_host_editor, self.proxy_port_editor,
self.proxy_username_editor, self.proxy_password_editor,
self.ok_button, self.cancel_button]
i = 1
while i != len(all_widgets):
self.setTabOrder(all_widgets[i-1], all_widgets[i])
i += 1
def connect_buttons(self):
self.cancel_button.pressed.connect(self.reject)
self.ok_button.pressed.connect(self.proceed)
self.browse_button.pressed.connect(self.fill_media_location)
self.more_button.toggled.connect(self.extension.setVisible)
self.save_button.pressed.connect(self.save_profiles_to_file)
self.load_button.pressed.connect(self.load_profiles_from_file)
def proceed(self):
if self.is_connection_valid():
profilename, info = self.collect_info()
if profilename in self.profiles:
self.profiles[profilename].update(info)
else:
self.profiles[profilename] = info
store_profiles(self.profiles)
use_chosen_profile(profilename)
self.accept()
def is_connection_valid(self):
profilename, info = self.collect_info()
mt = SignalSlotModelThread(lambda:None)
mt.start()
progress = ProgressDialog(_('Verifying database settings'))
mt.post(lambda:self.test_connection( info ),
progress.finished, progress.exception)
progress.exec_()
return self._connection_valid
def test_connection(self, profile):
self._connection_valid = False
connection_string = connection_string_from_profile( profile )
engine = create_engine(connection_string, pool_recycle=True)
try:
connection = engine.raw_connection()
cursor = connection.cursor()
cursor.close()
connection.close()
self._connection_valid = True
except Exception, e:
self._connection_valid = False
raise UserException( _('Could not connect to database, please check host and port'),
resolution = _('Verify driver, host and port or contact your system administrator'),
detail = unicode(e) )
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)
class AdvancedVisualizationForm(QWidget):
def __init__(self, mainwindow, result_manager):
QWidget.__init__(self, mainwindow)
#mainwindow is an OpusGui
self.mainwindow = mainwindow
self.result_manager = result_manager
self.toolboxBase = self.result_manager.mainwindow.toolboxBase
self.inGui = False
self.logFileKey = 0
self.xml_helper = ResultsManagerXMLHelper(toolboxBase = self.toolboxBase)
self.result_generator = OpusResultGenerator(
toolboxBase = self.toolboxBase)
self.result_generator.guiElement = self
self.tabIcon = QIcon(':/Images/Images/cog.png')
self.tabLabel = 'Advanced Visualization'
self.widgetLayout = QVBoxLayout(self)
self.widgetLayout.setAlignment(Qt.AlignTop)
self.resultsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.resultsGroupBox)
self.dataGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.dataGroupBox)
self.optionsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.optionsGroupBox)
self._setup_definition_widget()
self._setup_buttons()
self._setup_tabs()
def _setup_buttons(self):
# Add Generate button...
self.pbn_go = QPushButton(self.resultsGroupBox)
self.pbn_go.setObjectName('pbn_go')
self.pbn_go.setText(QString('Go!'))
QObject.connect(self.pbn_go, SIGNAL('released()'),
self.on_pbn_go_released)
self.widgetLayout.addWidget(self.pbn_go)
self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox)
self.pbn_set_esri_storage_location.setObjectName('pbn_set_esri_storage_location')
self.pbn_set_esri_storage_location.setText(QString('...'))
self.pbn_set_esri_storage_location.hide()
QObject.connect(self.pbn_set_esri_storage_location, SIGNAL('released()'),
self.on_pbn_set_esri_storage_location_released)
def _setup_tabs(self):
# Add a tab widget and layer in a tree view and log panel
self.tabWidget = QTabWidget(self.resultsGroupBox)
# Log panel
self.logText = QTextEdit(self.resultsGroupBox)
self.logText.setReadOnly(True)
self.logText.setLineWidth(0)
self.tabWidget.addTab(self.logText,'Log')
# Finally add the tab to the model page
self.widgetLayout.addWidget(self.tabWidget)
#
def _setup_definition_widget(self):
#### setup results group box ####
self.gridlayout = QGridLayout(self.resultsGroupBox)
self.gridlayout.setObjectName('gridlayout')
self.lbl_results = QLabel(self.resultsGroupBox)
self.lbl_results.setObjectName('lbl_results')
self.lbl_results.setText(QString('Results'))
self.gridlayout.addWidget(self.lbl_results,0,0,1,3)
self._setup_co_results()
self.gridlayout.addWidget(self.co_results,0,3,1,10)
self.pbn_add = QPushButton(self.resultsGroupBox)
self.pbn_add.setObjectName('pbn_add')
self.pbn_add.setText(QString('+'))
QObject.connect(self.pbn_add, SIGNAL('released()'),
self.on_pbn_add_released)
self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1)
self.lw_indicators = QListWidget(self.resultsGroupBox)
self.lw_indicators.setObjectName('lw_indicators')
self.gridlayout.addWidget(self.lw_indicators,1,1,1,13)
self.pbn_remove = QPushButton(self.resultsGroupBox)
self.pbn_remove.setObjectName('pbn_remove')
self.pbn_remove.setText(QString('-'))
QObject.connect(self.pbn_remove, SIGNAL('released()'),
self.on_pbn_remove_released)
self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1)
#### setup data group box ####
self.gridlayout2 = QGridLayout(self.dataGroupBox)
self.gridlayout2.setObjectName('gridlayout2')
self._setup_co_result_style()
self.gridlayout2.addWidget(self.co_result_style,1,0,1,2)
self.lbl_result_style_sep = QLabel(self.resultsGroupBox)
self.lbl_result_style_sep.setObjectName('lbl_result_style_sep')
self.lbl_result_style_sep.setText(QString('<center>as</center>'))
self.gridlayout2.addWidget(self.lbl_result_style_sep,1,2,1,1)
self._setup_co_result_type()
self.gridlayout2.addWidget(self.co_result_type,1,3,1,2)
##### setup options group box ####
self.gridlayout3 = QGridLayout(self.optionsGroupBox)
self.gridlayout3.setObjectName('gridlayout3')
self.le_esri_storage_location = QLineEdit(self.optionsGroupBox)
self.le_esri_storage_location.setObjectName('le_esri_storage_location')
self.le_esri_storage_location.setText('[set path]')
self.le_esri_storage_location.hide()
self.optionsGroupBox.hide()
QObject.connect(self.co_result_style, SIGNAL('currentIndexChanged(int)'),
self.on_co_result_style_changed)
QObject.connect(self.co_result_type, SIGNAL('currentIndexChanged(int)'),
self.on_co_result_type_changed)
def _setup_co_results(self):
self.co_results = QComboBox(self.resultsGroupBox)
self.co_results.setObjectName('co_results')
self.co_results.addItem(QString('[select]'))
results = self.xml_helper.get_available_results()
for result in results:
name = '%i.%s'%(result['run_id'],result['indicator_name'])
self.co_results.addItem(QString(name))
def _setup_co_result_style(self):
available_styles = [
'visualize',
'export',
]
self.co_result_style = QComboBox(self.dataGroupBox)
self.co_result_style.setObjectName('co_result_style')
for dataset in available_styles:
self.co_result_style.addItem(QString(dataset))
def _setup_co_result_type(self):
available_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
self.co_result_type = QComboBox(self.dataGroupBox)
self.co_result_type.setObjectName('co_result_type')
for dataset in available_types:
self.co_result_type.addItem(QString(dataset))
def on_pbnRemoveModel_released(self):
self.result_manager.removeTab(self)
self.result_manager.updateGuiElements()
def on_pbn_add_released(self):
cur_selected = self.co_results.currentText()
for i in range(self.lw_indicators.count()):
if self.lw_indicators.item(i).text() == cur_selected:
return
self.lw_indicators.addItem(cur_selected)
def on_pbn_remove_released(self):
selected_idxs = self.lw_indicators.selectedIndexes()
for idx in selected_idxs:
self.lw_indicators.takeItem(idx.row())
def on_co_result_style_changed(self, ind):
available_viz_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
available_export_types = [
'ESRI table (for loading in ArcGIS)'
]
txt = self.co_result_style.currentText()
if txt == 'visualize':
available_types = available_viz_types
else:
available_types = available_export_types
self.co_result_type.clear()
for result_type in available_types:
r_type = QString(result_type)
self.co_result_type.addItem(r_type)
def on_co_result_type_changed(self, ind):
self.gridlayout3.removeWidget(self.le_esri_storage_location)
self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location)
self.optionsGroupBox.hide()
self.pbn_set_esri_storage_location.hide()
self.le_esri_storage_location.hide()
txt = self.co_result_type.currentText()
print txt
if txt == 'ESRI table (for loading in ArcGIS)':
self.pbn_set_esri_storage_location.show()
self.le_esri_storage_location.show()
self.gridlayout3.addWidget(self.le_esri_storage_location,0,1,1,6)
self.gridlayout3.addWidget(self.pbn_set_esri_storage_location,0,7,1,1)
self.optionsGroupBox.show()
def on_pbn_set_esri_storage_location_released(self):
print 'pbn_set_esri_storage_location released'
from opus_core.misc import directory_path_from_opus_path
start_dir = directory_path_from_opus_path('opus_gui.projects')
configDialog = QFileDialog()
filter_str = QString("*.gdb")
fd = configDialog.getExistingDirectory(self,QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."),
QString(start_dir), QFileDialog.ShowDirsOnly)
if len(fd) != 0:
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameBaseName = fileNameInfo.completeBaseName()
self.le_esri_storage_location.setText(fileName)
def on_pbn_go_released(self):
# Fire up a new thread and run the model
print 'Go button pressed'
# References to the GUI elements for status for this run...
#self.statusLabel = self.runStatusLabel
#self.statusLabel.setText(QString('Model initializing...'))
indicator_names = []
for i in range(self.lw_indicators.count()):
indicator_names.append(str(self.lw_indicators.item(i).text()))
if indicator_names == []:
print 'no indicators selected'
return
indicator_type = str(self.co_result_type.currentText())
indicator_type = {
#'Map (per indicator per year)':'matplotlib_map',
'Map (per indicator per year)':'mapnik_map',
'Chart (per indicator, spans years)':'matplotlib_chart',
'Table (per indicator, spans years)':'table_per_attribute',
'Table (per year, spans indicators)':'table_per_year',
'ESRI table (for loading in ArcGIS)':'table_esri'
}[indicator_type]
kwargs = {}
if indicator_type == 'table_esri':
storage_location = str(self.le_esri_storage_location.text())
if not os.path.exists(storage_location):
print 'Warning: %s does not exist!!'%storage_location
kwargs['storage_location'] = storage_location
self.result_manager.addIndicatorForm(indicator_type = indicator_type,
indicator_names = indicator_names,
kwargs = kwargs)
def runUpdateLog(self):
self.logFileKey = self.result_generator._get_current_log(self.logFileKey)
def runErrorFromThread(self,errorMessage):
QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class ReferencedTableEditor(QWidget):
referenced_table_changed = pyqtSignal(str)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi()
self.cbo_ref_table.setInsertPolicy(QComboBox.InsertAlphabetically)
self.cbo_ref_table.currentIndexChanged[str].connect(self._on_ref_table_changed)
def setupUi(self):
self.setObjectName("ReferencedTableEditor")
self.gridLayout = QGridLayout(self)
self.gridLayout.setVerticalSpacing(10)
self.gridLayout.setObjectName("gridLayout")
self.label_2 = QLabel(self)
self.label_2.setMaximumSize(QSize(100, 16777215))
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.cbo_source_field = QComboBox(self)
self.cbo_source_field.setMinimumSize(QSize(0, 30))
self.cbo_source_field.setObjectName("cbo_source_field")
self.gridLayout.addWidget(self.cbo_source_field, 2, 1, 1, 1)
self.label = QLabel(self)
self.label.setObjectName("label")
self.gridLayout.addWidget(self.label, 2, 0, 1, 1)
self.label_3 = QLabel(self)
self.label_3.setObjectName("label_3")
self.gridLayout.addWidget(self.label_3, 3, 0, 1, 1)
self.cbo_referencing_col = QComboBox(self)
self.cbo_referencing_col.setMinimumSize(QSize(0, 30))
self.cbo_referencing_col.setObjectName("cbo_referencing_col")
self.gridLayout.addWidget(self.cbo_referencing_col, 3, 1, 1, 1)
self.cbo_ref_table = QComboBox(self)
self.cbo_ref_table.setMinimumSize(QSize(0, 30))
self.cbo_ref_table.setObjectName("cbo_ref_table")
self.gridLayout.addWidget(self.cbo_ref_table, 1, 1, 1, 1)
self.label_2.setText(QApplication.translate("ReferencedTableEditor",
"References"))
self.label.setText(QApplication.translate("ReferencedTableEditor",
"Data source field"))
self.label_3.setText(QApplication.translate("ReferencedTableEditor",
"Referencing"))
#Connect signals
QMetaObject.connectSlotsByName(self)
self.cbo_ref_table.currentIndexChanged[str].connect(self._load_source_table_fields)
@pyqtSlot(str)
def on_data_source_changed(self,data_source_name):
"""
Loads data source fields for the given data source name.
"""
self.load_data_source_fields(data_source_name)
def _on_ref_table_changed(self, table):
"""
Raise signal when the referenced table changes.
:param table: Selected table name.
:type table: str
"""
self.referenced_table_changed.emit(table)
def properties(self):
"""
:returns: Returns the user-defined mapping of linked table and column
pairings.
:rtype: LinkedTableProps
"""
l_table = self.cbo_ref_table.currentText()
s_field = self.cbo_source_field.currentText()
l_field = self.cbo_referencing_col.currentText()
return LinkedTableProps(linked_table=l_table,
source_field=s_field,
linked_field=l_field)
def set_properties(self, table_props):
"""
Sets the combo selection based on the text in the linked table
object properties.
:param table_props: Object containing the linked table information.
:type table_props: LinkedTableProps
"""
setComboCurrentIndexWithText(self.cbo_ref_table, table_props.linked_table)
setComboCurrentIndexWithText(self.cbo_referencing_col, table_props.linked_field)
setComboCurrentIndexWithText(self.cbo_source_field, table_props.source_field)
def load_data_source_fields(self, data_source_name):
"""
Load fields/columns of the given data source.
"""
if data_source_name == "":
self.clear()
return
columns_names = table_column_names(data_source_name)
if len(columns_names) == 0:
return
self.cbo_source_field.clear()
self.cbo_source_field.addItem("")
self.cbo_source_field.addItems(columns_names)
def clear(self):
"""
Resets combo box selections.
"""
self._reset_combo_index(self.cbo_ref_table)
self._reset_combo_index(self.cbo_referencing_col)
self._reset_combo_index(self.cbo_source_field)
def _reset_combo_index(self, combo):
if combo.count > 0:
combo.setCurrentIndex(0)
def reset_referenced_table(self):
self._reset_combo_index(self.cbo_ref_table)
def load_link_tables(self, reg_exp=None, source=TABLES|VIEWS):
self.cbo_ref_table.clear()
self.cbo_ref_table.addItem("")
ref_tables = []
#Table source
if (TABLES & source) == TABLES:
ref_tables.extend(pg_tables())
#View source
if (VIEWS & source) == VIEWS:
ref_tables.extend(pg_views())
source_tables = []
for t in ref_tables:
if not reg_exp is None:
if reg_exp.exactMatch(t):
source_tables.append(t)
else:
source_tables.append(t)
self.cbo_ref_table.addItems(source_tables)
def _load_source_table_fields(self, sel):
self.cbo_referencing_col.clear()
if not sel:
return
columns_names = table_column_names(sel)
self.cbo_referencing_col.clear()
self.cbo_referencing_col.addItem("")
self.cbo_referencing_col.addItems(columns_names)
class LayerSelectionPage(QFrame):
#TODO. Filtering, (visible) row selection, multi selection
colparams = ((0, 65, 'Name'), (1, 235, 'Title'), (2, 350, 'Keywords'))
XFER_BW = 40
def __init__(self, parent=None):
super(LayerSelectionPage, self).__init__(parent)
self.parent = parent
#convenience link
self.confconn_link = self.parent.parent.confconn
#flag top prevent read read action on keyword delete. New logic makes this redundant
#self.keywordbypass = False
QToolTip.setFont(QFont('SansSerif', 10))
#label
filterlabel = QLabel('Filter')
availablelabel = QLabel('Available Layers')
selectionlabel = QLabel('Layer Selections')
keywordlabel = QLabel('Keyword')
explainlabel = QLabel(
"Edit Group assignments using this dialog or to simply initialise the Layer-Config just click 'Finish'"
)
#selection buttons
chooseallbutton = QPushButton('>>')
chooseallbutton.setFixedWidth(self.XFER_BW)
chooseallbutton.clicked.connect(self.doChooseAllClickAction)
choosebutton = QPushButton('>')
choosebutton.setFixedWidth(self.XFER_BW)
choosebutton.clicked.connect(self.doChooseClickAction)
rejectbutton = QPushButton('<')
rejectbutton.setFixedWidth(self.XFER_BW)
rejectbutton.clicked.connect(self.doRejectClickAction)
rejectallbutton = QPushButton('<<')
rejectallbutton.setFixedWidth(self.XFER_BW)
rejectallbutton.clicked.connect(self.doRejectAllClickAction)
#operation buttons
finishbutton = QPushButton('Finish')
finishbutton.setToolTip('Finish and Close layer selection dialog')
finishbutton.clicked.connect(self.parent.close)
resetbutton = QPushButton('Reset')
resetbutton.font()
resetbutton.setToolTip(
'Read Layer from LDS GetCapabilities request. Overwrites current Layer Config'
)
resetbutton.clicked.connect(self.doResetClickAction)
self.available_sfpm = LDSSFPAvailableModel(self)
self.selection_sfpm = LDSSFPSelectionModel(self)
self.available_sfpm.setSourceModel(self.parent.available_model)
self.selection_sfpm.setSourceModel(self.parent.selection_model)
#textedits
filteredit = QLineEdit('')
filteredit.setToolTip(
'Filter Available-Layers pane (filter operates across Name and Title fields and accepts Regex expressions)'
)
filteredit.textChanged.connect(self.available_sfpm.setActiveFilter)
self.keywordcombo = QComboBox()
self.keywordcombo.setToolTip(
'Select or Add a unique identifier to be saved in layer config (keyword)'
)
self.keywordcombo.addItems(list(self.confconn_link.assigned))
self.keywordcombo.setEditable(True)
self.keywordcombo.activated.connect(self.doKeyComboChangeAction)
lgindex = self.confconn_link.getLayerGroupIndex(
self.confconn_link.lgval, col=1)
lgentry = self.confconn_link.lglist[lgindex] if LU.assessNone(
lgindex) else None
#keywordedit = self.keywordcombo.lineEdit().text().toUtf8().data().decode('utf8')# for writing
#if no entry or layer indicated then blank
self.keywordcombo.lineEdit().setText(
'' if lgentry is None or lgentry[0] == LORG.LAYER else
lgentry[1]) #self.confconn_link.lgval)#TODO. group only
#header
headmodel = QStandardItemModel()
headmodel.setHorizontalHeaderLabels([
i[2] for i in self.colparams
][:self.parent.available_model.columnCount()])
headview1 = QHeaderView(Qt.Horizontal)
headview1.setModel(headmodel)
headview1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
headview2 = QHeaderView(Qt.Horizontal)
headview2.setModel(headmodel)
headview2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
#table
self.available = QTableView()
self.available.setSelectionBehavior(QAbstractItemView.SelectRows)
self.available.setSelectionMode(QAbstractItemView.MultiSelection)
self.selection = QTableView()
self.selection.setSelectionBehavior(QAbstractItemView.SelectRows)
self.selection.setSelectionMode(QAbstractItemView.MultiSelection)
#interesting, must set model after selection attributes but before headers else row selections/headers don't work properly
self.available.setModel(self.available_sfpm)
self.selection.setModel(self.selection_sfpm)
self.available.setSortingEnabled(True)
self.available.setHorizontalHeader(headview1)
self.selection.setSortingEnabled(True)
self.selection.setHorizontalHeader(headview2)
for cp in self.colparams:
self.available.setColumnWidth(cp[0], cp[1])
self.selection.setColumnWidth(cp[0], cp[1])
self.available.verticalHeader().setVisible(False)
self.available.horizontalHeader().setVisible(True)
self.selection.verticalHeader().setVisible(False)
self.selection.horizontalHeader().setVisible(True)
#layout
vbox00 = QVBoxLayout()
vbox00.addWidget(availablelabel)
vbox00.addWidget(self.available)
vbox01 = QVBoxLayout()
vbox01.addWidget(chooseallbutton)
vbox01.addWidget(choosebutton)
vbox01.addWidget(rejectbutton)
vbox01.addWidget(rejectallbutton)
vbox02 = QVBoxLayout()
vbox02.addWidget(selectionlabel)
vbox02.addWidget(self.selection)
vbox10 = QVBoxLayout()
vbox10.addWidget(filterlabel)
vbox10.addWidget(filteredit)
hbox12 = QHBoxLayout()
hbox12.addWidget(keywordlabel)
hbox12.addStretch(1)
#hbox12.addWidget(inspbutton)
#hbox12.addWidget(addbutton)
#hbox12.addWidget(delbutton)
vbox12 = QVBoxLayout()
vbox12.addLayout(hbox12)
vbox12.addWidget(self.keywordcombo)
#00|01|02
#10|11|12
grid0 = QGridLayout()
grid0.addLayout(vbox00, 1, 0)
grid0.addLayout(vbox01, 1, 1)
grid0.addLayout(vbox02, 1, 2)
grid0.addLayout(vbox10, 0, 0)
grid0.addLayout(vbox12, 0, 2)
hbox2 = QHBoxLayout()
hbox2.addWidget(resetbutton)
hbox2.addStretch(1)
hbox2.addWidget(explainlabel)
hbox2.addWidget(finishbutton)
#gbox1.setLayout(hbox2)
vbox3 = QVBoxLayout()
vbox3.addLayout(grid0)
#vbox3.addLayout(hbox3)
#vbox3.addWidget(line0)
vbox3.addLayout(hbox2)
self.setLayout(vbox3)
def doChooseAllClickAction(self):
'''Moves the lot to Selected'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(
LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
self.parent.signalModels(self.parent.STEP.PRE)
#self.parent.selection_model.mdata += self.parent.available_model.mdata
self.parent.selection_model.initData(self.confconn_link.complete)
self.parent.available_model.initData([])
self.parent.signalModels(self.parent.STEP.POST)
#------------------------------
self.parent.writeKeysToLayerConfig(ktext)
#self.confconn_link.setupAssignedLayerList()
if self.keywordcombo.findText(ktext) == -1:
self.keywordcombo.addItem(ktext)
def doChooseClickAction(self):
'''Takes available selected and moves to selection'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(
LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
#ktext = str(self.keywordcombo.lineEdit().text())
if not self.checkKeyword(ktext): return
#------------------------------
select = self.available.selectionModel()
if select.hasSelection():
self.transferSelectedRows(select.selectedRows(),
self.available_sfpm, self.selection_sfpm)
#------------------------------
self.parent.writeKeysToLayerConfig(ktext)
#self.confconn_link.assigned = self.confconn_link.setupAssignedLayerList()
# -1 to indicate no index since 0,1,... are valid
if self.keywordcombo.findText(ktext) == -1:
self.keywordcombo.addItem(ktext)
else:
ldslog.warn('L2R > Transfer action without selection')
#TRACE#
#pdb.set_trace()
self.available.clearSelection()
def transferSelectedRows(self, indices, from_model, to_model):
tlist = []
for proxymodelindex in indices:
transfer = from_model.getData(proxymodelindex)
tlist.append((proxymodelindex, transfer), )
to_model.addData([t[1] for t in tlist])
from_model.delData([t[0] for t in tlist])
return tlist
def doRejectClickAction(self):
'''Takes available selected and moves to selection'''
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(
LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
select = self.selection.selectionModel()
if select.hasSelection():
tlist = self.transferSelectedRows(select.selectedRows(),
self.selection_sfpm,
self.available_sfpm)
#------------------------------
kindex = self.keywordcombo.findText(ktext)
remainder = self.parent.deleteKeysFromLayerConfig(
[ll[1][0] for ll in tlist], ktext)
if remainder > 0 and kindex == -1:
#items+newkey -> add
self.parent.writeKeysToLayerConfig(ktext)
self.keywordcombo.addItem(ktext)
elif remainder == 0 and kindex > -1:
#empty+oldkey -> del
self.keywordcombo.removeItem(kindex)
self.keywordcombo.clearEditText()
else:
ldslog.warn('R2L < Transfer action without selection')
#TRACE#
#pdb.set_trace()
self.selection.clearSelection()
def doRejectAllClickAction(self):
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(
LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
if not self.checkKeyword(ktext): return
#------------------------------
self.parent.deleteKeysFromLayerConfig(
[ll[0] for ll in self.parent.selection_model.mdata], ktext)
#------------------------------
self.parent.signalModels(self.parent.STEP.PRE)
#self.parent.available_model.mdata += self.parent.selection_model.mdata
self.parent.available_model.initData(self.confconn_link.complete)
self.parent.selection_model.initData([])
self.parent.signalModels(self.parent.STEP.POST)
#------------------------------
#self.confconn_link.setupAssignedLayerList()
#self.keywordbypass = True
self.keywordcombo.removeItem(self.keywordcombo.findText(ktext))
self.keywordcombo.clearEditText()
def doKeyComboChangeAction(self):
'''Reset the available pane and if there is anything in the keyword box use this to init the selection pane'''
#HACK
#if self.keywordbypass:
# self.keywordbypass = False
# return
#------------------------------
#ktext = LU.recode(self.keywordcombo.lineEdit().text().toUtf8().data())
ktext = LU.recode(
LQ.readWidgetText(self.keywordcombo.lineEdit().text()))
#------------------------------
av_sl = self.parent.splitData(ktext, self.confconn_link.complete)
#av_sl = self.parent.splitData(ktext,self.confconn_link.complete)
self.parent.signalModels(self.parent.STEP.PRE)
self.parent.available_model.initData(av_sl[0])
self.parent.selection_model.initData(av_sl[1])
self.parent.signalModels(self.parent.STEP.POST)
def doResetClickAction(self):
'''Dumps the LC and rebuilds from a fresh read of the caps doc'''
#int warning (QWidget parent, QString title, QString text, QString button0Text, QString button1Text = QString(), QString button2Text = QString(), int defaultButtonNumber = 0, int escapeButtonNumber = -1)
ans = QMessageBox.warning(
self, "Reset",
"This action will overwrite your Layer Configuration using the current LDS settings (potentially adding new or removing layers). Continue?",
"Continue", "Cancel")
if ans:
#Cancel
ldslog.warn('Cancelling Reset operation')
return
#Continue
ldslog.warn('Reset Layer Config')
self.parent.resetLayers()
self.keywordcombo.clear()
def checkKeyword(self, ktext):
'''Checks keyword isn't null and isn't part of the LDS supplied keywords'''
if LU.assessNone(ktext) is None:
QMessageBox.about(self, "Keyword Required",
"Please enter a Keyword to assign Layer(s) to")
return False
if ktext in self.confconn_link.reserved:
QMessageBox.about(
self, "Reserved Keyword",
"'{}' is a reserved keyword, please select again".format(
ktext))
return False
return True
class SimpleConnectWidget(QWidget):
"""
this widget displays a combobox with a list of instruments which the
user can connect to, it also has a refresh button
"""
def __init__(self, parent=None):
super(SimpleConnectWidget, self).__init__(parent)
# main layout of the form is the verticallayout
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
# moved the script stuff to a separate widget that lives in the toolbar
self.labelLayout = QHBoxLayout()
self.labelLayout.setObjectName("labelLayout")
self.portLabel = QLabel(self)
self.portLabel.setText("Availiable Ports")
self.instrLabel = QLabel(self)
self.instrLabel.setText("Instruments")
self.labelLayout.addWidget(self.portLabel)
self.labelLayout.addWidget(self.instrLabel)
self.verticalLayout.addLayout(self.labelLayout)
self.ports = QComboBox(self)
self.ports.addItems(refresh_device_port_list())
self.ports.setObjectName("cbb_ports")
self.instruments = QComboBox(self)
self.instruments.addItems(utils.list_drivers(interface="real")[0])
self.ports.setObjectName("cbb_instrs")
self.cbbLayout = QHBoxLayout()
self.cbbLayout.setObjectName("cbbLayout")
self.cbbLayout.addWidget(self.ports)
self.cbbLayout.addWidget(self.instruments)
self.verticalLayout.addLayout(self.cbbLayout)
self.connectButton = QPushButton(self)
self.connectButton.setText("Connect the instrument")
self.connectButton.setObjectName("connectButton")
self.refreshButton = QPushButton(self)
self.refreshButton.setText("refresh the port list")
self.refreshButton.setObjectName("refreshButton")
self.verticalLayout.addWidget(self.connectButton)
self.verticalLayout.addWidget(self.refreshButton)
self.headerTextEdit = QPlainTextEdit("")
fontsize = self.headerTextEdit.fontMetrics()
pal = QPalette()
textc = QColor(245, 245, 240)
pal.setColor(QPalette.Base, textc)
self.headerTextEdit.setPalette(pal)
# d3d3be
# self.headerTextEdit.ba
self.headerTextEdit.setFixedHeight(fontsize.lineSpacing() * 8)
self.verticalLayout.addWidget(self.headerTextEdit)
# moved the start stop button to the toolbar only
self.setLayout(self.verticalLayout)
self.connect(self.connectButton, SIGNAL('clicked()'),
self.on_connectButton_clicked)
self.connect(self.refreshButton, SIGNAL('clicked()'),
self.on_refreshButton_clicked)
def on_connectButton_clicked(self):
"""Connect a given instrument through a given port"""
port = self.ports.currentText()
instrument_name = self.instruments.currentText()
# load the module which contains the instrument's driver
if __name__ == "__main__":
class_inst = import_module(instrument_name)
else:
class_inst = import_module("." + instrument_name,
package=utils.LABDRIVER_PACKAGE_NAME)
msg = ""
# msg.append("example")
# msg.append("</span>")
self.headerTextEdit.appendHtml(msg)
# self.headerTextEdit.appendPlainText(msg)
try:
i = class_inst.Instrument(port)
self.headerTextEdit.appendPlainText("%s" % (i.identify()))
self.headerTextEdit.appendHtml(
"The connection to the instrument %s through the port %s <span style=\" color:#009933;\" >WORKED</span>\n"
% (instrument_name, port))
i.close()
except:
self.headerTextEdit.appendHtml(
"The connection to the instrument %s through the port %s <span style=\" color:#ff0000;\" >FAILED</span>\n"
% (instrument_name, port))
def on_refreshButton_clicked(self):
"""Refresh the list of the availiable ports"""
self.ports.clear()
self.ports.addItems(refresh_device_port_list())
class FindInFilesDialog(QDialog):
"""Dialog to configure and trigger the search in the files."""
def __init__(self, result_widget, parent):
super(FindInFilesDialog, self).__init__(parent)
self._find_thread = FindInFilesThread()
self.setWindowTitle(translations.TR_FIND_IN_FILES)
self.resize(400, 300)
#MAIN LAYOUT
main_vbox = QVBoxLayout(self)
self.pattern_line_edit = QLineEdit()
self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...")
self.dir_name_root = None
self.user_home = os.path.expanduser('~')
self.dir_combo = QComboBox()
self.dir_combo.addItem(self.user_home)
self.dir_combo.setEditable(True)
self.open_button = QPushButton(QIcon(":img/find"), translations.TR_OPEN)
self.filters_line_edit = QLineEdit("*.py")
self.filters_line_edit.setPlaceholderText("*.py")
self.filters_line_edit.setCompleter(QCompleter(
["*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS]))
self.replace_line = QLineEdit()
self.replace_line.setEnabled(False)
self.replace_line.setPlaceholderText(
translations.TR_TEXT_FOR_REPLACE + "...")
self.check_replace = QCheckBox(translations.TR_REPLACE)
self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE)
self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION)
self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE)
self.recursive_checkbox.setCheckState(Qt.Checked)
self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE)
self.phrase_radio.setChecked(True)
self.words_radio = QRadioButton(
translations.TR_SEARCH_FOR_ALL_THE_WORDS)
self.find_button = QPushButton(translations.TR_FIND + "!")
self.find_button.setMaximumWidth(150)
self.cancel_button = QPushButton(translations.TR_CANCEL)
self.cancel_button.setMaximumWidth(150)
self.result_widget = result_widget
hbox = QHBoxLayout()
hbox.addWidget(self.find_button)
hbox.addWidget(self.cancel_button)
#main section
find_group_box = QGroupBox(translations.TR_MAIN)
grid = QGridLayout()
grid.addWidget(QLabel(translations.TR_TEXT), 0, 0)
grid.addWidget(self.pattern_line_edit, 0, 1)
grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0)
grid.addWidget(self.dir_combo, 1, 1)
grid.addWidget(self.open_button, 1, 2)
grid.addWidget(QLabel(translations.TR_FILTER), 2, 0)
grid.addWidget(self.filters_line_edit, 2, 1)
grid.addWidget(self.check_replace, 3, 0)
grid.addWidget(self.replace_line, 3, 1)
find_group_box.setLayout(grid)
#add main section to MAIN LAYOUT
main_vbox.addWidget(find_group_box)
#options sections
options_group_box = QGroupBox(translations.TR_OPTIONS)
gridOptions = QGridLayout()
gridOptions.addWidget(self.case_checkbox, 0, 0)
gridOptions.addWidget(self.type_checkbox, 1, 0)
gridOptions.addWidget(self.recursive_checkbox, 2, 0)
gridOptions.addWidget(self.phrase_radio, 0, 1)
gridOptions.addWidget(self.words_radio, 1, 1)
options_group_box.setLayout(gridOptions)
#add options sections to MAIN LAYOUT
main_vbox.addWidget(options_group_box)
#add buttons to MAIN LAYOUT
main_vbox.addLayout(hbox)
#Focus
self.pattern_line_edit.setFocus()
self.open_button.setFocusPolicy(Qt.NoFocus)
#signal
self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
self.connect(self.find_button, SIGNAL("clicked()"),
self._find_in_files)
self.connect(self.cancel_button, SIGNAL("clicked()"),
self._kill_thread)
self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
self._found_match)
self.connect(self._find_thread, SIGNAL("finished()"),
self._find_thread_finished)
self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
self._change_radio_enabled)
self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
self._replace_activated)
self.connect(self.words_radio, SIGNAL("clicked(bool)"),
self._words_radio_pressed)
def _replace_activated(self):
"""If replace is activated, display the replace widgets."""
self.replace_line.setEnabled(self.check_replace.isChecked())
self.phrase_radio.setChecked(True)
def _words_radio_pressed(self, value):
"""If search by independent words is activated, replace is not."""
self.replace_line.setEnabled(not value)
self.check_replace.setChecked(not value)
self.words_radio.setChecked(True)
def _change_radio_enabled(self, val):
"""Control the state of the radio buttons."""
enabled = not self.type_checkbox.isChecked()
self.phrase_radio.setEnabled(enabled)
self.words_radio.setEnabled(enabled)
def show(self, actual_project=None, actual=None):
"""Display the dialog and load the projects."""
self.dir_combo.clear()
self.dir_name_root = actual_project if \
actual_project else [self.user_home]
self.dir_combo.addItems(self.dir_name_root)
if actual:
index = self.dir_combo.findText(actual)
self.dir_combo.setCurrentIndex(index)
super(FindInFilesDialog, self).show()
self.pattern_line_edit.setFocus()
def reject(self):
"""Close the dialog and hide the tools dock."""
self._kill_thread()
tools_dock = IDE.get_service('tools_dock')
if tools_dock:
tools_dock.hide()
super(FindInFilesDialog, self).reject()
def _find_thread_finished(self):
"""Wait on thread finished."""
self.emit(SIGNAL("finished()"))
self._find_thread.wait()
def _select_dir(self):
"""When a new folder is selected, add to the combo if needed."""
dir_name = QFileDialog.getExistingDirectory(self, translations.TR_OPEN,
self.dir_combo.currentText(),
QFileDialog.ShowDirsOnly)
index = self.dir_combo.findText(dir_name)
if index >= 0:
self.dir_combo.setCurrentIndex(index)
else:
self.dir_combo.insertItem(0, dir_name)
self.dir_combo.setCurrentIndex(0)
def _found_match(self, result):
"""Update the tree for each match found."""
file_name = result[0]
items = result[1]
self.result_widget.update_result(
self.dir_combo.currentText(), file_name, items)
def _kill_thread(self):
"""Kill the thread."""
if self._find_thread.isRunning():
self._find_thread.cancel()
self.accept()
def _find_in_files(self):
"""Trigger the search on the files."""
self.emit(SIGNAL("findStarted()"))
self._kill_thread()
self.result_widget.clear()
pattern = self.pattern_line_edit.text()
dir_name = self.dir_combo.currentText()
filters = re.split("[,;]", self.filters_line_edit.text())
#remove the spaces in the words Ex. (" *.foo"--> "*.foo")
filters = [f.strip() for f in filters]
case_sensitive = self.case_checkbox.isChecked()
type_ = QRegExp.RegExp if \
self.type_checkbox.isChecked() else QRegExp.FixedString
recursive = self.recursive_checkbox.isChecked()
by_phrase = True
if self.phrase_radio.isChecked() or self.type_checkbox.isChecked():
regExp = QRegExp(pattern, case_sensitive, type_)
elif self.words_radio.isChecked():
by_phrase = False
type_ = QRegExp.RegExp
pattern = '|'.join(
[word.strip() for word in pattern.split()])
regExp = QRegExp(pattern, case_sensitive, type_)
#save a reference to the root directory where we find
self.dir_name_root = dir_name
self._find_thread.find_in_files(dir_name, filters, regExp, recursive,
by_phrase)
class I4CheckWindow(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setup_model()
self.tableview = QTableView()
self.tableview.setSelectionMode(QAbstractItemView.NoSelection)
self.tableview.setEditTriggers(QAbstractItemView.DoubleClicked)
self.cbdelegate = CheckBoxDelegate()
self.tableview.setItemDelegate(self.cbdelegate)
self.tableview.setAutoScroll(False)
self.tableview.setModel(self.model)
self.tableview.sortByColumn(0, Qt.AscendingOrder)
self.adjust_headers()
#self.model.setHeaderData(0, Qt.Horizontal, u"")
#self.model.setHeaderData(1, Qt.Horizontal, u"Title")
self.radio_all = QRadioButton("All")
self.radio_all.setChecked(True)
self.radio_need = QRadioButton("Need")
self.connect(self.radio_all, SIGNAL("toggled(bool)"), self.set_show_all)
label = QLabel("DB:")
label.setFixedWidth(40)
label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.db_combo = QComboBox()
self.populate_db_combo()
self.connect(
self.db_combo, SIGNAL("currentIndexChanged(int)"),
self.db_index_changed)
self.new_button = QPushButton("New")
self.connect(self.new_button, SIGNAL("clicked()"), self.new_item)
self.box = QVBoxLayout(self)
self.box.addWidget(self.tableview)
self.button_box = QHBoxLayout()
self.button_box.setSpacing(0)
self.button_box.addWidget(self.new_button)
self.button_box.addWidget(self.radio_all)
self.button_box.addWidget(self.radio_need)
self.button_box.addWidget(label)
self.button_box.addWidget(self.db_combo)
self.box.addLayout(self.button_box)
# self.setStyleSheet("""
# QComboBox {
# font-size: 16px;
# }
# """)
self.dwim_after_load()
def dwim_after_load(self):
if self.model.need_anything():
self.radio_need.setChecked(True)
return
self.radio_all.setChecked(True)
if self.model.model.rowCount() == 0:
edit_index = self.model.new()
self.tableview.setCurrentIndex(edit_index)
self.tableview.scrollTo(edit_index)
self.tableview.edit(edit_index)
def adjust_headers(self):
log.debug("adjust_sizes()")
self.tableview.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.tableview.setColumnWidth(0, 1)
self.tableview.verticalHeader().setDefaultSectionSize(ITEM_HEIGHT)
self.tableview.verticalHeader().hide()
self.tableview.horizontalHeader().hide()
def setup_model(self):
self.model = CheckListModel()
def new_item(self):
index = self.model.new()
self.tableview.setCurrentIndex(index)
self.tableview.resizeRowToContents(index.row())
self.tableview.scrollTo(index)
self.tableview.edit(index)
def set_show_all(self, show_all):
if self.model.show_all == show_all:
return
self.model.set_show_all(show_all)
self.tableview.resizeRowsToContents()
def save(self):
self.model.save()
def checkout(self):
if QMessageBox.question(
self, "Checkout", "Are you sure you want to check out?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \
QMessageBox.Yes:
self.model.checkout()
def reset_items(self):
if QMessageBox.question(
self, "Checkout", "Are you sure you want to reset the list?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \
QMessageBox.Yes:
self.model.reset_items()
self.radio_all.setChecked(True)
def delete_database(self):
if QMessageBox.question(
self, "Delete database",
"Are you sure you want to delete the current database?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == \
QMessageBox.Yes:
self.model.delete_database()
self.populate_db_combo()
self.dwim_after_load()
_loading_db_combo = False
def populate_db_combo(self):
self._loading_db_combo = True
try:
self.db_combo.clear()
for db_name in self.model.databases:
self.db_combo.addItem(re.sub("\\.org$", "", db_name), db_name)
self.db_combo.addItem("New database...", "")
self.db_combo.setCurrentIndex(
self.model.databases.index(self.model.current_db))
finally:
self._loading_db_combo = False
def db_index_changed(self, index):
if self._loading_db_combo:
return
db_name = str(self.db_combo.itemData(index).toPyObject())
if db_name == self.model.current_db:
return
self.model.save()
if db_name:
self.model.load(db_name)
self.dwim_after_load()
return
db_name, ok = QInputDialog.getText(
self, "New Database", "Enter database name")
if ok:
if not re.match(r"^[\w-]+$", db_name):
QMessageBox.critical(
self, "Error",
"Database name must contain only the following chars: "
"A-Z a-z 0-9 _ -")
ok = False
elif db_name in self.model.databases:
QMessageBox.critical(
self, "Error", "Database '%s' already exists" % db_name)
ok = False
if not ok:
self.db_combo.setCurrentIndex(
self.model.databases.index(self.model.current_db))
return
db_name = str(db_name) + ".org"
self.model.load(db_name)
self.populate_db_combo()
self.dwim_after_load()
class AdvancedObjectWidget(QWidget):
def __init__(self, index, currentTemplate="classic.html", parent=None, entryTemplate = None):
QWidget.__init__(self, parent)
w = 24
h = 24
self.entryModel = None
# Standard pixmaps used by the widget
self.reloadPixmap = pixmapFromTheme(
"view-refresh", ":/icons/32/view-refresh", w, h)
self.savePixmap = pixmapFromTheme(
"document-save", ":/icons/32/document-save",w, h)
self.addPixmap = pixmapFromTheme(
"list-add", ":/icons/32/list-add", w, h)
self.deleteSmallPixmap = pixmapFromTheme(
"list-remove", ":/icons/32/list-remove", w, h)
self.treeIndex = index
self.setLayout(QVBoxLayout(self))
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# create the widget containing the data
self.textBrowser = QTextBrowser()
self.textBrowser.setOpenLinks(False)
self.textBrowser.setWordWrapMode(QTextOption.WrapAnywhere)
self.layout().addWidget(self.textBrowser)
self.textBrowser.anchorClicked.connect(self.anchorClicked)
self.currentDocument = ''
self.addingToComboBox = False
# create the combobox containing the different views
self.comboBox = QComboBox()
self.currentTemplate = currentTemplate
self.errorTemplate = "error.html"
self.usedTemplates = []
# FIXED: Need a more robust way for locating the path used in
# the TemplateFactory for locating the template view
# files
# >>> with base.util.Paths.getLumaRoot this should work.
# Probably needs some validation testing on platforms
# other than Linux
# Another issue occured when running Luma after a installation
# from a source distribution. Because the site-packages is only
# intended for pure python modules, the html templates is not
# installed, resulting in an Exception when trying to view an
# entry in the Browser plugin. The setup.py script is modified
# such that the needed html templates is copied into a folder
# in the path returned by `base.util.Paths.getConfigPrefix`.
s = QtCore.QSettings()
configPrefix = s.value('application/config_prefix').toString()
templatesPath = os.path.join(unicode(configPrefix).encode('utf-8'),
'browser-templates')
# If we run Luma from a development environment the isntalled
# templatesPath do most likely not exist. We therefore use the
# directory in the repository
if not os.path.isdir(templatesPath):
templatesPath = unicode(
os.path.join(
getLumaRoot(), 'plugins', 'browser', 'templates')
)
self.templateFactory = TemplateFactory(templatesPath)
self.htmlParser = HtmlParser(self.textBrowser)
self.str_RELOAD= QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Reload")
self.str_SAVE = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Save entry")
self.str_SAVE_CONTINUE = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Do you want to save the entry before continuing?")
self.str_SAVE_FAILED = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Saving failed, continue anyway?")
self.str_DELETE = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Delete object")
self.str_DELETE_CONFIRM = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Do you really want to delete the object?")
self.str_ADD = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Add attribute")
self.str_SWITCH_VIEWS = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Switch between views")
self.str_REASON = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Reason:")
self.str_EXPORT_BINARY = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Export binary attribute to file")
self.str_EXPORT_BINARY_EXCEPT = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Could not export binary data to file.")
self.str_SELECT_ANOTHER_FILE = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Please select another filename.")
self.str_NO_TEMPLATE = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"No templates available")
self.str_MISSING_ENTRY = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"Did'nt receive a ldap-object, it might have been deleted")
self.str_ENTRY_INVALID = QtCore.QCoreApplication.translate("AdvancedObjectWidget",
"The ldap object is not valid\nClick Yes to view the object anyway\nNo to view the errors \nIgnore to view the object and ignore this message in later attempts.")
self.buildToolBar()
###############################################################################
@staticmethod
def smartObjectCopy(smartObject):
return SmartDataObject(copy.deepcopy([smartObject.dn, smartObject.data]), copy.deepcopy(smartObject.serverMeta))
###############################################################################
def getSmartObject(self):
return self.entryModel.getSmartObject()
###############################################################################
def initModel(self, smartObject, create=False, entryTemplate = None):
""" sets up the model, and connects it to this object
"""
if not create:
# use a copy of the smartObject
smartObject = AdvancedObjectWidget.smartObjectCopy(smartObject)
self.baseDN = smartObject.getDN()
self.entryModel = EntryModel(smartObject, self, entryTemplate)
self.htmlParser.setModel(self.entryModel)
self.entryModel.modelChangedSignal.connect(self.modelChanged)
success, exceptionMsg, exceptionObject = self.entryModel.initModel(create)
if not success:
errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject))
QMessageBox.critical(self,
self.trUtf8(""),
self.trUtf8(errorMsg))
###############################################################################
def loadTemplates(self):
""" Loads all templates that matches with the current objectclasses
"""
self.usedTemplates = []
objectClasses = self.getSmartObject().getObjectClasses()
newIndex = -1
i = 0
for objectClass, fileName in self.templateFactory.getTemplateList():
if objectClass == '' or objectClass in objectClasses:
if fileName == self.currentTemplate:
newIndex = i
self.usedTemplates.append(fileName)
i += 1
if newIndex == -1:
newIndex = 0
self.currentTemplate = self.usedTemplates[newIndex]
#TODO do this properly, signals ignored
self.addingToComboBox = True
self.comboBox.clear()
self.comboBox.addItems(self.usedTemplates)
self.comboBox.setCurrentIndex(newIndex)
self.addingToComboBox = False
###############################################################################
@pyqtSlot(bool)
def modelChanged(self, reload):
if reload:
item = None
if self.treeIndex and self.treeIndex.isValid():
row = self.treeIndex.row()
column = self.treeIndex.column()
# QPersistenIndex doesn't have internalPointer()
# so we aquire a QModelIndex which does
item = self.treeIndex.sibling(row,column).internalPointer()
if not(self.entryModel.VALID):
if item == None or not(item.serverParent.ignoreItemErrors):
result = QMessageBox.question(self,
self.trUtf8(""),
self.str_ENTRY_INVALID,
QMessageBox.Yes | QMessageBox.No | QMessageBox.Ignore,
QMessageBox.No)
if result == QMessageBox.No:
self.currentTemplate = self.errorTemplate
elif result == QMessageBox.Ignore:
if not(item == None):
item.serverParent.ignoreItemErrors = True
self.displayValues()
###############################################################################
def displayValues(self):
# Something went wrong. We have no data object.
# This might happen if we want to refresh an item and
# it might be deleted already.
if None == self.entryModel.getSmartObject():
QMessageBox.critical(self, self.str_MISSING_ENTRY)
self.enableToolButtons(False)
return
self.loadTemplates()
if self.currentTemplate == None:
selt.textBrowser.setHtml(self.str_NO_TEMPLATE)
return
htmlTemplate = self.templateFactory.getTemplateFile(self.currentTemplate)
self.currentDocument = self.htmlParser.parseHtml(htmlTemplate)
self.textBrowser.setHtml(self.currentDocument)
self.enableToolButtons(True)
###############################################################################
def enableToolButtons(self, enable):
if None == self.entryModel:
self.saveButton.setEnabled(False)
self.deleteObjectButton.setEnabled(False)
self.reloadButton.setEnabled(True)
self.addAttributeButton.setEnabled(False)
return
if self.entryModel.EDITED and not self.entryModel.CREATE:
self.saveButton.setEnabled(enable)
else:
self.saveButton.setEnabled(False)
if self.entryModel.ISLEAF:
self.deleteObjectButton.setEnabled(enable)
else:
self.deleteObjectButton.setEnabled(False)
if self.entryModel.CREATE:
self.reloadButton.setEnabled(False)
else:
self.reloadButton.setEnabled(enable)
self.addAttributeButton.setEnabled(enable)
###############################################################################
def buildToolBar(self):
self.toolBar = QToolBar()
self.toolBar.layout().setContentsMargins(0, 0, 0, 0)
# Reload button
self.reloadButton = QToolButton(self.toolBar)
self.reloadButton.setIcon(QIcon(self.reloadPixmap))
self.reloadButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.reloadButton.setAutoRaise(True)
self.reloadButton.setBackgroundRole(self.backgroundRole())
self.reloadButton.setToolTip(self.str_RELOAD)
self.connect(self.reloadButton, SIGNAL("clicked()"), self.refreshView)
self.toolBar.addWidget(self.reloadButton)
# Save button
self.saveButton = QToolButton(self.toolBar)
self.saveButton.setIcon(QIcon(self.savePixmap))
self.saveButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.saveButton.setAutoRaise(True)
self.saveButton.setBackgroundRole(self.backgroundRole())
self.saveButton.setToolTip(self.str_SAVE)
self.connect(self.saveButton, SIGNAL("clicked()"), self.saveObject)
self.toolBar.addWidget(self.saveButton)
self.toolBar.addSeparator()
# Add attribute button
self.addAttributeButton = QToolButton(self.toolBar)
self.addAttributeButton.setIcon(QIcon(self.addPixmap))
self.addAttributeButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.addAttributeButton.setAutoRaise(True)
self.addAttributeButton.setBackgroundRole(self.backgroundRole())
self.addAttributeButton.setToolTip(self.str_ADD)
self.connect(self.addAttributeButton, SIGNAL("clicked()"), self.addAttribute)
self.toolBar.addWidget(self.addAttributeButton)
# Delete button
self.deleteObjectButton = QToolButton(self.toolBar)
self.deleteObjectButton.setIcon(QIcon(self.deleteSmallPixmap))
self.deleteObjectButton.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.deleteObjectButton.setAutoRaise(True)
self.deleteObjectButton.setBackgroundRole(self.backgroundRole())
self.deleteObjectButton.setToolTip(self.str_DELETE)
self.connect(self.deleteObjectButton, SIGNAL("clicked()"), self.deleteObject)
self.toolBar.addWidget(self.deleteObjectButton)
self.comboBox.setToolTip(self.str_SWITCH_VIEWS)
self.connect(self.comboBox, SIGNAL("currentIndexChanged(int)"), self.changeView)
self.toolBar.addWidget(self.comboBox)
self.enableToolButtons(False)
self.layout().insertWidget(0, self.toolBar)
###############################################################################
@pyqtSlot("int")
def changeView(self, index):
"""
change between different views
"""
if index == -1 or self.addingToComboBox:
return
self.currentTemplate = self.usedTemplates[index]
self.displayValues()
###############################################################################
def aboutToChange(self):
"""
Asks the user whether changes should be saved
returns True if changes were saved, or discarded
"""
if not self.entryModel.EDITED:
return True
result = QMessageBox.warning(self,
self.str_SAVE,
self.str_SAVE_CONTINUE,
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
QMessageBox.Cancel)
# TODO add exception message
if result == QMessageBox.Save:
if not self.saveObject():
# Saving failed
result = QMessageBox.question(None,
self.trUtf8(""),
self.str_SAVE_FAILED,
QMessageBox.Ok | QMessageBox.Cancel,
QMessageBox.Cancel)
return not(result == QMessageBox.Cancel)
###############################################################################
# TODO: add logging for each error
@pyqtSlot()
def refreshView(self):
""" Refreshes the LDAP data from server and displays values.
"""
if self.aboutToChange():
success, exceptionMsg, exceptionObject = self.entryModel.reloadModel()
if not success:
errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject))
QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg))
else:
self.displayValues()
###############################################################################
# TODO: add logging for each error
@pyqtSlot()
def saveObject(self):
success, exceptionMsg, exceptionObject = self.entryModel.saveModel()
if not success:
# Saving failed
errorMsg = "%s<br><br>%s: %s" % (exceptionMsg, self.str_REASON, str(exceptionObject))
QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg))
return False
else:
# update the smartObject in the tree
if self.entryModel.CREATE:
pass
elif self.treeIndex and self.treeIndex.isValid():
row = self.treeIndex.row()
column = self.treeIndex.column()
# QPersistenIndex doesn't have internalPointer()
# so we aquire a QModelIndex which does
index = self.treeIndex.sibling(row,column)
index.internalPointer().itemData = self.getSmartObject()
return True
###############################################################################
@pyqtSlot()
def addAttribute(self):
""" Add attributes to the current object.
"""
dialog = AddAttributeWizard(self)
dialog.setData(self.smartObjectCopy(self.entryModel.getSmartObject()))
dialog.exec_()
if dialog.result() == QDialog.Rejected:
return
attribute = str(dialog.attributeBox.currentText())
showAll = dialog.enableAllBox.isChecked()
if dialog.binaryBox.isChecked():
attributeSet = set([attribute + ";binary"])
else:
attributeSet = set([attribute])
if showAll and not(attribute.lower() in dialog.possibleAttributes):
objectClass = str(dialog.classBox.currentItem().text())
self.entryModel.addObjectClass(objectClass)
serverSchema = ObjectClassAttributeInfo(self.entryModel.smartObject.getServerMeta())
mustAttributes = serverSchema.getAllMusts([objectClass])
mustAttributes = mustAttributes.difference(set(self.entryModel.smartObject.getAttributeList()))
attributeSet = mustAttributes.union(set([attribute]))
for x in attributeSet:
self.entryModel.addAttributeValue(x, None)
self.displayValues()
###############################################################################
# TODO: add logging for each error, remove tab and node from parent
@pyqtSlot()
def deleteObject(self):
buttonClicked = QMessageBox.critical(self,
self.str_DELETE,
self.str_DELETE_CONFIRM,
QMessageBox.Yes,
QMessageBox.No)
if not (buttonClicked == QMessageBox.Yes):
return
# If we have an index, use it tell the item to delete itself
# so that the view is updated
if self.treeIndex and self.treeIndex.isValid():
row = self.treeIndex.row()
column = self.treeIndex.column()
# QPersistenIndex doesn't have internalPointer()
# so we aquire a QModelIndex which does
index = self.treeIndex.sibling(row,column)
success, message = index.model().deleteItem(index)
if success:
self.enableToolButtons(False)
self.deleteLater()
else:
errorMsg = "%s" % (message)
QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg))
# if not, we just delete it ourselves since there's not view on the object
else:
success, message, exceptionObject = self.entryModel.deleteObject()
if success:
self.enableToolButtons(False)
self.deleteLater()
else:
errorMsg = "%s<br><br>%s: %s" % (message, self.str_REASON, str(exceptionObject))
QMessageBox.critical(self, self.trUtf8(""), self.trUtf8(errorMsg))
###############################################################################
@pyqtSlot("QUrl")
def anchorClicked(self, url):
""" Called when an anchor (<a href=".." /> is clicked
"""
nameString = unicode(url.toString())
tmpList = nameString.split("__")
if tmpList[0] in self.entryModel.getSmartObject().getObjectClasses():
self.entryModel.deleteObjectClass(tmpList[0])
else:
if not len(tmpList) == 3:
return
attributeName, index, operation = tmpList[0], int(tmpList[1]), tmpList[2]
if operation == "edit":
self.editAttribute(attributeName, index)
elif operation == "delete":
self.deleteAttribute(attributeName, index)
elif operation == "export":
self.exportAttribute(attributeName, index)
###############################################################################
def editAttribute(self, attributeName, index):
smartObject = self.entryModel.getSmartObject()
oldDN = smartObject.getDN()
addAttribute = False
if attributeName == 'RDN':
# TODO correct this, used on creation?
oldValue = oldDN
smartObject.setDN(self.baseDN)
else:
if smartObject.hasAttribute(attributeName):
addValue = False
oldValue = smartObject.getAttributeValue(attributeName, index)
if oldValue == None:
oldValue = ''
else:
addValue = True
oldValue = ''
dialog = getEditorWidget(self, smartObject, attributeName, index)
dialog.exec_()
if dialog.result() == QDialog.Accepted:
# TODO check attribute types
newValue = dialog.getValue()
if not (newValue == None):
if attributeName == 'RDN':
self.entryModel.setDN(newValue)
if dialog.addAttributeBox.isChecked():
addAttribute = unicode(dialog.attributeBox.currentText())
addValue = unicode(dialog.valueEdit.text())
self.entryModel.addAttributeValue(addAttribute, [addValue])
else:
if addValue:
self.entryModel.addAttributeValue(attributeName, [newValue])
else:
self.entryModel.editAttribute(attributeName, index, newValue)
else:
if attributeName == 'RDN':
smartObject.setDN(oldDN.decode('utf-8'))
###############################################################################
def deleteAttribute(self, attributeName, index):
self.entryModel.deleteAttribute(attributeName, index)
###############################################################################
def exportAttribute(self, attributeName, index):
""" Show the dialog for exporting binary attribute data.
"""
value = self.getSmartObject().getAttributeValue(attributeName, index)
fileName = unicode(QFileDialog.getSaveFileName(\
self,
self.str_EXPORT_BINARY,
QString(""),
"All files (*)",
None))
if unicode(fileName) == "":
return
try:
fileHandler = open(fileName, "w")
fileHandler.write(value)
fileHandler.close()
SAVED = True
except IOError, e:
msg = "%s %s:\n\n%s\n\n%s" % (self.str_EXPORT_BINARY_EXCEPT,
self.str_REASON,
str(e),
self.str_SELECT_ANOTHER_FILE)
result = QMessageBox.warning(\
self,
self.str_EXPORT_BINARY,
msg,
QMessageBox.Cancel | QMessageBox.Ok,
QMessageBox.Cancel)
class ActionBar(QFrame):
"""
SIGNALS:
@changeCurrent(PyQt_PyObject)
@runFile(QString)
@reopenTab(QString)
@recentTabsModified()
"""
def __init__(self, main_combo=False):
super(ActionBar, self).__init__()
self.setObjectName("actionbar")
hbox = QHBoxLayout(self)
hbox.setContentsMargins(1, 1, 1, 1)
hbox.setSpacing(1)
self.lbl_checks = QLabel('')
self.lbl_checks.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.lbl_checks.setFixedWidth(48)
self.lbl_checks.setVisible(False)
hbox.addWidget(self.lbl_checks)
self.combo = ComboFiles()
self.combo.setIconSize(QSize(16, 16))
#model = QStandardItemModel()
#self.combo.setModel(model)
#self.combo.view().setDragDropMode(QAbstractItemView.InternalMove)
self.combo.setMaximumWidth(300)
self.combo.setObjectName("combotab")
self.connect(self.combo, SIGNAL("currentIndexChanged(int)"),
self.current_changed)
self.combo.setToolTip(translations.TR_COMBO_FILE_TOOLTIP)
self.combo.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(self.combo, SIGNAL(
"customContextMenuRequested(const QPoint &)"),
self._context_menu_requested)
hbox.addWidget(self.combo)
self.symbols_combo = QComboBox()
self.symbols_combo.setIconSize(QSize(16, 16))
self.symbols_combo.setObjectName("combo_symbols")
self.connect(self.symbols_combo, SIGNAL("activated(int)"),
self.current_symbol_changed)
hbox.addWidget(self.symbols_combo)
self.code_navigator = CodeNavigator()
hbox.addWidget(self.code_navigator)
self._pos_text = "Line: %d, Col: %d"
self.lbl_position = QLabel(self._pos_text % (0, 0))
self.lbl_position.setObjectName("position")
self.lbl_position.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hbox.addWidget(self.lbl_position)
self.btn_close = QPushButton(
self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
self.btn_close.setIconSize(QSize(16, 16))
if main_combo:
self.btn_close.setObjectName('navigation_button')
self.btn_close.setToolTip(translations.TR_CLOSE_FILE)
self.connect(self.btn_close, SIGNAL("clicked()"),
self.about_to_close_file)
else:
self.btn_close.setObjectName('close_split')
self.btn_close.setToolTip(translations.TR_CLOSE_SPLIT)
self.connect(self.btn_close, SIGNAL("clicked()"),
self.close_split)
self.btn_close.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hbox.addWidget(self.btn_close)
def resizeEvent(self, event):
super(ActionBar, self).resizeEvent(event)
if event.size().width() < 350:
self.symbols_combo.hide()
self.code_navigator.hide()
self.lbl_position.hide()
else:
self.symbols_combo.show()
self.code_navigator.show()
self.lbl_position.show()
def add_item(self, text, neditable):
"""Add a new item to the combo and add the neditable data."""
self.combo.addItem(text, neditable)
self.combo.setCurrentIndex(self.combo.count() - 1)
def get_editables(self):
editables = []
for index in range(self.combo.count()):
neditable = self.combo.itemData(index)
editables.append(neditable)
return editables
def add_symbols(self, symbols):
"""Add the symbols to the symbols's combo."""
self.symbols_combo.clear()
for symbol in symbols:
data = symbol[1]
if data[1] == 'f':
icon = QIcon(":img/function")
else:
icon = QIcon(":img/class")
self.symbols_combo.addItem(icon, data[0])
def set_current_symbol(self, index):
self.symbols_combo.setCurrentIndex(index)
def update_item_icon(self, neditable, icon):
index = self.combo.findData(neditable)
self.combo.setItemIcon(index, icon)
def update_item_text(self, neditable, text):
index = self.combo.findData(neditable)
self.combo.setItemText(index, text)
def current_changed(self, index):
"""Change the current item in the combo."""
neditable = self.combo.itemData(index)
self.emit(SIGNAL("changeCurrent(PyQt_PyObject, int)"), neditable, index)
def current_symbol_changed(self, index):
"""Change the current symbol in the combo."""
self.emit(SIGNAL("goToSymbol(int)"), index)
def update_line_col(self, line, col):
"""Update the line and column position."""
self.lbl_position.setText(self._pos_text % (line, col))
def _context_menu_requested(self, point):
"""Display context menu for the combo file."""
if self.combo.count() == 0:
# If there is not an Editor opened, don't show the menu
return
menu = QMenu()
actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT)
actionRun = menu.addAction(translations.TR_RUN_FILE)
menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX)
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(translations.TR_CLOSE_FILE)
actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES)
actionCloseAllNotThis = menu.addAction(
translations.TR_CLOSE_OTHER_FILES)
menu.addSeparator()
actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY)
actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY)
menu.addSeparator()
actionCopyPath = menu.addAction(
translations.TR_COPY_FILE_PATH_TO_CLIPBOARD)
actionShowFileInExplorer = menu.addAction(
translations.TR_SHOW_FILE_IN_EXPLORER)
actionReopen = menu.addAction(translations.TR_REOPEN_FILE)
actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR)
if len(settings.LAST_OPENED_FILES) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split(False))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split(True))
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
self.about_to_close_file)
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_files_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_files)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionShowFileInExplorer, SIGNAL("triggered()"),
self._show_file_in_explorer)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
self.connect(actionUndock, SIGNAL("triggered()"),
self._undock_editor)
menu.exec_(QCursor.pos())
def _create_menu_syntax(self, menuSyntax):
"""Create Menu with the list of syntax supported."""
syntax = list(settings.SYNTAX.keys())
syntax.sort()
for syn in syntax:
menuSyntax.addAction(syn)
self.connect(menuSyntax, SIGNAL("triggered(QAction*)"),
self._reapply_syntax)
def _reapply_syntax(self, syntaxAction):
#TODO
if [self.currentIndex(), syntaxAction] != self._resyntax:
self._resyntax = [self.currentIndex(), syntaxAction]
self.emit(SIGNAL("syntaxChanged(QWidget, QString)"),
self.currentWidget(), syntaxAction.text())
def set_current_file(self, neditable):
index = self.combo.findData(neditable)
self.combo.setCurrentIndex(index)
def set_current_by_index(self, index):
self.combo.setCurrentIndex(index)
def about_to_close_file(self, index=None):
"""Close the NFile object."""
if index is None:
index = self.combo.currentIndex()
neditable = self.combo.itemData(index)
if neditable:
neditable.nfile.close()
def close_split(self):
self.emit(SIGNAL("closeSplit()"))
def close_file(self, neditable):
"""Receive the confirmation to close the file."""
index = self.combo.findData(neditable)
self.combo.removeItem(index)
return index
def _run_this_file(self):
"""Execute the current file."""
neditable = self.combo.itemData(self.combo.currentIndex())
self.emit(SIGNAL("runFile(QString)"), neditable.file_path)
def _add_to_project(self):
"""Emit a signal to let someone handle the inclusion of the file
inside a project."""
neditable = self.combo.itemData(self.combo.currentIndex())
self.emit(SIGNAL("addToProject(QString)"), neditable.file_path)
def _show_file_in_explorer(self):
'''Triggered when the "Show File in Explorer" context
menu action is selected. Emits the "showFileInExplorer(QString)"
signal with the current file's full path as argument.'''
neditable = self.combo.itemData(self.combo.currentIndex())
self.emit(SIGNAL("showFileInExplorer(QString)"), neditable.file_path)
def _reopen_last_tab(self):
self.emit(SIGNAL("reopenTab(QString)"),
settings.LAST_OPENED_FILES.pop())
self.emit(SIGNAL("recentTabsModified()"))
def _undock_editor(self):
self.emit(SIGNAL("undockEditor()"))
def _split(self, orientation):
self.emit(SIGNAL("splitEditor(bool)"), orientation)
def _copy_file_location(self):
"""Copy the path of the current opened file to the clipboard."""
neditable = self.combo.itemData(self.combo.currentIndex())
QApplication.clipboard().setText(neditable.file_path,
QClipboard.Clipboard)
def _close_all_files(self):
"""Close all the files opened."""
for i in range(self.combo.count()):
self.about_to_close_file(0)
def _close_all_files_except_this(self):
"""Close all the files except the current one."""
neditable = self.combo.itemData(self.combo.currentIndex())
for i in reversed(list(range(self.combo.count()))):
ne = self.combo.itemData(i)
if ne is not neditable:
self.about_to_close_file(i)
class RangeByStrSettingUI(QDialog):
def __init__(self, iface, parent=None):
super(RangeByStrSettingUI, self).__init__()
self.iface = iface
self.parent = parent
self.iface.mapCanvas().currentLayerChanged[QgsMapLayer].connect(self.LayerChanged)
self.color_btn_list = [] # 保存各范围所设置的颜色按钮
self.delete_btn_list = [] # 保存各范围所设置的删除按钮
self.value_widget_list = []
self.setting_list = [] # 保存参数设置
self.setWindowTitle(u"分类显示")
layer_label = QLabel(u"选择图层:")
self.layer_combo = QComboBox()
layers_name = getAllLayerName(self.iface)
self.layer_combo.addItems(layers_name)
self.layer = getLayerByName(self.layer_combo.currentText(), self.iface)
self.connect(self.layer_combo, SIGNAL('currentIndexChanged(int)'), self.layerListener)
field_label = QLabel(u"选择字段:")
self.field_combo = QComboBox()
if self.layer != None:
fields_list = []
for field in self.layer.pendingFields():
fields_list.append(field.name().strip())
self.field_combo.addItems(fields_list)
ok = QPushButton(u"确定")
cancel = QPushButton(u"取消")
self.connect(ok, SIGNAL('clicked()'), self.run)
self.connect(cancel, SIGNAL('clicked()'), self.accept)
# 选择图层、字段Widget
source_grid = QGridLayout()
source_grid.setSpacing(10)
source_grid.addWidget(layer_label, 0, 1)
source_grid.addWidget(self.layer_combo, 0, 2)
source_grid.addWidget(field_label, 1, 1)
source_grid.addWidget(self.field_combo, 1, 2)
source_widget = QWidget()
source_widget.setLayout(source_grid)
# 参数设置窗口（带滚动条）
self.setting_Widget = QWidget()
self.setting_Widget.setMinimumSize(380, 800)
self.scroll_vbox = QVBoxLayout()
self.scroll_vbox.setSpacing(15)
self.setting_vbox = QVBoxLayout()
self.setting_vbox.setSpacing(5)
value_widget = self.createAValue()
self.setting_vbox.addWidget(value_widget)
self.add_range_btn = QPushButton(u"添加")
self.connect(self.add_range_btn, SIGNAL("clicked()"), self.add_value_box)
self.scroll_vbox.addLayout(self.setting_vbox)
self.scroll_vbox.addWidget(self.add_range_btn)
self.scroll_vbox.addStretch(1)
self.setting_Widget.setLayout(self.scroll_vbox)
self.scroll = QScrollArea()
self.scroll.setWidget(self.setting_Widget)
self.scroll.setAutoFillBackground(True)
self.scroll.setWidgetResizable(True)
# 确定/取消 按钮 Widget
btn_hbox = QHBoxLayout()
btn_hbox.setSpacing(15)
btn_hbox.addStretch(1)
btn_hbox.addWidget(ok)
btn_hbox.addWidget(cancel)
btn_hbox.addStretch(1)
btn_widget = QWidget()
btn_widget.setLayout(btn_hbox)
vbox = QVBoxLayout()
vbox.setSpacing(15)
vbox.addWidget(source_widget)
vbox.addWidget(self.scroll)
vbox.addWidget(btn_widget)
self.setLayout(vbox)
self.setFixedSize(430, 500)
# 生成一个范围设置控件组(Wigget)
def createAValue(self, color_value=u"yellow", value=u""):
delete_btn = QPushButton(self)
delete_icon = QIcon(os.path.join(cmd_folder, u"..", u'images', u'delete.png'))
delete_btn.setIcon(delete_icon)
delete_btn.setIconSize(QSize(25, 25))
delete_btn.setFixedSize(30, 30)
delete_btn.setFocusPolicy(Qt.NoFocus)
self.connect(delete_btn, SIGNAL("clicked()"), self.delete_value_box)
color = QColor(color_value)
color_btn = QPushButton(self)
color_btn.setStyleSheet('QWidget {background-color:%s}' % color.name())
color_btn.clicked.connect(self.colordialog)
value_edit = QLineEdit(value) # 搜索值
label1 = QLabel(u" : ")
value_widget = QWidget()
value_box = QHBoxLayout()
value_box.setSpacing(10)
value_box.addWidget(delete_btn)
value_box.addWidget(color_btn)
value_box.addWidget(label1)
value_box.addWidget(value_edit)
value_box.setStretchFactor(color_btn, 1.5)
value_box.setStretchFactor(value_edit, 1)
value_widget.setLayout(value_box)
self.color_btn_list.append(color_btn)
self.delete_btn_list.append(delete_btn)
self.value_widget_list.append(value_widget)
self.setting_list.append([color, value_edit])
return value_widget
# 新增一个可设置的范围
def add_value_box(self):
new_value_widget = self.createAValue()
# 重新布局
self.setting_vbox.addWidget(new_value_widget)
# 删除一组范围设置
def delete_value_box(self):
delete_index = None
delete_button = self.sender() # 获取信号来源
for (index, button) in enumerate(self.delete_btn_list):
if button is delete_button:
delete_index = index
# 删除 widget
if delete_index != None:
value_widget = self.value_widget_list[delete_index]
self.setting_vbox.removeWidget(value_widget)
value_widget.deleteLater()
del self.value_widget_list[delete_index]
del self.color_btn_list[delete_index]
del self.delete_btn_list[delete_index]
del self.setting_list[delete_index]
# 颜色设置对话框
def colordialog(self):
col = QColorDialog.getColor()
button = self.sender() # 获取信号来源
if col.isValid():
button.setStyleSheet('QWidget{background-color:%s}' % col.name())
for b in self.color_btn_list:
if button is b:
bindex = self.color_btn_list.index(b)
self.setting_list[bindex][0] = col
def layerListener(self):
# 先清空原有的字段选择combobox
self.field_combo.clear()
# 获取所选图层名字
layer_name = self.layer_combo.currentText()
self.layer = getLayerByName(layer_name, self.iface)
# 获取所选图层的所有字段
if self.layer:
fields_list = []
for field in self.layer.pendingFields():
fields_list.append(field.name().strip())
self.field_combo.addItems(fields_list)
def run(self):
# 先检查是否选中了图层
if not self.layer:
self.accept()
QMessageBox.critical(self, u"错误", u"<b>无法选中图层! <\b>")
return False
# 检查范围设置是否规范
setting_list = [] # 保存处理过的范围设置list (每个范围用元组保存)
for (color, value_edit) in self.setting_list:
value = value_edit.text().strip()
# 如果上下限其中有一个为空，则提示错误
if not value:
QMessageBox.critical(self, u"错误", u"<b>分类范围上下限不能为空! <\b>")
return False
setting_list.append((color, value))
field = self.field_combo.currentText().strip() # 获取所设置的字段
# 显示图例
self.accept()
legend = RangeByStrLegend(self.iface, self)
legend.showLegend(self.layer, field, setting_list)
if not legend.isVisible():
legend.show()
legend.exec_()
def LayerChanged(self, currentlayer):
if currentlayer != self.layer:
self.iface.messageBar().pushMessage(u'提示', u'切换图层，分析停止', QgsMessageBar.INFO, 4)
self.close()
class FindInFilesDialog(QDialog):
def __init__(self, result_widget, parent):
QDialog.__init__(self, parent)
self._find_thread = FindInFilesThread()
self.setWindowTitle("Find in files")
self.resize(400, 300)
#MAIN LAYOUT
main_vbox = QVBoxLayout(self)
self.pattern_line_edit = QLineEdit()
self.dir_name_root = None
self.user_home = os.path.expanduser('~')
self.dir_combo = QComboBox()
self.dir_combo.addItem(self.user_home)
self.dir_combo.setEditable(True)
self.open_button = QPushButton(QIcon(resources.IMAGES['find']),
self.tr("Open"))
self.filters_line_edit = QLineEdit("*.py")
self.replace_line = QLineEdit()
self.replace_line.setEnabled(False)
self.check_replace = QCheckBox(self.tr("Replace: "))
self.case_checkbox = QCheckBox(self.tr("C&ase sensitive"))
self.type_checkbox = QCheckBox(self.tr("R&egular Expression"))
self.recursive_checkbox = QCheckBox(self.tr("Rec&ursive"))
self.recursive_checkbox.setCheckState(Qt.Checked)
self.phrase_radio = QRadioButton(
self.tr("Search by Phrase (Exact Match)."))
self.phrase_radio.setChecked(True)
self.words_radio = QRadioButton(
self.tr("Search for all the words "
"(anywhere in the document, not together)."))
self.find_button = QPushButton(self.tr("Find!"))
self.find_button.setMaximumWidth(150)
self.cancel_button = QPushButton(self.tr("Cancel"))
self.cancel_button.setMaximumWidth(150)
self.result_widget = result_widget
hbox = QHBoxLayout()
hbox.addWidget(self.find_button)
hbox.addWidget(self.cancel_button)
#main section
find_group_box = QGroupBox(self.tr("Main"))
grid = QGridLayout()
grid.addWidget(QLabel(self.tr("Text: ")), 0, 0)
grid.addWidget(self.pattern_line_edit, 0, 1)
grid.addWidget(QLabel(self.tr("Directory: ")), 1, 0)
grid.addWidget(self.dir_combo, 1, 1)
grid.addWidget(self.open_button, 1, 2)
grid.addWidget(QLabel(self.tr("Filter: ")), 2, 0)
grid.addWidget(self.filters_line_edit, 2, 1)
grid.addWidget(self.check_replace, 3, 0)
grid.addWidget(self.replace_line, 3, 1)
find_group_box.setLayout(grid)
#add main section to MAIN LAYOUT
main_vbox.addWidget(find_group_box)
#options sections
options_group_box = QGroupBox(self.tr("Options"))
gridOptions = QGridLayout()
gridOptions.addWidget(self.case_checkbox, 0, 0)
gridOptions.addWidget(self.type_checkbox, 1, 0)
gridOptions.addWidget(self.recursive_checkbox, 2, 0)
gridOptions.addWidget(self.phrase_radio, 0, 1)
gridOptions.addWidget(self.words_radio, 1, 1)
options_group_box.setLayout(gridOptions)
#add options sections to MAIN LAYOUT
main_vbox.addWidget(options_group_box)
#add buttons to MAIN LAYOUT
main_vbox.addLayout(hbox)
#Focus
self.pattern_line_edit.setFocus()
self.open_button.setFocusPolicy(Qt.NoFocus)
#signal
self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
self.connect(self.find_button, SIGNAL("clicked()"),
self._find_in_files)
self.connect(self.cancel_button, SIGNAL("clicked()"),
self._kill_thread)
self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
self._found_match)
self.connect(self._find_thread, SIGNAL("finished()"),
self._find_thread_finished)
self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
self._change_radio_enabled)
self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
self._replace_activated)
self.connect(self.words_radio, SIGNAL("clicked(bool)"),
self._words_radio_pressed)
def _replace_activated(self):
self.replace_line.setEnabled(self.check_replace.isChecked())
self.phrase_radio.setChecked(True)
def _words_radio_pressed(self, value):
self.replace_line.setEnabled(not value)
self.check_replace.setChecked(not value)
self.words_radio.setChecked(True)
def _change_radio_enabled(self, val):
enabled = not self.type_checkbox.isChecked()
self.phrase_radio.setEnabled(enabled)
self.words_radio.setEnabled(enabled)
def show(self, actual_project=None, actual=None):
self.dir_combo.clear()
self.dir_name_root = actual_project if \
actual_project else [self.user_home]
self.dir_combo.addItems(self.dir_name_root)
if actual:
index = self.dir_combo.findText(actual)
self.dir_combo.setCurrentIndex(index)
super(FindInFilesDialog, self).show()
self.pattern_line_edit.setFocus()
def reject(self):
self._kill_thread()
# Crazy hack to avoid circular imports
self.result_widget.parent().parent().parent().hide()
super(FindInFilesDialog, self).reject()
def _find_thread_finished(self):
self.emit(SIGNAL("finished()"))
self._find_thread.wait()
def _select_dir(self):
dir_name = QFileDialog.getExistingDirectory(
self, self.tr("Open Directory"), self.dir_combo.currentText(),
QFileDialog.ShowDirsOnly)
index = self.dir_combo.findText(dir_name)
if index >= 0:
self.dir_combo.setCurrentIndex(index)
else:
self.dir_combo.insertItem(0, dir_name)
self.dir_combo.setCurrentIndex(0)
def _found_match(self, result):
file_name = result[0]
items = result[1]
self.result_widget.update_result(self.dir_combo.currentText(),
file_name, items)
def _kill_thread(self):
if self._find_thread.isRunning():
self._find_thread.cancel()
self.accept()
def _find_in_files(self):
self.emit(SIGNAL("findStarted()"))
self._kill_thread()
self.result_widget.clear()
pattern = self.pattern_line_edit.text()
dir_name = self.dir_combo.currentText()
filters = re.split("[,;]", self.filters_line_edit.text())
# Version of PyQt API 1
# filters = self.filters_line_edit.text().split(QRegExp("[,;]"),
# QString.SkipEmptyParts)
#remove the spaces in the words Ex. (" *.foo"--> "*.foo")
filters = [f.strip() for f in filters]
case_sensitive = self.case_checkbox.isChecked()
type_ = QRegExp.RegExp if \
self.type_checkbox.isChecked() else QRegExp.FixedString
recursive = self.recursive_checkbox.isChecked()
by_phrase = True
if self.phrase_radio.isChecked() or self.type_checkbox.isChecked():
regExp = QRegExp(pattern, case_sensitive, type_)
elif self.words_radio.isChecked():
by_phrase = False
type_ = QRegExp.RegExp
pattern = '|'.join([word.strip() for word in pattern.split()])
regExp = QRegExp(pattern, case_sensitive, type_)
#save a reference to the root directory where we find
self.dir_name_root = dir_name
self._find_thread.find_in_files(dir_name, filters, regExp, recursive,
by_phrase)
class ImageTab(QWidget):
def __init__(self, parent):
super(ImageTab, self).__init__(parent)
self.parent = parent
self.name = 'Images'
self.formats = config.image_formats
self.extra_img = config.image_extra_formats
validator = QRegExpValidator(QRegExp(r'^[1-9]\d*'), self)
converttoQL = QLabel(self.tr('Convert to:'))
self.extQCB = QComboBox()
self.extQCB.addItems(self.formats)
commandQL = QLabel(self.tr('Extra options:'))
self.commandQLE = QLineEdit()
hlayout2 = utils.add_to_layout(
'h', converttoQL, self.extQCB, commandQL, self.commandQLE)
sizeQL = QLabel(
'<html><p align="center">' + self.tr('Image Size:') +
'</p></html>')
self.widthQLE = utils.create_LineEdit((50, 16777215), validator, 4)
self.heightQLE = utils.create_LineEdit((50, 16777215), validator, 4)
label = QLabel('<html><p align="center">x</p></html>')
label.setMaximumWidth(25)
hlayout1 = utils.add_to_layout('h', self.widthQLE, label,self.heightQLE)
sizelayout = utils.add_to_layout('v', sizeQL, hlayout1)
self.imgaspectQChB = QCheckBox(self.tr("Maintain aspect ratio"))
self.autocropQChB = QCheckBox(self.tr("Auto-crop"))
vlayout = utils.add_to_layout('v', self.imgaspectQChB,self.autocropQChB)
rotateQL = QLabel(
"<html><div align='center'>" + self.tr("Rotate") +
":</div><br>(" + self.tr("degrees - clockwise") + ")</html>")
self.rotateQLE = utils.create_LineEdit((100, 16777215), validator, 3)
self.vflipQChB = QCheckBox(self.tr('Vertical flip'))
self.hflipQChB = QCheckBox(self.tr('Horizontal flip'))
vlayout2 = utils.add_to_layout('v', self.vflipQChB, self.hflipQChB)
hlayout3 = utils.add_to_layout(
'h', sizelayout, vlayout, rotateQL, self.rotateQLE,
vlayout2, None)
final_layout = utils.add_to_layout('v', hlayout2, hlayout3)
self.setLayout(final_layout)
def clear(self):
"""Clear self.widthQLE and self.heightQLE."""
self.widthQLE.clear()
self.heightQLE.clear()
self.commandQLE.clear()
self.rotateQLE.clear()
self.imgaspectQChB.setChecked(False)
self.autocropQChB.setChecked(False)
self.vflipQChB.setChecked(False)
self.hflipQChB.setChecked(False)
def fill_extension_combobox(self, extraformats):
extraformats = [i for i in extraformats.split("\n")] if extraformats else []
self.extQCB.clear()
self.extQCB.addItems(sorted(self.formats + extraformats))
def ok_to_continue(self):
"""
Check if everything is ok with imagetab to continue conversion.
Check if:
- ImageMagick is missing.
- Either none or both size lineEdits are active at a time.
Return True if all tests pass, else False.
"""
width = self.widthQLE.text()
height = self.heightQLE.text()
if not self.parent.imagemagick:
QMessageBox.warning(self, 'FF Multi Converter - ' + self.tr(
'Error!'), self.tr('ImageMagick is not installed.\nYou will '
'not be able to convert image files until you install it.'))
return False
if (width and not height) or (not width and height):
QMessageBox.warning(self, 'FF Multi Converter - ' + self.tr(
'Error!'), self.tr('The size LineEdit may not be empty.'))
if width and not height:
self.heightQLE.setFocus()
else:
self.widthQLE.setFocus()
return False
return True
def set_default_command(self):
"""Set the default value to self.commandQLE."""
self.clear()
self.commandQLE.setText(self.parent.default_command_image)
class NewDocument(preferences.Group):
def __init__(self, page):
super(NewDocument, self).__init__(page)
grid = QGridLayout()
self.setLayout(grid)
def changed():
self.changed.emit()
self.combo.setEnabled(self.template.isChecked())
self.emptyDocument = QRadioButton(toggled=changed)
self.lilyVersion = QRadioButton(toggled=changed)
self.template = QRadioButton(toggled=changed)
self.combo = QComboBox(currentIndexChanged=changed)
grid.addWidget(self.emptyDocument, 0, 0, 1, 2)
grid.addWidget(self.lilyVersion, 1, 0, 1, 2)
grid.addWidget(self.template, 2, 0, 1, 1)
grid.addWidget(self.combo, 2, 1, 1, 1)
self.loadCombo()
app.translateUI(self)
def translateUI(self):
self.setTitle(_("When creating new documents"))
self.emptyDocument.setText(_("Create an empty document"))
self.lilyVersion.setText(_("Create a document that contains the LilyPond version statement"))
self.template.setText(_("Create a document from a template:"))
from snippet import snippets
for i, name in enumerate(self._names):
self.combo.setItemText(i, snippets.title(name))
def loadCombo(self):
from snippet import snippets
self._names = [name for name in snippets.names()
if snippets.get(name).variables.get('template')]
self.combo.clear()
self.combo.addItems([''] * len(self._names))
def loadSettings(self):
s = QSettings()
ndoc = s.value("new_document", "empty", type(""))
template = s.value("new_document_template", "", type(""))
if template in self._names:
self.combo.setCurrentIndex(self._names.index(template))
if ndoc == "template":
self.template.setChecked(True)
elif ndoc == "version":
self.lilyVersion.setChecked(True)
else:
self.emptyDocument.setChecked(True)
def saveSettings(self):
s = QSettings()
if self._names and self.template.isChecked():
s.setValue("new_document", "template")
s.setValue("new_document_template", self._names[self.combo.currentIndex()])
elif self.lilyVersion.isChecked():
s.setValue("new_document", "version")
else:
s.setValue("new_document", "empty")
class ParamWidget(QWidget):
def __init__(self, dataset, title = '', settings = None, settingskey = None, parent = None):
super(ParamWidget, self).__init__(parent = parent)
self.settings = settings
self.settingskey = settingskey
self.mainLayout = QVBoxLayout()
self.setLayout(self.mainLayout)
if self.settings is not None and self.settingskey is not None:
stored_list = self.settings.getValueOrDefault('storedParameters/'+self.settingskey, [ ])
h = QHBoxLayout()
self.mainLayout.addLayout(h)
h.addStretch(1)
self.comboParam = QComboBox()
h.addWidget(self.comboParam, 3)
self.refreshCombo()
self.comboParam.currentIndexChanged.connect(self.comboParamChanged)
buttonSave = QPushButton(QIcon(':/list-add.png') ,'')
buttonSave.setMaximumSize(25,25)
h.addWidget(buttonSave)
buttonSave.clicked.connect(self.saveNewParam)
buttonDel = QPushButton(QIcon(':/list-remove.png') ,'')
buttonDel.setMaximumSize(25,25)
h.addWidget(buttonDel)
buttonDel.clicked.connect(self.delSavedParam)
self.params = DataSetEditGroupBox(title,dataset, show_button = False)
self.mainLayout.addWidget( self.params )
self.default_dict = self.to_dict()
def to_dict(self):
self.params.set()
ds = self.params.dataset
d = OrderedDict()
for item in ds._items:
if type(item) is ChoiceItem:
val = None
ind = getattr(ds, item._name)
choices = item.get_prop_value("data", item, "choices")
for choice in choices:
if choice[0] == ind:
val = choice[1]
else:
val = getattr(ds, item._name)
d[item._name] = val
return d
def update(self, d):
ds = self.params.dataset
for item in ds._items:
if item._name in d:
if type(item) is ChoiceItem:
choices = item.get_prop_value("data", item, "choices")
choices = [ c[1] for c in choices ]
ind = choices.index(d[item._name])
setattr(ds, item._name, ind)
else:
setattr(ds, item._name, d[item._name])
self.params.getInstance()
def reset(self):
self.update(self.default_dict)
def refreshCombo(self):
stored_list = self.settings['storedParameters/'+self.settingskey]
self.comboParam.clear()
list_name = [ l[0] for l in stored_list ]
self.comboParam.addItems(['Default' , ]+list_name )
def comboParamChanged(self, pos) :
if pos <= 0 :
self.reset()
else :
stored_list = self.settings['storedParameters/'+self.settingskey]
self.update(stored_list[pos-1][1])
def saveNewParam( self ) :
class Parameters(DataSet):
name = StringItem('name', default = '')
dia = ParamDialog(Parameters, title = 'key')
ok = dia.exec_()
if ok != QDialog.Accepted: return
name = dia.to_dict()['name']
stored_list = self.settings['storedParameters/'+self.settingskey]
stored_list += [ [ name , self.to_dict() ] ]
self.settings['storedParameters/'+self.settingskey] = stored_list
self.refreshCombo()
self.comboParam.setCurrentIndex(len(stored_list))
def delSavedParam( self) :
pos = self.comboParam.currentIndex()
if pos == 0: return
stored_list = self.settings['storedParameters/'+self.settingskey]
del stored_list[pos-1]
self.settings['storedParameters/'+self.settingskey] = stored_list
self.refreshCombo()
self.comboParam.setCurrentIndex(0)
class Browser(QWidget):
"""LilyPond documentation browser widget."""
def __init__(self, dockwidget):
super(Browser, self).__init__(dockwidget)
layout = QVBoxLayout(spacing=0)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.toolbar = tb = QToolBar()
self.webview = QWebView(contextMenuPolicy=Qt.CustomContextMenu)
self.chooser = QComboBox(sizeAdjustPolicy=QComboBox.AdjustToContents)
self.search = SearchEntry(maximumWidth=200)
layout.addWidget(self.toolbar)
layout.addWidget(self.webview)
ac = dockwidget.actionCollection
ac.help_back.triggered.connect(self.webview.back)
ac.help_forward.triggered.connect(self.webview.forward)
ac.help_home.triggered.connect(self.showHomePage)
ac.help_print.triggered.connect(self.slotPrint)
self.webview.page().setNetworkAccessManager(
lilydoc.network.accessmanager())
self.webview.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
self.webview.page().linkClicked.connect(self.openUrl)
self.webview.page().setForwardUnsupportedContent(True)
self.webview.page().unsupportedContent.connect(self.slotUnsupported)
self.webview.urlChanged.connect(self.slotUrlChanged)
self.webview.customContextMenuRequested.connect(
self.slotShowContextMenu)
tb.addAction(ac.help_back)
tb.addAction(ac.help_forward)
tb.addSeparator()
tb.addAction(ac.help_home)
tb.addAction(ac.help_print)
tb.addSeparator()
tb.addWidget(self.chooser)
tb.addWidget(self.search)
self.chooser.activated[int].connect(self.showHomePage)
self.search.textEdited.connect(self.slotSearchChanged)
self.search.returnPressed.connect(self.slotSearchReturnPressed)
dockwidget.mainwindow().iconSizeChanged.connect(
self.updateToolBarSettings)
dockwidget.mainwindow().toolButtonStyleChanged.connect(
self.updateToolBarSettings)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.loadDocumentation()
self.showInitialPage()
app.settingsChanged.connect(self.loadDocumentation)
app.translateUI(self)
def readSettings(self):
s = QSettings()
s.beginGroup("documentation")
ws = self.webview.page().settings()
family = s.value("fontfamily", self.font().family(), type(""))
size = s.value("fontsize", 16, int)
ws.setFontFamily(QWebSettings.StandardFont, family)
ws.setFontSize(QWebSettings.DefaultFontSize, size)
fixed = textformats.formatData('editor').font
ws.setFontFamily(QWebSettings.FixedFont, fixed.family())
ws.setFontSize(QWebSettings.DefaultFixedFontSize,
fixed.pointSizeF() * 96 / 72)
def keyPressEvent(self, ev):
if ev.text() == "/":
self.search.setFocus()
else:
super(Browser, self).keyPressEvent(ev)
def translateUI(self):
try:
self.search.setPlaceholderText(_("Search..."))
except AttributeError:
pass # not in Qt 4.6
def showInitialPage(self):
"""Shows the preferred start page.
If a local documentation instance already has a suitable version,
just loads it. Otherwise connects to the allLoaded signal, that is
emitted when all the documentation instances have loaded their version
information and then shows the start page (if another page wasn't yet
loaded).
"""
if self.webview.url().isEmpty():
docs = lilydoc.manager.docs()
version = lilypondinfo.preferred().version()
index = -1
if version:
for num, doc in enumerate(docs):
if doc.version() is not None and doc.version() >= version:
index = num # a suitable documentation is found
break
if index == -1:
# nothing found (or LilyPond version not available),
# wait for loading or show the most recent version
if not lilydoc.manager.loaded():
lilydoc.manager.allLoaded.connect(self.showInitialPage)
return
index = len(docs) - 1
self.chooser.setCurrentIndex(index)
self.showHomePage()
def loadDocumentation(self):
"""Puts the available documentation instances in the combobox."""
i = self.chooser.currentIndex()
self.chooser.clear()
for doc in lilydoc.manager.docs():
v = doc.versionString()
if doc.isLocal():
t = _("(local)")
else:
t = _("({hostname})").format(hostname=doc.url().host())
self.chooser.addItem("{0} {1}".format(v or _("<unknown>"), t))
self.chooser.setCurrentIndex(i)
if not lilydoc.manager.loaded():
lilydoc.manager.allLoaded.connect(self.loadDocumentation, -1)
return
def updateToolBarSettings(self):
mainwin = self.parentWidget().mainwindow()
self.toolbar.setIconSize(mainwin.iconSize())
self.toolbar.setToolButtonStyle(mainwin.toolButtonStyle())
def showManual(self):
"""Invoked when the user presses F1."""
self.slotHomeFrescobaldi() # TEMP
def slotUrlChanged(self):
ac = self.parentWidget().actionCollection
ac.help_back.setEnabled(self.webview.history().canGoBack())
ac.help_forward.setEnabled(self.webview.history().canGoForward())
def openUrl(self, url):
if url.path().endswith(('.ily', '.lyi', '.ly')):
self.sourceViewer().showReply(lilydoc.network.get(url))
else:
self.webview.load(url)
def slotUnsupported(self, reply):
helpers.openUrl(reply.url())
def slotSearchChanged(self):
text = self.search.text()
if not text.startswith(':'):
self.webview.page().findText(text,
QWebPage.FindWrapsAroundDocument)
def slotSearchReturnPressed(self):
text = self.search.text()
if not text.startswith(':'):
self.slotSearchChanged()
else:
pass # TODO: implement full doc search
def sourceViewer(self):
try:
return self._sourceviewer
except AttributeError:
from . import sourceviewer
self._sourceviewer = sourceviewer.SourceViewer(self)
return self._sourceviewer
def showHomePage(self):
"""Shows the homepage of the LilyPond documentation."""
i = self.chooser.currentIndex()
if i < 0:
i = 0
doc = lilydoc.manager.docs()[i]
url = doc.home()
if doc.isLocal():
path = url.toLocalFile()
langs = lilydoc.network.langs()
if langs:
for lang in langs:
if os.path.exists(path + '.' + lang + '.html'):
path += '.' + lang
break
url = QUrl.fromLocalFile(path + '.html')
self.webview.load(url)
def slotPrint(self):
printer = QPrinter()
dlg = QPrintDialog(printer, self)
dlg.setWindowTitle(app.caption(_("Print")))
if dlg.exec_():
self.webview.print_(printer)
def slotShowContextMenu(self, pos):
hit = self.webview.page().currentFrame().hitTestContent(pos)
menu = QMenu()
if hit.linkUrl().isValid():
a = self.webview.pageAction(QWebPage.CopyLinkToClipboard)
a.setIcon(icons.get("edit-copy"))
a.setText(_("Copy &Link"))
menu.addAction(a)
menu.addSeparator()
a = menu.addAction(icons.get("window-new"),
_("Open Link in &New Window"))
a.triggered.connect(
(lambda url: lambda: self.slotNewWindow(url))(hit.linkUrl()))
else:
if hit.isContentSelected():
a = self.webview.pageAction(QWebPage.Copy)
a.setIcon(icons.get("edit-copy"))
a.setText(_("&Copy"))
menu.addAction(a)
menu.addSeparator()
a = menu.addAction(icons.get("window-new"),
_("Open Document in &New Window"))
a.triggered.connect((lambda url: lambda: self.slotNewWindow(url))(
self.webview.url()))
if menu.actions():
menu.exec_(self.webview.mapToGlobal(pos))
def slotNewWindow(self, url):
helpers.openUrl(url)
class ExportPanel(QWidget):
updateExportButton = pyqtSignal(str, bool)
runExport = pyqtSignal(dict)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setMinimumWidth(500)
self.setMinimumHeight(200)
self._dynamic = False
self.setWindowTitle("Export data")
self.activateWindow()
layout = QFormLayout()
current_case = getCurrentCaseName()
self._case_model = AllCasesModel()
self._case_combo = QComboBox()
self._case_combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self._case_combo.setMinimumContentsLength(20)
self._case_combo.setModel(self._case_model)
self._case_combo.setCurrentIndex(self._case_model.indexOf(current_case))
layout.addRow("Select case:", self._case_combo)
self._export_keyword_model = ExportKeywordModel()
self._kw_model = self._export_keyword_model.getKeyWords()
self._keywords = QComboBox()
self._keywords.addItems(self._kw_model)
layout.addRow("Select keyword:", self._keywords)
self._active_realizations_model = ActiveRealizationsModel()
self._active_realizations_field = StringBox(self._active_realizations_model, "config/simulation/active_realizations")
self._active_realizations_field.setValidator(RangeStringArgument())
self._active_realizations_field.getValidationSupport().validationChanged.connect(self.validateExportDialog)
layout.addRow("Active realizations:", self._active_realizations_field)
file_name_button = QToolButton()
file_name_button.setText("Browse")
file_name_button.clicked.connect(self.selectFileDirectory)
self._defaultPath = QDir.currentPath() + "/export"
self._file_name = QLineEdit()
self._file_name.setEnabled(False)
self._file_name.setText(self._defaultPath)
self._file_name.textChanged.connect(self.validateExportDialog)
self._file_name.setMinimumWidth(250)
file_name_layout = QHBoxLayout()
file_name_layout.addWidget(self._file_name)
file_name_layout.addWidget(file_name_button)
layout.addRow("Select directory to save files to:", file_name_layout)
self._gen_kw_file_types = ["Parameter list", "Template based"]
self._field_kw_file_types = ["Eclipse GRDECL", "RMS roff"]
self._gen_data_file_types = ["Gen data"]
self._file_type_model = self._field_kw_file_types
self._file_type_combo = QComboBox()
self._file_type_combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self._file_type_combo.addItems(self._file_type_model)
layout.addRow("Select file format:", self._file_type_combo)
self._report_step = QLineEdit()
layout.addRow("Report step:", self._report_step)
self._gen_data_report_step_model = []
self._gen_data_report_step = QComboBox()
layout.addRow("Report step:", self._gen_data_report_step)
self.setLayout(layout)
self._keywords.currentIndexChanged.connect(self.keywordSelected)
self.keywordSelected()
def selectFileDirectory(self):
directory = QFileDialog().getExistingDirectory(self, "Directory", self._file_name.text(), QFileDialog.ShowDirsOnly)
if str(directory).__len__() > 0:
self._file_name.setText(str(directory))
def updateFileExportType(self, keyword):
self._file_type_combo.clear()
if self._export_keyword_model.isGenKw(keyword):
self._file_type_model = self._gen_kw_file_types
elif self._export_keyword_model.isGenParamKw(keyword):
self._file_type_model = self._gen_data_file_types
elif self._export_keyword_model.isGenDataKw(keyword):
self._file_type_model = self._gen_data_file_types
else:
self._file_type_model = self._field_kw_file_types
self._file_type_combo.addItems(self._file_type_model)
def export(self):
keyword = self._kw_model[self._keywords.currentIndex()]
report_step = self.getReportStep(keyword)
all_cases = self._case_model.getAllItems()
selected_case = all_cases[self._case_combo.currentIndex()]
path = self._file_name.text()
iactive = self._active_realizations_model.getActiveRealizationsMask()
file_type_key = self._file_type_model[self._file_type_combo.currentIndex()]
values = {"keyword": keyword,
"report_step": report_step,
"iactive": iactive,
"file_type_key": file_type_key,
"path": path,
"selected_case": selected_case}
self.runExport.emit(values)
def getReportStep(self, key):
report_step = 0
if self._dynamic:
report_step = self._report_step.text()
if self._export_keyword_model.isGenParamKw(key):
return report_step
if self._export_keyword_model.isGenDataKw(key):
lst = self._gen_data_report_step_model
idx = self._gen_data_report_step.currentIndex()
if lst and len(lst) > idx:
report_step = lst[idx]
else:
raise IndexError('No such model step: %d. Valid range: [0, %d)' % (idx, len(lst)))
return report_step
def keywordSelected(self):
key = self._kw_model[self._keywords.currentIndex()]
self.updateFileExportType(key)
self._dynamic = False
if self._export_keyword_model.isFieldKw(key):
self._dynamic = self._export_keyword_model.isDynamicField(key)
self._report_step.setVisible(self._dynamic)
self.layout().labelForField(self._report_step).setVisible(self._dynamic)
self._gen_data_report_step.setVisible(self._export_keyword_model.isGenDataKw(key))
self.layout().labelForField(self._gen_data_report_step).setVisible(self._export_keyword_model.isGenDataKw(key))
if self._export_keyword_model.isGenDataKw(key):
data = self._export_keyword_model.getGenDataReportSteps(key)
self._gen_data_report_step_model = data
self._gen_data_report_step.clear()
self._gen_data_report_step.addItems(self._gen_data_report_step_model)
def setSelectedCase(self, selected_case):
self._case_combo.setCurrentIndex(self._case_model.indexOf(selected_case))
def validateExportDialog(self):
validRealizations = False
if self._active_realizations_field.isValid():
validRealizations = True
path = str(self._file_name.text())
validPath = len(path) > 0
if validRealizations and validPath:
self.updateExportButton.emit("export", True)
else:
self.updateExportButton.emit("export", False)
class FindInFilesDialog(QDialog):
def __init__(self, result_widget, parent):
QDialog.__init__(self, parent)
self._find_thread = FindInFilesThread()
self.setWindowTitle("Find in files")
self.resize(400, 300)
#MAIN LAYOUT
main_vbox = QVBoxLayout(self)
self.pattern_line_edit = QLineEdit()
self.dir_name_root = None
self.user_home = os.path.expanduser('~')
self.dir_combo = QComboBox()
self.dir_combo.addItem(self.user_home)
self.dir_combo.setEditable(True)
self.open_button = QPushButton(QIcon(resources.IMAGES['find']),
self.tr("Open"))
self.filters_line_edit = QLineEdit("*.py")
self.replace_line = QLineEdit()
self.replace_line.setEnabled(False)
self.check_replace = QCheckBox(self.tr("Replace: "))
self.case_checkbox = QCheckBox(self.tr("C&ase sensitive"))
self.type_checkbox = QCheckBox(self.tr("R&egular Expression"))
self.recursive_checkbox = QCheckBox(self.tr("Rec&ursive"))
self.recursive_checkbox.setCheckState(Qt.Checked)
self.phrase_radio = QRadioButton(
self.tr("Search by Phrase (Exact Match)."))
self.phrase_radio.setChecked(True)
self.words_radio = QRadioButton(
self.tr("Search for all the words "
"(anywhere in the document, not together)."))
self.find_button = QPushButton(self.tr("Find!"))
self.find_button.setMaximumWidth(150)
self.cancel_button = QPushButton(self.tr("Cancel"))
self.cancel_button.setMaximumWidth(150)
self.result_widget = result_widget
hbox = QHBoxLayout()
hbox.addWidget(self.find_button)
hbox.addWidget(self.cancel_button)
#main section
find_group_box = QGroupBox(self.tr("Main"))
grid = QGridLayout()
grid.addWidget(QLabel(self.tr("Text: ")), 0, 0)
grid.addWidget(self.pattern_line_edit, 0, 1)
grid.addWidget(QLabel(self.tr("Directory: ")), 1, 0)
grid.addWidget(self.dir_combo, 1, 1)
grid.addWidget(self.open_button, 1, 2)
grid.addWidget(QLabel(self.tr("Filter: ")), 2, 0)
grid.addWidget(self.filters_line_edit, 2, 1)
grid.addWidget(self.check_replace, 3, 0)
grid.addWidget(self.replace_line, 3, 1)
find_group_box.setLayout(grid)
#add main section to MAIN LAYOUT
main_vbox.addWidget(find_group_box)
#options sections
options_group_box = QGroupBox(self.tr("Options"))
gridOptions = QGridLayout()
gridOptions.addWidget(self.case_checkbox, 0, 0)
gridOptions.addWidget(self.type_checkbox, 1, 0)
gridOptions.addWidget(self.recursive_checkbox, 2, 0)
gridOptions.addWidget(self.phrase_radio, 0, 1)
gridOptions.addWidget(self.words_radio, 1, 1)
options_group_box.setLayout(gridOptions)
#add options sections to MAIN LAYOUT
main_vbox.addWidget(options_group_box)
#add buttons to MAIN LAYOUT
main_vbox.addLayout(hbox)
#Focus
self.pattern_line_edit.setFocus()
self.open_button.setFocusPolicy(Qt.NoFocus)
#signal
self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
self.connect(self.find_button, SIGNAL("clicked()"),
self._find_in_files)
self.connect(self.cancel_button, SIGNAL("clicked()"),
self._kill_thread)
self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
self._found_match)
self.connect(self._find_thread, SIGNAL("finished()"),
self._find_thread_finished)
self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
self._change_radio_enabled)
self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
self._replace_activated)
self.connect(self.words_radio, SIGNAL("clicked(bool)"),
self._words_radio_pressed)
def _replace_activated(self):
self.replace_line.setEnabled(self.check_replace.isChecked())
self.phrase_radio.setChecked(True)
def _words_radio_pressed(self, value):
self.replace_line.setEnabled(not value)
self.check_replace.setChecked(not value)
self.words_radio.setChecked(True)
def _change_radio_enabled(self, val):
enabled = not self.type_checkbox.isChecked()
self.phrase_radio.setEnabled(enabled)
self.words_radio.setEnabled(enabled)
def show(self, actual_project=None, actual=None):
self.dir_combo.clear()
self.dir_name_root = actual_project if \
actual_project else [self.user_home]
self.dir_combo.addItems(self.dir_name_root)
if actual:
index = self.dir_combo.findText(actual)
self.dir_combo.setCurrentIndex(index)
super(FindInFilesDialog, self).show()
self.pattern_line_edit.setFocus()
def reject(self):
self._kill_thread()
# Crazy hack to avoid circular imports
self.result_widget.parent().parent().parent().hide()
super(FindInFilesDialog, self).reject()
def _find_thread_finished(self):
self.emit(SIGNAL("finished()"))
self._find_thread.wait()
def _select_dir(self):
dir_name = QFileDialog.getExistingDirectory(self,
self.tr("Open Directory"),
self.dir_combo.currentText(),
QFileDialog.ShowDirsOnly)
index = self.dir_combo.findText(dir_name)
if index >= 0:
self.dir_combo.setCurrentIndex(index)
else:
self.dir_combo.insertItem(0, dir_name)
self.dir_combo.setCurrentIndex(0)
def _found_match(self, result):
file_name = result[0]
items = result[1]
self.result_widget.update_result(
self.dir_combo.currentText(), file_name, items)
def _kill_thread(self):
if self._find_thread.isRunning():
self._find_thread.cancel()
self.accept()
def _find_in_files(self):
self.emit(SIGNAL("findStarted()"))
self._kill_thread()
self.result_widget.clear()
pattern = self.pattern_line_edit.text()
dir_name = self.dir_combo.currentText()
filters = re.split("[,;]", self.filters_line_edit.text())
# Version of PyQt API 1
# filters = self.filters_line_edit.text().split(QRegExp("[,;]"),
# QString.SkipEmptyParts)
#remove the spaces in the words Ex. (" *.foo"--> "*.foo")
filters = [f.strip() for f in filters]
case_sensitive = self.case_checkbox.isChecked()
type_ = QRegExp.RegExp if \
self.type_checkbox.isChecked() else QRegExp.FixedString
recursive = self.recursive_checkbox.isChecked()
by_phrase = True
if self.phrase_radio.isChecked() or self.type_checkbox.isChecked():
regExp = QRegExp(pattern, case_sensitive, type_)
elif self.words_radio.isChecked():
by_phrase = False
type_ = QRegExp.RegExp
pattern = '|'.join(
[word.strip() for word in pattern.split()])
regExp = QRegExp(pattern, case_sensitive, type_)
#save a reference to the root directory where we find
self.dir_name_root = dir_name
self._find_thread.find_in_files(dir_name, filters, regExp, recursive,
by_phrase)
class ComboChoice(HelpedWidget):
"""
A combo box widget for choices.
List of objects retrieved from model
str(item) is used for presentation
getValue and setValue uses the same object as from the list
"""
def __init__(self, model, combo_label="Choice", help_link=""):
HelpedWidget.__init__(self, combo_label, help_link)
assert model is not None and isinstance(model, ChoiceModelMixin)
self.model = model
model.observable().attach(
ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT,
self.getCurrentFromModel)
model.observable().attach(ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT,
self.updateChoicesFromModel)
self.combo = QComboBox()
self.combo.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.combo.addItem("Fail!")
self.addWidget(self.combo)
self.addStretch()
self.choice_list = None
""" @type: list """
self.connect(self.combo, SIGNAL('currentIndexChanged(int)'),
self.selectionChanged)
self.updateChoicesFromModel()
self.getCurrentFromModel()
def selectionChanged(self, index):
assert 0 <= index < len(
self.choice_list
), "Should not happen! Index out of range: 0 <= %i < %i" % (
index, len(self.choice_list))
item = self.choice_list[index]
self.model.setCurrentChoice(item)
def getCurrentFromModel(self):
new_value = self.model.getCurrentChoice()
if self.choice_list is None:
self.updateChoicesFromModel()
if new_value in self.choice_list:
index = self.choice_list.index(new_value)
if not index == self.combo.currentIndex():
self.combo.setCurrentIndex(index)
else:
self.combo.setCurrentIndex(0)
#sys.stderr.write("AssertionError: ComboBox can not be set to: " + str(new_value) + "\n")
# raise AssertionError("ComboBox can not be set to: " + str(new_value))
def updateChoicesFromModel(self):
block = self.combo.signalsBlocked()
self.combo.blockSignals(True)
self.choice_list = self.model.getChoices()
self.combo.clear()
for choice in self.choice_list:
self.combo.addItem(str(choice))
self.combo.blockSignals(block)
def cleanup(self):
self.model.observable().detach(
ChoiceModelMixin.CURRENT_CHOICE_CHANGED_EVENT,
self.getCurrentFromModel)
self.model.observable().detach(
ChoiceModelMixin.CHOICE_LIST_CHANGED_EVENT,
self.updateChoicesFromModel)
class ActionBar(QFrame):
"""
SIGNALS:
@changeCurrent(PyQt_PyObject)
@runFile(QString)
@reopenTab(QString)
@recentTabsModified()
"""
def __init__(self, main_combo=False):
super(ActionBar, self).__init__()
self.setObjectName("actionbar")
hbox = QHBoxLayout(self)
hbox.setContentsMargins(1, 1, 1, 1)
hbox.setSpacing(1)
self.lbl_checks = QLabel('')
self.lbl_checks.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.lbl_checks.setFixedWidth(48)
self.lbl_checks.setVisible(False)
hbox.addWidget(self.lbl_checks)
self.combo = QComboBox()
self.combo.setIconSize(QSize(16, 16))
#model = QStandardItemModel()
#self.combo.setModel(model)
#self.combo.view().setDragDropMode(QAbstractItemView.InternalMove)
self.combo.setMaximumWidth(300)
self.combo.setObjectName("combotab")
self.connect(self.combo, SIGNAL("currentIndexChanged(int)"),
self.current_changed)
self.combo.setToolTip(translations.TR_COMBO_FILE_TOOLTIP)
self.combo.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(self.combo, SIGNAL(
"customContextMenuRequested(const QPoint &)"),
self._context_menu_requested)
hbox.addWidget(self.combo)
self.symbols_combo = QComboBox()
self.symbols_combo.setIconSize(QSize(16, 16))
self.symbols_combo.setObjectName("combo_symbols")
self.connect(self.symbols_combo, SIGNAL("activated(int)"),
self.current_symbol_changed)
hbox.addWidget(self.symbols_combo)
self.code_navigator = CodeNavigator()
hbox.addWidget(self.code_navigator)
self._pos_text = "Line: %d, Col: %d"
self.lbl_position = QLabel(self._pos_text % (0, 0))
self.lbl_position.setObjectName("position")
self.lbl_position.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hbox.addWidget(self.lbl_position)
self.btn_close = QPushButton(
self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
self.btn_close.setIconSize(QSize(16, 16))
if main_combo:
self.btn_close.setObjectName('navigation_button')
self.btn_close.setToolTip(translations.TR_CLOSE_FILE)
self.connect(self.btn_close, SIGNAL("clicked()"),
self.about_to_close_file)
else:
self.btn_close.setObjectName('close_split')
self.btn_close.setToolTip(translations.TR_CLOSE_SPLIT)
self.connect(self.btn_close, SIGNAL("clicked()"),
self.close_split)
self.btn_close.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
hbox.addWidget(self.btn_close)
def resizeEvent(self, event):
super(ActionBar, self).resizeEvent(event)
if event.size().width() < 350:
self.symbols_combo.hide()
self.code_navigator.hide()
self.lbl_position.hide()
else:
self.symbols_combo.show()
self.code_navigator.show()
self.lbl_position.show()
def add_item(self, text, neditable):
"""Add a new item to the combo and add the neditable data."""
self.combo.addItem(text, neditable)
self.combo.setCurrentIndex(self.combo.count() - 1)
def get_editables(self):
editables = []
for index in range(self.combo.count()):
neditable = self.combo.itemData(index)
editables.append(neditable)
return editables
def add_symbols(self, symbols):
"""Add the symbols to the symbols's combo."""
self.symbols_combo.clear()
for symbol in symbols:
data = symbol[1]
if data[1] == 'f':
icon = QIcon(":img/function")
else:
icon = QIcon(":img/class")
self.symbols_combo.addItem(icon, data[0])
def set_current_symbol(self, index):
self.symbols_combo.setCurrentIndex(index)
def update_item_icon(self, neditable, icon):
index = self.combo.findData(neditable)
self.combo.setItemIcon(index, icon)
def update_item_text(self, neditable, text):
index = self.combo.findData(neditable)
self.combo.setItemText(index, text)
def current_changed(self, index):
"""Change the current item in the combo."""
neditable = self.combo.itemData(index)
self.emit(SIGNAL("changeCurrent(PyQt_PyObject, int)"), neditable, index)
def current_symbol_changed(self, index):
"""Change the current symbol in the combo."""
self.emit(SIGNAL("goToSymbol(int)"), index)
def update_line_col(self, line, col):
"""Update the line and column position."""
self.lbl_position.setText(self._pos_text % (line, col))
def _context_menu_requested(self, point):
"""Display context menu for the combo file."""
if self.combo.count() == 0:
# If there is not an Editor opened, don't show the menu
return
menu = QMenu()
actionAdd = menu.addAction(translations.TR_ADD_TO_PROJECT)
actionRun = menu.addAction(translations.TR_RUN_FILE)
menuSyntax = menu.addMenu(translations.TR_CHANGE_SYNTAX)
self._create_menu_syntax(menuSyntax)
menu.addSeparator()
actionClose = menu.addAction(translations.TR_CLOSE_FILE)
actionCloseAll = menu.addAction(translations.TR_CLOSE_ALL_FILES)
actionCloseAllNotThis = menu.addAction(
translations.TR_CLOSE_OTHER_FILES)
menu.addSeparator()
actionSplitH = menu.addAction(translations.TR_SPLIT_VERTICALLY)
actionSplitV = menu.addAction(translations.TR_SPLIT_HORIZONTALLY)
menu.addSeparator()
actionCopyPath = menu.addAction(
translations.TR_COPY_FILE_PATH_TO_CLIPBOARD)
actionReopen = menu.addAction(translations.TR_REOPEN_FILE)
actionUndock = menu.addAction(translations.TR_UNDOCK_EDITOR)
if len(settings.LAST_OPENED_FILES) == 0:
actionReopen.setEnabled(False)
#Connect actions
self.connect(actionSplitH, SIGNAL("triggered()"),
lambda: self._split(False))
self.connect(actionSplitV, SIGNAL("triggered()"),
lambda: self._split(True))
self.connect(actionRun, SIGNAL("triggered()"),
self._run_this_file)
self.connect(actionAdd, SIGNAL("triggered()"),
self._add_to_project)
self.connect(actionClose, SIGNAL("triggered()"),
self.about_to_close_file)
self.connect(actionCloseAllNotThis, SIGNAL("triggered()"),
self._close_all_files_except_this)
self.connect(actionCloseAll, SIGNAL("triggered()"),
self._close_all_files)
self.connect(actionCopyPath, SIGNAL("triggered()"),
self._copy_file_location)
self.connect(actionReopen, SIGNAL("triggered()"),
self._reopen_last_tab)
self.connect(actionUndock, SIGNAL("triggered()"),
self._undock_editor)
menu.exec_(QCursor.pos())
def _create_menu_syntax(self, menuSyntax):
"""Create Menu with the list of syntax supported."""
syntax = list(settings.SYNTAX.keys())
syntax.sort()
for syn in syntax:
menuSyntax.addAction(syn)
self.connect(menuSyntax, SIGNAL("triggered(QAction*)"),
self._reapply_syntax)
def _reapply_syntax(self, syntaxAction):
#TODO
if [self.currentIndex(), syntaxAction] != self._resyntax:
self._resyntax = [self.currentIndex(), syntaxAction]
self.emit(SIGNAL("syntaxChanged(QWidget, QString)"),
self.currentWidget(), syntaxAction.text())
def set_current_file(self, neditable):
index = self.combo.findData(neditable)
self.combo.setCurrentIndex(index)
def set_current_by_index(self, index):
self.combo.setCurrentIndex(index)
def about_to_close_file(self, index=None):
"""Close the NFile object."""
if index is None:
index = self.combo.currentIndex()
neditable = self.combo.itemData(index)
if neditable:
neditable.nfile.close()
def close_split(self):
self.emit(SIGNAL("closeSplit()"))
def close_file(self, neditable):
"""Receive the confirmation to close the file."""
index = self.combo.findData(neditable)
self.combo.removeItem(index)
return index
def _run_this_file(self):
"""Execute the current file."""
neditable = self.combo.itemData(self.combo.currentIndex())
self.emit(SIGNAL("runFile(QString)"), neditable.file_path)
def _add_to_project(self):
"""Emit a signal to let someone handle the inclusion of the file
inside a project."""
neditable = self.combo.itemData(self.combo.currentIndex())
self.emit(SIGNAL("addToProject(QString)"), neditable.file_path)
def _reopen_last_tab(self):
self.emit(SIGNAL("reopenTab(QString)"),
settings.LAST_OPENED_FILES.pop())
self.emit(SIGNAL("recentTabsModified()"))
def _undock_editor(self):
self.emit(SIGNAL("undockEditor()"))
def _split(self, orientation):
self.emit(SIGNAL("splitEditor(bool)"), orientation)
def _copy_file_location(self):
"""Copy the path of the current opened file to the clipboard."""
neditable = self.combo.itemData(self.combo.currentIndex())
QApplication.clipboard().setText(neditable.file_path,
QClipboard.Clipboard)
def _close_all_files(self):
"""Close all the files opened."""
for i in range(self.combo.count()):
self.about_to_close_file(0)
def _close_all_files_except_this(self):
"""Close all the files except the current one."""
neditable = self.combo.itemData(self.combo.currentIndex())
for i in reversed(list(range(self.combo.count()))):
ne = self.combo.itemData(i)
if ne is not neditable:
self.about_to_close_file(i)
class dlg_main(QDialog):
def __init__(self):
QDialog.__init__(self)
self.dlg_csv_error = dlg_csv_error(self)
self.dlg_csv_error.initGui()
self.kukaku_dict = OrderedDict()
self.kukaku_dict[u"第1次地域区画"] = 4
self.kukaku_dict[u"第2次地域区画"] = 6
self.kukaku_dict[u"第3次地域区画"] = 8
self.kukaku_dict[u"5倍地域メッシュ"] = 7
self.kukaku_dict[u"2倍地域メッシュ"] = 9
self.kukaku_dict[u"2分の1地域メッシュ"] = 9
self.kukaku_dict[u"4分の1地域メッシュ"] = 10
self.kukaku_dict[u"8分の1地域メッシュ"] = 11
self.kukaku_dict[u"10分の１細分地域メッシュ"] = 10
self.dat_str = np.array([])
self.table_header = np.array([])
self.csv_dat_str = np.array([])
self.EF_dia = myFileDialog(self)
self.f_len = np.vectorize(lambda x: len(x))
def initGui(self):
self.VBL_main = QVBoxLayout()
self.HBL_selectfile = QHBoxLayout()
self.Lab_selectfile = QLabel(u"ファイル名")
self.LiE_selectfile = QLineEdit()
self.PuB_selectfile = QPushButton()
self.PuB_selectfile.setText(u"参照")
self.HBL_selectfile.addWidget(self.Lab_selectfile)
self.HBL_selectfile.addWidget(self.LiE_selectfile)
self.HBL_selectfile.addWidget(self.PuB_selectfile)
self.VBL_main.addLayout(self.HBL_selectfile)
self.HBL_layername = QHBoxLayout()
self.Lab_layername = QLabel(u"レイヤ名")
self.LiE_layername = QLineEdit()
self.HBL_layername.addWidget(self.Lab_layername)
self.HBL_layername.addWidget(self.LiE_layername)
self.VBL_main.addLayout(self.HBL_layername)
self.GrL_config = QGridLayout()
self.Lab_recopt_title = QLabel(u"レコードオプション")
self.GrL_config.addWidget(self.Lab_recopt_title, 0, 0)
self.HBL_recopt = QHBoxLayout()
self.Lab_recopt = QLabel(u"無視するヘッダー行")
self.SpB_recopt = QSpinBox()
self.ChB_recopt = QCheckBox()
self.ChB_recopt.setText(u"最初のレコードはフィールド名を保持している")
self.HBL_recopt.addWidget(self.Lab_recopt)
self.HBL_recopt.addWidget(self.SpB_recopt)
self.HBL_recopt.addWidget(self.ChB_recopt)
self.GrL_config.addLayout(self.HBL_recopt,0,1)
self.Lab_mesh_titile = QLabel(u"メッシュ定義")
self.GrL_config.addWidget(self.Lab_mesh_titile,1,0)
self.HBL_mesh = QHBoxLayout()
self.Lab_mesh_field = QLabel(u"メッシュコード列")
self.CoB_mesh_field = QComboBox()
self.Lab_mesh_category = QLabel(u"地域メッシュ区画")
self.CoB_mesh_category = QComboBox()
self.CoB_mesh_category.addItems(self.kukaku_dict.keys())
self.HBL_mesh.addWidget(self.Lab_mesh_field)
self.HBL_mesh.addWidget(self.CoB_mesh_field)
self.HBL_mesh.addWidget(self.Lab_mesh_category)
self.HBL_mesh.addWidget(self.CoB_mesh_category)
self.GrL_config.addLayout(self.HBL_mesh,1,1)
self.Lab_crs_title = QLabel(u"測地系")
self.GrL_config.addWidget(self.Lab_crs_title,2,0)
self.CoB_crs = QComboBox()
self.CoB_crs.addItems([u"世界測地系(EPSG:4612)",u"日本測地系(EPSG:4301)"])
self.GrL_config.addWidget(self.CoB_crs,2,1)
self.VBL_main.addLayout(self.GrL_config)
self.model_content = QStandardItemModel()
self.TB_content = QTableView()
self.TB_content.setModel(self.model_content)
self.VBL_main.addWidget(self.TB_content)
self.DBB_main = QDialogButtonBox()
self.DBB_main.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.VBL_main.addWidget(self.DBB_main)
self.setLayout(self.VBL_main)
self.ChB_recopt.setChecked(True)
self.ChB_recopt.stateChanged.connect(self.update_csv_str)
self.SpB_recopt.valueChanged.connect(self.update_csv_str)
self.PuB_selectfile.clicked.connect(self.EF_dia.open)
self.DBB_main.accepted.connect(self.accept)
self.DBB_main.rejected.connect(self.reject)
def update_csv_str(self):
if len(self.dat_str) == 0:
pass
else:
if self.ChB_recopt.checkState() == 0:
csv_header = np.array(["field_{0}".format(x) for x in np.arange(0,self.dat_str.shape[1])])
self.csv_dat_str = self.dat_str[(self.SpB_recopt.value()):,]
else:
csv_header = self.dat_str[self.SpB_recopt.value(),]
self.csv_dat_str =self.dat_str[(self.SpB_recopt.value()+1):,]
self.clear()
self.table_header = np.array([hstr if hstr != u"" else 'field_{0}'.format(i) for i,hstr in enumerate(csv_header)])
load_table(self.model_content, self.table_header, np.arange(0,11), self.csv_dat_str)
self.CoB_mesh_field.addItems(self.table_header)
def clear(self):
self.model_content.clear()
self.CoB_mesh_field.clear()
def accept(self):
if len(self.LiE_selectfile.text()) == 0:
QMessageBox.warning(self,u"警告",u"ファイルを選択してください")
elif len(self.LiE_layername.text()) == 0:
QMessageBox.warning(self,u"警告",u"レイヤ名を入力してください")
else:
self.csv_meshid_str = self.csv_dat_str[:,self.CoB_mesh_field.currentIndex()]
if self.check_decimal():
self.dlg_csv_error.LB_caution.setText(u"以下のデータのメッシュコードに空白\nまたは数値以外の文字が含まれています")
load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str)
self.dlg_csv_error.show()
elif self.check_digit():
str = u"以下のデータのメッシュコードの桁数が不正です\n"
str += u'{0}コードは{1}桁の整数です。'.format(self.CoB_mesh_category.currentText(),
self.kukaku_dict[self.CoB_mesh_category.currentText()])
self.dlg_csv_error.LB_caution.setText(str)
load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str)
self.dlg_csv_error.show()
elif self.check_unique():
str = u'以下のデータのメッシュコードが重複しています'
self.dlg_csv_error.LB_caution.setText(str)
load_table(self.dlg_csv_error.model_content,self.table_header, self.e_ind, self.csv_dat_str)
self.dlg_csv_error.show()
else:
self.create_tmp_csv()
self.load_wkt_csv()
return QDialog.accept(self)
def check_decimal(self):
e_ind = np.where(~def_c.isdecimal(self.csv_meshid_str))[0]
if len(e_ind) > 0:
self.e_ind = e_ind
return True
else:
return False
def check_digit(self):
digit_arr = self.f_len(self.csv_meshid_str)
e_ind = np.where( digit_arr != self.kukaku_dict[self.CoB_mesh_category.currentText()])[0]
if len(e_ind) > 0:
self.e_ind = e_ind
return True
else:
return False
def check_unique(self):
u,c = np.unique(self.csv_meshid_str,return_counts=True)
tf = c > 1
if tf.any():
self.e_ind = np.where(np.in1d(self.csv_meshid_str, u[tf]))[0]
return True
else:
return False
def create_tmp_csv(self):
m_wkt = mesh_wkt(self.CoB_mesh_category.currentText())
infile_qstr = self.LiE_selectfile.text()
self.outfile_qstr = self.LiE_selectfile.text().replace(".","_wkt.")
in_fp = open(infile_qstr,"r")
out_fp = open(self.outfile_qstr,"wb")
reader = csv.reader(in_fp)
writer = csv.writer(out_fp)
n_skip = self.SpB_recopt.value()
if n_skip > 0:
for i in range(0,n_skip):
next(reader,None)
if self.ChB_recopt.checkState() == 2:
header = next(reader,None)
header.insert(0,"wkt")
writer.writerow(header)
for hrow in csv.reader(in_fp):
hrow.insert(0,m_wkt.res_wkt(hrow[self.CoB_mesh_field.currentIndex()]))
writer.writerow(hrow)
in_fp.close()
out_fp.close()
def load_wkt_csv(self):
uri = QUrl.fromLocalFile(self.outfile_qstr)
uri.addQueryItem("type","csv")
uri.addQueryItem("delimiter",",")
uri.addQueryItem("wktField","1")
uri.addQueryItem("encoding",self.EF_dia.encoding())
if self.ChB_recopt.checkState() == 2:
uri.addQueryItem("useHeader","yes")
else:
uri.addQueryItem("useHeader","no")
if self.CoB_crs.currentIndex() == 0:
uri.addQueryItem("crs","EPSG:4612")
elif self.CoB_crs.currentIndex() == 0:
uri.addQueryItem("crs","EPSG:4301")
self.vlayer = QgsVectorLayer(uri.toString(),self.LiE_layername.text(),"delimitedtext")
if self.vlayer.isValid():
QgsMapLayerRegistry.instance().addMapLayer( self.vlayer )
