Ejemplo n.º 1
0
 def __init__(self, parent, channels, refls):
   QDialog.__init__(self, parent)
   Reducer.__init__(self, parent, channels, refls)
   self.ui=UiReduction()
   self.ui.setupUi(self)
   self.ui.directoryEntry.setText(paths.results)
   self.ui.fileNameEntry.setText(paths.export_name)
   self.set_email_texts()
   for i in range(4):
     checkbutton=getattr(self.ui, 'export_'+str(i))
     if len(self.channels)>i:
       checkbutton.setText(self.channels[i])
     else:
       checkbutton.setEnabled(False)
       checkbutton.hide()
   if ('++' in self.channels and '--' in self.channels) or (
       '+' in self.channels and '-' in self.channels):
     self.ui.export_SA.setEnabled(True)
   if FROM_MANTID:
     self.ui.mantidplot.setEnabled(True)
   for key, value in export.items(): #@UndefinedVariable
     option=getattr(self.ui, key)
     if hasattr(option, 'setChecked'):
       option.setChecked(value)
     elif hasattr(option, 'setValue'):
       option.setValue(value)
     else:
       option.setText(value)
Ejemplo n.º 2
0
    def __init__(self, item, parent=None):
        QDialog.__init__(self, parent)
        self.item = item
        self.setupUi(self)

        self.db = self.item.database()
        self.schemas = self.db.schemas()
        self.hasSchemas = self.schemas is not None

        self.connect(self.buttonBox, SIGNAL("accepted()"), self.onOK)
        self.connect(self.buttonBox, SIGNAL("helpRequested()"), self.showHelp)

        self.populateSchemas()
        self.populateTables()

        if isinstance(item, Table):
            index = self.cboTable.findText(self.item.name)
            if index >= 0:
                self.cboTable.setCurrentIndex(index)

        self.connect(self.cboSchema, SIGNAL("currentIndexChanged(int)"), self.populateTables)

        # updates of SQL window
        self.connect(self.cboSchema, SIGNAL("currentIndexChanged(int)"), self.updateSql)
        self.connect(self.cboTable, SIGNAL("currentIndexChanged(int)"), self.updateSql)
        self.connect(self.chkCreateCurrent, SIGNAL("stateChanged(int)"), self.updateSql)
        self.connect(self.editPkey, SIGNAL("textChanged(const QString &)"), self.updateSql)
        self.connect(self.editStart, SIGNAL("textChanged(const QString &)"), self.updateSql)
        self.connect(self.editEnd, SIGNAL("textChanged(const QString &)"), self.updateSql)

        self.updateSql()
Ejemplo n.º 3
0
 def __init__(self, *args):
     QDialog.__init__(self, *args)
     self.setWindowFlags(self.windowFlags() | Qt.CustomizeWindowHint)
     self.setupUi(self)
     if self.style().metaObject().className() != "QMacStyle":
         self.buttonBox.setStyleSheet("")
     self.setFixedSize(self.size())
Ejemplo n.º 4
0
    def __init__(self, pathProjects, parent=None):
        #pathProjects must be a list
        QDialog.__init__(self, parent)
        self.setWindowTitle(self.tr("Add File to Project"))
        self.pathSelected = ''
        vbox = QVBoxLayout(self)

        self._tree = QTreeWidget()
        self._tree.header().setHidden(True)
        self._tree.setSelectionMode(QTreeWidget.SingleSelection)
        self._tree.setAnimated(True)
        vbox.addWidget(self._tree)
        hbox = QHBoxLayout()
        btnAdd = QPushButton(self.tr("Add here!"))
        btnCancel = QPushButton(self.tr("Cancel"))
        hbox.addWidget(btnCancel)
        hbox.addWidget(btnAdd)
        vbox.addLayout(hbox)
        #load folders
        self._root = None
        for pathProject in pathProjects:
            folderStructure = file_manager.open_project(pathProject)
            self._load_project(folderStructure, pathProject)

        self.connect(btnCancel, SIGNAL("clicked()"), self.close)
        self.connect(btnAdd, SIGNAL("clicked()"), self._select_path)
Ejemplo n.º 5
0
    def __init__(self, parent, lookup_entity_name, profile=None):
        """
        Initializes LookupValueSelector.
        :param parent: The parent of the dialog.
        :type parent: QWidget
        :param lookup_entity_name: The lookup entity name
        :type lookup_entity_name: String
        :param profile: The current profile object
        :type profile: Object
        """
        QDialog.__init__(self, parent, Qt.WindowTitleHint |
                         Qt.WindowCloseButtonHint)
        self.setupUi(self)
        self.value_and_code = None
        if profile is None:
            self._profile = current_profile()
        else:
            self._profile = profile

        self.lookup_entity = self._profile.entity_by_name(
            '{}_{}'.format(self._profile.prefix, lookup_entity_name)
        )

        self.notice = NotificationBar(self.notice_bar)
        self._view_model = QStandardItemModel()
        self.value_list_box.setModel(self._view_model)
        header_item = QStandardItem(lookup_entity_name)
        self._view_model.setHorizontalHeaderItem(0, header_item)
        self.populate_value_list_view()

        self.selected_code = None
        self.selected_value_code = None

        self.value_list_box.clicked.connect(self.validate_selected_code)
Ejemplo n.º 6
0
Archivo: gui.py Proyecto: jianlins/lpfw
    def __init__(self, direction):
        self.dns_lookup_id = 0  
        QDialog.__init__(self)
        self.setupUi(self)
        if (direction == 'OUT'):
            text = 'is trying to connect to'
        if (direction == 'IN'):
            text = 'is being connected to from'
        self.setWindowTitle("Leopard Flower firewall")
        self.label_text.setText(text)
        self.pushButton_allow.clicked.connect(self.allowClicked)
        self.pushButton_deny.clicked.connect(self.denyClicked)
        self.pushButton_hide.setVisible(False)
        self.tableWidget_details.setVisible(False)
        self.rejected.connect(self.escapePressed)
        self.finished.connect(self.dialogFinished)

        fullpath_text = QTableWidgetItem("Full path")
        self.tableWidget_details.setItem(0,0,fullpath_text)
        pid_text = QTableWidgetItem("Process ID")
        self.tableWidget_details.setItem(1,0,pid_text)
        remoteip_text = QTableWidgetItem("Remote IP")
        self.tableWidget_details.setItem(2,0,remoteip_text)
        remotedomain_text = QTableWidgetItem("Remote domain")
        self.tableWidget_details.setItem(3,0,remotedomain_text)
        remoteport_text = QTableWidgetItem("Remote port")
        self.tableWidget_details.setItem(4,0,remoteport_text)
        localport_text = QTableWidgetItem("Local port")
        self.tableWidget_details.setItem(5,0,localport_text)
        #make the incoming dialog stand out. It is not common to receive incoming connections
        if (direction == 'IN'):
            pal = QPalette()
            col = QColor(255, 0, 0, 127)
            pal.setColor(QPalette.Window, col)
            self.setPalette(pal)
Ejemplo n.º 7
0
 def __init__(self, *args):
     QDialog.__init__(self, *args)
     self.setupUi(self)
     self.fileNameEdit.addAction(self.actionCopy)
     self.connect(self.chooseFileButton, SIGNAL("clicked()"), self.chooseFile)
     self.allowedFileTypes = ""
     self._fileName = None
Ejemplo n.º 8
0
    def __init__(self, server_data, server_version, version, parent = None):
        QDialog.__init__(self, parent)
        self.ui = Stat.Ui_Dialog()
        self.ui.setupUi(self)

        self.ui.closeDialog.clicked.connect(self.close)

        self.ui.appVer.setText(version)

        self.ui.server_name.setText(server_data["site"]["name"])
        self.ui.server_address.setText(server_data["site"]["server"])
        self.ui.sn_version.setText(server_version)
        self.ui.dent_size.setText(server_data["site"]["textlimit"] + " characters")
        if server_data["attachments"]["uploads"]:
            upload_status = "Enabled"
            file_size = str(server_data["attachments"]["file_quota"] / 1024) + " KBytes"
            self.ui.max_file_size.setText(str(file_size))
        else:
            upload_status = "Disabled"
            self.ui.max_file_size.setText("Unknown")
        self.ui.uploads_status.setText(upload_status)
        
        server_type = ""
        
        if server_data["site"]["closed"] == "1":
            server_type += "Registrations closed"
        if server_data["site"]["inviteonly"] == "1":
            server_type += ", Inviation only"
        if server_data["site"]["private"] == "1":
            server_type += ", No anonymous reading"
            
        self.ui.server_type.setText(server_type)
Ejemplo n.º 9
0
    def __init__(self, parent, repo, packages=[], components=[]):
        QDialog.__init__(self, parent)
        self.setupUi(self)

        # Package repository
        self.repo = repo

        # Selected packages/components
        self.packages = packages
        self.components = components
        self.all_packages = []

        # Search widget
        self.connect(self.searchPackage, SIGNAL("textChanged(const QString &)"), self.slotSearchPackage)

        # Ok/cancel buttons
        self.connect(self.buttonBox, SIGNAL("accepted()"), self.accept)
        self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)

        # Filter combo
        self.connect(self.comboFilter, SIGNAL("currentIndexChanged(int)"), self.slotComboFilter)

        # Package/Component changes
        self.connect(self.treeComponents, SIGNAL("currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *)"), self.slotSelectComponent)
        self.connect(self.treeComponents, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.slotClickComponent)
        self.connect(self.treePackages, SIGNAL("currentItemChanged(QTreeWidgetItem *,QTreeWidgetItem *)"), self.slotSelectPackage)
        self.connect(self.treePackages, SIGNAL("itemClicked(QTreeWidgetItem *, int)"), self.slotClickPackage)

        # Go go go!
        self.initialize()
