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)