def addWidgets(self):
layout = QVBoxLayout()
self.setLayout(layout)
layout.addSpacing(10)
preamble = QLabel('This vault is locked.', self)
layout.addWidget(preamble)
passwdedt = QLineEdit(self)
passwdedt.setPlaceholderText('Type password to unlock')
passwdedt.setEchoMode(QLineEdit.Password)
passwdedt.textChanged.connect(self.passwordChanged)
passwdedt.returnPressed.connect(self.unlockVault)
layout.addSpacing(10)
layout.addWidget(passwdedt)
self.passwdedt = passwdedt
unlockcb = QCheckBox('Try unlock other vaults too', self)
unlockcb.stateChanged.connect(self.saveConfig)
unlockcb.setVisible(False)
layout.addWidget(unlockcb)
self.unlockcb = unlockcb
status = QLabel('', self)
status.setVisible(False)
status.setContentsMargins(0, 10, 0, 0)
layout.addWidget(status)
self.status = status
hbox = QHBoxLayout()
unlockbtn = QPushButton('Unlock', self)
unlockbtn.setFixedSize(unlockbtn.sizeHint())
unlockbtn.clicked.connect(self.unlockVault)
unlockbtn.setEnabled(False)
hbox.addWidget(unlockbtn)
self.unlockbtn = unlockbtn
hbox.addStretch(100)
layout.addSpacing(10)
layout.addLayout(hbox)
layout.addStretch(100)
def addWidgets(self):
layout = QVBoxLayout()
self.setLayout(layout)
layout.addSpacing(10)
preamble = QLabel('This vault is locked.', self)
layout.addWidget(preamble)
passwdedt = QLineEdit(self)
passwdedt.setPlaceholderText('Type password to unlock')
passwdedt.setEchoMode(QLineEdit.Password)
passwdedt.textChanged.connect(self.passwordChanged)
passwdedt.returnPressed.connect(self.unlockVault)
layout.addSpacing(10)
layout.addWidget(passwdedt)
self.passwdedt = passwdedt
unlockcb = QCheckBox('Try unlock other vaults too', self)
unlockcb.stateChanged.connect(self.saveConfig)
unlockcb.setVisible(False)
layout.addWidget(unlockcb)
self.unlockcb = unlockcb
status = QLabel('', self)
status.setVisible(False)
status.setContentsMargins(0, 10, 0, 0)
layout.addWidget(status)
self.status = status
hbox = QHBoxLayout()
unlockbtn = QPushButton('Unlock', self)
unlockbtn.setFixedSize(unlockbtn.sizeHint())
unlockbtn.clicked.connect(self.unlockVault)
unlockbtn.setEnabled(False)
hbox.addWidget(unlockbtn)
self.unlockbtn = unlockbtn
hbox.addStretch(100)
layout.addSpacing(10)
layout.addLayout(hbox)
layout.addStretch(100)
class WizardPageEx(QWizardPage):
def __init__(self, field='check', parent=None):
QWizardPage.__init__(self, parent)
self.check = QCheckBox()
self.check.setVisible(False)
self.registerField(field + '*', self.check)
self.check.setChecked(False)
def initializePage(self):
pass
class previewDlg(QMainWindow):
'''
classdocs
'''
def __init__(self, parent, comp, basePMCheck, model):
'''
Constructor
'''
QMainWindow.__init__(self, parent)
self.basePMCheck = basePMCheck
# self.ui = Ui_Previewself.grbPageProperty()
# self.ui.setupUi(self)
self.resize(1000, 700)
self.setWindowTitle("Preview Dialog")
self.view = QgsComposerView(self)
viewLayout = QGridLayout()
viewLayout.setSpacing(0)
viewLayout.setMargin(0)
mHorizontalRuler = QgsComposerRuler(QgsComposerRuler.Horizontal)
mVerticalRuler = QgsComposerRuler(QgsComposerRuler.Vertical)
mRulerLayoutFix = QWidget()
mRulerLayoutFix.setAttribute(Qt.WA_NoMousePropagation)
mRulerLayoutFix.setBackgroundRole(QPalette.Window)
mRulerLayoutFix.setFixedSize(mVerticalRuler.rulerSize(),
mHorizontalRuler.rulerSize())
viewLayout.addWidget(mRulerLayoutFix, 0, 0)
viewLayout.addWidget(mHorizontalRuler, 0, 1)
viewLayout.addWidget(mVerticalRuler, 1, 0)
self.view.setContentsMargins(0, 0, 0, 0)
self.view.setHorizontalRuler(mHorizontalRuler)
self.view.setVerticalRuler(mVerticalRuler)
viewLayout.addWidget(self.view, 1, 1)
# self.scene = comp
self.view.setZoomLevel(1.0)
self.view.setComposition(comp)
self.scene = self.view.composition()
layout = QVBoxLayout()
hLayout = QHBoxLayout()
hLayout.addLayout(viewLayout)
self.mapItem = self.scene.getComposerMapById(0)
self.view.scale(2.8, 2.8)
self.view.setPreviewModeEnabled(True)
self.toolBarAction = self.addToolBar("composer action")
self.actionMapRefresh = QAction(self)
self.actionMapRefresh.setObjectName("actionMapRefresh")
icon3 = QIcon("Resource/Refresh.png")
self.actionMapRefresh.setIcon(icon3)
self.actionMapRefresh.setToolTip("Refresh")
# self.textItemAction.setCheckable(True)
self.connect(self.actionMapRefresh, SIGNAL("triggered()"),
self.actionMapRefresh_triggered)
self.toolBarAction.addAction(self.actionMapRefresh)
# # self.templeteCreateAction = QAction(self)
# # self.templeteCreateAction.setObjectName("createTempleteAction")
# # icon4 = QIcon("Resource\\templetepointer.png")
# # self.templeteCreateAction.setIcon(icon4)
# # self.templeteCreateAction.setToolTip("Create Templete")
# # self.templeteCreateAction.setCheckable(True)
# # self.connect(self.templeteCreateAction, SIGNAL("triggered()"), self.createTempleteAction)
# # self.toolBar.addAction(self.templeteCreateAction)
# layout.insertWidget(0, self.toolBar)
# self.scene.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.cursorPosChanged.connect(self.cursorPosChangedEvent)
# self.connect(self.view, SIGNAL("selectedItemChanged(QgsComposerItem)"),self, SLOT("selectedItemDisplay(QgsComposerItem)"))
# self.scene.composerLabelAdded.connect(self.composerLabelAddedEvent)
self.view.itemRemoved.connect(self.deleteItem)
# self.connect( self.view, SIGNAL( "actionFinished()" ), self.setSelectionTool)
#listen out for position updates from the QgsComposerView
self.propertyWidget = QWidget(self)
hLayout.addWidget(self.propertyWidget)
self.propertyWidget.setObjectName("propertyWidget")
self.propertyWidget.resize(222, 302)
self.vLayout_3 = QVBoxLayout(self.propertyWidget)
self.vLayout_3.setObjectName("vLayout_3")
self.groupBox = QGroupBox(self.propertyWidget)
self.groupBox.setObjectName("groupBox")
self.horizontalLayout_2 = QHBoxLayout(self.groupBox)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.frame = QFrame(self.groupBox)
self.frame.setFrameShape(QFrame.StyledPanel)
self.frame.setFrameShadow(QFrame.Raised)
self.frame.setObjectName("frame")
self.verticalLayout = QVBoxLayout(self.frame)
self.verticalLayout.setObjectName("verticalLayout")
self.label = QLabel(self.frame)
self.label.setObjectName("label")
self.verticalLayout.addWidget(self.label)
self.labelText = QPlainTextEdit(self.frame)
self.labelText.setObjectName("labelText")
self.verticalLayout.addWidget(self.labelText)
self.btnLabelFont = QPushButton(self.frame)
self.btnLabelFont.setObjectName("btnLabelFont")
self.verticalLayout.addWidget(self.btnLabelFont)
self.btnLabelColor = QPushButton(self.frame)
self.btnLabelColor.setObjectName("btnLabelColor")
self.verticalLayout.addWidget(self.btnLabelColor)
self.frame_2 = QFrame(self.frame)
self.frame_2.setFrameShape(QFrame.StyledPanel)
self.frame_2.setFrameShadow(QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.horizontalLayout = QHBoxLayout(self.frame_2)
self.horizontalLayout.setObjectName("horizontalLayout")
self.label_2 = QLabel(self.frame_2)
self.label_2.setObjectName("label_2")
self.horizontalLayout.addWidget(self.label_2)
self.spinLabelRotation = QSpinBox(self.frame_2)
self.spinLabelRotation.setObjectName("spinLabelRotation")
self.spinLabelRotation.setMinimum(-360)
self.spinLabelRotation.setMaximum(360)
self.horizontalLayout.addWidget(self.spinLabelRotation)
self.verticalLayout.addWidget(self.frame_2)
self.chbBackgroundEnable = QCheckBox(self.frame)
self.chbBackgroundEnable.setChecked(True)
self.chbBackgroundEnable.setObjectName("chbBackgroundEnable")
self.verticalLayout.addWidget(self.chbBackgroundEnable)
self.horizontalLayout_2.addWidget(self.frame)
self.vLayout_3.addWidget(self.groupBox)
self.resolutionFrame = QFrame(self.frame)
self.resolutionFrame.setFrameShape(QFrame.StyledPanel)
self.resolutionFrame.setFrameShadow(QFrame.Raised)
self.resolutionFrame.setObjectName("resolutionFrame")
self.horizontalLayout4 = QHBoxLayout(self.resolutionFrame)
self.horizontalLayout4.setObjectName("horizontalLayout4")
self.label_resolution = QLabel(self.resolutionFrame)
self.label_resolution.setObjectName("label_resolution")
self.label_resolution.setText("Print Resolution (dpi):")
self.horizontalLayout4.addWidget(self.label_resolution)
self.spinResolution = QSpinBox(self.resolutionFrame)
self.spinResolution.setObjectName("spinResolution")
self.spinResolution.setMinimum(0)
self.spinResolution.setMaximum(1000)
self.spinResolution.setValue(300)
self.horizontalLayout4.addWidget(self.spinResolution)
# self.verticalLayout.addWidget(self.frame_2)
self.vLayout_3.addWidget(self.resolutionFrame)
self.gbTable = GroupBox(self.propertyWidget)
self.gbTable.Caption = "Table"
self.vLayout_3.addWidget(self.gbTable)
self.mTableView = QTableView(self.gbTable)
self.gbTable.Add = self.mTableView
hHeder = self.mTableView.horizontalHeader()
hHeder.setVisible(False)
vHeder = self.mTableView.verticalHeader()
vHeder.setVisible(False)
# self.mTableView.setFixedHeight(70)
# self.mTableView.setFixedWidth(comp.paperWidth() - 40)
# self.stdItemModel = QStandardItemModel()
# self.
self.spaceItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.vLayout_3.addItem(self.spaceItem)
self.groupBox.setTitle("Label Property")
self.label.setText("Label Text:")
self.btnLabelFont.setText("Label Font")
self.btnLabelColor.setText("Label Color")
self.label_2.setText("Label Rotation:")
self.chbBackgroundEnable.setText("Background Enable")
self.groupBox.setEnabled(False)
self.connect(self.btnLabelFont, SIGNAL("clicked()"),
self.btnLabelFontClick)
self.connect(self.btnLabelColor, SIGNAL("clicked()"),
self.btnLabelColorClick)
self.connect(self.chbBackgroundEnable, SIGNAL("clicked()"),
self.chbBackgroundEnableClick)
self.labelText.textChanged.connect(self.labelTextChanged)
self.spinLabelRotation.valueChanged.connect(
self.spinLabelRotationValueChanged)
layout.addLayout(hLayout)
#
self.btnBack = QPushButton()
self.btnBack.setText("back")
footerLayout = QHBoxLayout()
footerLayout.addWidget(self.btnBack)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
footerLayout.addWidget(self.buttonBox)
layout.addLayout(footerLayout)
self.setLayout(layout)
deleteItemKey = QShortcut(QKeySequence(Qt.Key_Delete), self)
deleteItemKey.activated.connect(self.deleteItem)
# self.btnBack.clicked.connect(self.back)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.acceptMethod)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.btnCancel = self.buttonBox.button(QDialogButtonBox.Cancel)
self.view.setCurrentTool(QgsComposerView.Select)
self.btnLabelColor.setVisible(False)
# self.btnBack.setVisible(False)
self.chbBackgroundEnable.setVisible(False)
# self.view.emit(SIGNAL("actionFinished"))
# if self.scene.plotStyle() != QgsComposition.Preview:
# self.scene.setPlotStyle(QgsComposition.Preview)
# self.mapItem.setPreviewMode(QgsComposerMap.Render)
# self.mapItem.updateCachedImage()
# self.mapItem.setSelected(True)
self.mComposition = comp
self.composerMapItem = self.mComposition.composerMapItems()[0]
self.composerMapItem.setUpdatesEnabled(True)
self.mStdModel = model
self.mTableView.setModel(self.mStdModel)
self.mTableView.setSpan(0, 0, 1, 6)
self.mTableView.setSpan(1, 0, 1, 2)
self.mTableView.setSpan(2, 0, 2, 1)
self.mTableView.setSpan(4, 0, 1, 2)
self.mTableView.setSpan(5, 0, 1, 2)
self.mTableView.setSpan(6, 0, 1, 2)
self.mTableView.setSpan(0, 6, 1, 8)
self.mTableView.setSpan(1, 7, 1, 4)
self.mTableView.setSpan(1, 11, 1, 3)
self.mTableView.setSpan(2, 7, 1, 4)
self.mTableView.setSpan(2, 11, 1, 3)
def acceptMethod(self):
# self.mStdModel.setItem(0, QStandardItem("nnnnnnnn"))
filePath = QFileDialog.getSaveFileName(
self, "Save PDF File", QCoreApplication.applicationDirPath(),
"pdf files(*.pdf )")
if filePath == "":
return
self.mComposition.clearSelection()
self.mComposition.setPrintResolution(self.spinResolution.value())
resultPdf = self.mComposition.exportAsPDF(filePath)
if resultPdf:
message = QMessageBox.information(self, "Result",
"Successful export PDF")
else:
message = QMessageBox.information(self, "Result",
"Don't export PDF")
def rePresent(self, comp, model):
self.mComposition = comp
self.mStdModel = model
self.view.setComposition(comp)
self.scene = self.view.composition()
def back(self):
self.done(2)
def spinLabelRotationValueChanged(self, rotationValue):
self.selectedLabelItem.setItemRotation(rotationValue)
def cursorPosChangedEvent(self, scenePointF):
self.scenePoint = scenePointF
# i = 100
def labelTextChanged(self):
self.selectedLabelItem.beginCommand(
"Label text changed", QgsComposerMergeCommand.ComposerLabelSetText)
self.selectedLabelItem.blockSignals(True)
self.selectedLabelItem.setText(self.labelText.toPlainText())
self.selectedLabelItem.update()
self.selectedLabelItem.blockSignals(False)
self.selectedLabelItem.endCommand()
def chbBackgroundEnableClick(self):
if self.chbBackgroundEnable.isChecked():
self.selectedLabelItem.setBackgroundEnabled(True)
self.mapItem.updateCachedImage()
else:
self.selectedLabelItem.setBackgroundEnabled(False)
self.mapItem.updateCachedImage()
def btnLabelFontClick(self):
dlgFont = QFontDialog(self)
dlgFont.setCurrentFont(self.selectedLabelItem.font())
result = dlgFont.exec_()
if result == 1:
self.labelFont = dlgFont.selectedFont()
else:
self.labelFont = QFont()
self.selectedLabelItem.setFont(self.labelFont)
def btnLabelColorClick(self):
dlgColor = QColorDialog(self)
dlgColor.setCurrentColor(self.selectedLabelItem.fontColor())
result = dlgColor.exec_()
if result == 1:
self.labelColor = dlgColor.selectedColor()
self.selectedLabelItem.setFontColor(self.labelColor)
def createTempleteAction(self):
if self.templeteCreateAction.isChecked() and self.basePMCheck:
font = QFont("Arial", 13)
font.setItalic(True)
self.compLabel1 = QgsComposerLabel(self.scene)
self.compLabel1.setFont(font)
self.compLabel1.setText("South China Sea")
self.compLabel1.setBackgroundEnabled(False)
self.compLabel1.setItemPosition(156, 100)
self.compLabel1.adjustSizeToText()
self.compLabel1.setItemRotation(60)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel1)
self.compLabel2 = QgsComposerLabel(self.scene)
self.compLabel2.setFont(font)
self.compLabel2.setText("Straits Of Malacca")
self.compLabel2.setBackgroundEnabled(False)
self.compLabel2.setItemPosition(35, 100)
self.compLabel2.adjustSizeToText()
self.compLabel2.setItemRotation(60)
self.scene.addItem(self.compLabel2)
font.setItalic(False)
self.compLabel3 = QgsComposerLabel(self.scene)
self.compLabel3.setFont(font)
self.compLabel3.setBackgroundEnabled(False)
self.compLabel3.setText("THAILAND")
self.compLabel3.setItemPosition(68, 60)
self.compLabel3.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel3)
# self.templeteCreateAction.setChecked(False)
self.compLabel4 = QgsComposerLabel(self.scene)
self.compLabel4.setFont(font)
self.compLabel4.setBackgroundEnabled(False)
self.compLabel4.setText("SINGAPORE")
self.compLabel4.setItemPosition(141, 218)
self.compLabel4.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel4)
self.templeteCreateAction.setChecked(False)
self.compLabel4.setSelected(True)
elif self.templeteCreateAction.isChecked(
) and self.basePMCheck == False:
font = QFont("Arial", 14)
font.setItalic(True)
self.compLabel5 = QgsComposerLabel(self.scene)
self.compLabel5.setFont(font)
self.compLabel5.setText("South China Sea")
self.compLabel5.setBackgroundEnabled(False)
self.compLabel5.setItemPosition(108, 86)
self.compLabel5.adjustSizeToText()
self.compLabel5.setItemRotation(-45)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel5)
self.compLabel6 = QgsComposerLabel(self.scene)
self.compLabel6.setFont(font)
self.compLabel6.setText("Sulu Sea")
self.compLabel6.setBackgroundEnabled(False)
self.compLabel6.setItemPosition(236, 38)
self.compLabel6.adjustSizeToText()
self.compLabel6.setItemRotation(45)
self.scene.addItem(self.compLabel6)
font.setItalic(False)
self.compLabel7 = QgsComposerLabel(self.scene)
self.compLabel7.setFont(font)
self.compLabel7.setBackgroundEnabled(False)
self.compLabel7.setText("Celebes Sea")
self.compLabel7.setItemPosition(242, 112)
self.compLabel7.adjustSizeToText()
self.compLabel7.setItemRotation(-45)
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel7)
# self.templeteCreateAction.setChecked(False)
self.compLabel8 = QgsComposerLabel(self.scene)
self.compLabel8.setFont(font)
self.compLabel8.setBackgroundEnabled(False)
self.compLabel8.setText("INDONESIA\n(Kalimantan)")
self.compLabel8.setItemPosition(172, 148, 32, 16)
# self.compLabel8.setHAlign(Qt.AlignHCenter)
# self.compLabel8.setVAlign(Qt.AlignVCenter)
# self.compLabel8.setFrameEnabled(False)
# self.compLabel8.setItemPosition()
# self.compLabel8.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel8)
self.compLabel9 = QgsComposerLabel(self.scene)
self.compLabel9.setFont(font)
self.compLabel9.setBackgroundEnabled(False)
self.compLabel9.setText("BRUNEI")
self.compLabel9.setItemPosition(136, 83)
self.compLabel9.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel9)
self.templeteCreateAction.setChecked(False)
pass
def actionMapRefresh_triggered(self):
self.view.setCurrentTool(QgsComposerView.AddRectangle)
def setSelectionTool(self):
self.view.deleteSelectedItems()
font = QFont("Arial", 14)
newLabelItem = QgsComposerLabel(self.scene)
newLabelItem.setText("QGIS")
newLabelItem.setFont(font)
newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y())
newLabelItem.adjustSizeToText()
self.scene.addItem(newLabelItem)
# selectItemPoint = self.scene.composerItemAt(self.scenePoint)
newLabelItem.setSelected(True)
self.groupBox.setEnabled(True)
self.selectedLabelItem = newLabelItem
# txt = self.selectedLabelItem.text()
# textDoc = QTextDocument(txt)
self.labelText.setPlainText(self.selectedLabelItem.text())
# self.scene.setSelectedItem(self.newLabelItem)
self.view.setCurrentTool(QgsComposerView.Select)
# self.selectedLabelItem = self.view.currentTool()
self.textItemAction.setChecked(False)
def selectedItemDisplay(self, item):
if self.scene.plotStyle() != QgsComposition.Preview:
self.scene.setPlotStyle(QgsComposition.Preview)
self.mapItem.setPreviewMode(QgsComposerMap.Render)
self.mapItem.updateCachedImage()
item._class_ = QgsComposerLabel
# selectedItems = self.scene.selectedComposerItems(True)
# if isinstance(item, QgsComposerItem):
# self.selectedLabelItem = item
# if isinstance(item, QGraphicsRectItem):
# self.selectedLabelItem = item
if isinstance(item, QgsComposerLabel):
self.selectedLabelItem = item
self.groupBox.setEnabled(True)
self.labelText.setPlainText(self.selectedLabelItem.text())
self.spinLabelRotation.setValue(self.selectedLabelItem.rotation())
else:
self.groupBox.setEnabled(False)
# print "debug"
itemName = self.view.currentTool()
if itemName == 5:
item.setText("label")
pass
def deleteItem(self):
self.view.deleteSelectedItems()
def __init__(self, adjustments, altitudes):
"""
Constructor
"""
QDialog.__init__(self)
self.__adjustements = adjustments
self.__altitudes = altitudes
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Elevations adjustments"))
self.setMinimumWidth(550)
self.setMinimumHeight(500)
self.__layout = QGridLayout()
self.__msgLabels = []
self.__msgChecks = []
displayButton = False
self.__scrollLayout = QGridLayout()
pt_last = -1
pos = 0
for i in range(len(self.__adjustements)):
adj = self.__adjustements[i]
pt = adj['point']
alti = self.__altitudes[pt]
if pt > pt_last:
msg = str(pt) + QCoreApplication.translate("VDLTools", ") height : ") + str(alti['diam']) + "m"
if alti['alt'] is not None:
msg += QCoreApplication.translate("VDLTools", ", invert elevation")
if alti['drawdown'] is not None:
msg += " (" + alti['drawdown'] + ")"
if alti['alt'] is not None:
msg += " : " + str(alti['alt']) + "m"
pt_last = pt
msgLabel = QLabel(msg)
self.__msgLabels.append(msgLabel)
self.__scrollLayout.addWidget(self.__msgLabels[pos], pos+1, 0, 1, 2)
pos += 1
msg = " - " + adj['layer'].name()
if 'comp' in adj:
msg += adj['comp']
previous = adj['previous']
msg += " : " + str(previous) + "m"
if adj['delta'] and alti['alt'] is not None:
delta = alti['alt'] - previous
msg += QCoreApplication.translate("VDLTools", ", adjustment : ") + str(delta) + "m"
msgLabel = QLabel(msg)
self.__msgLabels.append(msgLabel)
self.__scrollLayout.addWidget(self.__msgLabels[pos], pos+1, 0, 1, 2)
msgCheck = QCheckBox()
if not adj['delta'] or alti['alt'] is None or alti['alt'] == previous or alti['alt'] == 0:
msgCheck.setChecked(False)
msgCheck.setVisible(False)
else:
msgCheck.setChecked(True)
self.__msgChecks.append(msgCheck)
self.__scrollLayout.addWidget(self.__msgChecks[i], pos+1, 2)
pos += 1
displayButton = True
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 3)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
pos = len(self.__adjustements) + 1
self.__layout.addWidget(self.__cancelButton, pos, 0)
self.__applyButton = QPushButton(QCoreApplication.translate("VDLTools", "Apply correction(s)"))
self.__applyButton.setMinimumHeight(20)
self.__applyButton.setMinimumWidth(300)
if displayButton:
self.__layout.addWidget(self.__applyButton, pos, 1)
self.setLayout(self.__layout)
def __init__(self, adjustments, altitudes):
"""
Constructor
"""
QDialog.__init__(self)
self.__adjustements = adjustments
self.__altitudes = altitudes
self.setWindowTitle(
QCoreApplication.translate("VDLTools", "Elevations adjustments"))
self.setMinimumWidth(550)
self.setMinimumHeight(500)
self.__layout = QGridLayout()
self.__msgLabels = []
self.__msgChecks = []
displayButton = False
self.__scrollLayout = QGridLayout()
pt_last = -1
pos = 0
for i in range(len(self.__adjustements)):
adj = self.__adjustements[i]
pt = adj['point']
alti = self.__altitudes[pt]
if pt > pt_last:
msg = str(pt) + QCoreApplication.translate(
"VDLTools", ") height : ") + str(alti['diam']) + "m"
if alti['alt'] is not None:
msg += QCoreApplication.translate("VDLTools",
", invert elevation")
if alti['drawdown'] is not None:
msg += " (" + alti['drawdown'] + ")"
if alti['alt'] is not None:
msg += " : " + str(alti['alt']) + "m"
pt_last = pt
msgLabel = QLabel(msg)
self.__msgLabels.append(msgLabel)
self.__scrollLayout.addWidget(self.__msgLabels[pos], pos + 1,
0, 1, 2)
pos += 1
msg = " - " + adj['layer'].name()
if 'diam' in adj:
msg += " (" + str(adj['diam']) + "m) "
if 'comp' in adj:
msg += adj['comp']
previous = adj['previous']
msg += " : " + str(previous) + "m"
if adj['delta'] and alti['alt'] is not None:
delta = alti['alt'] - previous
msg += QCoreApplication.translate(
"VDLTools", ", adjustment : ") + str(delta) + "m"
msgLabel = QLabel(msg)
self.__msgLabels.append(msgLabel)
self.__scrollLayout.addWidget(self.__msgLabels[pos], pos + 1, 0, 1,
2)
msgCheck = QCheckBox()
if not adj['delta'] or alti['alt'] is None or alti[
'alt'] == previous or alti['alt'] == 0:
msgCheck.setChecked(False)
msgCheck.setVisible(False)
else:
msgCheck.setChecked(True)
self.__msgChecks.append(msgCheck)
self.__scrollLayout.addWidget(self.__msgChecks[i], pos + 1, 2)
pos += 1
displayButton = True
widget = QWidget()
widget.setLayout(self.__scrollLayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
self.__layout.addWidget(scroll, 1, 0, 1, 3)
self.__cancelButton = QPushButton(
QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
pos = len(self.__adjustements) + 1
self.__layout.addWidget(self.__cancelButton, pos, 0)
self.__applyButton = QPushButton(
QCoreApplication.translate("VDLTools", "Apply correction(s)"))
self.__applyButton.setMinimumHeight(20)
self.__applyButton.setMinimumWidth(300)
if displayButton:
self.__layout.addWidget(self.__applyButton, pos, 1)
self.setLayout(self.__layout)
class SingleCategoryView(QWidget):
def __init__(self, action, parent, logger, category=None, mode=None):
super(SingleCategoryView, self).__init__(parent)
self.logger = logger
self._action = action
self._category = category
self._resetting = False
if mode is not None:
topWidget = None
self._determineOwnMode = False
else:
self._determineOwnMode = True
mode = PrivacySettings.get().getPolicy(self._action, self._category, useModified=True, categoryPolicy=self._getCategoryPolicy())
topWidget = self._initTopView(mode)
centralWidget = self._initPeerList(mode)
bottomWidget = self._initBottomWidget()
mainLayout = QVBoxLayout(self)
if topWidget is None:
# inside multiple categories view -> no margins
mainLayout.setContentsMargins(0, 0, 0, 0)
if topWidget is not None:
mainLayout.addWidget(topWidget)
mainLayout.addWidget(centralWidget, 1)
mainLayout.addWidget(bottomWidget)
self._modeChanged(mode, notify=False, resetModel=False)
get_notification_center().connectPeerNameAdded(self._peerModel.peerNameAdded)
get_notification_center().connectDisplayedPeerNameChanged(self._peerModel.peerNameChanged)
get_notification_center().connectPrivacySettingsChanged(self._privacySettingsChanged)
get_notification_center().connectPrivacySettingsDiscarded(self._privacySettingsChanged)
def finish(self):
get_notification_center().disconnectPeerNameAdded(self._peerModel.peerNameAdded)
get_notification_center().disconnectDisplayedPeerNameChanged(self._peerModel.peerNameChanged)
get_notification_center().disconnectPrivacySettingsChanged(self._privacySettingsChanged)
get_notification_center().disconnectPrivacySettingsDiscarded(self._privacySettingsChanged)
def _getCategoryPolicy(self):
return PrivacySettings.CATEGORY_NEVER if self._category is None else PrivacySettings.CATEGORY_ALWAYS
def _initTopView(self, mode):
topWidget = QWidget(self)
self._modeCombo = QComboBox(topWidget)
self._modeCombo.addItem(u"nobody")
self._modeCombo.addItem(u"nobody, except")
self._modeCombo.addItem(u"everybody, except")
self._modeCombo.addItem(u"everybody")
self._modeCombo.setCurrentIndex(mode)
self._modeCombo.currentIndexChanged.connect(self._modeChanged)
topLayout = QHBoxLayout(topWidget)
topLayout.setContentsMargins(0, 0, 0, 0)
topLayout.addWidget(QLabel(u"Accept from"), 0)
topLayout.addWidget(self._modeCombo, 1, Qt.AlignLeft)
return topWidget
def _initPeerList(self, mode):
capsuleWidget = QWidget()
capsuleLayout = QVBoxLayout(capsuleWidget)
capsuleLayout.setContentsMargins(10, 0, 10, 0)
if mode in (PrivacySettings.POLICY_EVERYBODY_EX, PrivacySettings.POLICY_NOBODY_EX, PrivacySettings.POLICY_PEER_EXCEPTION):
exceptions = PrivacySettings.get().getExceptions(self._action, self._category, mode, useModified=True, categoryPolicy=self._getCategoryPolicy())
else:
exceptions = {}
self._peerModel = PeerModel(exceptions,
mode == PrivacySettings.POLICY_PEER_EXCEPTION,
self.logger)
self._peerModel.itemChanged.connect(self._peerDataChanged)
proxyModel = QSortFilterProxyModel(self)
proxyModel.setDynamicSortFilter(True)
proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
proxyModel.setSourceModel(self._peerModel)
proxyModel.sort(0)
self._peerList = QTreeView(self)
self._peerList.setAlternatingRowColors(False)
self._peerList.setHeaderHidden(True)
self._peerList.setItemsExpandable(False)
self._peerList.setIndentation(0)
self._peerList.setModel(proxyModel)
self._peerList.setSelectionMode(QTreeView.NoSelection)
self._peerList.setAutoFillBackground(False)
self._peerList.viewport().setAutoFillBackground(False)
self._peerList.setFrameShape(QFrame.NoFrame)
self._peerList.setFocusPolicy(Qt.NoFocus)
capsuleLayout.addWidget(self._peerList)
return capsuleWidget
def _initBottomWidget(self):
self._askForConfirmationBox = QCheckBox(u"Ask if state is unknown", self)
self._askForConfirmationBox.stateChanged.connect(self._askForConfirmationChanged)
return self._askForConfirmationBox
@loggingSlot(QStandardItem)
def _peerDataChanged(self, item):
if not self._resetting:
PrivacySettings.get().addException(self._action,
self._category,
self._mode,
convert_string(item.data(PeerModel.KEY_ROLE).toString()),
1 if item.checkState() == Qt.Checked else 0 if item.checkState() == Qt.Unchecked else -1,
applyImmediately=False,
categoryPolicy=self._getCategoryPolicy())
@loggingSlot(int)
def _askForConfirmationChanged(self, newState):
if not self._resetting:
PrivacySettings.get().setAskForConfirmation(self._action, self._category, newState == Qt.Checked, applyImmediately=False, categoryPolicy=self._getCategoryPolicy())
@loggingSlot(int)
def _modeChanged(self, newMode, notify=True, resetModel=True):
self._resetting = True
if newMode in (PrivacySettings.POLICY_EVERYBODY_EX, PrivacySettings.POLICY_NOBODY_EX, PrivacySettings.POLICY_PEER_EXCEPTION):
if resetModel:
# no change notifications, we are just resetting the model
self._peerModel.itemChanged.disconnect(self._peerDataChanged)
self._peerModel.setExceptionData(PrivacySettings.get().getExceptions(self._action, self._category, newMode, useModified=True, categoryPolicy=self._getCategoryPolicy()))
self._peerModel.itemChanged.connect(self._peerDataChanged)
self._peerList.setVisible(True)
else:
self._peerList.setVisible(False)
if newMode == PrivacySettings.POLICY_NOBODY_EX:
ask = PrivacySettings.get().getAskForConfirmation(self._action, self._category, useModified=True, categoryPolicy=self._getCategoryPolicy())
self._askForConfirmationBox.setCheckState(Qt.Checked if ask else Qt.Unchecked)
self._askForConfirmationBox.setVisible(True)
else:
self._askForConfirmationBox.setVisible(False)
self._mode = newMode
self._resetting = False
if notify:
PrivacySettings.get().setPolicy(self._action, self._category, self._mode, applyImmediately=False, categoryPolicy=self._getCategoryPolicy())
def setMode(self, newMode):
self._modeChanged(newMode, notify=False)
def getCategory(self):
return self._category
@loggingSlot(object, object)
def _privacySettingsChanged(self, pluginName, actionName):
if pluginName != self._action.getPluginName() or actionName != self._action.getName():
return
if self._determineOwnMode:
newMode = PrivacySettings.get().getPolicy(self._action, self._category, categoryPolicy=self._getCategoryPolicy())
else:
newMode = self._mode
self._modeChanged(newMode, notify=False)
class EditGeometryProperties(PyDialog):
force = True
def __init__(self, data, win_parent=None):
"""
+------------------+
| Edit Actor Props |
+------------------+------+
| Name1 |
| Name2 |
| Name3 |
| Name4 |
| |
| Active_Name main |
| Color box |
| Line_Width 2 |
| Point_Size 2 |
| Bar_Scale 2 |
| Opacity 0.5 |
| Show/Hide |
| |
| Apply OK Cancel |
+-------------------------+
"""
PyDialog.__init__(self, data, win_parent)
self.set_font_size(data['font_size'])
del self.out_data['font_size']
self.setWindowTitle('Edit Geometry Properties')
self.allow_update = True
#default
#self.win_parent = win_parent
#self.out_data = data
self.keys = sorted(data.keys())
self.keys = data.keys()
keys = self.keys
nrows = len(keys)
self.active_key = 'main' #keys[0]
items = keys
header_labels = ['Groups']
table_model = Model(items, header_labels, self)
view = SingleChoiceQTableView(self) #Call your custom QTableView here
view.setModel(table_model)
if qt_version == 4:
view.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.table = view
#self.opacity_edit.valueChanged.connect(self.on_opacity)
#mListWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(itemClicked(QListWidgetItem*)));
#self.table.itemClicked.connect(self.table.mouseDoubleClickEvent)
actor_obj = data[self.active_key]
name = actor_obj.name
line_width = actor_obj.line_width
point_size = actor_obj.point_size
bar_scale = actor_obj.bar_scale
opacity = actor_obj.opacity
color = actor_obj.color
show = actor_obj.is_visible
self.representation = actor_obj.representation
# table
header = self.table.horizontalHeader()
header.setStretchLastSection(True)
self._default_is_apply = False
self.name = QLabel("Name:")
self.name_edit = QLineEdit(str(name))
self.name_edit.setDisabled(True)
self.color = QLabel("Color:")
self.color_edit = QPushButton()
#self.color_edit.setFlat(True)
color = self.out_data[self.active_key].color
qcolor = QtGui.QColor()
qcolor.setRgb(*color)
#print('color =%s' % str(color))
palette = QtGui.QPalette(
self.color_edit.palette()) # make a copy of the palette
#palette.setColor(QtGui.QPalette.Active, QtGui.QPalette.Base, \
#qcolor)
palette.setColor(QtGui.QPalette.Background,
QtGui.QColor('blue')) # ButtonText
self.color_edit.setPalette(palette)
self.color_edit.setStyleSheet("QPushButton {"
"background-color: rgb(%s, %s, %s);" %
tuple(color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.use_slider = True
self.is_opacity_edit_active = False
self.is_opacity_edit_slider_active = False
self.is_line_width_edit_active = False
self.is_line_width_edit_slider_active = False
self.is_point_size_edit_active = False
self.is_point_size_edit_slider_active = False
self.is_bar_scale_edit_active = False
self.is_bar_scale_edit_slider_active = False
self.opacity = QLabel("Opacity:")
self.opacity_edit = QDoubleSpinBox(self)
self.opacity_edit.setRange(0.1, 1.0)
self.opacity_edit.setDecimals(1)
self.opacity_edit.setSingleStep(0.1)
self.opacity_edit.setValue(opacity)
if self.use_slider:
self.opacity_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.opacity_slider_edit.setRange(1, 10)
self.opacity_slider_edit.setValue(opacity * 10)
self.opacity_slider_edit.setTickInterval(1)
self.opacity_slider_edit.setTickPosition(QSlider.TicksBelow)
self.line_width = QLabel("Line Width:")
self.line_width_edit = QSpinBox(self)
self.line_width_edit.setRange(1, 15)
self.line_width_edit.setSingleStep(1)
self.line_width_edit.setValue(line_width)
if self.use_slider:
self.line_width_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.line_width_slider_edit.setRange(1, 15)
self.line_width_slider_edit.setValue(line_width)
self.line_width_slider_edit.setTickInterval(1)
self.line_width_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation in ['point', 'surface']:
self.line_width.setEnabled(False)
self.line_width_edit.setEnabled(False)
self.line_width_slider_edit.setEnabled(False)
self.point_size = QLabel("Point Size:")
self.point_size_edit = QSpinBox(self)
self.point_size_edit.setRange(1, 15)
self.point_size_edit.setSingleStep(1)
self.point_size_edit.setValue(point_size)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
if self.use_slider:
self.point_size_slider_edit = QSlider(QtCore.Qt.Horizontal)
self.point_size_slider_edit.setRange(1, 15)
self.point_size_slider_edit.setValue(point_size)
self.point_size_slider_edit.setTickInterval(1)
self.point_size_slider_edit.setTickPosition(QSlider.TicksBelow)
self.point_size_slider_edit.setVisible(False)
if self.representation in ['wire', 'surface']:
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.bar_scale = QLabel("Bar Scale:")
self.bar_scale_edit = QDoubleSpinBox(self)
#self.bar_scale_edit.setRange(0.01, 1.0) # was 0.1
#self.bar_scale_edit.setRange(0.05, 5.0)
self.bar_scale_edit.setDecimals(1)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
self.bar_scale_edit.setSingleStep(0.1)
self.bar_scale_edit.setValue(bar_scale)
#if self.use_slider:
#self.bar_scale_slider_edit = QSlider(QtCore.Qt.Horizontal)
#self.bar_scale_slider_edit.setRange(1, 100) # 1/0.05 = 100/5.0
#self.bar_scale_slider_edit.setValue(opacity * 0.05)
#self.bar_scale_slider_edit.setTickInterval(10)
#self.bar_scale_slider_edit.setTickPosition(QSlider.TicksBelow)
if self.representation != 'bar':
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setEnabled(False)
# show/hide
self.checkbox_show = QCheckBox("Show")
self.checkbox_hide = QCheckBox("Hide")
self.checkbox_show.setChecked(show)
self.checkbox_hide.setChecked(not show)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
if self.use_slider:
self.point_size_slider_edit.setEnabled(False)
self.cancel_button = QPushButton("Close")
self.create_layout()
self.set_connections()
def on_delete(self, irow):
"""deletes an actor based on the row number"""
if irow == 0: # main
return
nkeys = len(self.keys)
if nkeys in [0, 1]:
return
name = self.keys[irow]
nrows = nkeys - 1
self.keys.pop(irow)
header_labels = ['Groups']
table_model = Model(self.keys, header_labels, self)
self.table.setModel(table_model)
if len(self.keys) == 0:
self.update()
self.set_as_null()
return
if irow == nrows:
irow -= 1
new_name = self.keys[irow]
self.update_active_name(new_name)
if self.is_gui:
self.win_parent.delete_actor(name)
def set_as_null(self):
"""sets the null case"""
self.name.setVisible(False)
self.name_edit.setVisible(False)
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
self.checkbox_show.setVisible(False)
self.checkbox_hide.setVisible(False)
def on_update_geometry_properties_window(self, data):
"""Not Implemented"""
return
#new_keys = sorted(data.keys())
#if self.active_key in new_keys:
#i = new_keys.index(self.active_key)
#else:
#i = 0
#self.table.update_data(new_keys)
#self.out_data = data
#self.update_active_key(i)
def update_active_key(self, index):
"""
Parameters
----------
index : PyQt4.QtCore.QModelIndex
the index of the list
Internal Parameters
-------------------
name : str
the name of obj
obj : CoordProperties, AltGeometry
the storage object for things like line_width, point_size, etc.
"""
if qt_version == 4:
name = str(index.data().toString())
else:
name = str(index.data())
#print('name = %r' % name)
#i = self.keys.index(self.active_key)
self.update_active_name(name)
def update_active_name(self, name):
self.active_key = name
self.name_edit.setText(name)
obj = self.out_data[name]
if isinstance(obj, CoordProperties):
opacity = 1.0
representation = 'coord'
is_visible = obj.is_visible
elif isinstance(obj, AltGeometry):
line_width = obj.line_width
point_size = obj.point_size
bar_scale = obj.bar_scale
opacity = obj.opacity
representation = obj.representation
is_visible = obj.is_visible
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.allow_update = False
self.force = False
self.line_width_edit.setValue(line_width)
self.point_size_edit.setValue(point_size)
self.bar_scale_edit.setValue(bar_scale)
self.force = True
self.allow_update = True
else:
raise NotImplementedError(obj)
allowed_representations = [
'main', 'surface', 'coord', 'toggle', 'wire', 'point', 'bar'
]
if self.representation != representation:
self.representation = representation
if representation not in allowed_representations:
msg = 'name=%r; representation=%r is invalid\nrepresentations=%r' % (
name, representation, allowed_representations)
if self.representation == 'coord':
self.color.setVisible(False)
self.color_edit.setVisible(False)
self.line_width.setVisible(False)
self.line_width_edit.setVisible(False)
self.point_size.setVisible(False)
self.point_size_edit.setVisible(False)
self.bar_scale.setVisible(False)
self.bar_scale_edit.setVisible(False)
self.opacity.setVisible(False)
self.opacity_edit.setVisible(False)
if self.use_slider:
self.opacity_slider_edit.setVisible(False)
self.point_size_slider_edit.setVisible(False)
self.line_width_slider_edit.setVisible(False)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setVisible(True)
self.color_edit.setVisible(True)
self.line_width.setVisible(True)
self.line_width_edit.setVisible(True)
self.point_size.setVisible(True)
self.point_size_edit.setVisible(True)
self.bar_scale.setVisible(True)
#self.bar_scale_edit.setVisible(True)
self.opacity.setVisible(True)
self.opacity_edit.setVisible(True)
if self.use_slider:
self.opacity_slider_edit.setVisible(True)
self.line_width_slider_edit.setVisible(True)
self.point_size_slider_edit.setVisible(True)
#self.bar_scale_slider_edit.setVisible(True)
if name == 'main':
self.color.setEnabled(False)
self.color_edit.setEnabled(False)
self.point_size.setEnabled(False)
self.point_size_edit.setEnabled(False)
self.line_width.setEnabled(True)
self.line_width_edit.setEnabled(True)
self.bar_scale.setEnabled(False)
self.bar_scale_edit.setEnabled(False)
show_points = False
show_line_width = True
show_bar_scale = False
if self.use_slider:
self.line_width_slider_edit.setEnabled(True)
#self.bar_scale_slider_edit.setVisible(False)
else:
self.color.setEnabled(True)
self.color_edit.setEnabled(True)
show_points = False
if self.representation in ['point', 'wire+point']:
show_points = True
show_line_width = False
if self.representation in ['wire', 'wire+point', 'bar']:
show_line_width = True
if representation == 'bar':
show_bar_scale = True
else:
show_bar_scale = False
#self.bar_scale_button.setVisible(show_bar_scale)
#self.bar_scale_edit.setSingleStep(bar_scale / 10.)
#if self.use_slider:
#self.bar_scale_slider_edit.setEnabled(False)
self.point_size.setEnabled(show_points)
self.point_size_edit.setEnabled(show_points)
self.point_size.setVisible(show_points)
self.point_size_edit.setVisible(show_points)
self.line_width.setEnabled(show_line_width)
self.line_width_edit.setEnabled(show_line_width)
self.bar_scale.setEnabled(show_bar_scale)
self.bar_scale_edit.setEnabled(show_bar_scale)
self.bar_scale.setVisible(show_bar_scale)
self.bar_scale_edit.setVisible(show_bar_scale)
if self.use_slider:
self.point_size_slider_edit.setEnabled(show_points)
self.point_size_slider_edit.setVisible(show_points)
self.line_width_slider_edit.setEnabled(show_line_width)
#if self.representation in ['wire', 'surface']:
self.opacity_edit.setValue(opacity)
#if self.use_slider:
#self.opacity_slider_edit.setValue(opacity*10)
self.checkbox_show.setChecked(is_visible)
self.checkbox_hide.setChecked(not is_visible)
passed = self.on_validate()
#self.on_apply(force=True) # TODO: was turned on...do I want this???
#self.allow_update = True
#def on_name_select(self):
#print('on_name_select')
#return
def create_layout(self):
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.cancel_button)
grid = QGridLayout()
irow = 0
grid.addWidget(self.name, irow, 0)
grid.addWidget(self.name_edit, irow, 1)
irow += 1
grid.addWidget(self.color, irow, 0)
grid.addWidget(self.color_edit, irow, 1)
irow += 1
grid.addWidget(self.opacity, irow, 0)
if self.use_slider:
grid.addWidget(self.opacity_edit, irow, 2)
grid.addWidget(self.opacity_slider_edit, irow, 1)
else:
grid.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid.addWidget(self.line_width, irow, 0)
if self.use_slider:
grid.addWidget(self.line_width_edit, irow, 2)
grid.addWidget(self.line_width_slider_edit, irow, 1)
else:
grid.addWidget(self.line_width_edit, irow, 1)
irow += 1
grid.addWidget(self.point_size, irow, 0)
if self.use_slider:
grid.addWidget(self.point_size_edit, irow, 2)
grid.addWidget(self.point_size_slider_edit, irow, 1)
else:
grid.addWidget(self.point_size_edit, irow, 1)
irow += 1
grid.addWidget(self.bar_scale, irow, 0)
if self.use_slider and 0:
grid.addWidget(self.bar_scale_edit, irow, 2)
grid.addWidget(self.bar_scale_slider_edit, irow, 1)
else:
grid.addWidget(self.bar_scale_edit, irow, 1)
irow += 1
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox = QVBoxLayout()
vbox.addWidget(self.table)
vbox.addLayout(grid)
if 0:
vbox.addWidget(self.checkbox_show)
vbox.addWidget(self.checkbox_hide)
else:
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_show)
vbox1.addWidget(self.checkbox_hide)
vbox.addLayout(vbox1)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(ok_cancel_box)
self.setLayout(vbox)
def set_connections(self):
self.opacity_edit.valueChanged.connect(self.on_opacity)
self.line_width_edit.valueChanged.connect(self.on_line_width)
self.point_size_edit.valueChanged.connect(self.on_point_size)
self.bar_scale_edit.valueChanged.connect(self.on_bar_scale)
if self.use_slider:
self.opacity_slider_edit.valueChanged.connect(
self.on_opacity_slider)
self.line_width_slider_edit.valueChanged.connect(
self.on_line_width_slider)
self.point_size_slider_edit.valueChanged.connect(
self.on_point_size_slider)
#self.bar_scale_slider_edit.valueChanged.connect(self.on_bar_scale_slider)
# self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'), self.on_opacity)
# self.connect(self.line_width, QtCore.SIGNAL('clicked()'), self.on_line_width)
# self.connect(self.point_size, QtCore.SIGNAL('clicked()'), self.on_point_size)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
self.color_edit.clicked.connect(self.on_color)
self.checkbox_show.clicked.connect(self.on_show)
self.checkbox_hide.clicked.connect(self.on_hide)
self.cancel_button.clicked.connect(self.on_cancel)
# closeEvent
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
def closeEvent(self, event):
self.on_cancel()
def on_color(self):
"""called when the user clicks on the color box"""
name = self.active_key
obj = self.out_data[name]
rgb_color_ints = obj.color
msg = name
col = QColorDialog.getColor(QtGui.QColor(*rgb_color_ints), self,
"Choose a %s color" % msg)
if col.isValid():
color_float = col.getRgbF()[:3]
obj.color = color_float
color_int = [int(colori * 255) for colori in color_float]
self.color_edit.setStyleSheet(
"QPushButton {"
"background-color: rgb(%s, %s, %s);" % tuple(color_int) +
#"border:1px solid rgb(255, 170, 255); "
"}")
self.on_apply(force=self.force)
#print(self.allow_update)
def on_show(self):
"""shows the actor"""
name = self.active_key
is_checked = self.checkbox_show.isChecked()
self.out_data[name].is_visible = is_checked
self.on_apply(force=self.force)
def on_hide(self):
"""hides the actor"""
name = self.active_key
is_checked = self.checkbox_hide.isChecked()
self.out_data[name].is_visible = not is_checked
self.on_apply(force=self.force)
def on_line_width(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_active = True
name = self.active_key
line_width = self.line_width_edit.value()
self.out_data[name].line_width = line_width
if not self.is_line_width_edit_slider_active:
if self.use_slider:
self.line_width_slider_edit.setValue(line_width)
self.is_line_width_edit_active = False
self.on_apply(force=self.force)
self.is_line_width_edit_active = False
def on_line_width_slider(self):
"""increases/decreases the wireframe (for solid bodies) or the bar thickness"""
self.is_line_width_edit_slider_active = True
#name = self.active_key
line_width = self.line_width_slider_edit.value()
if not self.is_line_width_edit_active:
self.line_width_edit.setValue(line_width)
self.is_line_width_edit_slider_active = False
def on_point_size(self):
"""increases/decreases the point size"""
self.is_point_size_edit_active = True
name = self.active_key
point_size = self.point_size_edit.value()
self.out_data[name].point_size = point_size
if not self.is_point_size_edit_slider_active:
if self.use_slider:
self.point_size_slider_edit.setValue(point_size)
self.is_point_size_edit_active = False
self.on_apply(force=self.force)
self.is_point_size_edit_active = False
def on_point_size_slider(self):
"""increases/decreases the point size"""
self.is_point_size_edit_slider_active = True
name = self.active_key
point_size = self.point_size_slider_edit.value()
if not self.is_point_size_edit_active:
self.point_size_edit.setValue(point_size)
self.is_point_size_edit_slider_active = False
def on_bar_scale(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_active = True
name = self.active_key
float_bar_scale = self.bar_scale_edit.value()
self.out_data[name].bar_scale = float_bar_scale
if not self.is_bar_scale_edit_slider_active:
int_bar_scale = int(round(float_bar_scale * 20, 0))
#if self.use_slider:
#self.bar_scale_slider_edit.setValue(int_bar_scale)
self.is_bar_scale_edit_active = False
self.on_apply(force=self.force)
self.is_bar_scale_edit_active = False
def on_bar_scale_slider(self):
"""
Vectors start at some xyz coordinate and can increase in length.
Increases/decreases the length scale factor.
"""
self.is_bar_scale_edit_slider_active = True
name = self.active_key
int_bar_scale = self.bar_scale_slider_edit.value()
if not self.is_bar_scale_edit_active:
float_bar_scale = int_bar_scale / 20.
self.bar_scale_edit.setValue(float_bar_scale)
self.is_bar_scale_edit_slider_active = False
def on_opacity(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_active = True
name = self.active_key
float_opacity = self.opacity_edit.value()
self.out_data[name].opacity = float_opacity
if not self.is_opacity_edit_slider_active:
int_opacity = int(round(float_opacity * 10, 0))
if self.use_slider:
self.opacity_slider_edit.setValue(int_opacity)
self.is_opacity_edit_active = False
self.on_apply(force=self.force)
self.is_opacity_edit_active = False
def on_opacity_slider(self):
"""
opacity = 1.0 (solid/opaque)
opacity = 0.0 (invisible)
"""
self.is_opacity_edit_slider_active = True
name = self.active_key
int_opacity = self.opacity_slider_edit.value()
if not self.is_opacity_edit_active:
float_opacity = int_opacity / 10.
self.opacity_edit.setValue(float_opacity)
self.is_opacity_edit_slider_active = False
#def on_axis(self, text):
##print(self.combo_axis.itemText())
#self._axis = str(text)
#self.plane.setText('Point on %s? Plane:' % self._axis)
#self.point_a.setText('Point on %s Axis:' % self._axis)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def on_plane(self, text):
#self._plane = str(text)
#self.point_b.setText('Point on %s%s Plane:' % (self._axis, self._plane))
#def _on_float(self, field):
#try:
#eval_float_from_string(field.text())
#field.setStyleSheet("QLineEdit{background: white;}")
#except ValueError:
#field.setStyleSheet("QLineEdit{background: red;}")
#def on_default_name(self):
#self.name_edit.setText(str(self._default_name))
#self.name_edit.setStyleSheet("QLineEdit{background: white;}")
#def check_float(self, cell):
#text = cell.text()
#try:
#value = eval_float_from_string(text)
#cell.setStyleSheet("QLineEdit{background: white;}")
#return value, True
#except ValueError:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
#def check_name(self, cell):
#text = str(cell.text()).strip()
#if len(text):
#cell.setStyleSheet("QLineEdit{background: white;}")
#return text, True
#else:
#cell.setStyleSheet("QLineEdit{background: red;}")
#return None, False
def on_validate(self):
self.out_data['clicked_ok'] = True
self.out_data['clicked_cancel'] = False
old_obj = self.out_data[self.active_key]
old_obj.line_width = self.line_width_edit.value()
old_obj.point_size = self.point_size_edit.value()
old_obj.bar_scale = self.bar_scale_edit.value()
old_obj.opacity = self.opacity_edit.value()
#old_obj.color = self.color_edit
old_obj.is_visible = self.checkbox_show.isChecked()
return True
#name_value, flag0 = self.check_name(self.name_edit)
#ox_value, flag1 = self.check_float(self.transparency_edit)
#if flag0 and flag1:
#self.out_data['clicked_ok'] = True
#return True
#return False
@property
def is_gui(self):
return hasattr(self.win_parent, 'on_update_geometry_properties')
def on_apply(self, force=False):
passed = self.on_validate()
#print("passed=%s force=%s allow=%s" % (passed, force, self.allow_update))
if (passed or force) and self.allow_update and self.is_gui:
#print('obj = %s' % self.out_data[self.active_key])
self.win_parent.on_update_geometry_properties(self.out_data,
name=self.active_key)
return passed
def on_cancel(self):
passed = self.on_apply(force=True)
if passed:
self.close()
class FlightPlanBaseDlg(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
palette = QPalette();
brush = QBrush(QColor(255, 255, 255, 255));
brush.setStyle(Qt.SolidPattern);
palette.setBrush(QPalette.Active, QPalette.Base, brush);
palette.setBrush(QPalette.Active, QPalette.Window, brush);
palette.setBrush(QPalette.Inactive, QPalette.Base, brush);
palette.setBrush(QPalette.Inactive, QPalette.Window, brush);
palette.setBrush(QPalette.Disabled, QPalette.Base, brush);
palette.setBrush(QPalette.Disabled, QPalette.Window, brush);
self.setPalette(palette);
self.ui = Ui_FlightPlannerBase()
self.ui.setupUi(self)
self.newDlgExisting = False
self.chbHideCloseInObst = QCheckBox(self.ui.grbResult)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.chbHideCloseInObst.setFont(font)
self.chbHideCloseInObst.setObjectName("chbHideCloseInObst")
self.ui.vlResultGroup.addWidget(self.chbHideCloseInObst)
self.chbHideCloseInObst.setText("Hide close-in obstacles")
self.chbHideCloseInObst.setVisible(False)
self.ui.tblHistory.setSelectionBehavior(1)
# self.ui.tabCtrlGeneral.setTabsClosable(True)
self.ui.btnUpdateQA.setVisible(False)
self.ui.btnUpdateQA_2.setVisible(False)
''' combo boxes event '''
self.ui.cmbObstSurface.currentIndexChanged.connect(self.cmbObstSurfaceChanged)
self.ui.cmbUnits.currentIndexChanged.connect(self.changeResultUnit)
''' buttons clicked connect '''
self.ui.btnClose.clicked.connect(self.reject)
self.ui.btnClose_2.clicked.connect(self.reject)
self.ui.btnHistoryClose.clicked.connect(self.reject)
self.ui.btnConstruct.clicked.connect(self.btnConstruct_Click)
self.ui.btnEvaluate.clicked.connect(self.btnEvaluate_Click)
self.ui.btnOpenData.clicked.connect(self.openData)
self.ui.btnSaveData.clicked.connect(self.saveData)
self.ui.btnPDTCheck.clicked.connect(self.btnPDTCheck_Click)
self.ui.btnExportResult.clicked.connect(self.exportResult)
self.ui.tblHistory.clicked.connect(self.tblHistory_Click)
self.ui.btnUpdateQA.clicked.connect(self.btnUpdateQA_Click)
self.ui.btnUpdateQA_2.clicked.connect(self.btnUpdateQA_2_Click)
self.ui.btnCriticalLocate.clicked.connect(self.criticalLocate)
self.connect(self.ui.tblObstacles, SIGNAL("tableViewObstacleMouseReleaseEvent_rightButton"), self.tableViewObstacleMouseTeleaseEvent_rightButton)
self.connect(self.ui.tblObstacles, SIGNAL("pressedEvent"), self.tblObstacles_pressed)
''' properties '''
self.parametersPanel = None
self.obstaclesModel = None
self.surfaceType = ""
self.surfaceSubGroupNames = []
self.uiStateInit()
self.obstacleTableInit()
self.newDlgExisting = True
self.resultColumnNames = []
self.stdItemModelHistory = QStandardItemModel()
# self.stdItemModelHistory.
self.ui.tblHistory.setModel(self.stdItemModelHistory)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/btnImage/dlgIcon.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.resultLayerList = []
self.symbolLayers = []
self.selectedObstacleMoselIndex = None
self.changedCriticalObstacleValue = []
def tblObstacles_pressed(self, modelIndex):
self.selectedObstacleMoselIndex = modelIndex
def tableViewObstacleMouseTeleaseEvent_rightButton(self, e):
if self.obstaclesModel == None:
return
featID = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexObjectId)).toString()
layerID = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexLayerId)).toString()
name = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexName)).toString()
xValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexX)).toString()
yValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexY)).toString()
altitudeMValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexAltM)).toString()
surfaceName = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexSurface)).toString()
ocaMValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexOcaM)).toString()
# ocaMValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexOcaM)).toString()
obstacle = Obstacle(name, Point3D(float(xValue), float(yValue), float(altitudeMValue)), layerID, featID, None, 0.0, self.obstaclesModel.MocMultiplier, 0.0)
self.changedCriticalObstacleValue = {"Obstacle": obstacle,
"SurfaceName": surfaceName,
"OcaM": float(ocaMValue) if ocaMValue != "" else None}
menu = QMenu()
actionSetCriticalObst = QgisHelper.createAction(menu, "Set Most Critical Obstacles", self.menuSetCriticalObstClick)
menu.addAction( actionSetCriticalObst )
menu.exec_( self.ui.tblObstacles.mapToGlobal(e.pos() ))
def menuSetCriticalObstClick(self):
pass
# OasObstacles.resultCriticalObst.Obstacle = self.changedCriticalObstacleValue["Obstacle"]
# OasObstacles.resultCriticalObst.Surface = self.changedCriticalObstacleValue["SurfaceName"]
# OasObstacles.resultCriticalObst.Assigned = True
# ocaMValue = self.changedCriticalObstacleValue["OcaM"]
#
# OasObstacles.resultOCA = Altitude(float(ocaMValue) if ocaMValue != "" else None)
# if OasObstacles.resultOCA == None:
# OasObstacles.resultOCH = None
# else:
# OasObstacles.resultOCH = OasObstacles.resultOCA - self.ui.pnlThr.Altitude()
#
# point3d = self.ui.pnlThr.Point3d
# num = Unit.ConvertDegToRad(float(self.ui.txtTrack.Value))
# num1 = self.method_40()
# zC = OasObstacles.constants.ZC / OasObstacles.constants.ZA
# point3d1 = MathHelper.distanceBearingPoint(point3d, num, zC)
# metres2 = OasObstacles.resultCriticalObst.method_2(point3d).Metres
# z = metres2 - point3d.z()
# num3 = math.tan(Unit.ConvertDegToRad(num1))
# num4 = z / num3
# OasObstacles.resultSocPosition = MathHelper.distanceBearingPoint(point3d1, num + 3.14159265358979, num4).smethod_167(0)
# if (num4 > zC):
# OasObstacles.resultSocText = Messages.X_BEFORE_THRESHOLD % (num4 - zC)
# else:
# OasObstacles.resultSocText = Messages.X_PAST_THRESHOLD % (zC - num4)
# self.setCriticalObstacle()
def criticalLocate(self):
point = None
try:
point = QgsPoint(float(self.ui.txtCriticalX.text()), float(self.ui.txtCriticalY.text()))
except:
return
if define._units == QGis.Meters:
extent = QgsRectangle(point.x() - 350, point.y() - 350, point.x() + 350, point.y() + 350)
else:
extent = QgsRectangle(point.x() - 0.005, point.y() - 0.005, point.x() + 0.005, point.y() + 0.005)
if extent is None:
return
QgisHelper.zoomExtent(point, extent, 2)
def trackRadialPanelSetEnabled(self):
positionPanels = self.findChildren(PositionPanel)
if len(positionPanels) > 0:
flag = False
for pnl in positionPanels:
if pnl.IsValid():
flag = True
break
trPanels = self.findChildren(TrackRadialBoxPanel)
if len(trPanels) > 0:
for pnl in trPanels:
pnl.Enabled = flag
def setDataInHistoryModel(self, dataList, newFlag = False):
# dataList is list of list of tuple with name and data
# example
# dataList = [ list of name, list of data ]
# dataList = [["lat", "lon"], ["59", "17"]]
if newFlag:
self.stdItemModelHistory.setHorizontalHeaderLabels(dataList[0][0])
for i in range(len(dataList)):
for j in range(len(dataList[i][1])):
item = QStandardItem(dataList[i][1][j])
item.setEditable(False)
self.stdItemModelHistory.setItem(i, j, item)
return
if len(dataList) > 0:
rowcount = self.stdItemModelHistory.rowCount()
if self.stdItemModelHistory.rowCount() > 0:
for i in range(len(dataList[1])):
item = QStandardItem(dataList[1][i])
item.setEditable(False)
self.stdItemModelHistory.setItem(rowcount, i, item)
pass
else:
self.stdItemModelHistory.setHorizontalHeaderLabels(dataList[0])
for i in range(len(dataList[1])):
item = QStandardItem(dataList[1][i])
item.setEditable(False)
self.stdItemModelHistory.setItem(0, i, item)
def btnPDTCheck_Click(self):
pass
def cmbObstSurfaceChanged(self):
if self.obstaclesModel != None:
if self.ui.cmbObstSurface.currentIndex() == 0 and self.ui.cmbObstSurface.currentText() == "All":
self.obstaclesModel.setFilterFixedString("")
else:
self.obstaclesModel.setFilterFixedString(self.ui.cmbObstSurface.currentText())
def obstacleTableInit(self):
self.ui.tblObstacles.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ui.tblObstacles.setSortingEnabled(True)
def uiStateInit(self):
self.ui.cmbUnits.addItems([Captions.METRES, Captions.FEET])
self.ui.cmbUnits.setCurrentIndex(1)
self.ui.cmbUnits.currentIndexChanged.connect(self.changeResultUnit)
pass
def tblHistory_Click(self, modelIndex):
pass
def btnConstruct_Click(self):
# qgsLayerTreeView = define._mLayerTreeView
# groupName = self.surfaceType
# layerTreeModel = qgsLayerTreeView.layerTreeModel()
# layerTreeGroup = layerTreeModel.rootGroup()
# rowCount = layerTreeModel.rowCount()
# groupExisting = False
# if rowCount > 0:
# for i in range(rowCount):
# qgsLayerTreeNode = layerTreeModel.index2node(layerTreeModel.index(i, 0))
# if qgsLayerTreeNode.nodeType() == 0:
# qgsLayerTreeNode._class_ = QgsLayerTreeGroup
# if isinstance(qgsLayerTreeNode, QgsLayerTreeGroup) and qgsLayerTreeNode.name() == groupName:
# groupExisting = True
#
# if groupExisting:
# if len(self.resultLayerList) > 0:
# QgisHelper.removeFromCanvas(define._canvas, self.resultLayerList)
# self.resultLayerList = []
# else:
# QMessageBox.warning(self, "Warning", "Please remove \"" + self.surfaceType + "\" layer group from LayerTreeView.")
# return False
self.resultLayerList = []
return True
def btnUpdateQA_Click(self):
pass
def btnUpdateQA_2_Click(self):
pass
def btnEvaluate_Click(self):
try:
if self.obstaclesModel == None:
self.initObstaclesModel()
if self.obstaclesModel == None:
return
surfaceLayers = QgisHelper.getSurfaceLayers(self.surfaceType, self.surfaceSubGroupNames)
self.initObstaclesModel()
self.obstaclesModel.loadObstacles(surfaceLayers)
self.obstaclesModel.setLocateBtn(self.ui.btnLocate)
self.ui.tblObstacles.setModel(self.obstaclesModel)
self.obstaclesModel.setTableView(self.ui.tblObstacles)
self.obstaclesModel.setHiddenColumns(self.ui.tblObstacles)
self.ui.tabCtrlGeneral.setCurrentIndex(1)
if self.ui.cmbObstSurface.isVisible():
self.ui.cmbObstSurface.clear()
self.initSurfaceCombo()
self.ui.cmbObstSurface.setCurrentIndex(0)
self.ui.btnExportResult.setEnabled(True)
self.setResultPanel()
except UserWarning as e:
QMessageBox.warning(self, "Information", e.message)
def initParametersPan(self):
parametersPanelWidget = QWidget(self)
# self.parametersPanel = uiObject
if self.parametersPanel != None:
self.parametersPanel.setupUi(parametersPanelWidget)
self.ui.vlScrollWidget.addWidget(parametersPanelWidget)
lstTextControls = self.ui.grbGeneral.findChildren(QLineEdit)
for ctrl in lstTextControls:
ctrl.textChanged.connect(self.initResultPanel)
lstComboControls = self.ui.grbGeneral.findChildren(QComboBox)
for ctrl in lstComboControls:
ctrl.currentIndexChanged.connect(self.initResultPanel)
# lstTextControls = self.findChildren(QLineEdit)
# for ctrl in lstTextControls:
# ctrl.setMinimumWidth(100)
# ctrl.setMaximumWidth(100)
# lstComboControls = self.findChildren(QComboBox)
# for ctrl in lstComboControls:
# ctrl.setMinimumWidth(100)
# ctrl.setMaximumWidth(100)
# newWidth = int(define._appWidth / float(1280) * parametersPanelWidget.width())
# newHeight = int(define._appHeight / float(800) * parametersPanelWidget.height())
# if newWidth > define._appWidth:
# newWidth -= 50
# if newHeight > define._appHeight:
# newHeight -= 50
# parametersPanelWidget.resize(newWidth, newHeight)
def initResultPanel(self):
if self.obstaclesModel != None and self.ui.btnEvaluate.isEnabled():
self.obstaclesModel.clear()
lstTextControls = self.ui.grbResult.findChildren(QLineEdit)
for ctrl in lstTextControls:
if ctrl.objectName() == "txtOCH" or ctrl.objectName() == "txtOCA":
continue
ctrl.setText("")
self.ui.btnExportResult.setDisabled(True)
# self.ui.btnEvaluate.setEnabled(False)
def initObstaclesModel(self):
pass
def initSurfaceCombo(self):
pass
def setResultPanel(self):
pass
def saveData(self):
try:
filePathDir = QFileDialog.getSaveFileName(self, "Save Input Data",QCoreApplication.applicationDirPath (),"Xml Files(*.xml)")
if filePathDir == "":
return
DataHelper.saveInputParameters(filePathDir, self)
# contents = None
# with open(filePathDir, 'rb', 0) as tempFile:
# contents = tempFile.read()
# tempFile.flush()
# tempFile.close()
# bytes = FasDataBlockFile.CRC_Calculation(contents)
# string_0 = QString(filePathDir)
# path = string_0.left(string_0.length() - 3) + "crc"
# fileStream = open(path, 'wb')
# fileStream.write(bytes)
# fileStream.close()
return filePathDir
except UserWarning as e:
QMessageBox.warning(self, "Error", e.message)
def openData(self):
try:
filePathDir = QFileDialog.getOpenFileName(self, "Open Input Data",QCoreApplication.applicationDirPath (),"Xml Files(*.xml)")
if filePathDir == "":
return
layers = define._canvas.layers()
if layers != None and len(layers) > 0:
for layer in layers:
if layer.name() == "Symbols":
self.currentLayer = layer
try:
self.initAerodromeAndRwyCmb()
except:
pass
try:
self.initBasedOnCmb()
except:
pass
break
# contents = None
# with open(filePathDir, 'rb', 0) as tempFile:
# contents = tempFile.read()
# tempFile.close()
# bytes = FasDataBlockFile.CRC_Calculation(contents)
#
# string_0 = QString(filePathDir)
# crcFileDir = string_0.left(string_0.length() - 3) + "crc"
# crcFileContents = None
# with open(crcFileDir, 'rb', 0) as tempFileCrc:
# crcFileContents = tempFileCrc.read()
# tempFileCrc.close()
# if bytes != crcFileContents:
# QMessageBox.warning(self, "Error", "Input file has been changed by outside.")
# return
DataHelper.loadInputParameters(filePathDir, self)
return filePathDir
except UserWarning as e:
QMessageBox.warning(self, "Error", e.message)
def exportResult(self):
dlg = ExportDlg(self)
dlg.ui.txtHeading.setText(self.surfaceType + "_Export")
columnNames = []
if self.obstaclesModel != None:
columnNames = self.obstaclesModel.fixedColumnLabels
self.stModel = QStandardItemModel()
for i in range(len(columnNames)):
stItem = QStandardItem(columnNames[i])
stItem.setCheckable(True)
checkFlag = True
for hideColName in self.obstaclesModel.hideColumnLabels:
if columnNames[i] == hideColName:
checkFlag = False
break
if checkFlag:
stItem.setCheckState(Qt.Checked)
else:
stItem.setCheckState(Qt.Unchecked)
self.stModel.setItem(i, 0, stItem)
if len(columnNames) <= 0:
return
dlg.ui.listColumns.setModel(self.stModel)
result = dlg.exec_()
return (result, dlg.resultHideColumnIndexs)
def changeResultUnit(self):
pass
def method_27(self, qarecord_0):
pass
# QA.smethod_2(qarecord_0);
# self.method_20(Messages.QA_UPDATED);
class NuauthFrontEnd(FullFeaturedScrollArea):
COMPONENT = 'nuauth'
LABEL = tr('User directory')
REQUIREMENTS = ('nuauth',)
ICON = ':/icons/users.png'
def __init__(self, client, parent):
#Parent constructor
self.config = None
self.auth_page = None
self.group_page = None
self.auth_configs = {}
self.group_configs = {}
self.mainwindow = parent
self._module_disabled = False
FullFeaturedScrollArea.__init__(self, client, parent)
self.selected_auth = LDAP
self.auth_configs[self.selected_auth] = LDAPOrg()
self.selected_group = LDAP
self.group_configs[self.selected_group] = LDAPOrg()
@staticmethod
def get_calls():
"""
services called by initial multicall
"""
return (( 'nuauth', 'getNuauthConfig'), ( 'nuauth', 'availableModules'))
def buildInterface(self):
available_modules = self.mainwindow.init_call('nuauth', 'availableModules')
if available_modules is None:
self._no_backend()
return
# This boolean to support server versions 4.0.12/13. The new fake
# protocol NOT_CONFIGURED has been added recently, but other
# protocols are unchanged
option_no_directory_available = True
server_auth_protocols = available_modules['auth']
for module in auth_protocols:
if not module in server_auth_protocols:
if module == NOT_CONFIGURED:
option_no_directory_available = False
#we continue and simply won't show checkbox
continue
info("[User directory] Unsupported auth module, server side: %s (got %s)" % (module, server_auth_protocols))
self._ask_server_upgrade()
return
server_org_protocols = available_modules['group']
for module in org_protocols:
if not module in server_org_protocols:
if module == NOT_CONFIGURED:
option_no_directory_available = False
#we continue and simply won't show checkbox
continue
if module == NND:
continue
info("[User directory] Unsupported org module, server side: %s (got %s)" % (module, server_org_protocols))
self._ask_server_upgrade()
return
self.mkToolbar()
for module in available_modules['auth']:
if module not in auth_protocols:
self.mainwindow.addToInfoArea(
tr("User authentication: cannot handle the following protocol: ") +
module
)
for module in available_modules['group']:
if module not in org_protocols:
self.mainwindow.addToInfoArea(
tr("Organization: cannot handle the following protocol: ") +
module
)
frame = QFrame()
self.setWidget(frame)
self.setWidgetResizable(True)
v_box = QVBoxLayout(frame)
title = u'<h1>%s</h1>' % self.tr('Directory Configuration')
v_box.addWidget(QLabel(title))
self.use_directory = QCheckBox(tr("Use a user directory"))
self.mainwindow.writeAccessNeeded(self.use_directory)
self.tabs = QTabWidget()
# self.tabs.setTabPosition(QTabWidget.West)
#signature: QWidget * page, const QIcon & icon, const QString & label
self.tabs.addTab(*self.mkUsersTab(available_modules['auth']))
self.tabs.addTab(*self.mkGroupsTab(available_modules['group']))
self.tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.connect(self.use_directory, SIGNAL("stateChanged (int)"), self.use_directory_state)
v_box.addWidget(self.use_directory)
v_box.addWidget(self.tabs)
self.use_directory.setVisible(option_no_directory_available)
self.message_area = MessageArea()
v_box.addWidget(self.message_area)
def use_directory_state(self, state):
noconf = (state != Qt.Checked)
if noconf:
self.config = NuauthCfg()
self.auth_page.setViewData(self.config)
self.group_page.setViewData(self.config)
elif not self.config.isConfigured():
self.config = NuauthCfg(auth=SameAsOrgAuth(), org=LDAPOrg())
self.auth_page.setViewData(self.config)
self.group_page.setViewData(self.config)
self.tabs.setEnabled(not noconf)
self.setModified()
def mkToolbar(self):
self.test_action = QAction(
QIcon(":/icons-32/auth_protocol.png"),
tr("Test current configuration"),
self
)
self.contextual_toolbar = ToolBar((self.test_action,), self, 'User directory')
self.connect(self.test_action, SIGNAL('triggered(bool)'), self.testdialog)
def testdialog(self):
dialog = DirectoryTest(self.client, self)
dialog.exec_()
def reemit(self, *args):
self.setModified()
def mkUsersTab(self, available_modules):
self.auth_page = VariableConfigFrontend(
available_modules,
self.config,
self.auth_configs,
AUTH,
self.mainwindow
)
icon = QIcon(':/icons/one_user')
self.connect(self.auth_page, SIGNAL('modified'), self.reemit)
self.auth_page = self.auth_page
self.mainwindow.writeAccessNeeded(self.auth_page)
return self.auth_page, icon, tr('Authentication')
def mkGroupsTab(self, available_modules):
self.group_page = VariableConfigFrontend(
available_modules,
self.config,
self.group_configs,
GROUP,
self.mainwindow
)
icon = QIcon(':/icons/users')
self.connect(self.group_page, SIGNAL('modified'), self.reemit)
self.mainwindow.writeAccessNeeded(self.group_page)
return self.group_page, icon, tr('Groups')
def _ask_server_upgrade(self):
self._disable(
tr("Client-server version mismatch"),
tr(
"This version of the user interface cannot handle the current "
"software version of the appliance. The appliance may need upgrading."
),
tr("User directory interface disabled because of a version mismatch.")
)
def _no_backend(self):
self._disable(
tr("Could not fetch user directory parameters"),
tr(
"Problem while fetching the server configuration "
"for user directory"
),
tr(
"The user directory interface is disabled because the configuration "
"could not be fetched properly."
)
)
def _disable(self, title, message, main_message):
if self._module_disabled:
#already done
return
self._module_disabled = True
msg = MessageArea()
msg.setMessage(
title,
message,
"critical"
)
msg.setWidth(65)
self.setWidget(msg)
self.mainwindow.addToInfoArea(
main_message
)
self.setWidgetResizable(True)
def fetchConfig(self):
serialized = self.mainwindow.init_call('nuauth', 'getNuauthConfig')
if serialized is None:
self._no_backend()
return
#DON'T REMOVE: 3 is a major turn in this module conception
if serialized['DATASTRUCTURE_VERSION'] < 3:
self._ask_server_upgrade()
return
self.config = NuauthCfg.deserialize(serialized)
self.selected_auth = self.config.auth.protocol
self.selected_group = self.config.org.protocol
#instantiate all data structures
if len(self.auth_configs) == 0:
for protocol in auth_protocols:
if protocol == self.selected_auth:
self.auth_configs[protocol] = self.config.auth
else:
self.auth_configs[protocol] = auth_class(protocol)()
self.auth_configs[self.selected_auth] = self.config.auth
if len(self.group_configs) == 0:
for protocol in org_protocols:
if protocol == self.selected_group:
continue
self.group_configs[protocol] = org_class(protocol)()
self.group_configs[self.selected_group] = self.config.org
def setViewData(self):
if self._module_disabled:
return
configured = self.config.isConfigured()
self.use_directory_state(Qt.Checked if configured else Qt.Unchecked)
self.use_directory.setChecked(configured)
for page in (self.auth_page, self.group_page):
if page is not None:
page.setViewData(self.config)
def sendConfig(self, message):
if not self.config.isValidWithMsg(use_state=True)[0]:
return
serialized = self.config.serialize(downgrade=True)
self.client.call('nuauth', 'setNuauthConfig', serialized, message)
def isValid(self):
ok, msg = self.config.isValidWithMsg(use_state=True)
if not ok:
self.error_message = msg # used by main_window
return ok
class FindReplace(QWidget):
"""
Find widget
Signals:
visibility_changed(bool)
"""
STYLE = {False: "background-color:rgb(255, 175, 90);", True: ""}
def __init__(self, parent, enable_replace=False):
QWidget.__init__(self, parent)
self.enable_replace = enable_replace
self.editor = None
glayout = QGridLayout()
glayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(glayout)
self.close_button = create_toolbutton(self, triggered=self.hide, icon=get_std_icon("DialogCloseButton"))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self, tip=self.tr("Search string"), adjust_to_minimum=False)
self.connect(self.search_text, SIGNAL("editTextChanged(QString)"), self.text_has_changed)
self.previous_button = create_toolbutton(
self, text=self.tr("Previous"), triggered=self.find_previous, icon=get_std_icon("ArrowBack")
)
self.next_button = create_toolbutton(
self, text=self.tr("Next"), triggered=self.find_next, icon=get_std_icon("ArrowForward")
)
self.connect(self.next_button, SIGNAL("clicked()"), self.update_search_combo)
self.connect(self.previous_button, SIGNAL("clicked()"), self.update_search_combo)
self.case_check = QCheckBox(self.tr("Case Sensitive"))
self.connect(self.case_check, SIGNAL("stateChanged(int)"), self.find)
self.words_check = QCheckBox(self.tr("Whole words"))
self.connect(self.words_check, SIGNAL("stateChanged(int)"), self.find)
hlayout = QHBoxLayout()
self.widgets = [
self.close_button,
self.search_text,
self.previous_button,
self.next_button,
self.case_check,
self.words_check,
]
for widget in self.widgets[1:]:
hlayout.addWidget(widget)
glayout.addLayout(hlayout, 0, 1)
# Replace layout
replace_with1 = QLabel(self.tr("Replace"))
replace_with2 = QLabel()
font = replace_with2.font()
font.setBold(True)
replace_with2.setFont(font)
replace_with3 = QLabel(self.tr("with:"))
self.replace_text = PatternComboBox(self, adjust_to_minimum=False, tip=self.tr("Replace string"))
self.replace_button = create_toolbutton(
self, text=self.tr("Replace/find"), triggered=self.replace_find, icon=get_std_icon("DialogApplyButton")
)
self.connect(self.replace_button, SIGNAL("clicked()"), self.update_replace_combo)
self.connect(self.replace_button, SIGNAL("clicked()"), self.update_search_combo)
self.all_check = QCheckBox(self.tr("Replace all"))
self.replace_layout = QHBoxLayout()
widgets = [replace_with1, replace_with2, replace_with3, self.replace_text, self.replace_button, self.all_check]
for widget in widgets:
self.replace_layout.addWidget(widget)
self.connect(self.search_text, SIGNAL("editTextChanged(QString)"), replace_with2, SLOT("setText(QString)"))
glayout.addLayout(self.replace_layout, 1, 1)
self.widgets.extend(widgets)
self.replace_widgets = widgets
self.hide_replace()
self.search_text.setTabOrder(self.search_text, self.replace_text)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
def update_search_combo(self):
self.search_text.lineEdit().emit(SIGNAL("returnPressed()"))
def update_replace_combo(self):
self.replace_text.lineEdit().emit(SIGNAL("returnPressed()"))
def keyPressEvent(self, event):
"""Reimplemented to handle key events"""
ctrl = event.modifiers() & Qt.ControlModifier
if event.key() == Qt.Key_Escape:
self.hide()
event.accept()
return
elif event.key() == Qt.Key_F3:
# Find next
self.find_next()
event.accept()
elif event.key() == Qt.Key_F and ctrl:
# Toggle find widgets
if self.isVisible():
self.hide()
else:
self.show()
event.accept()
elif event.key() == Qt.Key_H and ctrl and self.enable_replace:
# Toggle replace widgets
if self.replace_widgets[0].isVisible():
self.hide_replace()
self.hide()
else:
self.show_replace()
self.replace_text.setFocus()
event.accept()
else:
event.ignore()
def show(self):
"""Overrides Qt Method"""
QWidget.show(self)
self.emit(SIGNAL("visibility_changed(bool)"), True)
if self.editor is not None:
text = self.editor.selectedText()
if len(text) > 0:
self.search_text.setEditText(text)
self.search_text.lineEdit().selectAll()
self.refresh()
else:
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
def hide(self):
"""Overrides Qt Method"""
for widget in self.replace_widgets:
widget.hide()
QWidget.hide(self)
self.emit(SIGNAL("visibility_changed(bool)"), False)
if self.editor is not None:
self.editor.setFocus()
def show_replace(self):
"""Show replace widgets"""
for widget in self.replace_widgets:
widget.show()
def hide_replace(self):
"""Hide replace widgets"""
for widget in self.replace_widgets:
widget.hide()
def refresh(self):
"""Refresh widget"""
if self.isHidden():
return
state = self.editor is not None
for widget in self.widgets:
widget.setEnabled(state)
if state:
self.find()
def set_editor(self, editor, refresh=True):
"""
Set associated editor/web page:
qtebase.TextEditBaseWidget
qscibase.TextEditBaseWidget
browser.WebView
"""
self.editor = editor
from PyQt4.QtWebKit import QWebView
self.words_check.setVisible(not isinstance(editor, QWebView))
if refresh:
self.refresh()
def find_next(self):
"""Find next occurence"""
return self.find(changed=False, forward=True)
def find_previous(self):
"""Find previous occurence"""
return self.find(changed=False, forward=False)
def text_has_changed(self, text):
"""Find text has changed"""
self.find(changed=True, forward=True)
def find(self, changed=True, forward=True):
"""Call the find function"""
text = self.search_text.currentText()
if len(text) == 0:
self.search_text.lineEdit().setStyleSheet("")
return None
else:
found = self.editor.find_text(
text, changed, forward, case=self.case_check.isChecked(), words=self.words_check.isChecked()
)
self.search_text.lineEdit().setStyleSheet(self.STYLE[found])
return found
def replace_find(self):
"""Replace and find"""
if self.editor is not None:
replace_text = self.replace_text.currentText()
search_text = self.search_text.currentText()
first = True
while True:
if first:
# First found
if self.editor.hasSelectedText() and self.editor.selectedText() == search_text:
# Text was already found, do nothing
pass
else:
if not self.find(changed=False, forward=True):
break
first = False
wrapped = False
position = self.editor.get_position("cursor")
position0 = position
else:
position1 = self.editor.get_position("cursor")
if wrapped:
if position1 == position or self.editor.is_position_sup(position1, position):
# Avoid infinite loop: replace string includes
# part of the search string
break
if position1 == position0:
# Avoid infinite loop: single found occurence
break
if self.editor.is_position_inf(position1, position0):
wrapped = True
position0 = position1
self.editor.replace(replace_text)
if not self.find_next():
break
if not self.all_check.isChecked():
break
self.all_check.setCheckState(Qt.Unchecked)