Ejemplo n.º 10
0
    def __init__(self, parent=None):
        """Constructor for the dialog.

        Show the grid converter dialog.

        :param parent: parent - widget to use as parent.
        :type parent: QWidget

        """
        QDialog.__init__(self, parent)
        self.parent = parent
        self.setupUi(self)
        self.setWindowTitle(
            self.tr('InaSAFE %s Shakemap Converter' % get_version()))
        self.warning_text = set()
        self.on_input_path_textChanged()
        self.on_output_path_textChanged()
        self.update_warning()

        # Event register
        # noinspection PyUnresolvedReferences
        self.use_output_default.toggled.connect(
            self.get_output_from_input)
        # noinspection PyUnresolvedReferences
        self.input_path.textChanged.connect(self.on_input_path_textChanged)
        # noinspection PyUnresolvedReferences
        self.output_path.textChanged.connect(self.on_output_path_textChanged)

        # Set up things for context help
        self.help_button = self.button_box.button(QtGui.QDialogButtonBox.Help)
        # Allow toggling the help button
        self.help_button.setCheckable(True)
        self.help_button.toggled.connect(self.help_toggled)
        self.main_stacked_widget.setCurrentIndex(1)
Ejemplo n.º 11
0
    def __init__(self, parent=None, **kwargs):
        QDialog.__init__(self, parent, **kwargs)

        if sys.platform == "darwin":
            self.setAttribute(Qt.WA_MacSmallSize, True)

        self.__setupUi()
Ejemplo n.º 12
0
    def __init__(self, parent, titre, contenu, fonction_modif):
        QDialog.__init__(self, parent)
        self.setWindowTitle(titre)
        sizer = QVBoxLayout()
        self.parent = parent
        self.fonction_modif = fonction_modif
        self.texte = PythonSTC(self)
#        self.texte.setMinimumSize(300, 10)
        self.texte.setText(contenu)
##        self.texte.SetInsertionPointEnd()
        sizer.addWidget(self.texte)

        boutons = QHBoxLayout()
        self.btn_modif = QPushButton(u"Modifier - F5")
        boutons.addWidget(self.btn_modif)
        self.btn_esc = QPushButton(u"Annuler - ESC")
        boutons.addStretch()
        boutons.addWidget(self.btn_esc)
        sizer.addLayout(boutons)
        self.setLayout(sizer)

        self.btn_modif.clicked.connect(self.executer)
        self.btn_esc.clicked.connect(self.close)

        self.setMinimumSize(400, 500)
        self.texte.setFocus()
Ejemplo n.º 13
0
 def accept(self):
     self.selectedoptions = []
     model = self.lstLayers.model()
     for i in xrange(model.rowCount()):
         item = model.item(i)
         self.selectedoptions.append(item.text())
     QDialog.accept(self)
Ejemplo n.º 14
0
    def __init__(self, project, parent=None):
        QDialog.__init__(self, parent, Qt.Dialog)
        self.project = project
        self.setWindowTitle(translations.TR_PROJECT_PROPERTIES)
        self.resize(600, 500)
        vbox = QVBoxLayout(self)
        self.tab_widget = QTabWidget()
        self.projectData = ProjectData(self)
        self.projectExecution = ProjectExecution(self)
        self.projectMetadata = ProjectMetadata(self)
        self.tab_widget.addTab(self.projectData, translations.TR_PROJECT_DATA)
        self.tab_widget.addTab(self.projectExecution,
            translations.TR_PROJECT_EXECUTION)
        self.tab_widget.addTab(self.projectMetadata,
            translations.TR_PROJECT_METADATA)

        vbox.addWidget(self.tab_widget)
        self.btnSave = QPushButton(translations.TR_SAVE)
        self.btnCancel = QPushButton(translations.TR_CANCEL)
        hbox = QHBoxLayout()
        hbox.addWidget(self.btnCancel)
        hbox.addWidget(self.btnSave)

        vbox.addLayout(hbox)

        self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
        self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
Ejemplo n.º 15
0
    def __init__(self, featureDict, selectedFeatures=None, parent=None, ndim=3):
        """
        Parameters:
        * featureDict: a nested dictionary. {plugin name : {feature name : {parameter name : parameter}}
        * selectedDict: like featureDict. entries will be checked and their parameters populated.

        """
        QDialog.__init__(self, parent)
        self.featureDict = featureDict
        if selectedFeatures is None or len(selectedFeatures) == 0:
            selectedFeatures = defaultdict(list)
        self.selectedFeatures = selectedFeatures
        self.setWindowTitle("Object Features")
        ui_class, widget_class = uic.loadUiType(os.path.split(__file__)[0] + "/featureSelection.ui")
        self.ui = ui_class()
        self.ui.setupUi(self)
        self.ui.buttonBox.accepted.connect(self.accept)
        self.ui.buttonBox.rejected.connect(self.reject)

        self.ui.allButton.pressed.connect(self.handleAll)
        self.ui.noneButton.pressed.connect(self.handleNone)

        self.populate()
        self.ndim = ndim
        
        self.set_margin()
        self.setObjectName("FeatureSelectionDialog")
Ejemplo n.º 16
0
    def __init__(self, parent = None, tabIndex = 0):
        QDialog.__init__(self, parent)

        self.ui = Ui_Settings()
        self.ui.setupUi(self)
        self.ui.tabWidget.setCurrentIndex(tabIndex)
        self.initSettings()
Ejemplo n.º 17
0
    def show(self, webPages):
        settings = Settings()
        server = xmlrpclib.Server(settings.serverAddress)

        self.setWindowTitle('updates')

        layout = self.layout()
        if layout == None:
            layout = QVBoxLayout()

        label = QLabel('Some Web Pages have changed:')
        layout.addWidget(label)

        for webPage in webPages:
            label = QLabel('<a href=' + webPage + '>' + self._truncate(webPage) + '</a>' )
            label.setOpenExternalLinks(True)
            layout.addWidget(label)

        #buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
        moreButton = QPushButton('More...')
        moreButton.setMaximumWidth(60)
        self.connect(moreButton, SIGNAL('clicked()'), self.showDiffWindow)
        layout.addWidget(moreButton)

        self.setLayout(layout)

        if debug.verbose:
            print('DEBUG: Showing notification dialog')
        QDialog.show(self)

        QTimer.singleShot(0, self.fixPosition)
        QTimer.singleShot(self._timeout, self.hide)
Ejemplo n.º 18
0
 def __init__(self, parent=None):
     QDialog.__init__(self)
     Ui_Dialog.__init__(self)
     self.setupUi(self)
     self.flag = False
     self.pushButton_save_path.clicked.connect(self.set_save_path)
     self.lineEdit_save_path.setText(basedir)
Ejemplo n.º 19
0
    def __init__(self, parent=None):
        """Constructor for the dialog.

        Show the grid converter dialog.

        :param parent: parent - widget to use as parent.
        :type parent: QWidget

        """
        QDialog.__init__(self, parent)
        self.parent = parent
        self.setupUi(self)
        self.setWindowTitle(self.tr('InaSAFE %1 Converter').arg(
            get_version()))

        self.warning_text = set()
        self.on_leInputPath_textChanged()
        self.on_leOutputPath_textChanged()
        self.update_warning()

        # Event register
        QObject.connect(self.cBDefaultOutputLocation,
                        SIGNAL('toggled(bool)'),
                        self.get_output_from_input)
        QObject.connect(self.leInputPath,
                        SIGNAL('textChanged(QString)'),
                        self.on_leInputPath_textChanged)
        QObject.connect(self.leOutputPath,
                        SIGNAL('textChanged(QString)'),
                        self.on_leOutputPath_textChanged)

        self.show_info()
Ejemplo n.º 20
0
 def __init__(self, options, title, text, resultReceiver):
 	
     QDialog.__init__(self)
     self.options = options
     self.resultReceiver = resultReceiver
     
     self.resize(250, 60)
     self.setWindowTitle(title)
     self.setModal(True)
     self.setSizeGripEnabled(False)
     label = QLabel(text)
     
     grid = QGridLayout()
     grid.setSpacing(10)
     
     grid.addWidget(label, 0, 0, 1, len(options))
     
     position = 0
     for option in options:
         button = QPushButton(option)
         receiver = lambda item = option: self.chooseOption(item)
         self.connect(button, SIGNAL('clicked()'), receiver)
         
         grid.addWidget(button, 1, position)
         position += 1
     
     self.setLayout(grid)
     self.show()
Ejemplo n.º 21
0
 def __init__(self, parent):
     QDialog.__init__(self, parent)
     self.resize(300, 75)
     self.setWindowTitle("Updating")
     self.vw = QWidget(self)
     self.vl = QVBoxLayout(self.vw)
     self.vl.setMargin(10)
     self.label = QLabel(self.vw)
     self.label.setText("<b>Downloading:</b> library.zip")
     self.vl.addWidget(self.label)
     self.horizontalLayoutWidget = QWidget()
     self.horizontalLayout = QHBoxLayout(self.horizontalLayoutWidget)
     self.horizontalLayout.setMargin(0)
     self.progressbar = QProgressBar(self.horizontalLayoutWidget)
     self.progressbar.setFixedWidth(260)
     self.progressbar.setMinimum(0)
     self.progressbar.setMaximum(100)
     self.stopButton = QPushButton(self.horizontalLayoutWidget)
     self.stopButton.setFlat(True)
     self.stopButton.setIcon(Icons.stop)
     self.stopButton.setFixedSize(16,16)
     self.horizontalLayout.addWidget(self.progressbar)
     self.horizontalLayout.addWidget(self.stopButton)
     self.vl.addWidget(self.horizontalLayoutWidget)
     self.stopButton.clicked.connect(self.forceStop)
Ejemplo n.º 22
0
    def __init__(self, item, parent=None):
        QDialog.__init__(self, parent, Qt.Dialog)
        self._item = item
        self.setWindowTitle(self.tr("Project Properties"))
        vbox = QVBoxLayout(self)
        self.tab_widget = QTabWidget()
        self.projectData = ProjectData(self)
        self.projectExecution = ProjectExecution(self)
        self.projectMetadata = ProjectMetadata(self)
        self.tab_widget.addTab(self.projectData, self.tr("Project Data"))
        self.tab_widget.addTab(self.projectExecution,
            self.tr("Project Execution"))
        self.tab_widget.addTab(self.projectMetadata,
            self.tr("Project Metadata"))

        vbox.addWidget(self.tab_widget)
        self.btnSave = QPushButton(self.tr("Save"))
        self.btnCancel = QPushButton(self.tr("Cancel"))
        hbox = QHBoxLayout()
        hbox.addWidget(self.btnCancel)
        hbox.addWidget(self.btnSave)

        vbox.addLayout(hbox)

        self.connect(self.btnCancel, SIGNAL("clicked()"), self.close)
        self.connect(self.btnSave, SIGNAL("clicked()"), self.save_properties)
Ejemplo n.º 23
0
    def __init__(self, parent=None):
        QDialog.__init__(self, parent, Qt.Dialog)
        self.setWindowTitle(self.tr("About SIDE-C"))
        self.setMaximumSize(QSize(0, 0))
        

        vbox = QVBoxLayout(self)

        #Create an icon for the Dialog
        # pixmap = QPixmap(":img/icon")
        # self.lblIcon = QLabel()
        # self.lblIcon.setPixmap(pixmap)

        hbox = QHBoxLayout()
        # hbox.addWidget(self.lblIcon)

        lblTitle = QLabel(
                '<h1>SIDE - C</h1>\n<i>Simple Integrated Development Environment for C<i>')
        lblTitle.setTextFormat(Qt.RichText)
        lblTitle.setAlignment(Qt.AlignLeft)
        hbox.addWidget(lblTitle)
        vbox.addLayout(hbox)
        #Add description
        vbox.addWidget(QLabel(
self.tr("""ALGO ACA""")))
        vbox.addWidget(QLabel("Hola"))
        link_ninja = QLabel(
            self.tr('Website: '))
        vbox.addWidget(link_ninja)
        link_source = QLabel(
            self.tr('Source Code'))
        vbox.addWidget(link_source)
Ejemplo n.º 24
0
    def __init__(self, parent=None, updateMainSignal = None, recDataSignal = None, toPickSignal = None, sendOrderSignal = None):
        """
        Constructor
        
        @param parent reference to the parent widget
        @type QWidget
        """
        QDialog.__init__(self, parent)

        self.setupUi(self)
        #SIGNALS used to update main window
        self.updateMainSignal = updateMainSignal
        #SIGNALS used to receive data
        self.toYingyanFuncSignal = recDataSignal
        self.toYingyanFuncSignal.connect(self.ExtractCommandData)
        #发送至pickFunc
        self.toPickPointSignal= toPickSignal
        #发送socket命令
        self.sendOrderSignal = sendOrderSignal

        #故障信息存储文件
        import os
        PATH = '/'.join(os.getcwd().split('\\'))
        self.errorFile = PATH + '/ErrorInfo/BugInfo-'+'-'.join(time.ctime().split(' ')).replace(':','-',10) +'.dat'
        try:
            with open(self.errorFile, 'a') as errorFile:
                errorFile.write('<Error File created at ' + time.ctime()+'>\n')
        except Exception as e:
            print ('error in creating errorFile:' ,e.message, 'please reopen the program')

        #upload data to BAIDU
        self.uploader = GpsUploader(updateMainSignal=updateMainSignal,toPickPointSignal= toPickSignal)
Ejemplo n.º 25
0
    def __init__(self, parent, objets, islabel = False):
        u"Le paramètre 'label' indique si l'objet à éditer est un label"
        print "OBJETS:"
        print objets
        print unicode(objets[0])
        print repr(objets[0])
        print objets[0].__class__
        print isinstance(objets[0], str)
        objets[0].titre_complet("du", False)
        self.parent = parent
        self.islabel = islabel
        self.fenetre_principale = self.parent.window()
        self.panel = self.fenetre_principale.onglets.onglet_actuel
        self.canvas = self.panel.canvas

        self.objets = objets
        if self.islabel:
            titre = u"du label"
        else:
            if len(objets) == 0:
                self.close()
            if len(objets) == 1:
                titre = objets[0].titre_complet("du", False)
            else:
                titre = u"des objets"
#        wx.MiniFrame.__init__(self, parent, -1, u"Propriétés " + titre, style=wx.DEFAULT_FRAME_STYLE | wx.TINY_CAPTION_HORIZ)
        QDialog.__init__(self, parent)
        self.setWindowTitle(u"Propriétés " + titre)
        self.setPalette(white_palette)
        ##self.SetExtraStyle(wx.WS_EX_BLOCK_EVENTS )
        main = QVBoxLayout()
        self.setLayout(main)
        self.onglets = OngletsProprietes(self)
        main.addWidget(self.onglets)
Ejemplo n.º 26
0
 def __init__(self, thread, parent):
     QDialog.__init__(self, parent)
     self.ui = Ui_PlotPreview()
     self.ui.setupUi(self)
     self.parent = parent
     icon = QIcon()
     icon.addPixmap(QPixmap(":/icons/reload.png"), QIcon.Normal, QIcon.Off)
     self.update_btn = QPushButton(icon, "Update")
     self.ui.buttonBox.addButton(self.update_btn, QDialogButtonBox.ApplyRole)
     self.update_btn.clicked.connect(self.render_image)
     self._pix = None
     self._image_list = None
     self._thread = thread
     self.scene = QGraphicsScene()
     self.scene.setSceneRect(0,0,1,1)
     self.ui.imageView.setScene(self.scene)
     self.pix_item = None
     self.ui.imageView.setEnabled(False)
     self.ui.imageView.setInteractive(False)
     self.ui.imageView.setDragMode(QGraphicsView.ScrollHandDrag)
     self.pic_w = None
     self.pic_c = None
     self.show_pic_w = None
     self.show_pic_c = None
     timer = QTimer(self)
     timer.setSingleShot(True)
     timer.setInterval(500)
     self.timer = timer
     timer.timeout.connect(self.render_image)
     if parameters.instance.use_OpenGL:
         self.ui.imageView.setViewport(QGLWidget(QGLFormat(QGL.SampleBuffers)))
Ejemplo n.º 27
0
    def __init__(self, title, widget, parent=None):
        QDialog.__init__(self, parent)

        self.setWindowTitle(title)
        self.setModal(True)
        self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint)
        self.setWindowFlags(self.windowFlags() & ~Qt.WindowCloseButtonHint)
        self.setWindowFlags(self.windowFlags() & ~Qt.WindowCancelButtonHint)


        layout = QVBoxLayout()
        layout.setSizeConstraint(QLayout.SetFixedSize) # not resizable!!!
        layout.addWidget(widget)

        self.__button_layout = QHBoxLayout()
        self.close_button = QPushButton("Close")
        self.close_button.setObjectName("CLOSE")
        self.close_button.clicked.connect(self.accept)
        self.__button_layout.addStretch()
        self.__button_layout.addWidget(self.close_button)

        layout.addStretch()
        layout.addLayout(self.__button_layout)

        self.setLayout(layout)
Ejemplo n.º 28
0
    def __init__(self, parent):
        QDialog.__init__(self, parent)
        self._createdObjects = []
        self._pageForItem = {}

        from PyQt4 import uic  # lazy import for better startup performance
        uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/UISettings.ui'), self)
        self.swPages.setCurrentIndex(0)
        
        self.setAttribute( Qt.WA_DeleteOnClose )

        # Expand all tree widget items
        self._pageForItem.update (  {u"General": self.pGeneral,
                                     u"File associations": self.pAssociations,
                                     u"Editor": self.pEditorGeneral,
                                     u"Editor/Auto completion": self.pAutoCompletion,
                                     u"Editor/Colours": self.pColours,
                                     u"Editor/Indentation": self.pIndentation,
                                     u"Editor/Brace matching": self.pBraceMatching,
                                     u"Editor/Edge": self.pEdgeMode,
                                     u"Editor/Caret": self.pCaret,
                                     u"Editor/EOL": self.pEditorVisibility,
                                     u"Modes": self.pModes})
        
        # resize to minimum size
        self.resize( self.sizeHint() )
Ejemplo n.º 29
0
    def __init__(self, layers):
        """
        Constructor
        """
        QDialog.__init__(self)
        self.__layers = layers
        self.setWindowTitle(QCoreApplication.translate("VDLTools", "Edition Confirmation"))
        self.__layout = QGridLayout()

        titleLabel = QLabel(QCoreApplication.translate("VDLTools", "Do you really want to edit these layers ?"))
        self.__layout.addWidget(titleLabel, 0, 0, 1, 2)

        pos = 1
        for layer in self.__layers:
            label = QLabel(" - " + layer.name())
            self.__layout.addWidget(label, pos, 0, 1, 2)
            pos += 1

        self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
        self.__cancelButton.setMinimumHeight(20)
        self.__cancelButton.setMinimumWidth(100)

        pos = len(self.__layers) + 1
        self.__layout.addWidget(self.__cancelButton, pos, 0)

        self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK"))
        self.__okButton.setMinimumHeight(20)
        self.__okButton.setMinimumWidth(100)
        self.__layout.addWidget(self.__okButton, pos, 1)


        self.setLayout(self.__layout)
Ejemplo n.º 30
0
 def keyPressEvent(self, e):
     """Handle default key actions or pass the event to the inherited method
     """
     if (int(e.modifiers()), e.key()) in OWWidget.defaultKeyActions:
         OWWidget.defaultKeyActions[int(e.modifiers()), e.key()](self)
     else:
         QDialog.keyPressEvent(self, e)
Ejemplo n.º 31
0
Archivo: prefs.py Proyecto: nyov/kodos
 def accept(self):
     self.apply_slot()
     QDialog.accept(self)
Ejemplo n.º 32
0
 def closeEvent(self, event):
     """Overloaded to save the geometry when the widget is closed
     """
     if self.save_position and self.isVisible():
         self.__updateSavedGeometry()
     QDialog.closeEvent(self, event)
Ejemplo n.º 33
0
 def hideEvent(self, event):
     """Overloaded to save the geometry when the widget is hidden
     """
     if self.save_position:
         self.__updateSavedGeometry()
     QDialog.hideEvent(self, event)
Ejemplo n.º 34
0
    def create_account_dialog(self):
        def coinapult_signup():
            try:
                self.client.createAccount(createLocalKeys=True, changeAuthMethod=True, tag="electrum-gfk36")
                self.client.activateAccount(agree=True)
            except (CoinapultError, CoinapultErrorECC) as ce:
                QMessageBox.warning(None, _("Unable to create Coinapult account because %s" % str(ce),
                                            QString(_("OK"))))

        def signup_done(result):
            self.ca_ok_button.setDisabled(False)
            self.wallet.storage.put("coinapult_ecc_public", str(self.client.ecc_pub_pem))
            self.ecc_pub_key_edit.setText(self.client.ecc_pub_pem)
            self.wallet.storage.put("coinapult_ecc_private", str(self.client.ecc['privkey'].to_pem()))
            self.ecc_priv_key_edit.setText(str(self.client.ecc['privkey'].to_pem()))
            self.config.set_key('coinapult_auth_method', 'ECC', True)
            ecc_pub = self.wallet.storage.get("coinapult_ecc_public", '')
            ecc_priv = self.wallet.storage.get("coinapult_ecc_private", '')
            try:
                self.client = CoinapultClient(ecc={'pubkey': ecc_pub, 'privkey': ecc_priv}, authmethod='ecc')
            except (CoinapultError, CoinapultErrorECC):
                self.client = None
                QMessageBox.warning(None, _('Coinapult Connection failed'),
                                    _('Failed to connect to Coinapult. Locks disabled for this session.'), _('OK'))
            d.accept()

        def on_change_tos(checked):
            if checked:
                self.config.set_key('plugin_coinapult_locks_tos', 'checked')
            else:
                self.config.set_key('plugin_coinapult_locks_tos', 'unchecked')

        def ok_clicked():
            if self.agreed_tos():
                self.ca_ok_button.setDisabled(True)
                self.waiting_dialog = WaitingDialog(d, 'Creating your Coinapult account. One moment please...',
                                                    coinapult_signup, signup_done)
                self.waiting_dialog.start()

        d = QDialog()
        d.setWindowTitle("Create Coinapult Account")
        layout = QGridLayout(d)

        # lable = None
        text_edit = QPlainTextEdit()
        text = open(os.path.dirname(__file__) + '/lib/TERMS.txt').read()
        text_edit.setPlainText(text)
        layout.addWidget(text_edit, 0, 0)
        layout.setRowStretch(0, 8)

        layout.addWidget(QLabel(_("Do you agree to Coinapult's Terms of Service (https://coinapult.com/terms)?: ")),
                         3, 0)
        tos_checkbox = QCheckBox()
        tos_checkbox.setEnabled(True)
        tos_checkbox.setChecked(self.config.get('plugin_coinapult_locks_tos', 'unchecked') != 'unchecked')
        tos_checkbox.stateChanged.connect(on_change_tos)
        layout.addWidget(tos_checkbox, 3, 1)

        layout.addWidget(
            QLabel(_("<font color='red'>This will overwrite any Coinapult API keys in your wallet.<br>"
                     "If you do not have backups of your API keys, this will lock you out of your "  # TODO This isn't actually stored in the wallet yet...
                     "account!</font>")), 4, 0)

        self.ca_ok_button = QPushButton(_("OK"))
        self.ca_ok_button.clicked.connect(ok_clicked)
        layout.addWidget(self.ca_ok_button, 5, 1)

        if d.exec_():
            return True
        else:
            return False
Ejemplo n.º 35
0
    def settings_dialog(self):
        def check_for_api_key(api_key):
            if api_key and len(api_key) > 12:
                self.config.set_key("plugin_coinapult_locks_api_key", str(api_key))

        def check_for_api_secret(api_secret):
            if api_secret and len(api_secret) > 12:
                self.config.set_key("plugin_coinapult_locks_api_secret", str(api_secret))

        def check_for_ecc_pub_key(pub_key):
            if pub_key and len(pub_key) > 12:
                self.wallet.storage.put("coinapult_ecc_public", str(pub_key))

        def check_for_ecc_priv_key(priv_key):
            if priv_key and len(priv_key) > 12:
                self.wallet.storage.put("coinapult_ecc_private", str(priv_key))

        def ok_clicked():
            # check_for_api_key(self.api_key_edit.text())
            # check_for_api_secret(self.api_secret_edit.text())
            check_for_ecc_pub_key(self.ecc_pub_key_edit.toPlainText())
            check_for_ecc_priv_key(self.ecc_priv_key_edit.toPlainText())
            if self.agreed_tos():
                d.accept()
            else:
                self.disable()
                return False

        def on_change_auth_method(method):
            if method == 'REST':
                self.config.set_key('coinapult_auth_method', 'REST', True)
            else:
                self.config.set_key('coinapult_auth_method', 'ECC', True)

        d = QDialog()
        d.setMaximumWidth(600)
        d.setWindowTitle("Settings")
        layout = QGridLayout(d)
        layout.setColumnMinimumWidth(1, 200)
        layout.setHorizontalSpacing(20)

        about_locks_label = QLabel(ABOUT_LOCKS)
        about_locks_label.setWordWrap(True)
        about_locks_label.setOpenExternalLinks(True)
        layout.addWidget(about_locks_label, 0, 1, 5, 1, Qt.AlignRight)

        create_account_label = QLabel(_("If you wish to use Locks, and do not already have an account, "
                                        "click here to generate your ECC keys:"))
        create_account_label.setWordWrap(True)
        create_account_label.setOpenExternalLinks(True)
        layout.addWidget(create_account_label, 0, 0)

        create_account_button = QPushButton(_('Create Account'))
        create_account_button.setMaximumWidth(120)
        create_account_button.clicked.connect(self.create_account_dialog)
        layout.addWidget(create_account_button, 1, 0, Qt.AlignTop)

        warning_label = QLabel(_("If you already have a Coinapult account, simply paste your ECC credentials below."
                                 "<br><br>"
                                 "<font color='red'>WARNING Back up the keys below somewhere safe! If you overwrite "
                                 "them here, you could lose access to your Coinapult account.</font><br><br>"
                                 "ECC public key"))
        warning_label.setWordWrap(True)
        layout.addWidget(warning_label, 3, 0, Qt.AlignBottom)
        self.ecc_pub_key_edit = QTextEdit(self.wallet.storage.get("coinapult_ecc_public", ''))
        # self.ecc_pub_key_edit.textChanged.connect(check_for_ecc_pub_key)
        layout.addWidget(self.ecc_pub_key_edit, 4, 0, Qt.AlignTop)
        # layout.setRowStretch(2, 3)

        layout.addWidget(QLabel(_('ECC private key')), 5, 0, Qt.AlignBottom)
        self.ecc_priv_key_edit = QTextEdit("hidden")
        # self.ecc_priv_key_edit.textChanged.connect(check_for_ecc_priv_key)
        layout.addWidget(self.ecc_priv_key_edit, 6, 0, Qt.AlignTop)
        # layout.setRowStretch(2, 3)

        ## Rest Layout
        # layout.addWidget(QLabel(_('Coinapult API key: ')), 0, 0)
        # self.api_key_edit = QLineEdit(self.api_key())
        # self.api_key_edit.textChanged.connect(check_for_api_key)
        # layout.addWidget(self.api_key_edit, 0, 1, 1, 2)
        #
        # layout.addWidget(QLabel(_('Coinapult API secret: ')), 1, 0)
        # self.api_secret_edit = QLineEdit("hidden")
        # self.api_key_edit.textChanged.connect(check_for_api_secret)
        # layout.addWidget(self.api_secret_edit, 1, 1, 1, 2)

        ok_button = QPushButton(_("OK"))
        ok_button.setMaximumWidth(50)
        ok_button.clicked.connect(lambda: ok_clicked())
        layout.addWidget(ok_button, 7, 0)

        if d.exec_():
            return True
        else:
            return False
Ejemplo n.º 36
0
        y = FractionSlider.YMARGIN - 0.5
        triangle = [QPointF(value * span, y),
                    QPointF((value * span) +
                            (2 * FractionSlider.XMARGIN), y),
                    QPointF((value * span) +
                            FractionSlider.XMARGIN, fm.height())]
        painter.setPen(Qt.yellow)
        painter.setBrush(Qt.darkYellow)
        painter.drawPolygon(QPolygonF(triangle))


if __name__ == "__main__":
    import sys

    app = QApplication(sys.argv)
    form = QDialog()
    sliderLabel = QLabel("&Fraction")
    slider = FractionSlider(denominator=12)
    sliderLabel.setBuddy(slider)
    denominatorLabel = QLabel("&Denominator")
    denominatorSpinBox = QSpinBox()
    denominatorLabel.setBuddy(denominatorSpinBox)
    denominatorSpinBox.setRange(3, 60)
    denominatorSpinBox.setValue(slider.fraction()[1])
    denominatorSpinBox.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
    numeratorLabel = QLabel("Numerator")
    numeratorLCD = QLCDNumber()
    numeratorLCD.setSegmentStyle(QLCDNumber.Flat)
    layout = QGridLayout()
    layout.addWidget(sliderLabel, 0, 0)
    layout.addWidget(slider, 0, 1, 1, 5)
Ejemplo n.º 37
0
    def __init__(self, parent=None, bool_0=None):
        QDialog.__init__(self, parent)

        self.resize(100, 70)
        self.setWindowTitle("QA Entry")
        sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
        self.setSizePolicy(sizePolicy)
        verticalLayoutDlg = QVBoxLayout(self)
        verticalLayoutDlg.setObjectName(("verticalLayoutDlg"))

        self.groupBox = GroupBox(self)
        self.groupBox.Caption = ""
        verticalLayoutDlg.addWidget(self.groupBox)

        # self.lblHeading = TextBoxPanel(self.groupBox)
        # self.lblHeading.Enabled = False
        # self.lblHeading.Caption = "Title"
        # self.lblHeading.LabelWidth = 120
        # self.groupBox.Add = self.lblHeading

        self.txtHeading = TextBoxPanel(self.groupBox)
        self.txtHeading.Caption = "Title"
        self.txtHeading.LabelWidth = 120
        self.txtHeading.Width = 200
        self.groupBox.Add = self.txtHeading

        self.chbLimit = CheckBox(self.groupBox)
        self.chbLimit.Caption = "Limit # of table entries to"
        self.groupBox.Add = self.chbLimit

        self.gbColumns = GroupBox(self.groupBox)
        self.groupBox.Add = self.gbColumns

        self.lstColumns = CheckedListBox(self.gbColumns)
        self.gbColumns.Add = self.lstColumns

        self.txtLimit = TextBoxPanel(self.groupBox)
        self.txtLimit.Caption = ""
        self.txtLimit.LabelWidth = 0
        self.txtLimit.Width = 200
        # self.txtLimit.LabelWidth = 120
        self.chbLimit.hLayout.addWidget(self.txtLimit)

        self.chbIgnoreNA = CheckBox(self.groupBox)
        self.chbIgnoreNA.Caption = "Ignore columns containing \"N/A\" values"
        self.groupBox.Add = self.chbIgnoreNA

        self.btnBoxOkCancel = QDialogButtonBox(self)
        self.btnBoxOkCancel.setObjectName(("btnBoxOkCancel"))
        self.btnBoxOkCancel.setStandardButtons(QDialogButtonBox.Cancel
                                               | QDialogButtonBox.Ok)
        # btnOK = self.btnBoxOkCancel.button(QDialogButtonBox.Ok)
        # btnOK.setText("Create")
        self.connect(self.btnBoxOkCancel, SIGNAL("accepted()"), self.acceptDlg)
        self.connect(self.btnBoxOkCancel, SIGNAL("rejected()"), self.reject)

        verticalLayoutDlg.addWidget(self.btnBoxOkCancel)

        if bool_0 != None:
            if (bool_0):
                # int width = base.ClientSize.Width
                # System.Drawing.Size clientSize = base.ClientSize
                # base.ClientSize = new System.Drawing.Size(width, clientSize.Height - (this.gbColumns.Bottom - this.txtHeading.Bottom))
                self.chbLimit.Visible = False
                self.txtLimit.Visible = False
                self.chbIgnoreNA.Visible = False
                self.gbColumns.Visible = False
            self.connect(self.chbLimit, SIGNAL("Event_0"),
                         self.chbLimit_Event_0)
        else:
            DlgQaHeading.rowLimit = 10
            DlgQaHeading.ignoreNAcolumns = True
Ejemplo n.º 38
0
 def open_about(self):
     dial = QDialog()
     self.about = Ui_Dialog()
     self.about.setupUi(dial)
     dial.exec()
Ejemplo n.º 39
0
    def __init__(self, parent):
        QDialog.__init__(self, parent)
        self.ui = ui_PinSVisualSegmentDepDlg()
        self.ui.setupUi(self)
        self.surfaceType = SurfaceTypes.PinSVisualSegmentDep
        QgisHelper.matchingDialogSize(self, 700, 650)
        ''' UI State Initialize '''
        #         self.ui.btnOpenData.setDisabled(True)
        #         self.ui.btnSaveData.setDisabled(True)
        self.ui.btnExportResult.setDisabled(True)
        self.ui.btnEvaluate.setEnabled(False)
        self.ui.btnUpdateQA.setVisible(False)
        self.ui.btnUpdateQA_2.setVisible(False)

        self.pnlMCAH = MCAHPanel(self.ui.groupBox_20)
        self.pnlMCAH.lblMCAH.setText("Minimum (ft):")
        self.pnlMCAH.setValue(Altitude(500, AltitudeUnits.FT))
        self.ui.verticalLayout_5.insertWidget(4, self.pnlMCAH)
        self.ui.cmbSegmentType.Items = [
            PinsVisualSegmentType.Direct, PinsVisualSegmentType.Manoeuvring
        ]
        self.ui.cmbDepartureType.Items = [
            PinsOperationType.DayOnly, PinsOperationType.DayNight
        ]
        self.ui.cmbDepartureType.SelectedIndex = 1
        #         self.ui.cmbMCAH.addItems([MCAHType.MCA, MCAHType.MCH])
        self.ui.cmbDepartureType.Visible = False
        self.ui.txtTakeOffSurfaceTrack.Visible = False
        self.ui.frame_Limitation.hide()

        self.pnlHRP = PositionPanel(self.ui.grbIDF)
        self.pnlHRP.groupBox.setTitle("Heliport Reference point (HRP)")
        self.pnlHRP.btnCalculater.hide()
        self.pnlHRP.setObjectName("positionHRP")
        self.ui.verticalLayout_HRP.insertWidget(0, self.pnlHRP)
        self.connect(self.pnlHRP, SIGNAL("positionChanged"),
                     self.initResultPanel)

        self.pnlIDF = PositionPanel(self.ui.grbIDF)
        self.pnlIDF.groupBox.setTitle("")
        self.pnlIDF.hideframe_Altitude()
        self.pnlIDF.setObjectName("positionIDF")
        self.pnlIDF.btnCalculater.hide()
        self.ui.verticalLayout_IDF.insertWidget(0, self.pnlIDF)
        self.connect(self.pnlIDF, SIGNAL("positionChanged"),
                     self.initResultPanel)

        self.ui.cmbConstructionType.Items = [
            ConstructionType.Construct2D, ConstructionType.Construct3D
        ]
        self.ui.tblObstacles.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.ui.tblObstacles.setSortingEnabled(True)
        '''Event Handlers Connect'''
        self.ui.btnOpenData.clicked.connect(self.openData)
        self.ui.btnSaveData.clicked.connect(self.saveData)
        self.connect(self.ui.cmbSegmentType, SIGNAL("Event_0"),
                     self.chbLeftTurnProhibited_Click)
        self.connect(self.ui.cmbDepartureType, SIGNAL("Event_0"),
                     self.chbLeftTurnProhibited_Click)
        self.connect(self.ui.txtVSDG, SIGNAL("Event_0"),
                     self.chbLeftTurnProhibited_Click)
        self.connect(self.ui.txtTakeOffSurfaceTrack, SIGNAL("Event_0"),
                     self.chbLeftTurnProhibited_Click)
        # self.ui.btnCaptureSurfaceTrack.clicked.connect(self.method_39)
        self.ui.chbLeftTurnProhibited.clicked.connect(
            self.chbLeftTurnProhibited_Click)
        self.ui.chbRightTurnProhibited.clicked.connect(
            self.chbLeftTurnProhibited_Click)
        # self.ui.btnCaptureTrackFrom.clicked.connect(self.method_37)
        self.pnlIDF.txtPointX.textChanged.connect(
            self.chbLeftTurnProhibited_Click)
        self.pnlIDF.txtPointY.textChanged.connect(
            self.chbLeftTurnProhibited_Click)
        self.pnlHRP.txtPointX.textChanged.connect(
            self.chbLeftTurnProhibited_Click)
        self.pnlHRP.txtPointY.textChanged.connect(
            self.chbLeftTurnProhibited_Click)
        self.pnlHRP.txtAltitudeM.textChanged.connect(
            self.chbLeftTurnProhibited_Click)
        self.ui.btnClose.clicked.connect(self.reject)
        self.ui.btnClose_2.clicked.connect(self.reject)
        self.ui.btnConstruct.clicked.connect(self.btnConstruct_Click)
        self.ui.btnEvaluate.clicked.connect(self.btnEvaluate_Click)
        self.ui.cmbSurface.currentIndexChanged.connect(self.cmbSurfaceChanged)
        self.ui.btnExportResult.clicked.connect(self.exportResult)
        self.obstaclesModel = None

        lstTextControls = self.ui.groupBox_20.findChildren(QLineEdit)
        for ctrl in lstTextControls:
            ctrl.textChanged.connect(self.initResultPanel)

        lstComboControls = self.ui.groupBox_20.findChildren(QComboBox)
        for ctrl in lstComboControls:
            ctrl.currentIndexChanged.connect(self.initResultPanel)
Ejemplo n.º 40
0
 def closeEvent(self, ce):
     # self.optimizationDlg.hide()
     QDialog.closeEvent(self, ce)
Ejemplo n.º 41
0
 def reject(self):
     # Back out of dialogue
     QDialog.reject(self)
Ejemplo n.º 42
0
    def __init__(self, parent=None):
        QDialog.__init__(self, parent)

        self.setObjectName("ui_ProjectMngForm")
        self.resize(200, 200)
        font = QFont()
        font.setFamily("Arial")
        font.setBold(False)
        font.setWeight(50)
        self.setFont(font)

        self.setWindowTitle("Project Manage Dialog")

        self.vlForm = QVBoxLayout(self)
        self.vlForm.setObjectName("vl_ProjectMngForm")
        self.vlForm.setSpacing(9)
        self.vlForm.setMargin(9)

        self.basicFrame = Frame(self)
        self.vlForm.addWidget(self.basicFrame)

        self.groubox = GroupBox(self.basicFrame)
        self.groubox.Caption = "Projects"
        self.basicFrame.Add = self.groubox

        self.listBoxProject = ListBox(self.groubox)
        self.groubox.Add = self.listBoxProject

        self.textNameProject = TextBoxPanel(self.basicFrame)
        self.textNameProject.Caption = "Name"
        self.textNameProject.LabelWidth = 50
        self.textNameProject.Width = 120
        self.basicFrame.Add = self.textNameProject

        self.textPathProject = TextBoxPanel(self.basicFrame)
        self.textPathProject.Caption = "Path"
        self.textPathProject.imageButton.setIcon(QIcon())
        self.textPathProject.Button = "opens.png"
        self.textPathProject.LabelWidth = 50
        self.textPathProject.textBox.setMaximumWidth(10000)
        self.textPathProject.textBox.setMinimumWidth(100)
        self.basicFrame.Add = self.textPathProject

        self.btnFrame = Frame(self.basicFrame, "HL")
        self.basicFrame.Add = self.btnFrame

        self.buttonAddProject = QPushButton(self.btnFrame)
        self.buttonAddProject.setObjectName("buttonAddProject")
        self.buttonAddProject.setText("Add")
        self.btnFrame.Add = self.buttonAddProject

        self.buttonModifyProject = QPushButton(self.btnFrame)
        self.buttonModifyProject.setObjectName("buttonModifyProject")
        self.buttonModifyProject.setText("Modify")
        self.btnFrame.Add = self.buttonModifyProject

        self.buttonDeleteProject = QPushButton(self.btnFrame)
        self.buttonDeleteProject.setObjectName("buttonDeleteProject")
        self.buttonDeleteProject.setText("Delete")
        self.btnFrame.Add = self.buttonDeleteProject

        self.buttonCloseProject = QPushButton(self.btnFrame)
        self.buttonCloseProject.setObjectName("buttonCloseProject")
        self.buttonCloseProject.setText("Close")
        self.btnFrame.Add = self.buttonCloseProject

        self.connect(self.listBoxProject, SIGNAL("Event_0"), self.listBoxProject_SelectedIndexChanged)
        self.connect(self.textPathProject, SIGNAL("Event_1"), self.buttonBrowseProject_Click)

        self.buttonAddProject.clicked.connect(self.buttonAddProject_Click)
        self.buttonModifyProject.clicked.connect(self.buttonModifyProject_Click)
        self.buttonDeleteProject.clicked.connect(self.buttonDeleteProject_Click)
        self.buttonCloseProject.clicked.connect(self.buttonCloseProject_Click)
        
        for pi in AirCraftOperation.g_projectList.ProjectsList:
            if pi.Pt == enumProjectType.ptProject:
                self.listBoxProject.Add(pi.Name)
Ejemplo n.º 43
0
    def __init__(self, parent=None, aptinkerQSettings=None):
        """Constructor"""

        QDialog.__init__(self, parent=parent)

        self.setupUi(self)

        self.setWindowFlags(Qt.Window)  # To add Maximize & Minimize buttons
        self.setWindowTitle('Select Configuration from Database')

        # Load Startup Preferences for Config Table
        self.default_config_pref = dict(
            vis_col_key_list=config.DEF_VIS_COL_KEYS['config_setup'][:])
        if osp.exists(PREF_CONFIG_JSON_FILEPATH):
            with open(PREF_CONFIG_JSON_FILEPATH, 'r') as f:
                self.config_pref = json.load(f)
        else:
            self.config_pref = self.default_config_pref

        # Load Startup Preferences for Config Meta Table
        self.default_config_meta_pref = dict(vis_col_key_list=[
            'config_id', 'config_ctime', 'config_name', 'username',
            'config_ref_step_size', 'config_masar_id'
        ])
        if osp.exists(PREF_CONFIG_META_JSON_FILEPATH):
            with open(PREF_CONFIG_META_JSON_FILEPATH, 'r') as f:
                self.config_meta_pref = json.load(f)
        else:
            self.config_meta_pref = self.default_config_meta_pref

        self.configDBViewWidget = ConfigDBViewWidget(
            self.groupBox_selected_conf)
        self.tableView_config = self.configDBViewWidget.tableView

        self.configMetaDBViewWidget = ConfigMetaDBViewWidget(
            self.groupBox_search_result)
        self.tableView_config_meta = self.configMetaDBViewWidget.tableView
        self.textEdit_description = \
            self.configMetaDBViewWidget.textEdit_description

        self.settings = QSettings('APHLA', 'TinkerConfigDBSelector')
        self.loadViewSettings()

        self._aptinkerQSettings = aptinkerQSettings

        self.pushButton_search.setIcon(QIcon(':/search.png'))

        all_ctime_operators = [
            self.comboBox_time_created_1.itemText(i)
            for i in range(self.comboBox_time_created_1.count())
        ]
        self.comboBox_time_created_1.setCurrentIndex(
            all_ctime_operators.index(''))
        self.dateTimeEdit_time_created_1.setDateTime(
            QDateTime.currentDateTime())
        self.dateTimeEdit_time_created_2.setDateTime(
            QDateTime.currentDateTime())

        self.search_params = dict(config_id_1='',
                                  config_id_2='',
                                  ref_step_size_1='',
                                  ref_step_size_2='',
                                  config_name='',
                                  config_desc='',
                                  username='',
                                  ctime_1='',
                                  ctime_2='',
                                  synced_gruop_weight='',
                                  masar_id_1='',
                                  masar_id_2='')

        db_id_validator = QIntValidator()
        db_id_validator.setBottom(1)
        self.lineEdit_config_id_1.setValidator(db_id_validator)
        self.lineEdit_config_id_2.setValidator(db_id_validator)
        self.lineEdit_masar_id_1.setValidator(db_id_validator)
        self.lineEdit_masar_id_2.setValidator(db_id_validator)

        self.prev_valid_ref_step_sizes = dict(lineEdit_ref_step_size_1=np.nan,
                                              lineEdit_ref_step_size_2=np.nan)

        # Set up Config Table
        self.config_model = ConfigModel()
        self.tableModel_config = self.config_model.table
        proxyModel = QSortFilterProxyModel()
        proxyModel.setSourceModel(self.tableModel_config)
        proxyModel.setDynamicSortFilter(False)
        tbV = self.tableView_config
        tbV.setModel(proxyModel)
        tbV.setItemDelegate(
            ConfigDBTableViewItemDelegate(tbV, self.tableModel_config,
                                          tbV.parent()))

        self.db = self.config_model.db
        if '[config_meta_table text view]' not in self.db.getViewNames(
                square_brackets=True):
            self.db.create_temp_config_meta_table_text_view()

        # Set up Config Meta Table
        self.config_meta_all_col_keys = self.configMetaDBViewWidget.all_col_keys
        self.search_result = {k: [] for k in self.config_meta_all_col_keys}

        self.tableModel_config_meta = MetaTableModel(
            self.search_result, self.configMetaDBViewWidget)
        proxyModel = QSortFilterProxyModel()
        proxyModel.setSourceModel(self.tableModel_config_meta)
        proxyModel.setDynamicSortFilter(False)
        tbV = self.tableView_config_meta
        tbV.setModel(proxyModel)
        self.selectionModel = QItemSelectionModel(proxyModel)
        tbV.setSelectionModel(self.selectionModel)

        # Apply Visible Column Preference to Config Table
        (col_keys, col_names) = config.COL_DEF.getColumnDataFromTable(
            'column_table',
            column_name_list=['column_key', 'short_descrip_name'],
            condition_str='column_key in ({0:s})'.format(','.join([
                '"{0:s}"'.format(k)
                for k in self.config_pref['vis_col_key_list']
            ])))
        config_vis_col_name_list = [
            col_names[col_keys.index(k)]
            for k in self.config_pref['vis_col_key_list']
        ]
        self.configDBViewWidget.on_column_selection_change(
            config_vis_col_name_list, force_visibility_update=True)

        # Apply Visible Column Preference to Config Meta Table
        config_meta_vis_col_name_list = [
            self.configMetaDBViewWidget.col_names_wo_desc[
                self.configMetaDBViewWidget.col_keys_wo_desc.index(k)]
            for k in self.config_meta_pref['vis_col_key_list']
        ]
        self.configMetaDBViewWidget.on_column_selection_change(
            config_meta_vis_col_name_list, force_visibility_update=True)

        # Make connection

        self.connect(self.lineEdit_ref_step_size_1,
                     SIGNAL('editingFinished()'), self.validate_ref_step_size)
        self.connect(self.lineEdit_ref_step_size_2,
                     SIGNAL('editingFinished()'), self.validate_ref_step_size)

        self.connect(self.pushButton_search, SIGNAL('clicked()'),
                     self.update_search)

        self.connect(
            self.selectionModel,
            SIGNAL(
                'currentRowChanged(const QModelIndex &, const QModelIndex &)'),
            self.on_selection_change)

        self.connect(self.configMetaDBViewWidget, SIGNAL('exportConfigToFile'),
                     self.exportConfigToFile)
        self.connect(self.configMetaDBViewWidget,
                     SIGNAL('editConfigNameOrDescription'),
                     self.editConfigNameOrDescription)
Ejemplo n.º 44
0
    def __init__(self, iface, parent=None, extent=None, crs=None):
        """Constructor for the dialog.

        :param iface: A Quantum GIS QGisAppInterface instance.
        :type iface: QGisAppInterface

        :param parent: Parent widget of this dialog
        :type parent: QWidget

        :param extent: Extent of the user's preferred analysis area.
        :type extent: QgsRectangle

        :param crs: Coordinate reference system for user defined analysis
            extent.
        :type crs: QgsCoordinateReferenceSystem
        """
        QDialog.__init__(self, parent)
        self.setupUi(self)

        self.iface = iface
        self.parent = parent
        self.canvas = iface.mapCanvas()
        self.previous_map_tool = None
        # Prepare the map tool
        self.tool = RectangleMapTool(self.canvas)
        self.previous_map_tool = self.canvas.mapTool()

        if extent is None:
            # Use the current map canvas extents as a starting point
            self.tool.set_rectangle(self.canvas.extent())
        else:

            if isinstance(extent, QgsGeometry):
                # In InaSAFE V4, the extent is a QgsGeometry.
                # This like a hack to transform a geometry to a rectangle.
                extent = wkt_to_rectangle(extent.exportToWkt())

            # Ensure supplied extent is in current canvas crs
            transform = QgsCoordinateTransform(
                crs,
                self.canvas.mapSettings().destinationCrs())
            transformed_extent = transform.transformBoundingBox(extent)
            self.tool.set_rectangle(transformed_extent)

        self._populate_coordinates()

        # Observe inputs for changes
        self.x_minimum.valueChanged.connect(self._coordinates_changed)
        self.y_minimum.valueChanged.connect(self._coordinates_changed)
        self.x_maximum.valueChanged.connect(self._coordinates_changed)
        self.y_maximum.valueChanged.connect(self._coordinates_changed)

        # Draw the rubberband
        self._coordinates_changed()

        # Wire up button events
        self.capture_button.clicked.connect(self.start_capture)
        # Handle cancel
        cancel_button = self.button_box.button(QtGui.QDialogButtonBox.Cancel)
        cancel_button.clicked.connect(self.reject)
        # Make sure to reshow this dialog when rectangle is captured
        self.tool.rectangle_created.connect(self.stop_capture)
        # Setup ok button
        self.ok_button = self.button_box.button(QtGui.QDialogButtonBox.Ok)
        self.ok_button.clicked.connect(self.accept)
        # Set up context help
        self.help_button = self.button_box.button(QtGui.QDialogButtonBox.Help)
        # Allow toggling the help button
        self.help_button.setCheckable(True)
        self.help_button.toggled.connect(self.help_toggled)
        self.main_stacked_widget.setCurrentIndex(1)
        # Reset / Clear button
        clear_button = self.button_box.button(QtGui.QDialogButtonBox.Reset)
        clear_button.setText(self.tr('Clear'))
        clear_button.clicked.connect(self.clear)

        # Populate the bookmarks list and connect the combobox
        self._populate_bookmarks_list()
        self.bookmarks_list.currentIndexChanged.connect(
            self.bookmarks_index_changed)

        # Reinstate the last used radio button
        settings = QSettings()
        mode = settings.value('inasafe/analysis_extents_mode',
                              HAZARD_EXPOSURE_VIEW)

        if mode == HAZARD_EXPOSURE_VIEW:
            self.hazard_exposure_view_extent.setChecked(True)
        elif mode == HAZARD_EXPOSURE:
            self.hazard_exposure_only.setChecked(True)
        elif mode == HAZARD_EXPOSURE_BOOKMARK:
            self.hazard_exposure_bookmark.setChecked(True)
        elif mode == HAZARD_EXPOSURE_BOUNDINGBOX:
            self.hazard_exposure_user_extent.setChecked(True)

        show_warnings = settings.value('inasafe/show_extent_warnings',
                                       True,
                                       type=bool)
        if show_warnings:
            self.show_warnings.setChecked(True)
        else:
            self.show_warnings.setChecked(False)

        show_confirmations = settings.value(
            'inasafe/show_extent_confirmations', True, type=bool)
        if show_confirmations:
            self.show_confirmations.setChecked(True)
        else:
            self.show_confirmations.setChecked(False)
Ejemplo n.º 45
0
 def __init__(self, parent=None):
     """
     Constructor
     """
     QDialog.__init__(self, parent)
     self.setupUi(self)
Ejemplo n.º 46
0
 def __init__(self, parent):
     self.window = QDialog(parent)
     self.ui = Ui_NewTaskDialog()
     self.ui.setupUi(self.window)
# Make your own signal
from PyQt4.QtCore import pyqtSignal
from PyQt4.QtGui import QDialog
from qgis.gui import QgsBlendModeComboBox

new_dialog = QDialog()
new_dialog.resize(200, 200)


class QgsBlendModeComboBoxWithCustomSignal(QgsBlendModeComboBox):
    onBlendChanged = pyqtSignal(int)

    def __init__(self, parent=None):
        # Initialize the QgsBlendModeComboBoxWithCustomSignal as a QgsBlendModeComboBox
        QgsBlendModeComboBox.__init__(self, parent)
        self.currentIndexChanged.connect(self._onBlendChanged)

    def _onBlendChanged(self):
        self.onBlendChanged.emit(self.blendMode())

blend_mode_combo_box = QgsBlendModeComboBoxWithCustomSignal(new_dialog)

enum_composition_mode = [
    'CompositionMode_SourceOver',
    'CompositionMode_DestinationOver',
    'CompositionMode_Clear',
    'CompositionMode_Source',
    'CompositionMode_Destination',
    'CompositionMode_SourceIn',
    'CompositionMode_DestinationIn',
    'CompositionMode_SourceOut',
Ejemplo n.º 48
0
    def showDialog(self):
        dialog = QDialog(mw)

        zoomScrollLayout = QHBoxLayout()
        zoomScrollLayout.addWidget(self.createZoomGroupBox())
        zoomScrollLayout.addWidget(self.createScrollGroupBox())

        zoomScrollTab = QWidget()
        zoomScrollTab.setLayout(zoomScrollLayout)

        tabWidget = QTabWidget()
        tabWidget.setUsesScrollButtons(False)
        tabWidget.addTab(self.createGeneralTab(), 'General')
        tabWidget.addTab(self.createExtractionTab(), 'Extraction')
        tabWidget.addTab(self.createHighlightingTab(), 'Highlighting')
        tabWidget.addTab(self.createSchedulingTab(), 'Scheduling')
        tabWidget.addTab(self.createQuickKeysTab(), 'Quick Keys')
        tabWidget.addTab(zoomScrollTab, 'Zoom / Scroll')

        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
        buttonBox.accepted.connect(dialog.accept)

        mainLayout = QVBoxLayout()
        mainLayout.addWidget(tabWidget)
        mainLayout.addWidget(buttonBox)

        dialog.setLayout(mainLayout)
        dialog.setWindowTitle('Incremental Reading Options')
        dialog.exec_()

        self.settings['zoomStep'] = self.zoomStepSpinBox.value() / 100.0
        self.settings['generalZoom'] = self.generalZoomSpinBox.value() / 100.0
        self.settings['lineScrollFactor'] = self.lineStepSpinBox.value() / 100.0
        self.settings['pageScrollFactor'] = self.pageStepSpinBox.value() / 100.0
        self.settings['editExtract'] = self.editExtractButton.isChecked()
        self.settings['editSource'] = self.editSourceCheckBox.isChecked()
        self.settings['plainText'] = self.plainTextCheckBox.isChecked()
        self.settings['schedSoonRandom'] = self.soonRandomCheckBox.isChecked()
        self.settings['schedLaterRandom'] = self.laterRandomCheckBox.isChecked()

        if self.extractDeckComboBox.currentText() == '[Current Deck]':
            self.settings['extractDeck'] = None
        else:
            self.settings['extractDeck'] = self.extractDeckComboBox.currentText()

        try:
            self.settings['schedSoonInt'] = int(
                self.soonIntegerEditBox.text())
            self.settings['schedLaterInt'] = int(
                self.laterIntegerEditBox.text())
        except:
            pass

        if self.soonPercentButton.isChecked():
            self.settings['schedSoonType'] = 'pct'
        else:
            self.settings['schedSoonType'] = 'cnt'

        if self.laterPercentButton.isChecked():
            self.settings['schedLaterType'] = 'pct'
        else:
            self.settings['schedLaterType'] = 'cnt'

        mw.viewManager.resetZoom(mw.state)
Ejemplo n.º 49
0
 def apply(self):
     if self.save_changes(save_to_db=False):
         QDialog.reject(self)
    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 = []
Ejemplo n.º 51
0
 def __init__(self, *args):
     QDialog.__init__(self, *args)
     self.setupUi(self)
     self.setWindowIcon(QIcon(":/icons/qtsixa.png"))
Ejemplo n.º 52
0
 def reject(self):
     self.close_connection()
     QDialog.reject(self)
Ejemplo n.º 53
0
    def __init__(self, iface, parent=None, qsetting=''):
        """Constructor for the dialog.

        :param iface: A Quantum GIS QGisAppInterface instance.
        :type iface: QGisAppInterface

        :param parent: Parent widget of this dialog
        :type parent: QWidget

        :param qsetting: String to specify the QSettings. By default,
            use empty string.
        :type qsetting: str
        """
        QDialog.__init__(self, parent)
        self.setupUi(self)

        self.setWindowTitle(self.tr('InaSAFE %s Options' % get_version()))
        # Save reference to the QGIS interface and parent
        self.iface = iface
        self.parent = parent
        if qsetting:
            self.settings = QSettings(qsetting)
        else:
            self.settings = QSettings()

        # InaSAFE default values
        self.default_value_parameters = []
        self.default_value_parameter_containers = []

        # Flag for restore default values
        self.is_restore_default = False

        # List of setting key and control
        self.boolean_settings = {
            'visibleLayersOnlyFlag': self.cbxVisibleLayersOnly,
            'set_layer_from_title_flag': self.cbxSetLayerNameFromTitle,
            'setZoomToImpactFlag': self.cbxZoomToImpact,
            'set_show_only_impact_on_report': self.cbx_show_only_impact,
            'print_atlas_report': self.cbx_print_atlas_report,
            'setHideExposureFlag': self.cbxHideExposure,
            'useSelectedFeaturesOnly': self.cbxUseSelectedFeaturesOnly,
            'useSentry': self.cbxUseSentry,
            'template_warning_verbose': self.template_warning_checkbox,
            'showOrganisationLogoInDockFlag':
                self.organisation_on_dock_checkbox,
            'developer_mode': self.cbxDevMode,
            'generate_report': self.checkbox_generate_reports,
            'memory_profile': self.check_box_memory
        }
        self.text_settings = {
            'keywordCachePath': self.leKeywordCachePath,
            'ISO19115_ORGANIZATION': self.iso19115_organization_le,
            'ISO19115_URL': self.iso19115_url_le,
            'ISO19115_EMAIL': self.iso19115_email_le,
            'ISO19115_LICENSE': self.iso19115_license_le,
        }

        # Set up things for context help
        self.help_button = self.button_box.button(QDialogButtonBox.Help)
        # Allow toggling the help button
        self.help_button.setCheckable(True)
        self.help_button.toggled.connect(self.help_toggled)
        self.main_stacked_widget.setCurrentIndex(1)

        # Always set first tab to be open, 0-th index
        self.tabWidget.setCurrentIndex(0)

        # Hide not implemented group
        self.grpNotImplemented.hide()
        self.adjustSize()

        # Demographic tab
        self.scroll_area = QScrollArea()
        self.scroll_area.setWidgetResizable(True)
        self.widget_container = QWidget()
        self.scroll_area.setWidget(self.widget_container)
        self.container_layout = QVBoxLayout()
        self.widget_container.setLayout(self.container_layout)
        self.default_values_layout.addWidget(self.scroll_area)

        self.restore_state()

        # Hide checkbox if not developers
        if not self.cbxDevMode.isChecked():
            self.checkbox_generate_reports.hide()

        # Set up listener for various UI
        self.custom_org_logo_checkbox.toggled.connect(
            self.set_organisation_logo)
        self.custom_north_arrow_checkbox.toggled.connect(self.set_north_arrow)
        self.custom_UseUserDirectory_checkbox.toggled.connect(
            self.set_user_dir)
        self.custom_templates_dir_checkbox.toggled.connect(
            self.set_templates_dir)
        self.custom_org_disclaimer_checkbox.toggled.connect(
            self.set_org_disclaimer)

        # Set up listener for restore defaults button
        self.restore_defaults = self.button_box_restore_defaults.button(
            QDialogButtonBox.RestoreDefaults)
        self.restore_defaults.setCheckable(True)
        self.restore_defaults.clicked.connect(
            self.restore_defaults_ratio)

        # TODO: Hide this until behaviour is defined
        # hide template warning toggle
        self.template_warning_checkbox.hide()

        # hide custom template dir toggle
        self.custom_templates_dir_checkbox.hide()
        self.splitter_custom_report.hide()
Ejemplo n.º 54
0
 def accept(self):
     if self.save_changes():
         QDialog.reject(self)
         self.close_connection()
Ejemplo n.º 55
0
 def closeEvent(self, e):
   settings = QSettings()
   settings.setValue( "/fTools/ValidateDialog/geometry", self.saveGeometry())
   QDialog.closeEvent(self, e)
   del self.marker
Ejemplo n.º 56
0
    def __init__(self, pointLayers, with_mnt):
        """
        Constructor
        :param pointLayers: available points layers
        """
        QDialog.__init__(self)
        self.__pointLayers = pointLayers
        self.__with_mnt = with_mnt
        self.setWindowTitle(QCoreApplication.translate("VDLTools", "Add Points Layers Profiles"))
        self.__layout = QGridLayout()
        self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK"))
        self.__okButton.setMinimumHeight(20)
        self.__okButton.setMinimumWidth(100)

        self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
        self.__cancelButton.setMinimumHeight(20)
        self.__cancelButton.setMinimumWidth(100)

        self.__layersLabel = QLabel(QCoreApplication.translate("VDLTools", "Also points layers profile ? :"))
        self.__layersLabel.setMinimumHeight(20)
        self.__layersLabel.setMinimumWidth(50)

        self.__layout.addWidget(self.__layersLabel, 0, 0, 1, 4)

        self.__layLabels = []
        self.__layChecks = []

        self.__scrollLayout = QGridLayout()

        for i in range(len(self.__pointLayers)):
            label = QLabel(self.__pointLayers[i].name() + " :")
            label.setMinimumHeight(20)
            label.setMinimumWidth(50)
            self.__layLabels.append(label)
            self.__scrollLayout.addWidget(self.__layLabels[i], i+1, 1)
            check = QCheckBox()
            check.setChecked(True)
            self.__layChecks.append(check)
            self.__scrollLayout.addWidget(self.__layChecks[i], i+1, 2)

        self.__mntLabels = []
        self.__mntChecks = []
        self.__mntTitles = ["MNT", "MNS", "Rocher"]

        if with_mnt:
            k = len(self.__pointLayers)
            for i in range(len(self.__mntTitles)):
                label = QLabel(self.__mntTitles[i] + " :")
                label.setMinimumHeight(20)
                label.setMinimumWidth(50)
                self.__mntLabels.append(label)
                self.__scrollLayout.addWidget(self.__mntLabels[i], i+k+1, 1)
                check = QCheckBox()
                check.setChecked(False)
                self.__mntChecks.append(check)
                self.__scrollLayout.addWidget(self.__mntChecks[i], i+k+1, 2)

        widget = QWidget()
        widget.setLayout(self.__scrollLayout)

        scroll = QScrollArea()
        scroll.setWidgetResizable(True)
        scroll.setWidget(widget)

        self.__layout.addWidget(scroll, 1, 0, 1, 4)

        self.__layout.addWidget(self.__okButton, 100, 1)
        self.__layout.addWidget(self.__cancelButton, 100, 2)

        self.setLayout(self.__layout)
Ejemplo n.º 57
0
    def __init__(self, parent = None):
        QDialog.__init__(self)

        self.setObjectName(("ui_WorkspaceMngForm"))
        self.resize(200, 200)
        font = QFont()
        font.setFamily(("Arial"))
        font.setBold(False)
        font.setWeight(50)
        self.setFont(font)

        self.vlForm = QVBoxLayout(self)
        self.vlForm.setObjectName(("vl_ProjectMngForm"))
        self.vlForm.setSpacing(9)
        self.vlForm.setMargin(9)

        self.setWindowTitle("Workspace Manage Dialog")

        self.basicFrame = Frame(self)
        self.vlForm.addWidget(self.basicFrame)

        self.frameName = Frame(self.basicFrame, "HL")
        self.basicFrame.Add = self.frameName

        self.frame = Frame(self.frameName)
        self.frameName.Add = self.frame

        self.comboProjectWorkspace = ComboBoxPanel(self.frame)
        self.comboProjectWorkspace.Caption = "Project"
        self.comboProjectWorkspace.LabelWidth = 120
        self.frame.Add = self.comboProjectWorkspace

        self.comboSubProjectWorkspace = ComboBoxPanel(self.frame)
        self.comboSubProjectWorkspace.Caption = "Sub-Project"
        self.comboSubProjectWorkspace.LabelWidth = 120
        self.frame.Add = self.comboSubProjectWorkspace

        self.textNameWorkspace = TextBoxPanel(self.frame)
        self.textNameWorkspace.Caption = "Workspace Name"
        self.textNameWorkspace.LabelWidth = 120
        self.textNameWorkspace.Width = 120
        self.frame.Add = self.textNameWorkspace

        self.textFullName = TextBoxPanel(self.frame)
        self.textFullName.Caption = "Full Name"
        self.textFullName.LabelWidth = 120
        self.textFullName.Width = 120
        self.textFullName.Visible = False
        self.frame.Add = self.textFullName

        self.groubox = GroupBox(self.frameName)
        self.groubox.Caption = "Workspaces"
        self.frameName.Add = self.groubox

        self.listBoxWorkspace = ListBox(self.groubox)
        self.groubox.Add = self.listBoxWorkspace

        self.textPathWorkspace = TextBoxPanel(self.basicFrame)
        self.textPathWorkspace.Caption = "Workspace Path"
        self.textPathWorkspace.imageButton.setIcon(QIcon())
        self.textPathWorkspace.Button = "opens.png"
        self.textPathWorkspace.LabelWidth = 120
        # self.textPathWorkspace.Enabled = False
        self.textPathWorkspace.textBox.setMaximumWidth(10000)
        self.textPathWorkspace.textBox.setMinimumWidth(100)
        self.basicFrame.Add = self.textPathWorkspace

        self.btnFrame = Frame(self.basicFrame, "HL")
        self.basicFrame.Add = self.btnFrame

        self.buttonAddWorkspace = QPushButton(self.btnFrame)
        self.buttonAddWorkspace.setObjectName("buttonAddWorkspace")
        self.buttonAddWorkspace.setText("Add")
        self.btnFrame.Add = self.buttonAddWorkspace

        self.buttonModifyWorkspace = QPushButton(self.btnFrame)
        self.buttonModifyWorkspace.setObjectName("buttonModifyWorkspace")
        self.buttonModifyWorkspace.setText("Modify")
        self.btnFrame.Add = self.buttonModifyWorkspace

        self.buttonDeleteWorkspace = QPushButton(self.btnFrame)
        self.buttonDeleteWorkspace.setObjectName("buttonDeleteWorkspace")
        self.buttonDeleteWorkspace.setText("Delete")
        self.btnFrame.Add = self.buttonDeleteWorkspace

        self.buttonSaveWorkspace = QPushButton(self.btnFrame)
        self.buttonSaveWorkspace.setObjectName("buttonSaveWorkspace")
        self.buttonSaveWorkspace.setText("Save")
        self.buttonSaveWorkspace.setVisible(False)
        self.btnFrame.Add = self.buttonSaveWorkspace

        self.buttonCloseWorkspace = QPushButton(self.btnFrame)
        self.buttonCloseWorkspace.setObjectName("buttonCloseWorkspace")
        self.buttonCloseWorkspace.setText("Close")
        self.btnFrame.Add = self.buttonCloseWorkspace

        self.connect(self.listBoxWorkspace, SIGNAL("Event_0"), self.listBoxWorkspace_SelectedIndexChanged)
        self.connect(self.comboProjectWorkspace, SIGNAL("Event_0"), self.comboProjectWorkspace_SelectedIndexChanged)
        self.connect(self.comboSubProjectWorkspace, SIGNAL("Event_0"), self.comboSubProjectWorkspace_SelectedIndexChanged)
        self.connect(self.textPathWorkspace, SIGNAL("Event_1"), self.buttonBrowseWorkspace_Click)
        self.connect(self.textNameWorkspace, SIGNAL("Event_0"), self.setFullName)

        self.buttonCloseWorkspace.clicked.connect(self.buttonCloseWorkspace_Click)
        self.buttonSaveWorkspace.clicked.connect(self.buttonSaveWorkspace_Click)
        self.buttonDeleteWorkspace.clicked.connect(self.buttonDeleteWorkspace_Click)
        self.buttonModifyWorkspace.clicked.connect(self.buttonModifyWorkspace_Click)
        self.buttonAddWorkspace.clicked.connect(self.buttonAddWorkspace_Click)
        self.editFlag = False
        for pi in AirCraftOperation.g_projectList.ProjectsList:
            if (pi.Pt == enumProjectType.ptWorkspace):
                self.listBoxWorkspace.Add(pi.Name)
            elif (pi.Pt == enumProjectType.ptProject):
                self.comboProjectWorkspace.Add(pi.Name)
            elif (pi.Pt == enumProjectType.ptSubProject):
                self.comboSubProjectWorkspace.Add(pi.Name)

        self.comboProjectWorkspace_SelectedIndexChanged()
Ejemplo n.º 58
0
 def reject(self):
   # Remove Marker
   self.marker.reset()
   QDialog.reject(self)
Ejemplo n.º 59
0
 def __init__(self):
     QDialog.__init__(self)
 def accept(self):
     if self.validate_data():
         QDialog.accept(self)