Ejemplo n.º 1
0
    def add_user(self, name):
        radio_button = QRadioButton(name, self)
        if not len(self.radio_buttons):
            radio_button.setChecked(True)

        self.groupBoxLayout.addWidget(radio_button)
        self.radio_buttons.append(radio_button)
Ejemplo n.º 2
0
class RadioButton(QWidget):
    selected = pyqtSignal()

    def __init__(self, caption, parent, selected=False):
        QWidget.__init__(self)

        self.value = selected
        self.radiobutton = QRadioButton(caption, parent)
        self.radiobutton.clicked.connect(self.__on_change)

        hbox = QHBoxLayout()
        hbox.addWidget(self.radiobutton)
        hbox.setMargin(0)
        self.setLayout(hbox)
        self.setContentsMargins(0, 0, 0, 0)
        self.radiobutton.setChecked(self.value)

    def __on_change(self):
        self.value = True
        self.selected.emit()

    def set_value(self, value):
        self.radiobutton.setChecked(value)

    def get_value(self):
        return self.radiobutton.isChecked()
Ejemplo n.º 3
0
 def get_widget(self):
     if self.widget is None:
         self.widget = QWidget()
         
         layout = QFormLayout()
         self.widget.setLayout(layout)
         
         self.desktopLabel = QLabel("Record Desktop")
         self.desktopButton = QRadioButton()
         layout.addRow(self.desktopLabel, self.desktopButton)
         
         # Record Area of Desktop
         areaGroup = QHBoxLayout()
         self.areaLabel = QLabel("Record Region")
         self.areaButton = QRadioButton()
         self.setAreaButton = QPushButton("Set")
         areaGroup.addWidget(self.areaButton)
         areaGroup.addWidget(self.setAreaButton)
         layout.addRow(self.areaLabel, areaGroup)
         
         # Select screen to record
         self.screenLabel = QLabel("Screen")
         self.screenSpinBox = QSpinBox()
         layout.addRow(self.screenLabel, self.screenSpinBox)
         
         # Connections
         self.widget.connect(self.desktopButton, SIGNAL('clicked()'), self.set_desktop_full)
         self.widget.connect(self.areaButton, SIGNAL('clicked()'), self.set_desktop_area)
         self.widget.connect(self.setAreaButton, SIGNAL('clicked()'), self.area_select)
         self.widget.connect(self.screenSpinBox, SIGNAL('valueChanged(int)'), self.set_screen)
         
         
     return self.widget
Ejemplo n.º 4
0
    def choice(self, title, msg, choices):
        vbox = QVBoxLayout()
        self.set_layout(vbox)
        vbox.addWidget(QLabel(title))
        gb2 = QGroupBox(msg)
        vbox.addWidget(gb2)

        vbox2 = QVBoxLayout()
        gb2.setLayout(vbox2)

        group2 = QButtonGroup()
        for i, c in enumerate(choices):
            button = QRadioButton(gb2)
            button.setText(c[1])
            vbox2.addWidget(button)
            group2.addButton(button)
            group2.setId(button, i)
            if i == 0:
                button.setChecked(True)
        vbox.addStretch(1)
        vbox.addLayout(Buttons(CancelButton(self), OkButton(self, _('Next'))))
        if not self.exec_():
            return
        wallet_type = choices[group2.checkedId()][0]
        return wallet_type
        class LabelDistributionOptionsDlg( QDialog ):
            """
            A little dialog to let the user specify how the labels should be
            distributed from the current stages to the other stages.
            """
            def __init__(self, source_stage_index, num_stages, *args, **kwargs):
                super(LabelDistributionOptionsDlg, self).__init__(*args, **kwargs)

                from PyQt4.QtCore import Qt
                from PyQt4.QtGui import QGroupBox, QCheckBox, QRadioButton, QDialogButtonBox
            
                self.setWindowTitle("Distributing from Stage {}".format(source_stage_index+1))

                self.stage_checkboxes = []
                for stage_index in range(1, num_stages+1):
                    self.stage_checkboxes.append( QCheckBox("Stage {}".format( stage_index )) )
                
                # By default, send labels back into the current stage, at least.
                self.stage_checkboxes[source_stage_index].setChecked(True)
                
                stage_selection_layout = QVBoxLayout()
                for checkbox in self.stage_checkboxes:
                    stage_selection_layout.addWidget( checkbox )

                stage_selection_groupbox = QGroupBox("Send labels from Stage {} to:".format( source_stage_index+1 ), self)
                stage_selection_groupbox.setLayout(stage_selection_layout)
                
                self.copy_button = QRadioButton("Copy", self)
                self.partition_button = QRadioButton("Partition", self)
                self.partition_button.setChecked(True)
                distribution_mode_layout = QVBoxLayout()
                distribution_mode_layout.addWidget(self.copy_button)
                distribution_mode_layout.addWidget(self.partition_button)
                
                distribution_mode_group = QGroupBox("Distribution Mode", self)
                distribution_mode_group.setLayout(distribution_mode_layout)
                
                buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
                buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
                buttonbox.accepted.connect( self.accept )
                buttonbox.rejected.connect( self.reject )
                
                dlg_layout = QVBoxLayout()
                dlg_layout.addWidget(stage_selection_groupbox)
                dlg_layout.addWidget(distribution_mode_group)
                dlg_layout.addWidget(buttonbox)
                self.setLayout(dlg_layout)

            def distribution_mode(self):
                if self.copy_button.isChecked():
                    return "copy"
                if self.partition_button.isChecked():
                    return "partition"
                assert False, "Shouldn't get here."
            
            def destination_stages(self):
                """
                Return the list of stage_indexes (0-based) that the user checked.
                """
                return [ i for i,box in enumerate(self.stage_checkboxes) if box.isChecked() ]
Ejemplo n.º 6
0
class RepoTypeWizardPage(QWizardPage):
    def __init__(self, parent=None):
        super(RepoTypeWizardPage, self).__init__(
            parent,
            title="Select Account Type",
            subTitle="Select the type of Repo to create")
        
        # RadioButtons

        self.githubRadioButton = QRadioButton('Github Repo')

        # Layout

        self.mainLayout = QVBoxLayout()
        self.mainLayout.addWidget(self.githubRadioButton)
        self.setLayout(self.mainLayout)
        
        # Setup

        self.githubRadioButton.toggle() 
    
    def nextId(self):
        
        if self.githubRadioButton.isChecked():
            return 1
Ejemplo n.º 7
0
    def __getTermGroupbox( self ):
        " Creates the term groupbox "
        termGroupbox = QGroupBox( self )
        sizePolicy = QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred )
        sizePolicy.setHorizontalStretch( 0 )
        sizePolicy.setVerticalStretch( 0 )
        sizePolicy.setHeightForWidth(
                        termGroupbox.sizePolicy().hasHeightForWidth() )
        termGroupbox.setSizePolicy( sizePolicy )

        layoutTerm = QVBoxLayout( termGroupbox )
        self.__redirectRButton = QRadioButton( termGroupbox )
        self.__redirectRButton.setText( "&Redirect to IDE" )
        self.__redirectRButton.toggled.connect( self.__redirectedChanged )
        layoutTerm.addWidget( self.__redirectRButton )
        self.__autoRButton = QRadioButton( termGroupbox )
        self.__autoRButton.setText( "Aut&o detection" )
        layoutTerm.addWidget( self.__autoRButton )
        self.__konsoleRButton = QRadioButton( termGroupbox )
        self.__konsoleRButton.setText( "Default &KDE konsole" )
        layoutTerm.addWidget( self.__konsoleRButton )
        self.__gnomeRButton = QRadioButton( termGroupbox )
        self.__gnomeRButton.setText( "gnome-&terminal" )
        layoutTerm.addWidget( self.__gnomeRButton )
        self.__xtermRButton = QRadioButton( termGroupbox )
        self.__xtermRButton.setText( "&xterm" )
        layoutTerm.addWidget( self.__xtermRButton )
        return termGroupbox
Ejemplo n.º 8
0
 def __init__(self, db, mainWindow, username, contact):
     QWidget.__init__(self)
     self.contact = contact
     self.username = username
     self.mainWindow = mainWindow
     self.db = db
     
     self.resize(400, 300)
     self.setWindowTitle('Edit Contact')
     
     self.addressListLabel = QLabel('Addresses')
     
     addresses = self.contact.getAddresses(self.db)
     addresses = [("%s: %s" % (address['strAddressType'], address['strAddress']), address['strAddress']) for address in addresses]
     self.addresses = AutoCompleteListBox(self, addresses)
     self.addresses.getLineEdit().hide()
     
     saveButton = QPushButton('Save')
     cancelButton = QPushButton('Cancel')
     
     self.personRadio = QRadioButton('Contact is a person', self)
     self.companyRadio = QRadioButton('Contact is an organization', self)
     
     self.personWidget = self._getPersonWidget()
     self.companyWidget = self._getCompanyWidget()
     
     self.personRadio.toggled.connect(self.switchToPerson)
     self.companyRadio.toggled.connect(self.switchToCompany)
     
     grid = QGridLayout()
     grid.setSpacing(10)
     
     grid.addWidget(self.addressListLabel, 1, 0)
     grid.addWidget(self.addresses.getLineEdit(), 0, 1, 1, 2)
     grid.addWidget(self.addresses.getListBox(), 1, 1, 1, 2)
     
     grid.addWidget(self.personRadio, 2, 1, 1, 2)
     grid.addWidget(self.companyRadio, 3, 1, 1, 2)
     
     grid.addWidget(self.personWidget, 4, 0, 1, 3)
     grid.addWidget(self.companyWidget, 5, 0, 1, 3)
     
     grid.addWidget(saveButton, 7, 1)
     grid.addWidget(cancelButton, 7, 2)
     
     self.setLayout(grid)
     
     if contact.isPerson == True:
         self.personRadio.setChecked(True)
         self.switchToPerson()
     elif contact.isPerson == False:
         self.companyRadio.setChecked(True)
         self.switchToCompany()
     else:
         self.personWidget.hide()
         self.companyWidget.hide()
     
     self.connect(cancelButton, SIGNAL('clicked()'), SLOT('close()'))
     self.connect(saveButton, SIGNAL('clicked()'), self.save)
Ejemplo n.º 9
0
 def RadioSet(widget : QtGui.QRadioButton, val : str, id : int) -> bool:
     """If QRadioButton name match 'val' select it and return True."""
     # if widget.accessibleName() != val: return False
     # widget.setChecked(True)
     # return True                
     assert len(self.enum) > id
     if self.enum[id] != val: return False
     widget.setChecked(True)
     return True
Ejemplo n.º 10
0
 def makeSortButton(name, sortFunction):
     bname = "%sSortButton" % name
     button = QRadioButton(self.sortBox)
     setattr(self, bname, button)
     def buttonClicked():
         self.__sortOrder = name
         self.model.setSortOrder(sortFunction)
     self.connect(button, SIGNAL("clicked()"),
                  buttonClicked)
     self.sortLayout.addWidget(button)
     button.setText("By %s" % name.capitalize())
Ejemplo n.º 11
0
    def __init__(self, parent=None):
        '''
        Constructor
        '''
        QRadioButton.__init__(self, parent)
        self.setStyleSheet(self.styleSheet)
        font = QFont( "Arial", 18)
        self.setFont(font)

        #VARIABILI INTERNE
        self.__intValue = 0
        self.__strValue = ""
Ejemplo n.º 12
0
 def makeOddsButton(name, oddsDisplayer):
     bname = "%sButton" % name
     button = QRadioButton(self.oddsGroupBox)
     setattr(self, bname, button)
     def buttonClicked():
         self.__oddsDisplay = name
         self.model.setOddsDisplay(oddsDisplayer)
     self.connect(button, SIGNAL("clicked()"),
                  buttonClicked)
     button.setEnabled(oddsDisplayer.implemented)
     self.oddsLayout.addWidget(button)
     button.setText(name.capitalize())
Ejemplo n.º 13
0
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)
        self.setup_model()

        self.tableview = QTableView()
        self.tableview.setSelectionMode(QAbstractItemView.NoSelection)
        self.tableview.setEditTriggers(QAbstractItemView.DoubleClicked)
        self.cbdelegate = CheckBoxDelegate()
        self.tableview.setItemDelegate(self.cbdelegate)
        self.tableview.setAutoScroll(False)
        self.tableview.setModel(self.model)
        self.tableview.sortByColumn(0, Qt.AscendingOrder)
        self.adjust_headers()

        #self.model.setHeaderData(0, Qt.Horizontal, u"")
        #self.model.setHeaderData(1, Qt.Horizontal, u"Title")

        self.radio_all = QRadioButton("All")
        self.radio_all.setChecked(True)
        self.radio_need = QRadioButton("Need")
        self.connect(self.radio_all, SIGNAL("toggled(bool)"), self.set_show_all)

        label = QLabel("DB:")
        label.setFixedWidth(40)
        label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)

        self.db_combo = QComboBox()
        self.populate_db_combo()
        self.connect(
            self.db_combo, SIGNAL("currentIndexChanged(int)"),
            self.db_index_changed)

        self.new_button = QPushButton("New")
        self.connect(self.new_button, SIGNAL("clicked()"), self.new_item)

        self.box = QVBoxLayout(self)
        self.box.addWidget(self.tableview)
        self.button_box = QHBoxLayout()
        self.button_box.setSpacing(0)
        self.button_box.addWidget(self.new_button)
        self.button_box.addWidget(self.radio_all)
        self.button_box.addWidget(self.radio_need)
        self.button_box.addWidget(label)
        self.button_box.addWidget(self.db_combo)
        self.box.addLayout(self.button_box)

        # self.setStyleSheet("""
        # QComboBox {
        #     font-size: 16px;
        # }
        # """)

        self.dwim_after_load()
Ejemplo n.º 14
0
    def __init__(self):
        super(IntroductionPage, self).__init__()
        self.setTitle(self.tr("Creación de un nuevo Proyecto"))
        self.setSubTitle(self.tr("Información básica del Proyecto"))
        container = QVBoxLayout(self)
        hbox = QHBoxLayout()
        # Nombre
        hbox.addWidget(QLabel(self.tr("Nombre del Proyecto:")))
        self.line_name = QLineEdit()
        hbox.addWidget(self.line_name)
        container.addLayout(hbox)
        # Ubicación
        group = QGroupBox(self.tr("Ubicación:"))
        box = QVBoxLayout(group)
        button_group = QButtonGroup(self)
        radio_buttons = [
            self.tr("Directorio por defecto"),
            self.tr("Otro")
            ]
        for _id, radiob in enumerate(radio_buttons):
            radio_button = QRadioButton(radiob)
            button_group.addButton(radio_button, _id)
            box.addWidget(radio_button)
            if _id == 0:
                # El primero checked por defecto
                radio_button.setChecked(True)
        container.addWidget(group)

        self.line_location = QLineEdit()
        container.addWidget(self.line_location)

        hbox = QHBoxLayout()
        hbox.addWidget(QLabel(self.tr("Archivo del Proyecto: ")))
        self._project_filename = QLineEdit()
        hbox.addWidget(self._project_filename)
        container.addLayout(hbox)

        hbox = QHBoxLayout()
        hbox.addWidget(QLabel(self.tr("Archivo resultante: ")))
        self._resulting_filename = QLineEdit()
        hbox.addWidget(self._resulting_filename)
        container.addLayout(hbox)

        # Conexiones
        self.connect(button_group, SIGNAL("buttonClicked(int)"),
                     self._update_location)
        self.connect(self.line_name, SIGNAL("textChanged(const QString&)"),
                     self._on_project_name_changed)
        self.connect(self.line_name, SIGNAL("textChanged(const QString&)"),
                     lambda: self.emit(SIGNAL("completeChanged()")))

        self._update_location(0)
Ejemplo n.º 15
0
 def __init__(self, parent=None):
     super(ShortcutEditDialog, self).__init__(parent)
     self.setMinimumWidth(400)
     # create gui
     
     layout = QVBoxLayout()
     layout.setSpacing(10)
     self.setLayout(layout)
     
     top = QHBoxLayout()
     top.setSpacing(4)
     p = self.toppixmap = QLabel()
     l = self.toplabel = QLabel()
     l.setWordWrap(True)
     top.addWidget(p)
     top.addWidget(l, 1)
     layout.addLayout(top)
     
     grid = QGridLayout()
     grid.setSpacing(4)
     grid.setColumnStretch(1, 2)
     layout.addLayout(grid)
     
     self.buttonDefault = QRadioButton(self)
     self.buttonNone = QRadioButton(self)
     self.buttonCustom = QRadioButton(self)
     grid.addWidget(self.buttonDefault, 0, 0, 1, 2)
     grid.addWidget(self.buttonNone, 1, 0, 1, 2)
     grid.addWidget(self.buttonCustom, 2, 0, 1, 2)
     
     self.keybuttons = []
     self.keylabels = []
     for num in range(4):
         l = QLabel(self)
         l.setStyleSheet("margin-left: 2em;")
         l.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
         b = KeySequenceWidget(self)
         b.keySequenceChanged.connect(self.slotKeySequenceChanged)
         l.setBuddy(b)
         self.keylabels.append(l)
         self.keybuttons.append(b)
         grid.addWidget(l, num+3, 0)
         grid.addWidget(b, num+3, 1)
     
     layout.addWidget(Separator(self))
     
     b = QDialogButtonBox(self)
     b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
     layout.addWidget(b)
     b.accepted.connect(self.accept)
     b.rejected.connect(self.reject)
     app.translateUI(self)
Ejemplo n.º 16
0
 def __init__(self, page):
     super(Target, self).__init__(page)
     
     layout = QGridLayout()
     self.setLayout(layout)
     
     self.targetPDF = QRadioButton(toggled=page.changed)
     self.targetSVG = QRadioButton(toggled=page.changed)
     self.openDefaultView = QCheckBox(clicked=page.changed)
     
     layout.addWidget(self.targetPDF, 0, 0)
     layout.addWidget(self.targetSVG, 0, 1)
     layout.addWidget(self.openDefaultView, 1, 0, 1, 5)
     app.translateUI(self)
Ejemplo n.º 17
0
 def createWidgets(self, layout):
     self.bookOutputInfo = QLabel(wordWrap=True)
     self.bookOutputLabel = QLabel()
     self.bookOutput = widgets.lineedit.LineEdit()
     self.bookOutputFileName = QRadioButton()
     self.bookOutputSuffix = QRadioButton(checked=True)
     
     layout.addWidget(self.bookOutputInfo)
     grid = QGridLayout(spacing=0)
     grid.addWidget(self.bookOutputLabel, 0, 0)
     grid.addWidget(self.bookOutput, 0, 1, 1, 2)
     grid.addWidget(self.bookOutputFileName, 1, 1)
     grid.addWidget(self.bookOutputSuffix, 1, 2)
     layout.addLayout(grid)
Ejemplo n.º 18
0
    def setup_method_layout(self):
        self.group = QButtonGroup(self, exclusive=True)

        if self.initialize_methods:
            self.methods = [method() for method in self.methods]

        for i, method in enumerate(self.methods):
            rb = QRadioButton(self, text=self.textify(method.name))
            rb.setChecked(i == self.method_index)
            rb.setToolTip(self.get_tooltip(method))
            self.group.addButton(rb, i)
            self.method_layout.addWidget(rb, i, 0)

        self.group.buttonClicked.connect(self.update_value)
Ejemplo n.º 19
0
    def __init__(self, setup):
        super(CrossModeGroupItem, self).__init__("Cross-Mode Terms", [("Cross-Mode Term", CrossModeItem)], setup)
        self.context_menu.add_action('Add Terms From Matrix', self.add_from_matrix)

        self.array_model = UpperHalfArrayModel()
        array_view = QTableView()
        array_view.setModel(self.array_model)
        type_group = QGroupBox()
        type_layout = QVBoxLayout(type_group)
        self.cross_kerr_type_radio = QRadioButton("Cross-Kerr")
        self.cross_kerr_type_radio.setChecked(True)
        self.xx_type_radio = QRadioButton("X-X")
        type_layout.addWidget(self.cross_kerr_type_radio)
        type_layout.addWidget(self.xx_type_radio)
        self.dialog = OKCancelDialog(QLabel("Mode Array"), array_view, type_group)
Ejemplo n.º 20
0
    def add_node(self, parentItem, path, type):
        item = QTreeWidgetItem(parentItem)
        item.setText(0, path_leaf(path))
        buttonGroup = QButtonGroup()

        isNewFile = type is "UNTRACKED"
        isModifiedFile = type is "MODIFIED"
        isMissing = type is "MISSING"
        isDirectory = type is "DIR"

        if isNewFile:
            item.setText(1, type)
            item.setForeground(1, QBrush(QColor(0, 255, 0)))
        if isModifiedFile:
            item.setText(1, type)
            item.setForeground(1, QBrush(QColor(0, 0, 255)))
        if isMissing:
            item.setText(1, type)
            item.setForeground(1, QBrush(QColor(255, 0, 0)))
        if isDirectory:
            for i in range(self.tree.columnCount()):
                item.setBackground(i, QBrush(QColor(230, 230, 255)))

        # must keep reference to buttonGroup for its callback to work
        parent_data = self.retrieve_data(parentItem)
        if parent_data != None:
            path = os.path.join(parent_data[0], path)
        self.attach_data(item, (path, buttonGroup, type))

        for i in range(self.uncheckableColumns, self.tree.columnCount()):
            if i == self.tree.columnCount() - 7 and isMissing:
                continue # option to add not enabled for missing files
            if i == self.tree.columnCount() - 4 and isNewFile:
                continue # option to resolve not enabled for new files
            if i == self.tree.columnCount() - 3 and not isMissing:
                continue # option to stop tracking enabled only for missing files
            if i == self.tree.columnCount() - 2 and not isNewFile:
                continue # option to delete enabled only for untracked files
            if i == self.tree.columnCount() - 2 and isDirectory:
                continue # option to delete not enabled for directories, too dangerous
            button = QRadioButton()
            buttonGroup.addButton(button, i - self.uncheckableColumns) # id is the index
            button.treeItem = item
            self.tree.setItemWidget(item, i, button)

        buttonGroup.buttonClicked.connect(self.tree_item_radio_clicked)

        return item
Ejemplo n.º 21
0
 def RadioGet(widget : QtGui.QRadioButton, id : int) -> str or None:
     """If QRadioButton name match 'val' return it state."""
     # if not widget.isChecked(): return
     # return widget.accessibleName()      
     if not widget.isChecked(): return
     assert len(self.enum) > id
     return self.enum[id]
Ejemplo n.º 22
0
    def __init__(self, parent=None):
        super(DatabaseTypePage, self).__init__(parent)

        self.setTitle(self.tr(u"Typ databáze"))
        self.textRB = QRadioButton(QApplication.translate("DatabaseTypePage", 'Databáze uložená jako textové soubory v adresáři', None, QApplication.UnicodeUTF8), None)
        self.pgRB = QRadioButton(QApplication.translate("DatabaseTypePage", 'Databáze PostGIS', None, QApplication.UnicodeUTF8), None)
        self.setCheckedButton()

        grid = QGridLayout()
        grid.addWidget(self.textRB, 0, 0)
        grid.addWidget(self.pgRB, 1, 0)

        self.setLayout(grid)

        self.connect(self.textRB, SIGNAL("clicked()"), self.updateDatabaseTypeText)
        self.connect(self.pgRB, SIGNAL("clicked()"), self.updateDatabaseTypePG)
Ejemplo n.º 23
0
    def __init__(self, settings, parent=None):
        super(SettingsDialog, self).__init__(parent)

        self.settings = settings

        self.setWindowTitle('Settings')
        layout = QVBoxLayout()

        settings_layout = QGridLayout()

        username_label = QLabel('Username:'******'Password:'******'Deck:')
        settings_layout.addWidget(deck_label, 2, 0)
        self.deck_edit = QLineEdit()
        settings_layout.addWidget(self.deck_edit, 2, 1)

        moc_label = QLabel('Minimize on close:')
        settings_layout.addWidget(moc_label, 3, 0)
        moc_layout = QHBoxLayout()
        self.moc_radio_button = QRadioButton('Yes', self)
        moc_layout.addWidget(self.moc_radio_button)
        self.nomoc_radio_button = QRadioButton('No', self)
        moc_layout.addWidget(self.nomoc_radio_button)
        settings_layout.addLayout(moc_layout, 3, 1)

        layout.addLayout(settings_layout)

        button_layout = QHBoxLayout()
        accept_button = QPushButton('&Accept')
        accept_button.clicked.connect(self.accept)
        button_layout.addWidget(accept_button)
        reject_button = QPushButton('&Cancel')
        reject_button.clicked.connect(self.reject)
        button_layout.addWidget(reject_button)
        layout.addLayout(button_layout)

        self.setLayout(layout)
Ejemplo n.º 24
0
    def network_dialog(self):
        # skip this if config already exists
        if self.config.get('server') is not None:
            return

        grid = QGridLayout()
        grid.setSpacing(5)

        label = QLabel(_(
            "Electrum communicates with remote servers to get ",
            'information about your transactions and addresses. ',
            'The servers all fulfil the same purpose only ',
            'differing in hardware. In most cases you simply ',
            'want to let Electrum pick one at random if you ',
            'have a preference though feel free to select a server manually.') + "\n\n" + _(
            "How do you want to connect to a server:") + " ")
        label.setWordWrap(True)
        grid.addWidget(label, 0, 0)

        gb = QGroupBox()

        b1 = QRadioButton(gb)
        b1.setText(_("Auto connect"))
        b1.setChecked(True)

        b2 = QRadioButton(gb)
        b2.setText(_("Select server manually"))

        # b3 = QRadioButton(gb)
        # b3.setText(_("Stay offline"))

        grid.addWidget(b1, 1, 0)
        grid.addWidget(b2, 2, 0)
        # grid.addWidget(b3, 3, 0)

        vbox = QVBoxLayout()
        vbox.addLayout(grid)

        vbox.addStretch(1)
        vbox.addLayout(Buttons(CancelButton(self), OkButton(self, _('Next'))))

        self.set_layout(vbox)
        if not self.exec_():
            return

        if b2.isChecked():
            return NetworkDialog(self.network, self.config, None).do_exec()
        else:
            self.config.set_key('auto_connect', True, True)
            return
Ejemplo n.º 25
0
    def rebuild_editor ( self ):
        """ Rebuilds the contents of the editor whenever the original factory
            object's **values** facet changes.
        """
        # Clear any existing content:
        ### self.clear_layout()

        # Get the current facet value:
        cur_name = self.str_value

        # Create a sizer to manage the radio buttons:
        names   = self.names
        mapping = self.mapping
        n       = len( names )
        cols    = self.factory.cols
        rows    = (n + cols - 1) / cols
        incr    = [ n / cols ] * cols
        rem     = n % cols
        for i in range( cols ):
            incr[i] += (rem > i)

        incr[-1] = -( reduce( lambda x, y: x + y, incr[:-1], 0 ) - 1 )

        # Add the set of all possible choices:
        index = 0

        for i in range( rows ):
            for j in range( cols ):
                if n > 0:
                    name = label = names[ index ]
                    label = self.string_value( label, capitalize )
                    rb = QRadioButton( label )
                    rb.value = mapping[ name ]

                    rb.setChecked( name == cur_name )

                    QObject.connect( rb, SIGNAL( 'clicked()' ), self._mapper,
                                     SLOT( 'map()' ) )
                    self._mapper.setMapping( rb, rb )

                    self.set_tooltip( rb )
                    self.control.addWidget( rb, i, j )

                    index += incr[j]
                    n     -= 1
Ejemplo n.º 26
0
    def _initPolicyWidget(self):
        policyWidget = QWidget(self)
        self._policyGroup = QButtonGroup(self)

        once = QRadioButton("Once", policyWidget)
        once.setChecked(True)
        once.clicked.connect(partial(self._setPolicy, self.POLICY_ONCE))
        self._policyGroup.addButton(once)

        forever = QRadioButton("Forever", policyWidget)
        forever.clicked.connect(partial(self._setPolicy, self.POLICY_FOREVER))
        self._policyGroup.addButton(forever)

        policyLayout = QHBoxLayout(policyWidget)
        policyLayout.setContentsMargins(5, 0, 5, 0)
        policyLayout.addWidget(once, 0)
        policyLayout.addWidget(forever, 1, Qt.AlignLeft)
        return policyWidget
    def __init__(self, parameter, parent=None):
        """Constructor.

        :param parameter: A DefaultValueParameter object.
        :type parameter: DefaultValueParameter

        """
        super(DefaultValueParameterWidget, self).__init__(parameter, parent)

        self.radio_button_layout = QHBoxLayout()

        # Create radio button group
        self.input_button_group = QButtonGroup()

        for i in range(len(self._parameter.labels)):
            if '%s' in self._parameter.labels[i]:
                label = (
                    self._parameter.labels[i] %
                    self._parameter.options[i])
            else:
                label = self._parameter.labels[i]

            radio_button = QRadioButton(label)
            self.radio_button_layout.addWidget(radio_button)
            self.input_button_group.addButton(radio_button, i)
            if self._parameter.value == \
                    self._parameter.options[i]:
                radio_button.setChecked(True)

        # Create double spin box for custom value
        self.custom_value = QDoubleSpinBox()
        self.custom_value.setSingleStep(0.1)
        if self._parameter.options[-1]:
            self.custom_value.setValue(self._parameter.options[-1])
        self.radio_button_layout.addWidget(self.custom_value)

        self.toggle_custom_value()

        self.inner_input_layout.addLayout(self.radio_button_layout)

        # Connect
        # noinspection PyUnresolvedReferences
        self.input_button_group.buttonClicked.connect(
            self.toggle_custom_value)
Ejemplo n.º 28
0
    def add_radio_btns(self, choicesL, 
                          name='isBell', init_val=3, layout=None,
                          advance_n=True, fulldesc='Nozzle Geometry', 
                          text_font=ARIAL_10, col=0, parent=None):
                       
        # if parent is input, add widget to parent
        if parent is None:
            parent = self
                                            
        if layout is None:
            NRow = parent.get_next_row_number(advance_n)
            # Need to change next row number by length of choicesL
            if advance_n:
                for i in range(1, len(choicesL)):
                    parent.get_next_row_number(advance_n)
        
        radio_btnL = [] # a list of radio buttons in this group
        self.selection_textD[name] = ''
        
        # First build the radio buttons
        groupBox = QGroupBox(fulldesc)
        vbox = QVBoxLayout()
        for i,choice in enumerate( choicesL ):
            radio = QRadioButton(choice, groupBox)
            vbox.addWidget(radio)
            if i == init_val:
                radio.setChecked(True)
                self.selection_textD[name] = str( choice )
                
            radio_btnL.append( radio )
            
            radio.toggled.connect( lambda: self.radio_btn_changed( '%s_radio_group_box'%name ) ) 

            
        #vbox.addStretch(1)
        groupBox.setLayout(vbox)
        
        if layout is None:
            parent.grid.addWidget(groupBox,      NRow, col, len(choicesL), 1)
        else:
            layout.addWidget( groupBox )
        
        self.objectD['%s_radio_group_box'%name] = radio_btnL
        self.input_widget_by_nameD[name] = (radio_btnL , 'radio_btn_list')
Ejemplo n.º 29
0
class GuiOptionTriggerMock(GuiOptionMock):

    def __init__(self):
        GuiOptionMock.__init__(self)
        self.w = QWidget()
        self.list_trigger = QComboBox()
        self.list_conn_trigger = QComboBox()
        self.pattern_trigger = QLineEdit()
        self.command_trigger = QLineEdit()
        self.case_trigger = QCheckBox()
        self.delete_trigger = QPushButton()
        self.save_trigger = QPushButton()
        self.radio_command_trigger = QRadioButton(self.w)
        self.radio_command_trigger.setChecked(True)
        self.radio_color_trigger = QRadioButton(self.w)
        self.text_color_trigger_button = QPushButton()
        self.bg_color_trigger_button = QPushButton()
        self.text_color_trigger = QLabel()
        self.bg_color_trigger = QLabel()
Ejemplo n.º 30
0
    def _setupUi(self):
        self.setWindowTitle(tr("Export Options"))
        self.mainLayout = QVBoxLayout(self)

        self.label1 = QLabel(tr("Which accounts do you want to export?"), self)
        self.mainLayout.addWidget(self.label1)
        self.exportTypeButtons = QButtonGroup(self)
        self.exportAllButton = QRadioButton(tr("All"), self)
        self.mainLayout.addWidget(self.exportAllButton)
        self.exportTypeButtons.addButton(self.exportAllButton, ExportType.All)
        self.exportAllButton.setChecked(True)
        self.exportSelectedButton = QRadioButton(tr("Selected"), self)
        self.mainLayout.addWidget(self.exportSelectedButton)
        self.exportTypeButtons.addButton(self.exportSelectedButton, ExportType.Selected)

        self.tableView = QTableView(self)
        self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
        self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.tableView.verticalHeader().setVisible(False)
        self.tableView.verticalHeader().setDefaultSectionSize(18)
        self.mainLayout.addWidget(self.tableView)

        self.label2 = QLabel(tr("Export format:"), self)
        self.mainLayout.addWidget(self.label2)
        self.exportFormatButtons = QButtonGroup(self)
        self.exportAsQIFButton = QRadioButton("QIF", self)
        self.mainLayout.addWidget(self.exportAsQIFButton)
        self.exportFormatButtons.addButton(self.exportAsQIFButton, ExportFormat.QIF)
        self.exportAsQIFButton.setChecked(True)
        self.exportAsCSVButton = QRadioButton("CSV", self)
        self.mainLayout.addWidget(self.exportAsCSVButton)
        self.exportFormatButtons.addButton(self.exportAsCSVButton, ExportFormat.CSV)

        self.label3 = QLabel(tr("Export scope:"))
        self.mainLayout.addWidget(self.label3)
        self.dateRangeOnlyCheckbox = QCheckBox(tr("Current date range only"))
        self.mainLayout.addWidget(self.dateRangeOnlyCheckbox)

        self.buttonBox = QDialogButtonBox(self)
        self.buttonBox.setOrientation(Qt.Horizontal)
        self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
        self.exportButton = self.buttonBox.addButton(tr("Export"), QDialogButtonBox.ActionRole)
        self.mainLayout.addWidget(self.buttonBox)
Ejemplo n.º 31
0
class CADOptionsToolbar_Modify(CADOptionsToolbar):
    def __init__(self, layerType):
        super(CADOptionsToolbar_Modify, self).__init__()

        self.add_btn = QRadioButton(
            tr(u"Add"), self.optionsToolBar)
        self.add_btn.setToolTip(
            tr(u"Add extension"))
        self.add_btn.setObjectName("add_rbtn")
        self.modify_btn = QRadioButton(
            tr(u"Modify"), self.optionsToolBar)
        self.modify_btn.setToolTip(
            tr(u"Modify the entity"))
        self.modify_btn.setObjectName("modify_rbtn")
        self.extend_btn = QRadioButton(
            tr(u"Add opposite"), self.optionsToolBar)
        self.extend_btn.setToolTip(
            tr(u"Add an extended line"))
        self.extend_btn.setObjectName("extend_rbtn")
        self.optionsToolBar.addWidget(self.add_btn)
        self.optionsToolBar.addWidget(self.modify_btn)
        self.optionsToolBar.addWidget(self.extend_btn)
        self.add_btn.setChecked(True)

        if layerType == QGis.Polygon:
            self.modify_btn.setChecked(True)
            self.add_btn.setEnabled(False)
            self.extend_btn.setEnabled(False)
        else:
            self.add_btn.setEnabled(True)
            self.extend_btn.setEnabled(True)
Ejemplo n.º 32
0
class Target(preferences.Group):
    def __init__(self, page):
        super(Target, self).__init__(page)

        layout = QGridLayout()
        self.setLayout(layout)

        self.targetPDF = QRadioButton(toggled=page.changed)
        self.targetSVG = QRadioButton(toggled=page.changed)
        self.openDefaultView = QCheckBox(clicked=page.changed)

        layout.addWidget(self.targetPDF, 0, 0)
        layout.addWidget(self.targetSVG, 0, 1)
        layout.addWidget(self.openDefaultView, 1, 0, 1, 5)
        app.translateUI(self)

    def translateUI(self):
        self.setTitle(_("Default output format"))
        self.targetPDF.setText(_("PDF"))
        self.targetPDF.setToolTip(
            _("Create PDF (Portable Document Format) documents by default."))
        self.targetSVG.setText(_("SVG"))
        self.targetSVG.setToolTip(
            _("Create SVG (Scalable Vector Graphics) documents by default."))
        self.openDefaultView.setText(
            _("Open default viewer after successful compile"))
        self.openDefaultView.setToolTip(
            _("Shows the PDF or SVG music view when a compile job finishes "
              "successfully."))

    def loadSettings(self):
        s = settings()
        target = s.value("default_output_target", "pdf", type(""))
        if target == "svg":
            self.targetSVG.setChecked(True)
            self.targetPDF.setChecked(False)
        else:
            self.targetSVG.setChecked(False)
            self.targetPDF.setChecked(True)
        self.openDefaultView.setChecked(
            s.value("open_default_view", True, bool))

    def saveSettings(self):
        s = settings()
        if self.targetSVG.isChecked():
            target = "svg"
        else:
            target = "pdf"
        s.setValue("default_output_target", target)
        s.setValue("open_default_view", self.openDefaultView.isChecked())
    def __init__(self, parameter, parent=None):
        """Constructor.

        :param parameter: A GroupSelectParameter object.
        :type parameter: GroupSelectParameter
        """
        QWidget.__init__(self, parent)
        self._parameter = parameter

        # Store spin box
        self.spin_boxes = {}

        # Create elements
        # Label (name)
        self.label = QLabel(self._parameter.name)

        # Layouts
        self.main_layout = QVBoxLayout()
        self.input_layout = QVBoxLayout()

        # _inner_input_layout must be filled with widget in the child class
        self.inner_input_layout = QVBoxLayout()

        self.radio_button_layout = QGridLayout()

        # Create radio button group
        self.input_button_group = QButtonGroup()

        # List widget
        self.list_widget = QListWidget()
        self.list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.list_widget.setDragDropMode(QAbstractItemView.DragDrop)
        self.list_widget.setDefaultDropAction(Qt.MoveAction)
        self.list_widget.setEnabled(False)
        self.list_widget.setSizePolicy(QSizePolicy.Maximum,
                                       QSizePolicy.Expanding)

        for i, key in enumerate(self._parameter.options):
            value = self._parameter.options[key]
            radio_button = QRadioButton(value.get('label'))
            self.radio_button_layout.addWidget(radio_button, i, 0)
            if value.get('type') == SINGLE_DYNAMIC:
                percentage_spin_box = PercentageSpinBox(self)
                self.radio_button_layout.addWidget(percentage_spin_box, i, 1)
                percentage_spin_box.setValue(value.get('value', 0))
                step = percentage_spin_box.singleStep()
                if step > 1:
                    precision = 0
                else:
                    precision = len(str(step).split('.')[1])
                    if precision > 3:
                        precision = 3
                percentage_spin_box.setDecimals(precision)
                self.spin_boxes[key] = percentage_spin_box

                # Enable spin box depends on the selected option
                if self._parameter.selected == key:
                    percentage_spin_box.setEnabled(True)
                else:
                    percentage_spin_box.setEnabled(False)

            elif value.get('type') == STATIC:
                static_value = value.get('value', 0)
                if static_value is not None:
                    self.radio_button_layout.addWidget(
                        QLabel(str(static_value * 100) + ' %'), i, 1)
            elif value.get('type') == MULTIPLE_DYNAMIC:
                if self._parameter.selected == key:
                    self.list_widget.setEnabled(True)
                else:
                    self.list_widget.setEnabled(False)

            self.input_button_group.addButton(radio_button, i)
            if self._parameter.selected == key:
                radio_button.setChecked(True)

        # Help text
        self.help_label = QLabel(self._parameter.help_text)
        self.help_label.setSizePolicy(QSizePolicy.Maximum,
                                      QSizePolicy.Expanding)
        self.help_label.setWordWrap(True)
        self.help_label.setAlignment(Qt.AlignTop)

        self.inner_input_layout.addLayout(self.radio_button_layout)
        self.inner_input_layout.addWidget(self.list_widget)

        # Put elements into layouts
        self.input_layout.addWidget(self.label)
        self.input_layout.addLayout(self.inner_input_layout)

        self.help_layout = QVBoxLayout()
        self.help_layout.addWidget(self.help_label)

        self.main_layout.addLayout(self.input_layout)
        self.main_layout.addLayout(self.help_layout)

        self.setLayout(self.main_layout)

        self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Expanding)

        # Update list widget
        self.update_list_widget()

        # Connect signal
        # noinspection PyUnresolvedReferences
        self.input_button_group.buttonClicked.connect(
            self.radio_buttons_clicked)
Ejemplo n.º 34
0
class SettingsPage(QWidget):
    """
    """
    ReloadSettings = pyqtSignal()
    TestSettings = pyqtSignal(dict)

    def __init__(self, parent):
        """
        """
        super(SettingsPage, self).__init__()
        self.__core = parent
        self.config = None

        self.createWidgets()
        self.createConnections()

        self.loadCfg()

    def core(self):
        """
        """
        return self.__core

    def createConnections(self):
        """
        """
        self.saveButton.clicked.connect(self.__saveCfg)
        self.testButton.clicked.connect(self.testConnection)

    def createWidgets(self):
        """
        """
        qcCredGroup = QGroupBox(self.tr("HP ALM server credentials"))
        self.hpCredLogin = QLineEdit()
        self.hpCredPwd = QLineEdit()
        self.hpCredPwd.setEchoMode(QLineEdit.Password)
        qcCredLayout = QGridLayout()
        qcCredLayout.addWidget(QLabel("Login"), 0, 0)
        qcCredLayout.addWidget(self.hpCredLogin, 0, 1)
        qcCredLayout.addWidget(QLabel("Password"), 1, 0)
        qcCredLayout.addWidget(self.hpCredPwd, 1, 1)
        qcCredGroup.setLayout(qcCredLayout)

        qcSvrGroup = QGroupBox(self.tr("HP ALM server informations"))
        self.hpSvrURL = QLineEdit()
        self.hpSvrDomain = QLineEdit()
        self.hpSvrProject = QLineEdit()

        self.comAPI = QRadioButton("COM")
        self.comAPI.setChecked(False)
        self.comAPI.setEnabled(False)

        self.restAPI = QRadioButton("REST")
        self.restAPI.setChecked(True)

        layoutApi = QHBoxLayout()
        layoutApi.addWidget(self.comAPI)
        layoutApi.addWidget(self.restAPI)

        qcSvrLayout = QGridLayout()
        qcSvrLayout.addWidget(QLabel("URL"), 0, 0)
        qcSvrLayout.addWidget(self.hpSvrURL, 0, 1)
        qcSvrLayout.addWidget(QLabel("Domain"), 1, 0)
        qcSvrLayout.addWidget(self.hpSvrDomain, 1, 1)
        qcSvrLayout.addWidget(QLabel("Project"), 2, 0)
        qcSvrLayout.addWidget(self.hpSvrProject, 2, 1)
        qcSvrLayout.addWidget(QLabel("API"), 3, 0)
        qcSvrLayout.addLayout(layoutApi, 3, 1)

        qcSvrGroup.setLayout(qcSvrLayout)

        # begin export result settings
        qcExportResultGroup = QGroupBox(self.tr("Export results"))
        self.ignoreTcCheckBox = QCheckBox(self.tr("Ignore testcase(s)"))
        self.ignoreUncompleteCheckBox = QCheckBox(
            self.tr("Ignore uncomplete test(s)"))
        self.addFoldersTlCheckBox = QCheckBox(
            self.tr("Create missing folders in test lab"))
        self.addTestsetCheckBox = QCheckBox(
            self.tr("Create testset if missing in test lab"))
        self.addTestinstanceCheckBox = QCheckBox(
            self.tr("Create test instance in test set"))
        self.cfgsTestsetTable = DesignPage.ConfigsTableView(self,
                                                            core=self.core())
        qcExportResultLayout = QVBoxLayout()
        qcExportResultLayout.addWidget(self.ignoreTcCheckBox)
        qcExportResultLayout.addWidget(self.ignoreUncompleteCheckBox)
        qcExportResultLayout.addWidget(self.addFoldersTlCheckBox)
        qcExportResultLayout.addWidget(self.addTestsetCheckBox)
        qcExportResultLayout.addWidget(self.addTestinstanceCheckBox)
        qcExportResultLayout.addWidget(QLabel("Custom TestSet Fields"))
        qcExportResultLayout.addWidget(self.cfgsTestsetTable)
        qcExportResultLayout.addStretch(1)
        qcExportResultGroup.setLayout(qcExportResultLayout)
        # end

        # begin export test settings
        qcExportGroup = QGroupBox(self.tr("Export tests"))

        self.mergeCheckBox = QCheckBox(self.tr("Merge all tests in one"))
        self.mergeStepsCheckBox = QCheckBox(self.tr("Merge all steps in one"))
        self.showTcNameCheckBox = QCheckBox(
            self.tr("Load with original test name"))
        self.replaceTcCheckBox = QCheckBox(
            self.tr("Replace testcase with testname"))
        self.addFoldersTpCheckBox = QCheckBox(
            self.tr("Create missing folders in test plan"))
        self.overwriteTcCheckBox = QCheckBox(
            self.tr("Overwrite testcases in test plan"))
        self.cfgsTable = DesignPage.ConfigsTableView(self, core=self.core())

        qcExportLayout = QGridLayout()
        qcExportLayout.addWidget(self.mergeCheckBox, 0, 0)
        qcExportLayout.addWidget(self.mergeStepsCheckBox, 1, 0)
        qcExportLayout.addWidget(self.showTcNameCheckBox, 2, 0)
        qcExportLayout.addWidget(self.replaceTcCheckBox, 3, 0)
        qcExportLayout.addWidget(self.addFoldersTpCheckBox, 4, 0)
        qcExportLayout.addWidget(self.overwriteTcCheckBox, 5, 0)
        qcExportLayout.addWidget(QLabel("Custom Test Fields"), 6, 0)
        qcExportLayout.addWidget(self.cfgsTable, 7, 0)
        qcExportGroup.setLayout(qcExportLayout)
        # end

        layoutCtrls = QHBoxLayout()
        self.saveButton = QPushButton(self.tr("Save Settings"), self)
        self.testButton = QPushButton(self.tr("Test Connection"), self)
        layoutCtrls.addWidget(self.saveButton)
        layoutCtrls.addWidget(self.testButton)

        mainLayout = QGridLayout()
        mainLayout.addWidget(qcSvrGroup, 0, 0)
        mainLayout.addWidget(qcCredGroup, 0, 1)
        mainLayout.addWidget(qcExportGroup, 2, 0)
        mainLayout.addWidget(qcExportResultGroup, 2, 1)
        mainLayout.addLayout(layoutCtrls, 3, 1)
        self.setLayout(mainLayout)

    def loadCfg(self):
        """
        """
        with open("%s/config.json" % (QtHelper.dirExec())) as f:
            CONFIG_RAW = f.read()
        self.config = json.loads(CONFIG_RAW)

        self.hpCredLogin.setText(self.config["credentials"]["login"])
        self.hpSvrURL.setText(self.config["qc-server"]["url"])
        self.hpSvrDomain.setText(self.config["qc-server"]["domain"])
        self.hpSvrProject.setText(self.config["qc-server"]["project"])

        self.restAPI.setChecked(True)

        if self.config["export-tests"]["merge-all-tests"]:
            self.mergeCheckBox.setCheckState(Qt.Checked)
        if self.config["export-tests"]["merge-all-steps"]:
            self.mergeStepsCheckBox.setCheckState(Qt.Checked)
        if self.config["export-tests"]["original-test"]:
            self.showTcNameCheckBox.setCheckState(Qt.Checked)
        if self.config["export-tests"]["replace-testcase"]:
            self.replaceTcCheckBox.setCheckState(Qt.Checked)
        if self.config["export-tests"]["add-folders"]:
            self.addFoldersTpCheckBox.setCheckState(Qt.Checked)
        if self.config["export-tests"]["overwrite-tests"]:
            self.overwriteTcCheckBox.setCheckState(Qt.Checked)
        self.cfgsTable.loadTable(data=self.config["custom-test-fields"])

        if self.config["export-results"]["ignore-testcase"]:
            self.ignoreTcCheckBox.setCheckState(Qt.Checked)
        if self.config["export-results"]["ignore-uncomplete"]:
            self.ignoreUncompleteCheckBox.setCheckState(Qt.Checked)
        if self.config["export-results"]["add-folders"]:
            self.addFoldersTlCheckBox.setCheckState(Qt.Checked)
        if self.config["export-results"]["add-testset"]:
            self.addTestsetCheckBox.setCheckState(Qt.Checked)
        if self.config["export-results"]["add-testinstance"]:
            self.addTestinstanceCheckBox.setCheckState(Qt.Checked)
        self.cfgsTestsetTable.loadTable(
            data=self.config["custom-testset-fields"])

        # decrypt password
        if len(self.config["credentials"]["password"]):
            decrypted = self.decryptPwd(
                key=bytes(self.config["credentials"]["login"], "utf8"),
                ciphertext=bytes(self.config["credentials"]["password"],
                                 "utf8"))
            self.config["credentials"]["password"] = decrypted
            self.hpCredPwd.setText(decrypted)

    def __saveCfg(self):
        """
        """
        self.saveCfg(successMsg=True)

    def saveCfg(self, successMsg=True):
        """
        """
        # if successMsg:
        if not len(self.hpSvrURL.text()):
            QMessageBox.warning(self, self.tr("Save Settings"),
                                self.tr("Please to set the server url"))
            return
        if not len(self.hpSvrDomain.text()):
            QMessageBox.warning(self, self.tr("Save Settings"),
                                self.tr("Please to set the server domain"))
            return
        if not len(self.hpSvrProject.text()):
            QMessageBox.warning(self, self.tr("Save Settings"),
                                self.tr("Please to set the server project"))
            return

        if not len(self.hpCredLogin.text()):
            QMessageBox.warning(self, self.tr("Save Settings"),
                                self.tr("Please to set a login"))
            return
        if not len(self.hpCredPwd.text()):
            QMessageBox.warning(self, self.tr("Save Settings"),
                                self.tr("Please to set a password"))
            return

        self.config["credentials"]["login"] = self.hpCredLogin.text()
        # encrypt password
        encryptPwd = self.encryptPwd(key=self.hpCredLogin.text(),
                                     plaintext=self.hpCredPwd.text())
        self.config["credentials"]["password"] = str(encryptPwd, "utf8")

        self.config["qc-server"]["url"] = self.hpSvrURL.text()
        self.config["qc-server"]["domain"] = self.hpSvrDomain.text()
        self.config["qc-server"]["project"] = self.hpSvrProject.text()
        self.config["qc-server"]["use-rest"] = False
        if self.restAPI.isChecked():
            self.config["qc-server"]["use-rest"] = True

        self.config["export-tests"]["merge-all-tests"] = False
        self.config["export-tests"]["merge-all-steps"] = False
        self.config["export-tests"]["original-test"] = False
        self.config["export-tests"]["replace-testcase"] = False
        self.config["export-tests"]["add-folders"] = False
        self.config["export-tests"]["overwrite-tests"] = False
        if self.mergeCheckBox.isChecked():
            self.config["export-tests"]["merge-all-tests"] = True
        if self.mergeStepsCheckBox.isChecked():
            self.config["export-tests"]["merge-all-steps"] = True
        if self.showTcNameCheckBox.isChecked():
            self.config["export-tests"]["original-test"] = True
        if self.replaceTcCheckBox.isChecked():
            self.config["export-tests"]["replace-testcase"] = True
        if self.addFoldersTpCheckBox.isChecked():
            self.config["export-tests"]["add-folders"] = True
        if self.overwriteTcCheckBox.isChecked():
            self.config["export-tests"]["overwrite-tests"] = True
        self.config["custom-test-fields"] = self.cfgsTable.model.getData()

        self.config["export-results"]["add-folders"] = False
        self.config["export-results"]["ignore-testcase"] = False
        self.config["export-results"]["ignore-uncomplete"] = False
        self.config["export-results"]["add-testset"] = False
        self.config["export-results"]["add-testinstance"] = False
        if self.ignoreTcCheckBox.isChecked():
            self.config["export-results"]["ignore-testcase"] = True
        if self.ignoreUncompleteCheckBox.isChecked():
            self.config["export-results"]["ignore-uncomplete"] = True
        if self.addFoldersTlCheckBox.isChecked():
            self.config["export-results"]["add-folders"] = True
        if self.addTestsetCheckBox.isChecked():
            self.config["export-results"]["add-testset"] = True
        if self.addTestinstanceCheckBox.isChecked():
            self.config["export-results"]["add-testinstance"] = True
        self.config[
            "custom-testset-fields"] = self.cfgsTestsetTable.model.getData()

        with open("%s/config.json" % (QtHelper.dirExec()), "w") as f:
            f.write(json.dumps(self.config))

        if len(self.config["credentials"]["password"]):
            self.config["credentials"]["password"] = self.decryptPwd(
                key=bytes(self.config["credentials"]["login"], "utf8"),
                ciphertext=bytes(self.config["credentials"]["password"],
                                 "utf8"))

        self.ReloadSettings.emit()

        if successMsg:
            QMessageBox.information(self, self.tr("Save Settings"),
                                    self.tr("Settings saved."))

    def cfg(self):
        """
        """
        return self.config

    def encryptPwd(self, key, plaintext):
        """
        """
        return base64.b64encode(bytes(plaintext, "utf8"))

    def decryptPwd(self, key, ciphertext):
        """
        """
        return str(base64.b64decode(ciphertext), "utf8")

    def testConnection(self):
        """
        """
        self.TestSettings.emit(self.config)
Ejemplo n.º 35
0
class GUI(QtGui.QMainWindow):
    def __init__(self, win_parent=None):
        '''
        Initialize main window
        '''
        QtGui.QMainWindow.__init__(self, win_parent)
        self.setWindowTitle('MapFormers: Get nodes geolocations')
        self.setGeometry(250, 200, 714, 491)
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.setWindowFlags(Qt.CustomizeWindowHint)
        self.setWindowFlags(Qt.WindowSystemMenuHint)
        self.setWindowIcon(QtGui.QIcon(Paths["Icon"]))
        self.Elem_init()
        self.InitialValues()
        self.setGeometry_()
        self.InitialValues()
        self.setLabels()
        self.SetLayouts()

        if not CheckAttr(Visum.Net.Nodes, 'Google_X'):
            Visum.Net.Nodes.AddUserDefinedAttribute('Google_X', 'Google_X',
                                                    'Google_X', 2,
                                                    10)  #else create UDAs
        if not CheckAttr(Visum.Net.Nodes, 'Google_Y'):
            Visum.Net.Nodes.AddUserDefinedAttribute('Google_Y', 'Google_Y',
                                                    'Google_Y', 2,
                                                    10)  #else create UDAs

        self.connect(self.SB_NodeNumber, QtCore.SIGNAL('editingFinished()'),
                     self.MakeVisScreenshot)
        self.connect(self.DSB_Zoom, QtCore.SIGNAL('editingFinished()'),
                     self.MakeVisScreenshot)

        self.connect(self.SB_NodeNumber, QtCore.SIGNAL('editingFinished()'),
                     self.UpdateGeoPos)
        self.connect(self.SB_NodeNumber, QtCore.SIGNAL('valueChanged()'),
                     self.UpdateGeoPos)

        self.connect(self.B_ImportPos, QtCore.SIGNAL('clicked()'),
                     self.ImportGeoPosition)

        self.connect(self.B_Next, QtCore.SIGNAL('clicked()'), self.NextWindow)
        self.connect(self.B_Back, QtCore.SIGNAL('clicked()'), self.BackWindow)

        self.connect(self.B_Calculate, QtCore.SIGNAL('clicked()'),
                     self.Transform)
        self.connect(self.RB_prj, QtCore.SIGNAL('clicked()'), self.RBPrjClick)
        self.connect(self.RB_regression, QtCore.SIGNAL('clicked()'),
                     self.RBRegClick)
        self.connect(self.RB_partiall, QtCore.SIGNAL('clicked()'),
                     self.RBParClick)

        self.connect(self.B_Cancel, QtCore.SIGNAL('clicked()'),
                     self.closeEvent)
        self.connect(self.B_Cancel_T2, QtCore.SIGNAL('clicked()'),
                     self.closeEvent)

        self.connect(self.B_Help, QtCore.SIGNAL('clicked()'), self.openHelp)
        self.connect(self.B_Help_T2, QtCore.SIGNAL('clicked()'), self.openHelp)

    def Elem_init(self):

        self.SW_Main = QStackedWidget(self)

        self.SW_Tab1 = QWidget(self.SW_Main)
        self.SW_Tab2 = QWidget(self.SW_Main)

        self.GB_LeftSide = QGroupBox(self.SW_Tab1)
        self.GB_RightSide = QGroupBox(self.SW_Tab1)
        self.BottomWidget = QtGui.QWidget(self.SW_Tab1)

        self.Wid_LayVer_LeftSide = QtGui.QWidget(self.GB_LeftSide)
        self.L_ImageLeft = QtGui.QLabel(self.Wid_LayVer_LeftSide)

        self.GB_Options_LB = QtGui.QGroupBox(self.GB_LeftSide)

        self.L_NodeNumber = QtGui.QLabel(self.GB_Options_LB)
        self.L_zoom = QtGui.QLabel(self.GB_Options_LB)
        self.SB_NodeNumber = QtGui.QSpinBox(self.GB_Options_LB)
        self.DSB_Zoom = QtGui.QDoubleSpinBox(self.GB_Options_LB)
        self.L_GeoT = QtGui.QLabel(self.GB_Options_LB)
        self.L_GeoPos = QtGui.QLabel(self.GB_Options_LB)

        self.ImageLeft = QtGui.QPixmap(Paths["Screenshot"])

        self.Wid_LayVer_RightSide = QtGui.QWidget(self.GB_RightSide)

        self.B_ImportPos = QtGui.QPushButton(self.Wid_LayVer_RightSide)
        self.Web = QWebView(self.Wid_LayVer_RightSide)

        self.B_Help = QtGui.QPushButton(self.BottomWidget)
        self.B_Next = QtGui.QPushButton(self.BottomWidget)
        self.B_Cancel = QtGui.QPushButton(self.BottomWidget)
        self.L_ImageLogo = QtGui.QLabel(self.BottomWidget)

        self.ImageLogo = QtGui.QPixmap(Paths["Logo"])

        self.BG_Transform = QtGui.QGroupBox(self.SW_Tab2)
        self.BottomWidget_T2 = QtGui.QWidget(self.SW_Tab2)

        self.GB_Opt_T2 = QtGui.QGroupBox(self.SW_Tab2)

        self.SB_NodeNumber_T2 = QtGui.QSpinBox(self.GB_Opt_T2)
        self.DSB_Factor_T2 = QtGui.QDoubleSpinBox(self.GB_Opt_T2)
        self.L_Factor_T2 = QtGui.QLabel(self.GB_Opt_T2)
        self.L_NodeNumber_T2 = QtGui.QLabel(self.GB_Opt_T2)

        self.RB_prj = QRadioButton(self.BG_Transform)
        self.RB_regression = QRadioButton(self.BG_Transform)
        self.RB_partiall = QRadioButton(self.BG_Transform)

        self.B_Help_T2 = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Back = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Calculate = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Cancel_T2 = QtGui.QPushButton(self.BottomWidget_T2)
        self.L_ImageLogo_T2 = QtGui.QLabel(self.BottomWidget_T2)

        self.LayGrid_Main = QtGui.QGridLayout()
        self.LayVer_LeftSide = QtGui.QVBoxLayout()
        self.LayVer_RightSide = QtGui.QVBoxLayout()
        self.LayGrid_Bottom = QtGui.QGridLayout()
        self.LayGrid_Opt = QtGui.QGridLayout()
        self.LayVer_Main_T2 = QtGui.QVBoxLayout()
        self.Lay_Transform = QVBoxLayout()
        self.LayGrid_Bottom_T2 = QtGui.QGridLayout()
        self.BL_Lay_Transform = QtGui.QVBoxLayout()

        self.LayHor_Opt_T2 = QtGui.QHBoxLayout()

        self.V_NodeFilter = Visum.Filters.NodeFilter()
        self.V_LinkFilter = Visum.Filters.LinkFilter()

    def setLabels(self):

        self.GB_LeftSide.setTitle("Visum Node")
        self.GB_RightSide.setTitle("Map reference")
        self.L_NodeNumber.setText("Node number:")
        self.L_zoom.setText("Zoom:")
        self.L_GeoT.setText("Current node's geoposition:")
        self.L_GeoPos.setText("no reference")
        self.B_ImportPos.setText("Save reference")
        self.B_Help.setText("Help")
        self.B_Next.setText("Next ->")
        self.B_Cancel.setText("Cancel")
        self.RB_prj.setText(
            "Option 1: Transform network by means of .prj file.\n (This option will worn only if network scale is linear (scale for X axis = scale for Y axis) - \n in most cases it will not work for Your network."
        )
        self.RB_regression.setText(
            "Option 2: Transform network by means of linear regression calibrated with input reference data. \n Specify confidence factor [0-1] for input data in the box below - default value is 0.8"
        )
        self.RB_partiall.setText(
            "Option 3: Adjust only active part of the network (nodes, and links) based on reference node from box below"
        )
        self.BG_Transform.setTitle("Transform network")
        self.B_Help_T2.setText("Help")
        self.B_Back.setText("<- Back")
        self.B_Calculate.setText("Calculate")
        self.B_Cancel_T2.setText("Cancel")
        self.L_Factor_T2.setText("Confidence factor:")
        self.L_NodeNumber_T2.setText("Node number:")

    def setGeometry_(self):

        self.B_Help.setFixedSize(85, 23)
        self.B_Next.setFixedSize(85, 23)
        self.B_Cancel.setFixedSize(85, 23)
        self.L_ImageLogo.setFixedSize(200, 32)
        self.B_Help_T2.setFixedSize(85, 23)
        self.B_Back.setFixedSize(85, 23)
        self.B_Calculate.setFixedSize(85, 23)
        self.B_Cancel_T2.setFixedSize(85, 23)
        self.L_ImageLogo_T2.setFixedSize(200, 32)

        self.L_ImageLeft.setMinimumSize(300, 300)
        self.L_ImageLeft.setBaseSize(350, 350)
        self.Web.setContentsMargins(0, 0, 0, 0)
        self.Web.setMinimumSize(350, 350)
        self.Web.setBaseSize(375, 375)

    def InitialValues(self):

        self.setCentralWidget(self.SW_Main)

        self.Web.page().mainFrame().load(QUrl(Paths["Html"]))
        self.Web.page().setViewportSize(
            self.Web.page().mainFrame().contentsSize())

        NodeIter = Visum.Net.Nodes.Iterator
        try:
            FirstActiveNode = NodeIter.Item.AttValue("No")
        except:
            Visum.Net.AddNode(1, 1, 1)
            NodeIter = Visum.Net.Nodes.Iterator
            FirstActiveNode = NodeIter.Item.AttValue("No")

        Visum.Graphic.Autozoom(Visum.Net.Nodes.ItemByKey(FirstActiveNode))
        self.V_NodeFilter.Init()
        self.V_NodeFilter.AddCondition("OP_NONE", False, "NO", "EqualVal",
                                       FirstActiveNode)
        self.V_NodeFilter.UseFilter = True

        self.V_LinkFilter.Init()
        self.V_LinkFilter.AddCondition("OP_NONE", False, "ToNodeNo",
                                       "EqualVal", FirstActiveNode)
        self.V_LinkFilter.UseFilter = True

        Visum.Graphic.Screenshot(Paths["Screenshot"])
        Screenshot = QtGui.QPixmap(Paths["Screenshot"])

        self.SB_NodeNumber.setValue(FirstActiveNode)
        self.SB_NodeNumber.setMaximum(1000000000)

        self.SB_NodeNumber_T2.setValue(FirstActiveNode)
        self.SB_NodeNumber_T2.setMaximum(1000000000)

        self.DSB_Factor_T2.setValue(0.8)
        self.DSB_Factor_T2.setMaximum(1)

        self.DSB_Zoom.setValue(1)
        self.DSB_Zoom.setSingleStep(0.5)
        self.DSB_Zoom.setMaximum(1000000)

        self.L_ImageLeft.setPixmap(Screenshot)
        self.L_ImageLeft.setScaledContents(True)

        self.ImageLogo.scaled(200, 23, Qt.IgnoreAspectRatio,
                              Qt.SmoothTransformation)
        #self.L_ImageLogo.setScaledContents(True)
        self.L_ImageLogo.setPixmap(self.ImageLogo)

        self.L_ImageLogo_T2.setScaledContents(True)
        self.L_ImageLogo_T2.setPixmap(self.ImageLogo)

        self.L_ImageLeft.show()
        self.RBRegClick()

        self.RB_regression.setChecked(True)

    def SetLayouts(self):

        self.L_NodeNumber.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.L_zoom.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.SB_NodeNumber.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
        self.DSB_Zoom.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
        self.L_GeoT.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.L_GeoPos.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
        self.L_ImageLogo_T2.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
        self.L_ImageLogo.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)

        self.L_NodeNumber_T2.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.SB_NodeNumber_T2.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)
        self.L_Factor_T2.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.DSB_Factor_T2.setAlignment(Qt.AlignVCenter | Qt.AlignLeft)

        self.GB_Options_LB.setSizePolicy(QSizePolicy.Expanding,
                                         QSizePolicy.Fixed)
        self.BottomWidget_T2.setSizePolicy(QSizePolicy.Expanding,
                                           QSizePolicy.Fixed)
        self.GB_Opt_T2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)

        self.LayGrid_Opt.addWidget(self.L_NodeNumber, 1, 0, 1, 1)
        self.LayGrid_Opt.addWidget(self.L_zoom, 1, 2, 1, 1)
        self.LayGrid_Opt.addWidget(self.SB_NodeNumber, 1, 1, 1, 1)
        self.LayGrid_Opt.addWidget(self.DSB_Zoom, 1, 3, 1, 1)
        self.LayGrid_Opt.addWidget(self.L_GeoT, 0, 0, 1, 2)
        self.LayGrid_Opt.addWidget(self.L_GeoPos, 0, 2, 1, 2)
        self.LayGrid_Opt.setVerticalSpacing(20)

        self.LayVer_LeftSide.addWidget(self.L_ImageLeft)
        self.LayVer_LeftSide.addWidget(self.GB_Options_LB)
        self.LayVer_LeftSide.setSpacing(20)

        self.LayVer_RightSide.addWidget(self.Web)
        self.LayVer_RightSide.addWidget(self.B_ImportPos)
        self.LayVer_RightSide.setSpacing(20)

        self.LayGrid_Bottom.addWidget(self.B_Help, 0, 0, 1, 1)
        self.LayGrid_Bottom.addWidget(QWidget(), 0, 1, 1, 1)
        self.LayGrid_Bottom.addWidget(self.L_ImageLogo, 0, 2, 1, 1)
        self.LayGrid_Bottom.addWidget(QWidget(), 0, 3, 1, 1)
        self.LayGrid_Bottom.addWidget(self.B_Next, 0, 4, 1, 1)
        self.LayGrid_Bottom.addWidget(self.B_Cancel, 0, 5, 1, 1)

        self.LayGrid_Main.addWidget(self.GB_LeftSide, 0, 0, 1, 2)
        self.LayGrid_Main.addWidget(self.GB_RightSide, 0, 2, 1, 4)
        self.LayGrid_Main.addWidget(self.BottomWidget, 1, 0, 1, 6)

        self.BL_Lay_Transform.addWidget(self.RB_prj)
        self.BL_Lay_Transform.addWidget(self.RB_regression)
        self.BL_Lay_Transform.addWidget(self.RB_partiall)

        self.LayGrid_Bottom_T2.addWidget(self.B_Help_T2, 0, 0, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(QWidget(), 0, 1, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(self.L_ImageLogo_T2, 0, 2, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(QWidget(), 0, 3, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(self.B_Back, 0, 4, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(self.B_Calculate, 0, 5, 1, 1)
        self.LayGrid_Bottom_T2.addWidget(self.B_Cancel_T2, 0, 6, 1, 1)

        self.LayHor_Opt_T2.addWidget(self.L_NodeNumber_T2)
        self.LayHor_Opt_T2.addWidget(self.SB_NodeNumber_T2)
        self.LayHor_Opt_T2.addWidget(self.L_Factor_T2)
        self.LayHor_Opt_T2.addWidget(self.DSB_Factor_T2)
        self.LayHor_Opt_T2.addWidget(QWidget())

        self.LayVer_Main_T2.addWidget(self.BG_Transform)
        self.LayVer_Main_T2.addWidget(self.GB_Opt_T2)
        self.LayVer_Main_T2.addWidget(QWidget())
        self.LayVer_Main_T2.addWidget(self.BottomWidget_T2)

        self.GB_Opt_T2.setLayout(self.LayHor_Opt_T2)

        self.SW_Main.addWidget(self.SW_Tab1)
        self.SW_Main.addWidget(self.SW_Tab2)

        self.GB_LeftSide.setLayout(self.LayVer_LeftSide)
        self.GB_RightSide.setLayout(self.LayVer_RightSide)
        self.GB_Options_LB.setLayout(self.LayGrid_Opt)
        self.BottomWidget.setLayout(self.LayGrid_Bottom)
        self.SW_Tab1.setLayout(self.LayGrid_Main)
        self.BG_Transform.setLayout(self.BL_Lay_Transform)
        self.BottomWidget_T2.setLayout(self.LayGrid_Bottom_T2)
        self.SW_Tab2.setLayout(self.LayVer_Main_T2)

    def RBPrjClick(self):
        self.DSB_Factor_T2.setDisabled(True)
        self.SB_NodeNumber_T2.setDisabled(True)

    def RBRegClick(self):
        self.DSB_Factor_T2.setEnabled(True)
        self.SB_NodeNumber_T2.setDisabled(True)

    def RBParClick(self):
        self.DSB_Factor_T2.setDisabled(True)
        self.SB_NodeNumber_T2.setEnabled(True)

    def NextWindow(self):
        self.SW_Main.setCurrentIndex(1)
        self.setWindowTitle('MapFormers: Transform network'
                            )  #dodanie filtra na nodes - Google_X>0
        self.V_NodeFilter.Init()
        self.V_NodeFilter.AddCondition("OP_NONE", False, "Google_X", 3, 0)
        self.V_NodeFilter.UseFilter = True

    def BackWindow(self):
        self.SW_Main.setCurrentIndex(0)
        self.setWindowTitle('MapFormers: Get nodes geolocations')

    def UpdateGeoPos(self):
        '''
        Script updates label displaying node's geolocation
        '''

        NodeNumber = self.SB_NodeNumber.value()
        try:

            xf = Visum.Net.Nodes.ItemByKey(NodeNumber).AttValue("Google_X")
            x = QString()
            x.setNum(xf, 'g', 5)
            yf = Visum.Net.Nodes.ItemByKey(NodeNumber).AttValue("Google_Y")
            y = QString()
            y.setNum(yf, 'g', 5)
            if (xf == 0 and yf == 0):
                self.Web.page().mainFrame().evaluateJavaScript(
                    "removemarkers();")
                self.L_GeoPos.setText("no reference")
            else:
                self.L_GeoPos.setText("x: " + x + " N" + " y: " + y + " E")
                self.Web.page().mainFrame().evaluateJavaScript(
                    "Gx = %f; Gy = %f;" % (xf, yf))
                self.Web.page().mainFrame().evaluateJavaScript("markerf();")

        except:
            self.L_GeoPos.setText("node does not exist")

    def ImportGeoPosition(self):
        '''        
        evaluate JavaScript to return previously selected geographical position in OpenLayers WebWidget
        '''
        NodeNumber = self.SB_NodeNumber.value()
        try:
            Visum.Net.Nodes.GetMultiAttValues(
                'Google_X')  #check if UDAs exists
        except:
            Visum.Net.Nodes.AddUserDefinedAttribute('Google_X', 'Google_X',
                                                    'Google_X', 2,
                                                    10)  #else create UDAs
            Visum.Net.Nodes.AddUserDefinedAttribute('Google_Y', 'Google_Y',
                                                    'Google_Y', 2, 10)

        Visum.Net.Nodes.ItemByKey(NodeNumber).SetAttValue(
            "Google_X",
            self.Web.page().mainFrame().evaluateJavaScript(
                "returnposx();").toReal()[0]
        )  # w pliku html trzeba sie upewnic, ze to zawsze bedzie wspolrzedna lon/lat ! ! ! czasami osm samo zmienia na Projected Coordinate System (czyli wartosci okolo miliona, tak nie moze byc, bo nigdy nie dojdziemy do ladu!zawsze musza byc lon/lat
        Visum.Net.Nodes.ItemByKey(NodeNumber).SetAttValue(
            "Google_Y",
            self.Web.page().mainFrame().evaluateJavaScript(
                "returnposy();").toReal()[0])
        self.UpdateGeoPos()

    def Transform(self):

        type = [
            self.RB_prj.isChecked(), False,
            self.RB_regression.isChecked(),
            self.RB_partiall.isChecked()
        ]

        nodeno = self.SB_NodeNumber_T2.value()
        factor = self.DSB_Factor_T2.value()

        def rescale(scaleX, scaleY, deltaX, deltaY, activeOnly):
            def link_iter():
                def New_WKT(WKT, scaleX, scaleY, deltaX, deltaY):

                    WKT = str(WKT[11:-1])
                    WKT = WKT.split(',')
                    for i in range(len(WKT)):
                        WKT[i] = WKT[i].split(' ')
                    WKT = [[i for i in el] for el in WKT]
                    del WKT[0]
                    del WKT[-1]
                    Mtx = [[
                        scaleX * float(el[0]) + deltaX,
                        scaleY * float(el[1]) + deltaY
                    ] for el in WKT]

                    Nowy = [[float(el[0]), float(el[1])] for el in Mtx]
                    Nowy = ', '.join([str(x) for x in Nowy])
                    Nowy = Nowy.replace('],', 'www')
                    Nowy = Nowy.replace(',', '')
                    Nowy = Nowy.replace('www', ',')
                    Nowy = Nowy.replace('[', '')
                    Nowy = Nowy.replace(']', '')
                    Nowy = 'LINESTRING(' + Nowy + ')'
                    return Nowy

                Container = Visum.Net.Links
                WKTs = Container.GetMultiAttValues('WKTPOLY', activeOnly)
                New_WKTs = []
                for i in range(len(WKTs)):
                    New_WKTs.append((WKTs[i][0],
                                     New_WKT(WKTs[i][1], scaleX, scaleY,
                                             deltaX, deltaY)))
                return tuple(New_WKTs)

            def iter(Container):
                Xy = Container.GetMultiAttValues('XCoord', activeOnly)
                Yy = Container.GetMultiAttValues('YCoord', activeOnly)
                New_Xy = []
                New_Yy = []
                for i in range(len(Xy)):
                    New_Xy.append((Xy[i][0], scaleX * Xy[i][1] + deltaX))
                    New_Yy.append((Yy[i][0], scaleY * Yy[i][1] + deltaY))
                return tuple(New_Xy), tuple(New_Yy)
                Container.SetMultiAttValues('XCoord', tuple(New_Xy))
                Container.SetMultiAttValues('YCoord', tuple(New_Yy))

            Node_X, Node_Y = iter(Visum.Net.Nodes)
            New_WKTs = link_iter()
            Zone_X, Zone_Y = iter(Visum.Net.Zones)
            #Visum.Graphic.ShowMinimized()
            Visum.Net.Nodes.SetMultiAttValues('XCoord', Node_X)
            Visum.Net.Nodes.SetMultiAttValues('YCoord', Node_Y)
            try:
                Visum.Net.Links.SetMultiAttValues('WKTPOLY', New_WKTs)
            except:
                pass
            try:
                Visum.Net.Zones.SetMultiAttValues('XCoord', Zone_X)
                Visum.Net.Zones.SetMultiAttValues('YCoord', Zone_Y)
            except:
                pass

        def get_wgs(X):  #transform google lon lat to X,Y

            from pyproj import Proj

            pr_tm = Proj(
                '+proj=merc +lat_0=0 +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +units=m +no_defs'
            )

            x_latlong = X[0]
            y_latlong = X[1]

            x_tm, y_tm = pr_tm(X[0], X[1])

            return x_tm, y_tm

        def set_Visum_projection(false_easting, false_northing, scale):
            scale = 1 / float(
                scale)  #""" reciprocal of scale  correct effect """
            Visum_Projection = u'PROJCS["Mapformers",GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["GRS_1980",6378137.0,298.257223562]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]],PROJECTION["Mercator"],PARAMETER["False_Easting",' + str(
                false_easting
            ) + ' ],PARAMETER["False_Northing",' + str(
                false_northing
            ) + ' ],PARAMETER["Central_Meridian",0],PARAMETER["Standard_Parallel_1",0],UNIT["Meter",' + str(
                scale) + ']]'
            Visum.Net.NetParameters.SetProjection(Visum_Projection, True)

        def get_coords():
            Visum_X = Visum.Net.Nodes.GetMultiAttValues('XCoord', True)
            Visum_X = [el[1] for el in Visum_X]
            Visum_Y = Visum.Net.Nodes.GetMultiAttValues('YCoord', True)
            Visum_Y = [el[1] for el in Visum_Y]
            Google_X = Visum.Net.Nodes.GetMultiAttValues('Google_X', True)
            Google_X = [el[1] for el in Google_X]
            Google_Y = Visum.Net.Nodes.GetMultiAttValues('Google_Y', True)
            Google_Y = [el[1] for el in Google_Y]

            #if Google_X[0]<200:
            #    for i in range(len(Google_X)):
            #        point=[Google_X[i],Google_Y[i]]
            #        [Google_X[i],Google_Y[i]]=get_wgs(point)

            return Visum_X, Visum_Y, Google_X, Google_Y

        def linreg(Visum_, Google_):
            try:
                numpy
            except:
                import numpy as np

            (scale, delta) = np.polyfit(Visum_, Google_, 1)
            nGoogle_ = np.polyval([scale, delta], Visum_)
            err = (sum((nGoogle_ - Google_)**2) / len(Visum_))**.5
            return scale, delta, err

        def cleaned_linreg(Visum_, Google_, cut_factor):
            try:
                numpy
            except:
                import numpy as np

            errs = []
            cut_factor = min((max(cut_factor, .1)), 1)
            range_ = range(max(1, int(len(Google_) * cut_factor)))
            for j in range_:
                (scale, delta) = np.polyfit(Visum_, Google_, 1)
                nGoogle_ = np.polyval([scale, delta], Visum_)
                err = [(nGoogle_[i] - Google_[i])**2
                       for i in range(len(nGoogle_))]
                errs.append((sum((nGoogle_ - Google_)**2) / len(Visum_))**.5)
                max_err = err.index(max(err))
                Visum_.remove(Visum_[max_err])
                Google_.remove(Google_[max_err])

            return scale, delta, errs

        def dist(X, Y):
            return ((X[0] - X[1])**2 + (Y[0] - Y[1])**2)**.5

        def do_projection(Visum_X, Visum_Y, Google_X, Google_Y):
            dist_Visum = dist(
                Visum_X, Visum_Y
            )  #"""calculate distance in Visum, and real distance in Google"""
            dist_Google = dist(Google_X, Google_Y)
            scale = dist_Google / dist_Visum
            set_Visum_projection(
                0, 0, 1)  #"""first set base projection with scale =1"""
            set_Visum_projection(0, 0, scale)  #"""now adjust the scale"""
            Visum_X = Visum.Net.Nodes.GetMultiAttValues('XCoord', True)
            Visum_X = [el[1] for el in Visum_X]
            Visum_Y = Visum.Net.Nodes.GetMultiAttValues('YCoord', True)
            Visum_Y = [el[1] for el in Visum_Y]  #"""get new rescaled coords"""
            delta_X = Google_X[0] - Visum_X[0]
            delta_Y = Google_Y[0] - Visum_Y[0]
            set_Visum_projection(
                0, 0, 1)  #"""first set base projection with scale = 1"""
            set_Visum_projection(0, 0, scale)  #"""now adjust the scale"""
            set_Visum_projection(
                0, 0, 1)  #"""now set bas projection one more time"""
            set_Visum_projection(delta_X, delta_Y,
                                 scale)  #"""and go to proper projection"""

        def analyse_Coords(Visum_X, Visum_Y, Google_X, Google_Y):
            def dst_mtx(A, *B):
                try:
                    B
                    mtx = [[abs(a - b) for a in A] for b in B]
                except:
                    mtx = [[abs(a - b) for a in A] for b in A]
                return mtx

            def get_scale(Visum_d, Google_d):
                range_ = range(len(Visum_d))
                Visum_deltas = dst_mtx(Visum_d)
                for i in range_:
                    for j in range_:
                        if i == j:
                            Visum_deltas[i][i] = 1000000000000000000000

                Google_deltas = dst_mtx(Google_d)
                scales = [[
                    Google_deltas[i][j] / Visum_deltas[i][j] for i in range_
                ] for j in range_]
                return sum([sum(row) for row in scales
                            ]) / (len(Visum_d)**2 - len(Visum_d))

            def get_delta(Visum_d, Google_d, scale):
                size = len(Visum_d)

                return -sum(
                    [Visum_d[i] * scale - Google_d[i]
                     for i in range(size)]) / float(size)

            def get_tg_Mtx(Visum_X, Visum_Y, Google_X, Google_Y):
                # to do ! dla macierzy obliczyc tg nachylenia par punktow dla Googla i dla Visuma
                # policzyc roznice miedzy katami i statycznie opisac (mean, std, dev, etc.)
                pass

            scale_X = get_scale(Visum_X, Google_X)
            scale_Y = get_scale(Visum_Y, Google_Y)
            delta_X = get_delta(Visum_X, Google_X, scale_X)
            delta_Y = get_delta(Visum_Y, Google_Y, scale_Y)
            return scale_X, scale_Y, delta_X, delta_Y

        #tg_V=abs(Visum_X[0]-Visum_X[1])/abs(Visum_Y[0]-Visum_Y[1])
        #tg_G=abs(Google_X[0]-Google_X[1])/abs(Google_Y[0]-Google_Y[1])
        #dev=1-tg_V/tg_G

        Visum_X, Visum_Y, Google_X, Google_Y = get_coords()
        Visum.Graphic.ShowMinimized()

        if type == [1, 0, 0, 0]:
            """ poprzez projekcje Visum set projection """
            do_projection(Visum_X, Visum_Y, Google_X, Google_Y)

        elif type == [0, 1, 0, 0]:
            """ przypadek rescale dla dwu punktow """

            scale_X, scale_Y, delta_X, delta_Y = analyse_Coords(
                Visum_X, Visum_Y, Google_X, Google_Y)
            rescale(scale_X, scale_Y, delta_X, delta_Y, False)

        elif type == [0, 0, 1, 0]:
            """ przypadek rescale dla wielu punktow """
            scale_X, delta_X, _ = cleaned_linreg(
                Visum_X, Google_X, factor)  #zmiana 0,8 -> factor.
            scale_Y, delta_Y, _ = cleaned_linreg(Visum_Y, Google_Y, factor)
            rescale(scale_X, scale_Y, delta_X, delta_Y, False)

        else:
            """ przesuniecie czesci sieci (dodatkowy tuning) """
            Node = Visum.Net.Nodes.ItemByKey(nodeno)
            delta_X = Node.AttValue('Google_X') - Node.AttValue('XCoord')
            delta_Y = Node.AttValue('Google_Y') - Node.AttValue('YCoord')
            rescale(1, 1, delta_X, delta_Y, True)

        Visum.Graphic.ShowMaximized()
        #"""finito"""

    def MakeVisScreenshot(self):
        '''
        make the screenshot of visum network with selected options
        '''
        NodeNumber = self.SB_NodeNumber.value()
        zoom = self.DSB_Zoom.value()
        try:
            zoom = 1 / zoom
        except:
            pass

        try:
            Visum.Graphic.Autozoom(Visum.Net.Nodes.ItemByKey(NodeNumber))
            self.V_NodeFilter.Init()
            self.V_NodeFilter.AddCondition("OP_NONE", False, "NO", "EqualVal",
                                           NodeNumber)
            self.V_NodeFilter.UseFilter = True

            self.V_LinkFilter.Init()
            self.V_LinkFilter.AddCondition("OP_NONE", False, "ToNodeNo",
                                           "EqualVal", NodeNumber)
            self.V_LinkFilter.UseFilter = True

            Window = Visum.Graphic.GetWindow()
            WWidth = Window[2] - Window[0]
            WHeight = Window[3] - Window[1]
            WXCenter = Window[0] + WWidth / 2
            WYCenter = Window[1] + WHeight / 2
            WXmin = WXCenter - (WWidth * zoom)
            WYmin = WYCenter - (WHeight * zoom)
            WXmax = WXCenter + (WWidth * zoom)
            WYmax = WYCenter + (WHeight * zoom)
            Visum.Graphic.SetWindow(WXmin, WYmin, WXmax, WYmax)
            Visum.Graphic.Screenshot(Paths["Screenshot"])

            Screenshot = QtGui.QPixmap(Paths["Screenshot"])
            Screenshot.scaled(350, 350, 0, 1)
            self.L_ImageLeft.setPixmap(Screenshot)

        except:
            self.L_GeoPos.setText("node does not exist")

    def closeEvent(self):
        os.remove(Paths["Screenshot"])
        QtGui.qApp.quit()

    def openHelp(self):
        os.startfile(Paths["Help"])
Ejemplo n.º 36
0
    def setupUI(self, mainData):
        ####
        #Creation of supporting layouts
        baseLayout = QVBoxLayout()
        controlsLayout = QGridLayout()  #This is everything except the buttons

        ####
        #Mode controls
        modeGrpBox = QGroupBox("Mode:")
        self.modeRadBtns = [QRadioButton("Live"), QRadioButton("Offline")]
        for i in range(len(self.modeRadBtns)):
            self.modeRadBtns[i].setChecked(mainData.mode[i])
            self.modeRadBtns[i].clicked.connect(self.modeRadBtnClick)
        modeLayout = QHBoxLayout()
        self.addWidgetListToLayout(self.modeRadBtns, modeLayout)
        modeGrpBox.setLayout(modeLayout)
        controlsLayout.addWidget(modeGrpBox, 0, 0)

        ####
        #Calib controls
        calibLayout = QVBoxLayout()
        calibGrpBox = QGroupBox("Calibration Type:")
        self.calibRadBtns = [
            QRadioButton("Calibration"),
            QRadioButton("Calibration F1"),
            QRadioButton("Calibration F2")
        ]
        for i in range(len(self.calibRadBtns)):
            self.calibRadBtns[i].clicked.connect(self.calibRadBtnClick)
            self.calibRadBtns[i].setChecked(mainData.calibType[i])
        calibGrpLayout = QVBoxLayout()
        self.addWidgetListToLayout(self.calibRadBtns, calibGrpLayout)
        calibGrpBox.setLayout(calibGrpLayout)
        calibLayout.addWidget(calibGrpBox)

        calibConfBtn = QPushButton("Configure Calibration...")
        calibConfBtn.clicked.connect(self.calibConfClick)
        calibLayout.addWidget(calibConfBtn)

        controlsLayout.addLayout(calibLayout, 1, 0, 3, 1)

        ####
        #Data location
        dataDirGrpBox = QGroupBox("Data directory:")
        self.dataDirTextBox = QLineEdit()
        self.dataDirTextBox.setText(str(mainData.dataDir))
        self.dataDirTextBox.textChanged.connect(self.dataDirPathChanged)
        self.browseDataDirBtn = QPushButton("Browse...")
        self.browseDataDirBtn.clicked.connect(self.dataDirBrowseBtnClick)

        dataDirLayout = QHBoxLayout()
        dataDirLayout.addWidget(self.dataDirTextBox)
        dataDirLayout.addWidget(self.browseDataDirBtn)
        dataDirGrpBox.setLayout(dataDirLayout)
        controlsLayout.addWidget(dataDirGrpBox, 0, 1, 1, 2)

        ####
        #US/DS selector
        fileGrpBox = QGroupBox("Spectrum data files (US/DS) :")
        self.prevUSDSPairBtn = QPushButton("<")
        self.prevUSDSPairBtn.setFixedWidth(40)
        self.prevUSDSPairBtn.clicked.connect(self.changeUSDSPairBtnClick)
        self.nextUSDSPairBtn = QPushButton(">")
        self.nextUSDSPairBtn.clicked.connect(self.changeUSDSPairBtnClick)
        self.nextUSDSPairBtn.setFixedWidth(40)
        self.usdsPairTextBoxes = []
        for i in range(2):
            self.usdsPairTextBoxes.append(QLineEdit())
            #Set initial values of USDS pair boxes.
            if mainData.usdsPair[i] == '':
                self.usdsPairTextBoxes[i].setText(mainData.usdsPair[i])
            else:
                self.usdsPairTextBoxes[i].setText(
                    os.path.basename(mainData.usdsPair[i]))
            self.usdsPairTextBoxes[i].textChanged.connect(
                self.usdsPairTextChanged)
            self.usdsPairTextBoxes[i].setFixedWidth(100)

        fileLayout = QHBoxLayout()
        fileLayout.addWidget(self.prevUSDSPairBtn)
        fileLayout.addWidget(self.usdsPairTextBoxes[0])
        fileLayout.addWidget(self.usdsPairTextBoxes[1])
        fileLayout.addWidget(self.nextUSDSPairBtn)
        fileGrpBox.setLayout(fileLayout)
        controlsLayout.addWidget(fileGrpBox, 1, 1, 1, 2)

        ###
        #Integration range
        # - N.B. set text values before setting the textchanged slot
        integRangeGrpBox = QGroupBox("Integration Range:")
        integRangeLayout = QGridLayout()
        integrationTextInputWidth = 40
        integElemNames = ["Beginning:", "End:", "Window Size:"]
        integElemLabels = []
        integNmLabels = []
        self.integElemTextBoxes = []
        colNr, rowNr = 0, 0
        for i in range(len(integElemNames)):
            integElemLabels.append(QLabel(integElemNames[i]))
            self.integElemTextBoxes.append(QLineEdit())
            self.integElemTextBoxes[i].setFixedWidth(integrationTextInputWidth)
            self.integElemTextBoxes[i].setText(str(
                mainData.integrationConf[i]))
            self.integElemTextBoxes[i].textChanged.connect(
                self.integConfigChanged)
            integNmLabels.append(QLabel("nm"))

            colNr = i % 2
            if colNr == 0:
                rowNr += 1
            integRangeLayout.addWidget(integElemLabels[i], rowNr, 3 * colNr)
            integRangeLayout.addWidget(self.integElemTextBoxes[i], rowNr,
                                       (3 * colNr) + 1)
            integRangeLayout.addWidget(integNmLabels[i], rowNr,
                                       (3 * colNr) + 2)

        integRangeGrpBox.setLayout(integRangeLayout)
        controlsLayout.addWidget(integRangeGrpBox, 2, 1, 2, 2)

        ###
        #Calculation results
        planckTempLabel = QLabel("Average T(Planck):")
        self.planckTempValLabel = QLabel()
        self.planckTempValLabel.setFixedWidth(50)
        self.planckTempValLabel.setAlignment(QtCore.Qt.AlignRight)
        planckKLabel = QLabel("K")
        planckKLabel.setAlignment(QtCore.Qt.AlignLeft)
        dPlancKTempLabel = QLabel(u"\u0394 T(Planck):")
        self.dPlanckTempValLabel = QLabel()
        self.dPlanckTempValLabel.setFixedWidth(50)
        self.dPlanckTempValLabel.setAlignment(QtCore.Qt.AlignRight)
        dPlanckKLabel = QLabel("K")
        dPlanckKLabel.setAlignment(QtCore.Qt.AlignLeft)
        wienTempLabel = QLabel("Average T(Wien):")
        self.wienTempValLabel = QLabel()
        self.wienTempValLabel.setFixedWidth(50)
        self.wienTempValLabel.setAlignment(QtCore.Qt.AlignRight)
        wienKLabel = QLabel("K")
        wienKLabel.setAlignment(QtCore.Qt.AlignLeft)
        dWienTempLabel = QLabel(u"\u0394 T(Wien):")
        self.dWienTempValLabel = QLabel()
        self.dWienTempValLabel.setFixedWidth(50)
        self.dWienTempValLabel.setAlignment(QtCore.Qt.AlignRight)
        dWienKLabel = QLabel("K")
        dWienKLabel.setAlignment(QtCore.Qt.AlignLeft)
        self.updateTTextLabels()

        resultsLayout = QGridLayout()
        resultsLayout.addWidget(planckTempLabel, 0, 0)
        resultsLayout.addWidget(self.planckTempValLabel,
                                0,
                                1,
                                alignment=QtCore.Qt.AlignRight)
        resultsLayout.addWidget(planckKLabel,
                                0,
                                2,
                                alignment=QtCore.Qt.AlignLeft)
        resultsLayout.addWidget(dPlancKTempLabel, 1, 0)
        resultsLayout.addWidget(self.dPlanckTempValLabel,
                                1,
                                1,
                                alignment=QtCore.Qt.AlignRight)
        resultsLayout.addWidget(dPlanckKLabel,
                                1,
                                2,
                                alignment=QtCore.Qt.AlignLeft)
        resultsLayout.addWidget(wienTempLabel, 0, 3)
        resultsLayout.addWidget(self.wienTempValLabel,
                                0,
                                4,
                                alignment=QtCore.Qt.AlignRight)
        resultsLayout.addWidget(wienKLabel,
                                0,
                                5,
                                alignment=QtCore.Qt.AlignLeft)
        resultsLayout.addWidget(dWienTempLabel, 1, 3)
        resultsLayout.addWidget(self.dWienTempValLabel,
                                1,
                                4,
                                alignment=QtCore.Qt.AlignRight)
        resultsLayout.addWidget(dWienKLabel,
                                1,
                                5,
                                alignment=QtCore.Qt.AlignLeft)

        controlsLayout.addLayout(resultsLayout, 4, 0, 1, 3)

        ####
        #Control buttons
        self.runBtn = QPushButton('Run')
        self.runBtn.clicked.connect(self.runBtnClicked)
        self.stopBtn = QPushButton('Stop')
        self.stopBtn.clicked.connect(self.stopBtnClicked)
        quitBtn = QPushButton('Quit')
        quitBtn.clicked.connect(QtCore.QCoreApplication.instance().quit
                                )  #TODO Add control to kill plots properly

        buttonLayout = QHBoxLayout()
        buttonLayout.addWidget(self.runBtn)
        buttonLayout.addWidget(self.stopBtn)
        buttonLayout.addWidget(quitBtn)

        ####
        #Add the 1st tier layouts & set the base layout
        baseLayout.addLayout(controlsLayout)
        baseLayout.addLayout(buttonLayout)
        self.setLayout(baseLayout)
Ejemplo n.º 37
0
    def __init__(self, parent=None):
        super(ViewDataTools, self).__init__(parent)

        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        # DATATOOLS WINDOWS:
        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        self.setWindowTitle(ui_strings.DATATOOLS_TITLE)
        self._width = 680
        self._height = 560
        self._left_margin = 10
        self.resize(self._width, self._height)
        size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        size_policy.setHorizontalStretch(0)
        size_policy.setVerticalStretch(0)
        size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
        self.setSizePolicy(size_policy)
        self.setMinimumSize(QtCore.QSize(self._width, self._height))
        self.setMaximumSize(QtCore.QSize(self._width, self._height))
        self.setWindowIcon(QIcon(resources.ICON_LOGO))

        # central widget
        self.central_widget = QWidget(self)

        # DataTools description
        self.lbl_description = QLabel(self.central_widget)
        self.lbl_description.setGeometry(QtCore.QRect(0, 0, self._width, 30))
        self.lbl_description.setAlignment(QtCore.Qt.AlignCenter)
        self.lbl_description.setText(ui_strings.DATATOOLS_DESCRIPTION)

        # group input files
        self.group_input_file = QGroupBox(self.central_widget)
        self.group_input_file.setGeometry(
            QtCore.QRect(self._left_margin, 30, 660, 80))
        self.group_input_file.setTitle(ui_strings.DATATOOLS_GROUP_INPUT)

        # frame input files
        self.frame_inputs = QFrame(self.group_input_file)
        self.frame_inputs.setGeometry(
            QtCore.QRect(self._left_margin, 0, 270, 80))
        self.frame_inputs.setFrameShape(QFrame.StyledPanel)
        self.frame_inputs.setFrameShadow(QFrame.Raised)

        # label input type
        self.lbl_input_type = QLabel(self.frame_inputs)
        self.lbl_input_type.setGeometry(QtCore.QRect(20, 20, 60, 15))
        self.lbl_input_type.setText(ui_strings.DATATOOLS_INPUT_TYPE)

        # button xls
        self.btn_xls = QToolButton(self.frame_inputs)
        self.btn_xls.setGeometry(QtCore.QRect(20, 35, 35, 35))
        icon_xls = QIcon()
        icon_xls.addPixmap(QPixmap(resources.ICON_XLS), QIcon.Normal,
                           QIcon.Off)
        self.btn_xls.setIcon(icon_xls)
        self.btn_xls.setIconSize(QtCore.QSize(24, 24))
        self.btn_xls.setCheckable(True)
        self.btn_xls.setAutoExclusive(True)
        self.btn_xls.setObjectName("xls_button")

        # button csv
        self.btn_csv = QToolButton(self.frame_inputs)
        self.btn_csv.setGeometry(QtCore.QRect(60, 35, 35, 35))
        icon_csv = QIcon()
        icon_csv.addPixmap(QPixmap(resources.ICON_CSV), QIcon.Normal,
                           QIcon.Off)
        self.btn_csv.setIcon(icon_csv)
        self.btn_csv.setIconSize(QtCore.QSize(24, 24))
        self.btn_csv.setCheckable(True)
        self.btn_csv.setAutoExclusive(True)
        self.btn_csv.setObjectName("csv_button")

        # checkbox csv with headers
        self.chk_csv_headers = QCheckBox(ui_strings.DATATOOLS_WITH_HEADERS,
                                         self.frame_inputs)
        self.chk_csv_headers.setGeometry(QtCore.QRect(100, 45, 110, 15))
        self.chk_csv_headers.setEnabled(False)

        # TextEdit + PushButton (FindFolder)
        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        # lbl sheet name
        self.lbl_file_path = QLabel(self.group_input_file)
        self.lbl_file_path.setGeometry(QtCore.QRect(250, 20, 120, 15))
        self.lbl_file_path.setText(ui_strings.DATATOOLS_SELECT_FILE)

        self.txt_file = QLineEdit(self.group_input_file)
        self.txt_file.setGeometry(QtCore.QRect(250, 35, 160, 20))
        self.txt_file.setReadOnly(True)

        self.btn_path = QPushButton(self.group_input_file)
        self.btn_path.setGeometry(QtCore.QRect(410, 34, 50, 22))
        self.btn_path.setText(ui_strings.DATATOOLS_SELECT_BUTTON)
        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        # lbl sheet name
        self.lbl_sheet_name = QLabel(self.group_input_file)
        self.lbl_sheet_name.setGeometry(QtCore.QRect(500, 20, 120, 15))
        self.lbl_sheet_name.setText(ui_strings.DATATOOLS_SHEET_NAME)

        # Combobox select sheet - initially does not contain values
        self.cbo_sheet = QComboBox(self.group_input_file)
        self.cbo_sheet.setGeometry(QtCore.QRect(500, 35, 130, 20))

        # data grid to visualize error messages
        self.tbl_errors = QTableWidget(self.central_widget)
        self.tbl_errors.setGeometry(
            QtCore.QRect(self._left_margin, 420, 660, 100))

        # data grid to visualize those records with errors.
        self.tbl_uploaded_data = QTableWidget(self.central_widget)
        self.tbl_uploaded_data.setGeometry(
            QtCore.QRect(self._left_margin, 120, 500, 220))

        # group run options
        self.group_run_options = QGroupBox(self.central_widget)
        self.group_run_options.setGeometry(QtCore.QRect(520, 120, 150, 220))
        self.group_run_options.setTitle(ui_strings.DATATOOLS_GROUP_RUN)

        # Errors summary:
        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        # group summary errors
        self.group_errors = QGroupBox(self.central_widget)
        self.group_errors.setGeometry(
            QtCore.QRect(self._left_margin, 350, 660, 60))
        self.group_errors.setTitle(ui_strings.DATATOOLS_HEADER_ERRORS)

        # lbl records
        self.lbl_records = QLabel(self.group_errors)
        self.lbl_records.setGeometry(QtCore.QRect(165, 15, 80, 15))
        self.lbl_records.setAlignment(QtCore.Qt.AlignCenter)
        self.lbl_records.setText(ui_strings.DATATOOLS_RECORDS)

        self.txt_records = QLineEdit(self.group_errors)
        self.txt_records.setGeometry(QtCore.QRect(165, 30, 80, 20))
        self.txt_records.setAlignment(QtCore.Qt.AlignCenter)
        self.txt_records.setReadOnly(True)

        # lbl errors
        self.lbl_errors = QLabel(self.group_errors)
        self.lbl_errors.setGeometry(QtCore.QRect(275, 15, 80, 15))
        self.lbl_errors.setAlignment(QtCore.Qt.AlignCenter)
        self.lbl_errors.setText(ui_strings.DATATOOLS_ERRORS)

        self.txt_errors = QLineEdit(self.group_errors)
        self.txt_errors.setGeometry(QtCore.QRect(275, 30, 80, 20))
        self.txt_errors.setAlignment(QtCore.Qt.AlignCenter)
        self.txt_errors.setReadOnly(True)

        # lbl time
        self.lbl_time = QLabel(self.group_errors)
        self.lbl_time.setGeometry(QtCore.QRect(385, 15, 80, 15))
        self.lbl_time.setAlignment(QtCore.Qt.AlignCenter)
        self.lbl_time.setText(ui_strings.DATATOOLS_TIME)

        self.txt_time = QLineEdit(self.group_errors)
        self.txt_time.setGeometry(QtCore.QRect(385, 30, 80, 20))
        self.txt_time.setAlignment(QtCore.Qt.AlignCenter)
        self.txt_time.setReadOnly(True)

        # history button
        self.btn_history = QToolButton(self.group_errors)
        self.btn_history.setGeometry(QtCore.QRect(500, 25, 100, 25))
        icon_history = QIcon()
        icon_history.addPixmap(QPixmap(resources.ICON_HISTORY), QIcon.Normal,
                               QIcon.Off)
        self.btn_history.setIcon(icon_history)
        self.btn_history.setIconSize(QtCore.QSize(20, 20))
        self.btn_history.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
        self.btn_history.setText(ui_strings.DATATOOLS_HISTORY)
        self.btn_history.setCheckable(True)
        self.btn_history.setAutoExclusive(True)
        self.btn_history.setObjectName("history_button")
        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        # btn data uploader
        self.btn_data_uploader = QPushButton(
            ui_strings.DATATOOLS_DATA_UPLOADER, self.group_run_options)
        self.btn_data_uploader.setGeometry(QtCore.QRect(10, 120, 90, 25))
        self.btn_data_uploader.setCheckable(True)
        self.btn_data_uploader.setAutoExclusive(True)
        self.btn_data_uploader.setFlat(False)

        # btn data testing
        self.btn_data_testing = QPushButton(ui_strings.DATATOOLS_DATA_TESTING,
                                            self.group_run_options)
        self.btn_data_testing.setEnabled(False)
        self.btn_data_testing.setGeometry(QtCore.QRect(10, 150, 90, 25))
        self.btn_data_testing.setCheckable(True)
        self.btn_data_testing.setAutoExclusive(True)

        # btn data to database
        self.btn_data_db = QPushButton(ui_strings.DATATOOLS_DATA_DB,
                                       self.group_run_options)
        self.btn_data_db.setEnabled(False)
        self.btn_data_db.setGeometry(QtCore.QRect(10, 179, 91, 23))
        self.btn_data_db.setCheckable(True)
        self.btn_data_db.setAutoExclusive(True)

        # frame run options
        self.frame_run = QFrame(self.group_run_options)
        self.frame_run.setGeometry(QtCore.QRect(10, 30, 130, 80))
        self.frame_run.setFrameShape(QFrame.StyledPanel)
        self.frame_run.setFrameShadow(QFrame.Raised)

        # option process until first error
        self.rbtn_process_error = QRadioButton(
            ui_strings.DATATOOLS_PROCESS_ERROR, self.frame_run)
        self.rbtn_process_error.setGeometry(QtCore.QRect(0, 0, 150, 20))

        # option process all data
        self.rbtn_process_all = QRadioButton(ui_strings.DATATOOLS_PROCESS_ALL,
                                             self.frame_run)
        self.rbtn_process_all.setGeometry(QtCore.QRect(0, 20, 150, 30))

        # checkbox to filter by records with errors.
        #self.chk_filter_errors = QCheckBox(ui_strings.DATATOOLS_FILTER_ERRORS, self.frame_run)
        #self.chk_filter_errors.setGeometry(QtCore.QRect(0, 50, 100, 15))
        #self.chk_filter_errors.setEnabled(False)

        # icons -> pass - error: Initially are empty labels
        # if not started -> ICON_MINI_WAIT
        # if error -> ICON_DELETE
        # if pass -> ICON_CHECK

        # state icon data uploader
        self.lbl_state_du = QLabel(self.group_run_options)
        self.lbl_state_du.setGeometry(QtCore.QRect(110, 120, 20, 20))
        self.lbl_state_du.setPixmap(QPixmap(resources.ICON_MINI_WAIT))
        self.lbl_state_du.setScaledContents(True)

        # state icon data to database
        self.lbl_state_dt = QLabel(self.group_run_options)
        self.lbl_state_dt.setGeometry(QtCore.QRect(110, 150, 20, 20))
        self.lbl_state_dt.setPixmap(QPixmap(resources.ICON_MINI_WAIT))
        self.lbl_state_dt.setScaledContents(True)

        # state icon data testing
        self.lbl_state_db = QLabel(self.group_run_options)
        self.lbl_state_db.setGeometry(QtCore.QRect(110, 180, 20, 20))
        self.lbl_state_db.setPixmap(QPixmap(resources.ICON_MINI_WAIT))
        self.lbl_state_db.setScaledContents(True)

        # progress bar
        self.progress_bar = QProgressBar(self.central_widget)
        self.progress_bar.setGeometry(
            QtCore.QRect(self._left_margin, 530, 660, 15))
        self.progress_bar.setMaximum(100)
        self.progress_bar.setProperty("value", 0)
        self.progress_bar.setTextVisible(True)
        self.progress_bar.setOrientation(QtCore.Qt.Horizontal)
        self.progress_bar.setInvertedAppearance(False)
        self.progress_bar.setTextDirection(QProgressBar.TopToBottom)

        self.setCentralWidget(self.central_widget)
Ejemplo n.º 38
0
    def __init__(self, parent=None):
        super(StudentForm, self).__init__(parent)
        #self.setGeometry(50, 50, 820, 530)
        self.resize(530, 430)

        self.tabz = QTabWidget(self)
        self.tab1 = QWidget(self)
        self.tab2 = QWidget(self)
        self.tab3 = QWidget(self)
        self.tab4 = QWidget(self)

        #main form
        self.schno = QLabel("School Number")
        self.schnoData = QLineEdit()
        self.schnoData.setObjectName("schno")
        self.schnoData.setPlaceholderText("00000000")

        self.surname = QLabel("Surname")
        self.surnameData = QLineEdit()
        self.surnameData.setObjectName("surname")
        self.surnameData.setPlaceholderText("Surname")

        self.firstname = QLabel("Firstname")
        self.firstnameData = QLineEdit()
        self.firstnameData.setObjectName("firstname")
        self.firstnameData.setPlaceholderText("Firstname")

        self.middlename = QLabel("Middlename")
        self.middlenameData = QLineEdit()
        self.middlenameData.setObjectName("middlename")
        self.middlenameData.setPlaceholderText("middlename")

        self.soo = QLabel("State/Region of Origin")
        self.sooData = QLineEdit()
        self.sooData.setObjectName("soo")
        self.sooData.setPlaceholderText("Lagos")

        self.lga = QLabel("LGA/District")
        self.lgaData = QLineEdit()
        self.lgaData.setObjectName("lga")
        self.lgaData.setPlaceholderText("Ikeja")

        self.addr = QLabel("House Address")
        self.addrData = QTextEdit()
        self.addrData.setObjectName("addr")
        #self.addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")

        self.dob = QLabel("Date of Birth")
        self.dobData = QDateEdit()
        self.dobData.setObjectName("dob")

        self.admit = QLabel("Date Admitted")
        self.admitData = QDateEdit()
        self.admitData.setObjectName("admit")

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()
        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout = QFormLayout()
        Formlayout.addRow(self.schno, self.schnoData)
        Formlayout.addRow(self.surname, self.surnameData)
        Formlayout.addRow(self.firstname, self.firstnameData)
        Formlayout.addRow(self.middlename, self.middlenameData)
        Formlayout.addRow(self.gender, hbo)
        Formlayout.addRow(self.dob, self.dobData)
        Formlayout.addRow(self.admit, self.admitData)
        Formlayout.addRow(self.soo, self.sooData)
        Formlayout.addRow(self.lga, self.lgaData)
        Formlayout.addRow(self.addr, self.addrData)

        grid = QGridLayout()
        grid.addWidget(self.pb1, 0, 1)
        grid.addWidget(self.pb, 0, 0)

        groupBox = QGroupBox('BIODATA')
        groupBox.setLayout(Formlayout)

        vbox = QVBoxLayout()
        vbox.addWidget(groupBox)
        vbox.addStretch()
        vbox.addLayout(grid)

        #self.setLayout(vbox)
        self.connect(self.pb, SIGNAL("clicked()"),
                     lambda: self.button_click(1))
        self.connect(self.pb1, SIGNAL("clicked()"), self.close)
        self.setWindowTitle("Student Data")
        #self.setTabText(0, 'BioData')
        self.tab1.setLayout(vbox)

        #guardian data
        relations = [
            'Father', 'Mother', 'Aunt', 'Uncle', 'Grand Parent', 'Guardian',
            'Others'
        ]

        #first guardian details
        self.g1name = QLabel("First Guardian")
        self.g1Data = QLineEdit()
        self.g1Data.setObjectName("g1name")
        self.g1Data.setPlaceholderText("Fullname")

        self.g1rel = QLabel('Relationship')
        self.g1relData = QComboBox()
        self.g1relData.addItems(relations)

        self.g1p1 = QLabel("Phone Number")
        self.g1p1Data = QLineEdit()
        self.g1p1Data.setObjectName("g1p1")
        self.g1p1Data.setPlaceholderText("08000000000")

        self.g1p2 = QLabel("Alt. Phone Number")
        self.g1p2Data = QLineEdit()
        self.g1p2Data.setObjectName("g1p2")
        self.g1p2Data.setPlaceholderText("08000000000")

        self.g1email = QLabel("Email")
        self.g1emailData = QLineEdit()
        self.g1emailData.setObjectName("g1email")
        self.g1emailData.setPlaceholderText("*****@*****.**")

        self.g1addr = QLabel("Address")
        self.g1addrData = QTextEdit()
        self.g1addrData.setObjectName("g1add")
        #self.g1addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")
        #second guardian details
        self.g2name = QLabel("Second Guardian")
        self.g2Data = QLineEdit()
        self.g2Data.setObjectName("g2name")
        self.g2Data.setPlaceholderText("Mr. Surname Lastname")

        self.g2rel = QLabel('Relationship')
        self.g2relData = QComboBox()
        self.g2relData.addItems(relations)

        self.g2p1 = QLabel("Phone Number")
        self.g2p1Data = QLineEdit()
        self.g2p1Data.setObjectName("g2p1")
        self.g2p1Data.setPlaceholderText("08000000000")

        self.g2p2 = QLabel("Alt. Phone Number")
        self.g2p2Data = QLineEdit()
        self.g2p2Data.setObjectName("g2p2")
        self.g2p2Data.setPlaceholderText("08000000000")

        self.g2email = QLabel("Email")
        self.g2emailData = QLineEdit()
        self.g2emailData.setObjectName("g2email")
        self.g2emailData.setPlaceholderText("*****@*****.**")

        self.g2addr = QLabel("Address")
        self.g2addrData = QTextEdit()
        self.g2addrData.setObjectName("g2add")
        #self.g2addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()

        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout1 = QFormLayout()
        Formlayout1.addRow(self.g1name, self.g1Data)
        Formlayout1.addRow(self.g1rel, self.g1relData)
        Formlayout1.addRow(self.g1p1, self.g1p1Data)
        Formlayout1.addRow(self.g1p2, self.g1p2Data)
        Formlayout1.addRow(self.g1email, self.g1emailData)
        Formlayout1.addRow(self.g1addr, self.g1addrData)

        Formlayout2 = QFormLayout()
        Formlayout2.addRow(self.g2name, self.g2Data)
        Formlayout2.addRow(self.g2rel, self.g2relData)
        Formlayout2.addRow(self.g2p1, self.g2p1Data)
        Formlayout2.addRow(self.g2p2, self.g2p2Data)
        Formlayout2.addRow(self.g2email, self.g2emailData)
        Formlayout2.addRow(self.g2addr, self.g2addrData)

        grid1 = QGridLayout()
        grid1.addWidget(self.pb, 0, 0)
        grid1.addWidget(self.pb1, 0, 1)

        hbox1 = QHBoxLayout()
        hbox1.addLayout(Formlayout1)
        hbox1.addLayout(Formlayout2)

        groupBox2 = QGroupBox('GUARDIAN')
        groupBox2.setLayout(hbox1)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(groupBox2)
        vbox1.addStretch()
        vbox1.addLayout(grid1)

        #photo
        self.pic1 = QLabel()
        image1 = Image.open('img/studentz.png')
        self.pic1.resize(100, 150)
        self.pic1.setLabel(image1)

        self.pic2 = QLabel()
        image2 = Image.open('img/studentz.png')
        self.pic2.resize(100, 150)
        self.pic2.setPixmap(image2)

        self.pic3 = QLabel()
        image3 = Image.open('img/studentz.png')
        self.pic3.resize(100, 150)
        self.pic3.setPixmap(image3)

        self.picBtn1 = QPushButton('Select Image')
        self.picBtn1.clicked.connect(self.getFilez)

        self.picBtn2 = QPushButton('Select Image')
        self.picBtn2.clicked.connect(self.getFilez)

        self.picBtn3 = QPushButton('Select Image')
        self.picBtn3.clicked.connect(self.getFilez)

        picGrid = QGridLayout()

        picGrid.addWidget(self.pic1, 0, 1)
        picGrid.addWidget(self.pic2, 0, 2)
        picGrid.addWidget(self.pic3, 0, 3)

        picGrid.addWidget(self.picBtn1, 1, 1)
        picGrid.addWidget(self.picBtn2, 2, 2)
        picGrid.addWidget(self.picBtn3, 3, 3)

        self.tabz.addTab(self.tab1, 'Bio-Data')
        self.tabz.addTab(self.tab2, 'Contact Details')
        self.tabz.addTab(self.tab3, 'Passports')

        #self.tabz.setTabEnabled(1, False)
        #self.tabz.setTabEnabled(2, False)

        self.setWindowTitle("Add Student Data")
        self.show()
Ejemplo n.º 39
0
class StudentForm(QDialog):
    def __init__(self, parent=None):
        super(StudentForm, self).__init__(parent)
        #self.setGeometry(50, 50, 820, 530)
        self.resize(530, 430)

        self.tabz = QTabWidget(self)
        self.tab1 = QWidget(self)
        self.tab2 = QWidget(self)
        self.tab3 = QWidget(self)
        self.tab4 = QWidget(self)

        #main form
        self.schno = QLabel("School Number")
        self.schnoData = QLineEdit()
        self.schnoData.setObjectName("schno")
        self.schnoData.setPlaceholderText("00000000")

        self.surname = QLabel("Surname")
        self.surnameData = QLineEdit()
        self.surnameData.setObjectName("surname")
        self.surnameData.setPlaceholderText("Surname")

        self.firstname = QLabel("Firstname")
        self.firstnameData = QLineEdit()
        self.firstnameData.setObjectName("firstname")
        self.firstnameData.setPlaceholderText("Firstname")

        self.middlename = QLabel("Middlename")
        self.middlenameData = QLineEdit()
        self.middlenameData.setObjectName("middlename")
        self.middlenameData.setPlaceholderText("middlename")

        self.soo = QLabel("State/Region of Origin")
        self.sooData = QLineEdit()
        self.sooData.setObjectName("soo")
        self.sooData.setPlaceholderText("Lagos")

        self.lga = QLabel("LGA/District")
        self.lgaData = QLineEdit()
        self.lgaData.setObjectName("lga")
        self.lgaData.setPlaceholderText("Ikeja")

        self.addr = QLabel("House Address")
        self.addrData = QTextEdit()
        self.addrData.setObjectName("addr")
        #self.addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")

        self.dob = QLabel("Date of Birth")
        self.dobData = QDateEdit()
        self.dobData.setObjectName("dob")

        self.admit = QLabel("Date Admitted")
        self.admitData = QDateEdit()
        self.admitData.setObjectName("admit")

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()
        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout = QFormLayout()
        Formlayout.addRow(self.schno, self.schnoData)
        Formlayout.addRow(self.surname, self.surnameData)
        Formlayout.addRow(self.firstname, self.firstnameData)
        Formlayout.addRow(self.middlename, self.middlenameData)
        Formlayout.addRow(self.gender, hbo)
        Formlayout.addRow(self.dob, self.dobData)
        Formlayout.addRow(self.admit, self.admitData)
        Formlayout.addRow(self.soo, self.sooData)
        Formlayout.addRow(self.lga, self.lgaData)
        Formlayout.addRow(self.addr, self.addrData)

        grid = QGridLayout()
        grid.addWidget(self.pb1, 0, 1)
        grid.addWidget(self.pb, 0, 0)

        groupBox = QGroupBox('BIODATA')
        groupBox.setLayout(Formlayout)

        vbox = QVBoxLayout()
        vbox.addWidget(groupBox)
        vbox.addStretch()
        vbox.addLayout(grid)

        #self.setLayout(vbox)
        self.connect(self.pb, SIGNAL("clicked()"),
                     lambda: self.button_click(1))
        self.connect(self.pb1, SIGNAL("clicked()"), self.close)
        self.setWindowTitle("Student Data")
        #self.setTabText(0, 'BioData')
        self.tab1.setLayout(vbox)

        #guardian data
        relations = [
            'Father', 'Mother', 'Aunt', 'Uncle', 'Grand Parent', 'Guardian',
            'Others'
        ]

        #first guardian details
        self.g1name = QLabel("First Guardian")
        self.g1Data = QLineEdit()
        self.g1Data.setObjectName("g1name")
        self.g1Data.setPlaceholderText("Fullname")

        self.g1rel = QLabel('Relationship')
        self.g1relData = QComboBox()
        self.g1relData.addItems(relations)

        self.g1p1 = QLabel("Phone Number")
        self.g1p1Data = QLineEdit()
        self.g1p1Data.setObjectName("g1p1")
        self.g1p1Data.setPlaceholderText("08000000000")

        self.g1p2 = QLabel("Alt. Phone Number")
        self.g1p2Data = QLineEdit()
        self.g1p2Data.setObjectName("g1p2")
        self.g1p2Data.setPlaceholderText("08000000000")

        self.g1email = QLabel("Email")
        self.g1emailData = QLineEdit()
        self.g1emailData.setObjectName("g1email")
        self.g1emailData.setPlaceholderText("*****@*****.**")

        self.g1addr = QLabel("Address")
        self.g1addrData = QTextEdit()
        self.g1addrData.setObjectName("g1add")
        #self.g1addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")
        #second guardian details
        self.g2name = QLabel("Second Guardian")
        self.g2Data = QLineEdit()
        self.g2Data.setObjectName("g2name")
        self.g2Data.setPlaceholderText("Mr. Surname Lastname")

        self.g2rel = QLabel('Relationship')
        self.g2relData = QComboBox()
        self.g2relData.addItems(relations)

        self.g2p1 = QLabel("Phone Number")
        self.g2p1Data = QLineEdit()
        self.g2p1Data.setObjectName("g2p1")
        self.g2p1Data.setPlaceholderText("08000000000")

        self.g2p2 = QLabel("Alt. Phone Number")
        self.g2p2Data = QLineEdit()
        self.g2p2Data.setObjectName("g2p2")
        self.g2p2Data.setPlaceholderText("08000000000")

        self.g2email = QLabel("Email")
        self.g2emailData = QLineEdit()
        self.g2emailData.setObjectName("g2email")
        self.g2emailData.setPlaceholderText("*****@*****.**")

        self.g2addr = QLabel("Address")
        self.g2addrData = QTextEdit()
        self.g2addrData.setObjectName("g2add")
        #self.g2addrData.setPlaceholderText("No. 12 Harrrison For Str., Ney York")

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()

        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout1 = QFormLayout()
        Formlayout1.addRow(self.g1name, self.g1Data)
        Formlayout1.addRow(self.g1rel, self.g1relData)
        Formlayout1.addRow(self.g1p1, self.g1p1Data)
        Formlayout1.addRow(self.g1p2, self.g1p2Data)
        Formlayout1.addRow(self.g1email, self.g1emailData)
        Formlayout1.addRow(self.g1addr, self.g1addrData)

        Formlayout2 = QFormLayout()
        Formlayout2.addRow(self.g2name, self.g2Data)
        Formlayout2.addRow(self.g2rel, self.g2relData)
        Formlayout2.addRow(self.g2p1, self.g2p1Data)
        Formlayout2.addRow(self.g2p2, self.g2p2Data)
        Formlayout2.addRow(self.g2email, self.g2emailData)
        Formlayout2.addRow(self.g2addr, self.g2addrData)

        grid1 = QGridLayout()
        grid1.addWidget(self.pb, 0, 0)
        grid1.addWidget(self.pb1, 0, 1)

        hbox1 = QHBoxLayout()
        hbox1.addLayout(Formlayout1)
        hbox1.addLayout(Formlayout2)

        groupBox2 = QGroupBox('GUARDIAN')
        groupBox2.setLayout(hbox1)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(groupBox2)
        vbox1.addStretch()
        vbox1.addLayout(grid1)

        #photo
        self.pic1 = QLabel()
        image1 = Image.open('img/studentz.png')
        self.pic1.resize(100, 150)
        self.pic1.setLabel(image1)

        self.pic2 = QLabel()
        image2 = Image.open('img/studentz.png')
        self.pic2.resize(100, 150)
        self.pic2.setPixmap(image2)

        self.pic3 = QLabel()
        image3 = Image.open('img/studentz.png')
        self.pic3.resize(100, 150)
        self.pic3.setPixmap(image3)

        self.picBtn1 = QPushButton('Select Image')
        self.picBtn1.clicked.connect(self.getFilez)

        self.picBtn2 = QPushButton('Select Image')
        self.picBtn2.clicked.connect(self.getFilez)

        self.picBtn3 = QPushButton('Select Image')
        self.picBtn3.clicked.connect(self.getFilez)

        picGrid = QGridLayout()

        picGrid.addWidget(self.pic1, 0, 1)
        picGrid.addWidget(self.pic2, 0, 2)
        picGrid.addWidget(self.pic3, 0, 3)

        picGrid.addWidget(self.picBtn1, 1, 1)
        picGrid.addWidget(self.picBtn2, 2, 2)
        picGrid.addWidget(self.picBtn3, 3, 3)

        self.tabz.addTab(self.tab1, 'Bio-Data')
        self.tabz.addTab(self.tab2, 'Contact Details')
        self.tabz.addTab(self.tab3, 'Passports')

        #self.tabz.setTabEnabled(1, False)
        #self.tabz.setTabEnabled(2, False)

        self.setWindowTitle("Add Student Data")
        self.show()

    def getFile(self, a):
        fname = QFileDialog.getOpenFileName(self, 'Open', 'c:\\',
                                            "Image File (*.jpg *.png)")
        if a == 1:
            self.pic1.setPixmap(QPixmap(fname))
        elif a == 2:
            self.pic2.setPixmap(QPixmap(fname))
        elif a == 2:
            self.pic3.setPixmap(QPixmap(fname))

    def getFilez(self):
        fname = QFileDialog.getOpenFileName(self, 'Open', 'c:\\',
                                            "Image File (*.jpg *.png)")
        self.pic1.setPixmap(QPixmap(fname))

    def contFill(self, a):

        sid = a
        data = self.pullStudents(a)
        self.resize(430, 530)

        #self.tabz = QTabWidget(self)
        self.tabz.clear()

        self.tab1 = QWidget(self)
        self.tab2 = QWidget(self)
        self.tab3 = QWidget(self)

        self.schno = QLabel("School Number")
        self.schnoData = QLineEdit()
        self.schnoData.setObjectName("schno")
        if (data['schno'] and len(data['schno']) > 1):
            self.schnoData.setText(data['schno'])
        else:
            self.schnoData.setPlaceholderText("00000000")

        self.surname = QLabel("Surname")
        self.surnameData = QLineEdit()
        self.surnameData.setObjectName("surname")
        if (data['surname'] and len(data['surname']) > 1):
            tx = data['surname']
            self.surnameData.setText(tx.title())
        else:
            self.surnameData.setPlaceholderText("Surname")

        self.firstname = QLabel("Firstname")
        self.firstnameData = QLineEdit()
        self.firstnameData.setObjectName("firstname")
        if (data['firstname'] and len(data['firstname'])):
            tx = data['firstname']
            self.firstnameData.setText(tx.title())
        else:
            self.firstnameData.setPlaceholderText("Firstname")

        self.middlename = QLabel("Middlename")
        self.middlenameData = QLineEdit()
        self.middlenameData.setObjectName("middlename")
        if (data['othername'] and len(data['othername']) > 1):
            tx = data['othername']
            self.middlenameData.setText(tx.title())
        else:
            self.middlenameData.setPlaceholderText("othername")

        self.soo = QLabel("State/Region of Origin")
        self.sooData = QLineEdit()
        self.sooData.setObjectName("soo")
        if (data['soo'] and len(data['soo']) > 1):
            tx = data['soo']
            self.sooData.setText(tx.title())
        else:
            self.sooData.setPlaceholderText("Lagos")

        self.lga = QLabel("LGA/District")
        self.lgaData = QLineEdit()
        self.lgaData.setObjectName("lga")
        if (data['lga'] and len(data['lga'])):
            tx = data['lga']
            self.lgaData.setText(tx.title())
        else:
            self.lgaData.setPlaceholderText("Ikeja")

        self.addr = QLabel("House Address")
        self.addrData = QTextEdit()
        self.addrData.setObjectName("addr")
        if (data['addr'] and len(data['addr'])):
            tx = data['addr']
            self.addrData.setText(tx)
        else:
            pass

        self.dob = QLabel("Date of Birth")
        self.dobData = QDateEdit()
        self.dobData.setObjectName("dob")
        tx = QDate.fromString(data['dob'], 'yyyy-MM-dd')
        self.dobData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.admit = QLabel("Date Admitted")
        self.admitData = QDateEdit()
        self.admitData.setObjectName("admit")
        tx = QDate.fromString(data['admit'], 'yyyy-MM-dd')
        self.admitData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.pb4 = QPushButton()
        self.pb4.setObjectName("Submit")
        self.pb4.setText("Submit")

        self.pb5 = QPushButton()
        self.pb5.setObjectName("Cancel")
        self.pb5.setText("Cancel")

        hbo = QHBoxLayout()
        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        if (data['gender'] == 'Male'):
            self.r1.setChecked(True)
        elif (data['gender'] == 'Female'):
            self.r2.setChecked(True)

        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout = QFormLayout()
        Formlayout.addRow(self.schno, self.schnoData)
        Formlayout.addRow(self.surname, self.surnameData)
        Formlayout.addRow(self.firstname, self.firstnameData)
        Formlayout.addRow(self.middlename, self.middlenameData)
        Formlayout.addRow(self.gender, hbo)
        Formlayout.addRow(self.dob, self.dobData)
        Formlayout.addRow(self.admit, self.admitData)
        Formlayout.addRow(self.soo, self.sooData)
        Formlayout.addRow(self.lga, self.lgaData)
        Formlayout.addRow(self.addr, self.addrData)

        grid = QGridLayout()
        grid.addWidget(self.pb1, 0, 1)
        grid.addWidget(self.pb, 0, 0)

        groupBox = QGroupBox('BIODATA')
        groupBox.setLayout(Formlayout)

        vbox = QVBoxLayout()
        vbox.addWidget(groupBox)
        vbox.addStretch()
        vbox.addLayout(grid)

        #self.setLayout(vbox)
        self.connect(self.pb4, SIGNAL("clicked()"),
                     lambda: self.button1_click(sid))
        self.connect(self.pb5, SIGNAL("clicked()"), self.close)
        self.tab1.setLayout(vbox)

        relations = [
            'Father', 'Mother', 'Aunt', 'Uncle', 'Grand Parent', 'Guardian',
            'Others'
        ]

        #first guardian details
        self.g1name = QLabel("First Guardian")
        self.g1Data = QLineEdit()
        self.g1Data.setObjectName("g1name")
        if (data['g1'] and len(data['g1']) > 1):
            tx = data['g1']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("Mr. Surname Lastname")

        self.g1rel = QLabel('Relationship')
        self.g1relData = QComboBox()
        self.g1relData.addItems(relations)
        if data['g1rel'] and len(data['g1rel']) > 0:
            index1 = self.g1relData.findText(data['g1rel'],
                                             Qt.QtMatchFixedString)
            if index1 >= 0:
                self.g1relData.setCurrentIndex(index1)

        self.g1p1 = QLabel("Phone Number")
        self.g1p1Data = QLineEdit()
        self.g1p1Data.setObjectName("g1p1")
        if (data['g1p1'] and len(data['g1p1']) > 1):
            tx = data['g1p1']
            self.g1p1Data.setText(tx.title())
        else:
            self.g1p1Data.setPlaceholderText("08000000000")

        self.g1p2 = QLabel("Alt. Phone Number")
        self.g1p2Data = QLineEdit()
        self.g1p2Data.setObjectName("g1p2")
        if (data['g1p2'] and len(data['g1p2']) > 1):
            tx = data['g1p2']
            self.g1p2Data.setText(tx.title())
        else:
            self.g1p2Data.setPlaceholderText("08000000000")

        self.g1email = QLabel("Email")
        self.g1emailData = QLineEdit()
        self.g1emailData.setObjectName("g1email")
        if (data['g1email'] and len(data['g1email']) > 1):
            tx = data['g1email']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("*****@*****.**")

        self.g1addr = QLabel("Address")
        self.g1addrData = QTextEdit()
        self.g1addrData.setObjectName("g1add")
        if (data['g1addr'] and len(data['g1addr']) > 1):
            tx = data['g1addr']
            self.g1Data.setText(tx.title())
        else:
            pass

        #second guardian details
        self.g2name = QLabel("Second Guardian")
        self.g2Data = QLineEdit()
        self.g2Data.setObjectName("g2name")
        if (data['g2'] and len(data['g2']) > 1):
            tx = data['g2']
            self.g2Data.setText(tx.title())
        else:
            self.g2Data.setPlaceholderText("Title. Surname Lastname")

        self.g2rel = QLabel('Relationship')
        self.g2relData = QComboBox()
        self.g2relData.addItems(relations)
        if data['g2rel'] and len(data['g2rel']) > 0:
            index2 = self.g2relData.findText(data['g2rel'],
                                             Qt.QtMatchFixedString)
            if index2 >= 0:
                self.g2relData.setCurrentIndex(index2)

        self.g2p1 = QLabel("Phone Number")
        self.g2p1Data = QLineEdit()
        self.g2p1Data.setObjectName("g2p1")
        if (data['g2p1'] and len(data['g2p1']) > 1):
            tx = data['g2p1']
            self.g2p1Data.setText(tx.title())
        else:
            self.g2p1Data.setPlaceholderText("08000000000")

        self.g2p2 = QLabel("Alt. Phone Number")
        self.g2p2Data = QLineEdit()
        self.g2p2Data.setObjectName("g2p2")
        if (data['g2p2'] and len(data['g2p2']) > 1):
            tx = data['g2p2']
            self.g2p2Data.setText(tx.title())
        else:
            self.g2p2Data.setPlaceholderText("0800000000")

        self.g2email = QLabel("Email")
        self.g2emailData = QLineEdit()
        self.g2emailData.setObjectName("g2email")
        if (data['g2email'] and len(data['g2email']) > 1):
            tx = data['g2email']
            self.g2emailData.setText(tx.title())
        else:
            self.g2emailData.setPlaceholderText("*****@*****.**")

        self.g2addr = QLabel("Address")
        self.g2addrData = QTextEdit()
        self.g2addrData.setObjectName("g2add")
        if (data['g2addr'] and len(data['g2addr']) > 1):
            tx = data['g2addr']
            self.g2Data.setText(tx.title())
        else:
            pass

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()

        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout1 = QFormLayout()
        Formlayout1.addRow(self.g1name, self.g1Data)
        Formlayout1.addRow(self.g1rel, self.g1relData)
        Formlayout1.addRow(self.g1p1, self.g1p1Data)
        Formlayout1.addRow(self.g1p2, self.g1p2Data)
        Formlayout1.addRow(self.g1email, self.g1emailData)
        Formlayout1.addRow(self.g1addr, self.g1addrData)

        Formlayout2 = QFormLayout()
        Formlayout2.addRow(self.g2name, self.g2Data)
        Formlayout2.addRow(self.g2rel, self.g2relData)
        Formlayout2.addRow(self.g2p1, self.g2p1Data)
        Formlayout2.addRow(self.g2p2, self.g2p2Data)
        Formlayout2.addRow(self.g2email, self.g2emailData)
        Formlayout2.addRow(self.g2addr, self.g2addrData)

        grid1 = QGridLayout()
        grid1.addWidget(self.pb, 0, 0)
        grid1.addWidget(self.pb1, 0, 1)

        hbox1 = QHBoxLayout()
        hbox1.addLayout(Formlayout1)
        hbox1.addStretch()
        hbox1.addLayout(Formlayout2)

        groupBox2 = QGroupBox('GUARDIAN')
        groupBox2.setLayout(hbox1)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(groupBox2)
        vbox1.addStretch()
        vbox1.addLayout(grid1)

        self.tab2.setLayout(vbox1)

        #photo
        picstyle = QSize(120, 180)
        picstyle1 = Qt.KeepAspectRatio

        self.pic1Lbl = QLabel('YEAR 1 & 2')
        self.pic2Lbl = QLabel('YEAR 3 & 4')
        self.pic3Lbl = QLabel('YEAR 5 & 6')

        self.pic1 = QLabel()
        pixmap1 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic1.setPixmap(pixmap1)

        self.pic2 = QLabel()
        pixmap2 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic2.setPixmap(pixmap2)

        self.pic3 = QLabel()
        pixmap3 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic3.setPixmap(pixmap3)

        self.picBtn1 = QPushButton('Select Image')
        self.picBtn1.clicked.connect(self.getFilez)

        self.picBtn2 = QPushButton('Select Image')
        self.picBtn2.clicked.connect(self.getFilez)

        self.picBtn3 = QPushButton('Select Image')
        self.picBtn3.clicked.connect(self.getFilez)

        self.pic1Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic2Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic3Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        self.picBtn1.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn2.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn3.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        h1pic = QVBoxLayout()
        h2pic = QVBoxLayout()
        h3pic = QVBoxLayout()
        vpic = QHBoxLayout()

        h1pic.addWidget(self.pic1Lbl)
        h1pic.addStretch(0)
        h1pic.addWidget(self.pic1)
        h1pic.addStretch(0)
        h1pic.addWidget(self.picBtn1)
        h1pic.setContentsMargins(0, 0, 0, 0)
        h1pic.setSpacing(0)
        h1pic.setMargin(0)

        h2pic.addWidget(self.pic2Lbl)
        h2pic.addStretch(0)
        h2pic.addWidget(self.pic2)
        h2pic.addStretch(0)
        h2pic.addWidget(self.picBtn2)
        h2pic.setContentsMargins(0, 0, 0, 0)
        h2pic.setSpacing(0)
        h2pic.setMargin(0)

        h3pic.addWidget(self.pic3Lbl)
        h3pic.addStretch(0)
        h3pic.addWidget(self.pic3)
        h3pic.addStretch(0)
        h3pic.addWidget(self.picBtn3)
        h3pic.setContentsMargins(0, 0, 0, 0)
        h3pic.setSpacing(0)
        h3pic.setMargin(0)

        vpic.addLayout(h1pic)
        vpic.addStretch(0)
        vpic.addLayout(h2pic)
        vpic.addStretch(0)
        vpic.addLayout(h3pic)
        vpic.setSpacing(0)
        vpic.setMargin(0)
        vpic.setContentsMargins(0, 0, 0, 0)

        self.tab3.setLayout(vpic)
        self.tab3.resize(100, 100)
        #self.tab3.setStyleSheet("background-color: red; margin:5px; border:1px solid red;")

        self.tabz.addTab(self.tab1, 'Bio-Data')
        self.tabz.addTab(self.tab2, 'Contact Details')
        self.tabz.addTab(self.tab3, 'Passports')

        self.setWindowTitle("Add Student Data")
        self.show()

    def eContFill(self, a):

        sid = 23
        data = self.pullStudents(a)
        self.resize(430, 530)

        #self.tabz = QTabWidget(self)
        self.tabz.clear()

        self.tab1 = QWidget(self)
        self.tab2 = QWidget(self)
        self.tab3 = QWidget(self)

        self.schno = QLabel("School Number")
        self.schnoData = QLineEdit()
        self.schnoData.setObjectName("schno")
        if (data['schno'] and len(data['schno']) > 1):
            self.schnoData.setText(data['schno'])
        else:
            self.schnoData.setPlaceholderText("00000000")

        self.surname = QLabel("Surname")
        self.surnameData = QLineEdit()
        self.surnameData.setObjectName("surname")
        if (data['surname'] and len(data['surname']) > 1):
            tx = data['surname']
            self.surnameData.setText(tx.title())
        else:
            self.surnameData.setPlaceholderText("Surname")

        self.firstname = QLabel("Firstname")
        self.firstnameData = QLineEdit()
        self.firstnameData.setObjectName("firstname")
        if (data['firstname'] and len(data['firstname'])):
            tx = data['firstname']
            self.firstnameData.setText(tx.title())
        else:
            self.firstnameData.setPlaceholderText("Firstname")

        self.middlename = QLabel("Middlename")
        self.middlenameData = QLineEdit()
        self.middlenameData.setObjectName("middlename")
        if (data['othername'] and len(data['othername']) > 1):
            tx = data['othername']
            self.middlenameData.setText(tx.title())
        else:
            self.middlenameData.setPlaceholderText("othername")

        self.soo = QLabel("State/Region of Origin")
        self.sooData = QLineEdit()
        self.sooData.setObjectName("soo")
        if (data['soo'] and len(data['soo']) > 1):
            tx = data['soo']
            self.sooData.setText(tx.title())
        else:
            self.sooData.setPlaceholderText("Lagos")

        self.lga = QLabel("LGA/District")
        self.lgaData = QLineEdit()
        self.lgaData.setObjectName("lga")
        if (data['lga'] and len(data['lga'])):
            tx = data['lga']
            self.lgaData.setText(tx.title())
        else:
            self.lgaData.setPlaceholderText("Ikeja")

        self.addr = QLabel("House Address")
        self.addrData = QTextEdit()
        self.addrData.setObjectName("addr")
        if (data['addr'] and len(data['addr'])):
            tx = data['addr']
            self.addrData.setText(tx)
        else:
            pass

        self.dob = QLabel("Date of Birth")
        self.dobData = QDateEdit()
        self.dobData.setObjectName("dob")
        tx = QDate.fromString(data['dob'], 'yyyy-MM-dd')
        self.dobData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.admit = QLabel("Date Admitted")
        self.admitData = QDateEdit()
        self.admitData.setObjectName("admit")
        tx = QDate.fromString(data['admit'], 'yyyy-MM-dd')
        self.admitData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.pb4 = QPushButton()
        self.pb4.setObjectName("Submit")
        self.pb4.setText("Submit")

        self.pb5 = QPushButton()
        self.pb5.setObjectName("Cancel")
        self.pb5.setText("Cancel")

        hbo = QHBoxLayout()
        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        if (data['gender'] == 'Male'):
            self.r1.setChecked(True)
        elif (data['gender'] == 'Female'):
            self.r2.setChecked(True)

        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout = QFormLayout()
        Formlayout.addRow(self.schno, self.schnoData)
        Formlayout.addRow(self.surname, self.surnameData)
        Formlayout.addRow(self.firstname, self.firstnameData)
        Formlayout.addRow(self.middlename, self.middlenameData)
        Formlayout.addRow(self.gender, hbo)
        Formlayout.addRow(self.dob, self.dobData)
        Formlayout.addRow(self.admit, self.admitData)
        Formlayout.addRow(self.soo, self.sooData)
        Formlayout.addRow(self.lga, self.lgaData)
        Formlayout.addRow(self.addr, self.addrData)

        grid = QGridLayout()
        grid.addWidget(self.pb1, 0, 1)
        grid.addWidget(self.pb, 0, 0)

        groupBox = QGroupBox('BIODATA')
        groupBox.setLayout(Formlayout)

        vbox = QVBoxLayout()
        vbox.addWidget(groupBox)
        vbox.addStretch()
        vbox.addLayout(grid)

        #self.setLayout(vbox)
        self.connect(self.pb4, SIGNAL("clicked()"),
                     lambda: self.button1_click(sid))
        self.connect(self.pb5, SIGNAL("clicked()"), self.close)
        self.tab1.setLayout(vbox)

        relations = [
            'Father', 'Mother', 'Aunt', 'Uncle', 'Grand Parent', 'Guardian',
            'Others'
        ]

        #first guardian details
        self.g1name = QLabel("First Guardian")
        self.g1Data = QLineEdit()
        self.g1Data.setObjectName("g1name")
        if (data['g1'] and len(data['g1']) > 1):
            tx = data['g1']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("Mr. Surname Lastname")

        self.g1rel = QLabel('Relationship')
        self.g1relData = QComboBox()
        self.g1relData.addItems(relations)
        if data['g1rel'] and len(data['g1rel']) > 0:
            index1 = self.g1relData.findText(data['g1rel'],
                                             Qt.QtMatchFixedString)
            if index1 >= 0:
                self.g1relData.setCurrentIndex(index1)

        self.g1p1 = QLabel("Phone Number")
        self.g1p1Data = QLineEdit()
        self.g1p1Data.setObjectName("g1p1")
        if (data['g1p1'] and len(data['g1p1']) > 1):
            tx = data['g1p1']
            self.g1p1Data.setText(tx.title())
        else:
            self.g1p1Data.setPlaceholderText("08000000000")

        self.g1p2 = QLabel("Alt. Phone Number")
        self.g1p2Data = QLineEdit()
        self.g1p2Data.setObjectName("g1p2")
        if (data['g1p2'] and len(data['g1p2']) > 1):
            tx = data['g1p2']
            self.g1p2Data.setText(tx.title())
        else:
            self.g1p2Data.setPlaceholderText("08000000000")

        self.g1email = QLabel("Email")
        self.g1emailData = QLineEdit()
        self.g1emailData.setObjectName("g1email")
        if (data['g1email'] and len(data['g1email']) > 1):
            tx = data['g1email']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("*****@*****.**")

        self.g1addr = QLabel("Address")
        self.g1addrData = QTextEdit()
        self.g1addrData.setObjectName("g1add")
        if (data['g1addr'] and len(data['g1addr']) > 1):
            tx = data['g1addr']
            self.g1Data.setText(tx.title())
        else:
            pass

        #second guardian details
        self.g2name = QLabel("Second Guardian")
        self.g2Data = QLineEdit()
        self.g2Data.setObjectName("g2name")
        if (data['g2'] and len(data['g2']) > 1):
            tx = data['g2']
            self.g2Data.setText(tx.title())
        else:
            self.g2Data.setPlaceholderText("Title. Surname Lastname")

        self.g2rel = QLabel('Relationship')
        self.g2relData = QComboBox()
        self.g2relData.addItems(relations)
        if data['g2rel'] and len(data['g2rel']) > 0:
            index2 = self.g2relData.findText(data['g2rel'],
                                             Qt.QtMatchFixedString)
            if index2 >= 0:
                self.g2relData.setCurrentIndex(index2)

        self.g2p1 = QLabel("Phone Number")
        self.g2p1Data = QLineEdit()
        self.g2p1Data.setObjectName("g2p1")
        if (data['g2p1'] and len(data['g2p1']) > 1):
            tx = data['g2p1']
            self.g2p1Data.setText(tx.title())
        else:
            self.g2p1Data.setPlaceholderText("08000000000")

        self.g2p2 = QLabel("Alt. Phone Number")
        self.g2p2Data = QLineEdit()
        self.g2p2Data.setObjectName("g2p2")
        if (data['g2p2'] and len(data['g2p2']) > 1):
            tx = data['g2p2']
            self.g2p2Data.setText(tx.title())
        else:
            self.g2p2Data.setPlaceholderText("0800000000")

        self.g2email = QLabel("Email")
        self.g2emailData = QLineEdit()
        self.g2emailData.setObjectName("g2email")
        if (data['g2email'] and len(data['g2email']) > 1):
            tx = data['g2email']
            self.g2emailData.setText(tx.title())
        else:
            self.g2emailData.setPlaceholderText("*****@*****.**")

        self.g2addr = QLabel("Address")
        self.g2addrData = QTextEdit()
        self.g2addrData.setObjectName("g2add")
        if (data['g2addr'] and len(data['g2addr']) > 1):
            tx = data['g2addr']
            self.g2Data.setText(tx.title())
        else:
            pass

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()

        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout1 = QFormLayout()
        Formlayout1.addRow(self.g1name, self.g1Data)
        Formlayout1.addRow(self.g1rel, self.g1relData)
        Formlayout1.addRow(self.g1p1, self.g1p1Data)
        Formlayout1.addRow(self.g1p2, self.g1p2Data)
        Formlayout1.addRow(self.g1email, self.g1emailData)
        Formlayout1.addRow(self.g1addr, self.g1addrData)

        Formlayout2 = QFormLayout()
        Formlayout2.addRow(self.g2name, self.g2Data)
        Formlayout2.addRow(self.g2rel, self.g2relData)
        Formlayout2.addRow(self.g2p1, self.g2p1Data)
        Formlayout2.addRow(self.g2p2, self.g2p2Data)
        Formlayout2.addRow(self.g2email, self.g2emailData)
        Formlayout2.addRow(self.g2addr, self.g2addrData)

        grid1 = QGridLayout()
        grid1.addWidget(self.pb, 0, 0)
        grid1.addWidget(self.pb1, 0, 1)

        hbox1 = QHBoxLayout()
        hbox1.addLayout(Formlayout1)
        hbox1.addStretch()
        hbox1.addLayout(Formlayout2)

        groupBox2 = QGroupBox('GUARDIAN')
        groupBox2.setLayout(hbox1)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(groupBox2)
        vbox1.addStretch()
        vbox1.addLayout(grid1)

        self.tab2.setLayout(vbox1)

        #photo
        picstyle = QSize(120, 180)
        picstyle1 = Qt.KeepAspectRatio

        self.pic1Lbl = QLabel('YEAR 1 & 2')
        self.pic2Lbl = QLabel('YEAR 3 & 4')
        self.pic3Lbl = QLabel('YEAR 5 & 6')

        self.pic1 = QLabel()
        pixmap1 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic1.setPixmap(pixmap1)

        self.pic2 = QLabel()
        pixmap2 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic2.setPixmap(pixmap2)

        self.pic3 = QLabel()
        pixmap3 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic3.setPixmap(pixmap3)

        self.picBtn1 = QPushButton('Select Image')
        self.picBtn1.clicked.connect(self.getFilez)

        self.picBtn2 = QPushButton('Select Image')
        self.picBtn2.clicked.connect(self.getFilez)

        self.picBtn3 = QPushButton('Select Image')
        self.picBtn3.clicked.connect(self.getFilez)

        self.pic1Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic2Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic3Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        self.picBtn1.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn2.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn3.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        h1pic = QVBoxLayout()
        h2pic = QVBoxLayout()
        h3pic = QVBoxLayout()
        vpic = QHBoxLayout()

        h1pic.addWidget(self.pic1Lbl)
        h1pic.addStretch(0)
        h1pic.addWidget(self.pic1)
        h1pic.addStretch(0)
        h1pic.addWidget(self.picBtn1)
        h1pic.setContentsMargins(0, 0, 0, 0)
        h1pic.setSpacing(0)
        h1pic.setMargin(0)

        h2pic.addWidget(self.pic2Lbl)
        h2pic.addStretch(0)
        h2pic.addWidget(self.pic2)
        h2pic.addStretch(0)
        h2pic.addWidget(self.picBtn2)
        h2pic.setContentsMargins(0, 0, 0, 0)
        h2pic.setSpacing(0)
        h2pic.setMargin(0)

        h3pic.addWidget(self.pic3Lbl)
        h3pic.addStretch(0)
        h3pic.addWidget(self.pic3)
        h3pic.addStretch(0)
        h3pic.addWidget(self.picBtn3)
        h3pic.setContentsMargins(0, 0, 0, 0)
        h3pic.setSpacing(0)
        h3pic.setMargin(0)

        vpic.addLayout(h1pic)
        vpic.addStretch(0)
        vpic.addLayout(h2pic)
        vpic.addStretch(0)
        vpic.addLayout(h3pic)
        vpic.setSpacing(0)
        vpic.setMargin(0)
        vpic.setContentsMargins(0, 0, 0, 0)

        self.tab3.setLayout(vpic)
        self.tab3.resize(100, 100)
        self.tab3.setStyleSheet(
            "background-color: red; margin:5px; border:1px solid red;")

        self.tabz.addTab(self.tab1, 'Bio-Data')
        self.tabz.addTab(self.tab2, 'Contact Details')
        self.tabz.addTab(self.tab3, 'Passports')

        self.setWindowTitle("Add Student Data")
        self.show()

    def button_click(self, a):
        # shost is a QString object
        arr = {}
        arr['schno'] = self.schnoData.text()
        arr['surname'] = self.surnameData.text()
        arr['firstname'] = self.firstnameData.text()
        arr['othername'] = self.middlenameData.text()
        arr['soo'] = self.sooData.text()
        arr['lga'] = self.lgaData.text()
        arr['addr'] = self.addrData.toPlainText()
        dob = self.dobData.date()
        arr['dob'] = dob.toPyDate()
        admit = self.admitData.date()
        arr['admit'] = admit.toPyDate()
        arr['active'] = 0
        if self.r1.isChecked():
            arr['gender'] = 0
        else:
            arr['gender'] = 1

        self.a = a

        g = Db()
        if ((arr['surname']) and (arr['firstname']) and (arr['schno'])):
            h = g.insert('students', arr)

        self.contFill(h)

    def button1_click(self, a):
        # shost is a QString object
        arr = {}
        arr['schno'] = self.schnoData.text()
        arr['surname'] = self.surnameData.text()
        arr['firstname'] = self.firstnameData.text()
        arr['othername'] = self.middlenameData.text()
        arr['soo'] = self.sooData.text()
        arr['lga'] = self.lgaData.text()
        arr['addr'] = self.addrData.toPlainText()
        dob = self.dobData.date()
        arr['dob'] = dob.toPyDate()
        admit = self.admitData.date()
        arr['admit'] = admit.toPyDate()
        arr['active'] = 0

        arr['g1'] = self.g1Data.text()
        arr['g1rel'] = self.g1relData.itemData(self.g1relData.currentIndex())
        arr['g1p1'] = self.g1p1Data.text()
        arr['g1p2'] = self.g1p2Data.text()
        arr['g1email'] = self.g1emailData.text()
        arr['g1addr'] = self.g1addData.text()
        arr['g2'] = self.g2Data.text()
        arr['g2rel'] = self.g2relData.itemData(self.g2relData.currentIndex())
        arr['g2p1'] = self.g2p1Data.text()
        arr['g2p2'] = self.g2p2Data.text()
        arr['g2email'] = self.g2emailData.text()
        arr['g2addr'] = self.g2addData.text()

        self.a = a
        print(arr)
        g = Db()
        if ((arr['surname']) and (arr['firstname']) and (arr['schno'])):
            r = g.update('students', arr, {'id': self.a})
        print(r)
        self.close()

    def button_click1(self, a):
        # shost is a QString object
        s1 = self.le.text()
        s2 = self.le2.text()
        self.a = a
        g = Db()
        if (len(s1) > 0):
            y = {'name': s1, 'subID': self.a, 'abbrv': s2}
            j = g.insert('datas', y)
            return j

    def pullClass(self, a):
        self.a = a
        cn = Db()
        students = cn.select('datas', '', '', {'subID': self.a})
        arr = {}

        for j in students:
            arr[j[0]] = j[2]
        return arr

    def pullStudents(self, a):
        self.a = a
        cn = Db()
        students = cn.selectn('students', '', 1, {'id': self.a})
        return students

    def lunchUnitForm(self, a):
        self.a = a

        self.form = UnitForm(self.a)
        self.form.show()
Ejemplo n.º 40
0
    def __init__(self, parameter, parent=None):
        """Constructor

        :param parameter: A DefaultSelectParameter object.
        :type parameter: DefaultSelectParameter

        """
        super(DefaultSelectParameterWidget, self).__init__(parameter, parent)

        self.default_layout = QHBoxLayout()
        self.radio_button_layout = QHBoxLayout()
        self.radio_button_widget = QWidget()

        self.default_label = QLabel(tr('Default'))

        # Create radio button group
        self.default_input_button_group = QButtonGroup()

        # Define string enabler for radio button
        self.radio_button_enabler = self.input.itemData(0, Qt.UserRole)

        for i in range(len(self._parameter.default_labels)):
            if '%s' in self._parameter.default_labels[i]:
                label = (self._parameter.default_labels[i] %
                         self._parameter.default_values[i])
            else:
                label = self._parameter.default_labels[i]

            radio_button = QRadioButton(label)
            self.radio_button_layout.addWidget(radio_button)
            self.default_input_button_group.addButton(radio_button, i)
            if self._parameter.default_value == \
                    self._parameter.default_values[i]:
                radio_button.setChecked(True)

        # Create double spin box for custom value
        self.custom_value = QDoubleSpinBox()
        if self._parameter.default_values[-1]:
            self.custom_value.setValue(self._parameter.default_values[-1])
        has_min = False
        if self._parameter.minimum is not None:
            has_min = True
            self.custom_value.setMinimum(self._parameter.minimum)
        has_max = False
        if self._parameter.maximum is not None:
            has_max = True
            self.custom_value.setMaximum(self._parameter.maximum)
        if has_min and has_max:
            step = (self._parameter.maximum - self._parameter.minimum) / 100.0
            self.custom_value.setSingleStep(step)
        self.radio_button_layout.addWidget(self.custom_value)

        self.toggle_custom_value()

        # Reset the layout
        self.input_layout.setParent(None)
        self.help_layout.setParent(None)

        self.label.setParent(None)
        self.inner_input_layout.setParent(None)

        self.input_layout = QGridLayout()
        self.input_layout.setSpacing(0)

        self.input_layout.addWidget(self.label, 0, 0)
        self.input_layout.addLayout(self.inner_input_layout, 0, 1)
        self.input_layout.addWidget(self.default_label, 1, 0)
        self.input_layout.addLayout(self.radio_button_layout, 1, 1)

        self.main_layout.addLayout(self.input_layout)
        self.main_layout.addLayout(self.help_layout)

        # check every added combobox, it could have been toggled by
        # the existing keyword
        self.toggle_input()

        # Connect
        # noinspection PyUnresolvedReferences
        self.input.currentIndexChanged.connect(self.toggle_input)
        self.default_input_button_group.buttonClicked.connect(
            self.toggle_custom_value)
Ejemplo n.º 41
0
    def createSchedulingTab(self):
        soonLabel = QLabel('Soon Button')
        laterLabel = QLabel('Later Button')

        self.soonPercentButton = QRadioButton('Percent')
        soonPositionButton = QRadioButton('Position')
        self.laterPercentButton = QRadioButton('Percent')
        laterPositionButton = QRadioButton('Position')
        self.soonRandomCheckBox = QCheckBox('Randomize')
        self.laterRandomCheckBox = QCheckBox('Randomize')

        self.soonIntegerEditBox = QLineEdit()
        self.soonIntegerEditBox.setFixedWidth(100)
        self.laterIntegerEditBox = QLineEdit()
        self.laterIntegerEditBox.setFixedWidth(100)

        if self.settings['schedSoonType'] == 'pct':
            self.soonPercentButton.setChecked(True)
        else:
            soonPositionButton.setChecked(True)

        if self.settings['schedLaterType'] == 'pct':
            self.laterPercentButton.setChecked(True)
        else:
            laterPositionButton.setChecked(True)

        if self.settings['schedSoonRandom']:
            self.soonRandomCheckBox.setChecked(True)

        if self.settings['schedLaterRandom']:
            self.laterRandomCheckBox.setChecked(True)

        self.soonIntegerEditBox.setText(str(self.settings['schedSoonInt']))
        self.laterIntegerEditBox.setText(str(self.settings['schedLaterInt']))

        soonLayout = QHBoxLayout()
        soonLayout.addWidget(soonLabel)
        soonLayout.addStretch()
        soonLayout.addWidget(self.soonIntegerEditBox)
        soonLayout.addWidget(self.soonPercentButton)
        soonLayout.addWidget(soonPositionButton)
        soonLayout.addWidget(self.soonRandomCheckBox)

        laterLayout = QHBoxLayout()
        laterLayout.addWidget(laterLabel)
        laterLayout.addStretch()
        laterLayout.addWidget(self.laterIntegerEditBox)
        laterLayout.addWidget(self.laterPercentButton)
        laterLayout.addWidget(laterPositionButton)
        laterLayout.addWidget(self.laterRandomCheckBox)

        soonButtonGroup = QButtonGroup(soonLayout)
        soonButtonGroup.addButton(self.soonPercentButton)
        soonButtonGroup.addButton(soonPositionButton)

        laterButtonGroup = QButtonGroup(laterLayout)
        laterButtonGroup.addButton(self.laterPercentButton)
        laterButtonGroup.addButton(laterPositionButton)

        layout = QVBoxLayout()
        layout.addLayout(soonLayout)
        layout.addLayout(laterLayout)
        layout.addStretch()

        tab = QWidget()
        tab.setLayout(layout)

        return tab
Ejemplo n.º 42
0
class SettingsManager():
    def __init__(self):
        self.settingsChanged = False
        self.loadSettings()

        if self.settingsChanged:
            showInfo('Your Incremental Reading settings file has been modified'
                     ' for compatibility reasons. Please take a moment to'
                     ' reconfigure the add-on to your liking.')

        addHook('unloadProfile', self.saveSettings)

    def addMenuItem(self):
        addMenuItem('Read', 'Options...', self.showDialog, 'Alt+1')

    def saveSettings(self):
        with codecs.open(self.jsonPath, 'w', encoding='utf-8') as jsonFile:
            json.dump(self.settings, jsonFile)

        updateModificationTime(self.mediaDir)

    def loadSettings(self):
        self.defaults = {'editExtract': False,
                         'editSource': False,
                         'extractBgColor': 'Green',
                         'extractDeck': None,
                         'extractKey': 'X',
                         'extractTextColor': 'White',
                         'generalZoom': 1,
                         'highlightBgColor': 'Yellow',
                         'highlightKey': 'H',
                         'highlightTextColor': 'Black',
                         'lineScrollFactor': 0.05,
                         'modelName': 'IR3',
                         'pageScrollFactor': 0.5,
                         'plainText': False,
                         'quickKeys': {},
                         'removeKey': 'R',
                         'schedLaterInt': 50,
                         'schedLaterRandom': True,
                         'schedLaterType': 'pct',
                         'schedSoonInt': 10,
                         'schedSoonRandom': True,
                         'schedSoonType': 'pct',
                         'scroll': {},
                         'zoom': {},
                         'zoomStep': 0.1}

        self.mediaDir = os.path.join(mw.pm.profileFolder(), 'collection.media')
        self.jsonPath = os.path.join(self.mediaDir, '_ir.json')

        if os.path.isfile(self.jsonPath):
            with codecs.open(self.jsonPath, encoding='utf-8') as jsonFile:
                self.settings = json.load(jsonFile)
            self.addMissingSettings()
            self.removeOutdatedQuickKeys()
        else:
            self.settings = self.defaults

        self.loadMenuItems()

    def addMissingSettings(self):
        for k, v in self.defaults.items():
            if k not in self.settings:
                self.settings[k] = v
                self.settingsChanged = True

    def removeOutdatedQuickKeys(self):
        required = ['alt', 'bgColor', 'ctrl', 'deckName', 'editExtract',
                    'editSource', 'fieldName', 'modelName', 'regularKey',
                    'shift', 'textColor']

        for keyCombo, quickKey in self.settings['quickKeys'].copy().items():
            for k in required:
                if k not in quickKey:
                    self.settings['quickKeys'].pop(keyCombo)
                    self.settingsChanged = True
                    break

    def loadMenuItems(self):
        self.clearMenuItems()

        for keyCombo, quickKey in self.settings['quickKeys'].items():
            menuText = 'Add Card [%s -> %s]' % (quickKey['modelName'],
                                                quickKey['deckName'])
            function = partial(mw.readingManager.quickAdd, quickKey)
            mw.readingManager.quickKeyActions.append(
                addMenuItem('Read', menuText, function, keyCombo))

    def clearMenuItems(self):
        if mw.readingManager.quickKeyActions:
            for action in mw.readingManager.quickKeyActions:
                mw.customMenus['Read'].removeAction(action)
            mw.readingManager.quickKeyActions = []

    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)

    def createGeneralTab(self):
        extractKeyLabel = QLabel('Extract Key')
        highlightKeyLabel = QLabel('Highlight Key')
        removeKeyLabel = QLabel('Remove Key')

        self.extractKeyComboBox = QComboBox()
        self.highlightKeyComboBox = QComboBox()
        self.removeKeyComboBox = QComboBox()

        keys = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789')
        for comboBox in [self.extractKeyComboBox,
                         self.highlightKeyComboBox,
                         self.removeKeyComboBox]:
            comboBox.addItems(keys)

        self.setDefaultKeys()

        extractKeyLayout = QHBoxLayout()
        extractKeyLayout.addWidget(extractKeyLabel)
        extractKeyLayout.addWidget(self.extractKeyComboBox)

        highlightKeyLayout = QHBoxLayout()
        highlightKeyLayout.addWidget(highlightKeyLabel)
        highlightKeyLayout.addWidget(self.highlightKeyComboBox)

        removeKeyLayout = QHBoxLayout()
        removeKeyLayout.addWidget(removeKeyLabel)
        removeKeyLayout.addWidget(self.removeKeyComboBox)

        saveButton = QPushButton('Save')
        saveButton.clicked.connect(self.saveKeys)

        buttonLayout = QHBoxLayout()
        buttonLayout.addStretch()
        buttonLayout.addWidget(saveButton)

        basicControlsLayout = QVBoxLayout()
        basicControlsLayout.addLayout(extractKeyLayout)
        basicControlsLayout.addLayout(highlightKeyLayout)
        basicControlsLayout.addLayout(removeKeyLayout)
        basicControlsLayout.addLayout(buttonLayout)
        basicControlsLayout.addStretch()

        groupBox = QGroupBox('Basic Controls')
        groupBox.setLayout(basicControlsLayout)

        layout = QHBoxLayout()
        layout.addWidget(groupBox)

        tab = QWidget()
        tab.setLayout(layout)

        return tab

    def setDefaultKeys(self):
        setComboBoxItem(self.extractKeyComboBox, self.settings['extractKey'])
        setComboBoxItem(self.highlightKeyComboBox,
                        self.settings['highlightKey'])
        setComboBoxItem(self.removeKeyComboBox, self.settings['removeKey'])

    def saveKeys(self):
        keys = [self.extractKeyComboBox.currentText(),
                self.highlightKeyComboBox.currentText(),
                self.removeKeyComboBox.currentText()]

        if len(set(keys)) < 3:
            showInfo('There is a conflict with the keys you have chosen.'
                     ' Please try again.')
            self.setDefaultKeys()
        else:
            self.settings['extractKey'] = self.extractKeyComboBox.currentText()
            self.settings['highlightKey'] = self.highlightKeyComboBox.currentText()
            self.settings['removeKey'] = self.removeKeyComboBox.currentText()

    def createExtractionTab(self):
        extractDeckLabel = QLabel('Extracts Deck')
        self.extractDeckComboBox = QComboBox()
        deckNames = sorted([d['name'] for d in mw.col.decks.all()])
        self.extractDeckComboBox.addItem('[Current Deck]')
        self.extractDeckComboBox.addItems(deckNames)

        if self.settings['extractDeck']:
            setComboBoxItem(self.extractDeckComboBox,
                            self.settings['extractDeck'])
        else:
            setComboBoxItem(self.extractDeckComboBox, '[Current Deck]')

        extractDeckLayout = QHBoxLayout()
        extractDeckLayout.addWidget(extractDeckLabel)
        extractDeckLayout.addWidget(self.extractDeckComboBox)

        self.editExtractButton = QRadioButton('Edit Extracted Note')
        enterTitleButton = QRadioButton('Enter Title Only')

        if self.settings['editExtract']:
            self.editExtractButton.setChecked(True)
        else:
            enterTitleButton.setChecked(True)

        radioButtonsLayout = QHBoxLayout()
        radioButtonsLayout.addWidget(self.editExtractButton)
        radioButtonsLayout.addWidget(enterTitleButton)
        radioButtonsLayout.addStretch()

        self.editSourceCheckBox = QCheckBox('Edit Source Note')
        self.plainTextCheckBox = QCheckBox('Extract as Plain Text')

        if self.settings['editSource']:
            self.editSourceCheckBox.setChecked(True)

        if self.settings['plainText']:
            self.plainTextCheckBox.setChecked(True)

        layout = QVBoxLayout()
        layout.addLayout(extractDeckLayout)
        layout.addLayout(radioButtonsLayout)
        layout.addWidget(self.editSourceCheckBox)
        layout.addWidget(self.plainTextCheckBox)
        layout.addStretch()

        tab = QWidget()
        tab.setLayout(layout)

        return tab

    def createHighlightingTab(self):
        colorsGroupBox = self.createColorsGroupBox()
        colorPreviewGroupBox = self.createColorPreviewGroupBox()

        horizontalLayout = QHBoxLayout()
        horizontalLayout.addWidget(colorsGroupBox)
        horizontalLayout.addWidget(colorPreviewGroupBox)

        buttonBox = QDialogButtonBox(QDialogButtonBox.Save)
        buttonBox.accepted.connect(self.saveHighlightSettings)

        layout = QVBoxLayout()
        layout.addWidget(self.targetComboBox)
        layout.addLayout(horizontalLayout)
        layout.addWidget(buttonBox)
        layout.addStretch()

        tab = QWidget()
        tab.setLayout(layout)

        return tab

    def saveHighlightSettings(self):
        target = self.targetComboBox.currentText()
        bgColor = self.bgColorComboBox.currentText()
        textColor = self.textColorComboBox.currentText()

        if target == self.settings['highlightKey']:
            self.settings['highlightBgColor'] = bgColor
            self.settings['highlightTextColor'] = textColor
        elif target == self.settings['extractKey']:
            self.settings['extractBgColor'] = bgColor
            self.settings['extractTextColor'] = textColor
        else:
            self.settings['quickKeys'][target]['bgColor'] = bgColor
            self.settings['quickKeys'][target]['textColor'] = textColor

    def createColorsGroupBox(self):
        self.targetComboBox = QComboBox()
        self.targetComboBox.addItem(self.settings['highlightKey'])
        self.targetComboBox.addItem(self.settings['extractKey'])
        self.targetComboBox.addItems(self.settings['quickKeys'].keys())
        self.targetComboBox.currentIndexChanged.connect(
            self.updateHighlightingTab)

        targetLayout = QHBoxLayout()
        targetLayout.addWidget(self.targetComboBox)
        targetLayout.addStretch()

        colors = self.getColorList()

        self.bgColorComboBox = QComboBox()
        self.bgColorComboBox.addItems(colors)
        setComboBoxItem(self.bgColorComboBox,
                        self.settings['highlightBgColor'])
        self.bgColorComboBox.currentIndexChanged.connect(
            self.updateColorPreview)

        self.textColorComboBox = QComboBox()
        self.textColorComboBox.addItems(colors)
        setComboBoxItem(self.textColorComboBox,
                        self.settings['highlightTextColor'])
        self.textColorComboBox.currentIndexChanged.connect(
            self.updateColorPreview)

        bgColorLabel = QLabel('Background')
        bgColorLayout = QHBoxLayout()
        bgColorLayout.addWidget(bgColorLabel)
        bgColorLayout.addSpacing(10)
        bgColorLayout.addWidget(self.bgColorComboBox)

        textColorLabel = QLabel('Text')
        textColorLayout = QHBoxLayout()
        textColorLayout.addWidget(textColorLabel)
        textColorLayout.addSpacing(10)
        textColorLayout.addWidget(self.textColorComboBox)

        layout = QVBoxLayout()
        layout.addLayout(bgColorLayout)
        layout.addLayout(textColorLayout)
        layout.addStretch()

        groupBox = QGroupBox('Colors')
        groupBox.setLayout(layout)

        return groupBox

    def updateHighlightingTab(self):
        target = self.targetComboBox.currentText()
        if target == self.settings['highlightKey']:
            setComboBoxItem(self.bgColorComboBox,
                            self.settings['highlightBgColor'])
            setComboBoxItem(self.textColorComboBox,
                            self.settings['highlightTextColor'])
        elif target == self.settings['extractKey']:
            setComboBoxItem(self.bgColorComboBox,
                            self.settings['extractBgColor'])
            setComboBoxItem(self.textColorComboBox,
                            self.settings['extractTextColor'])
        else:
            setComboBoxItem(self.bgColorComboBox,
                            self.settings['quickKeys'][target]['bgColor'])
            setComboBoxItem(self.textColorComboBox,
                            self.settings['quickKeys'][target]['textColor'])

    def getColorList(self):
        moduleDir, _ = os.path.split(__file__)
        colorsFilePath = os.path.join(moduleDir, 'data', 'colors.u8')
        with codecs.open(colorsFilePath, encoding='utf-8') as colorsFile:
            return [line.strip() for line in colorsFile]

    def updateColorPreview(self):
        bgColor = self.bgColorComboBox.currentText()
        textColor = self.textColorComboBox.currentText()
        styleSheet = ('QLabel {'
                      'background-color: %s;'
                      'color: %s;'
                      'padding: 10px;'
                      'font-size: 16px;'
                      'font-family: tahoma, geneva, sans-serif;'
                      '}') % (bgColor, textColor)
        self.colorPreviewLabel.setStyleSheet(styleSheet)
        self.colorPreviewLabel.setAlignment(Qt.AlignCenter)

    def createColorPreviewGroupBox(self):
        self.colorPreviewLabel = QLabel('Example Text')
        self.updateColorPreview()
        colorPreviewLayout = QVBoxLayout()
        colorPreviewLayout.addWidget(self.colorPreviewLabel)

        groupBox = QGroupBox('Preview')
        groupBox.setLayout(colorPreviewLayout)

        return groupBox

    def createSchedulingTab(self):
        soonLabel = QLabel('Soon Button')
        laterLabel = QLabel('Later Button')

        self.soonPercentButton = QRadioButton('Percent')
        soonPositionButton = QRadioButton('Position')
        self.laterPercentButton = QRadioButton('Percent')
        laterPositionButton = QRadioButton('Position')
        self.soonRandomCheckBox = QCheckBox('Randomize')
        self.laterRandomCheckBox = QCheckBox('Randomize')

        self.soonIntegerEditBox = QLineEdit()
        self.soonIntegerEditBox.setFixedWidth(100)
        self.laterIntegerEditBox = QLineEdit()
        self.laterIntegerEditBox.setFixedWidth(100)

        if self.settings['schedSoonType'] == 'pct':
            self.soonPercentButton.setChecked(True)
        else:
            soonPositionButton.setChecked(True)

        if self.settings['schedLaterType'] == 'pct':
            self.laterPercentButton.setChecked(True)
        else:
            laterPositionButton.setChecked(True)

        if self.settings['schedSoonRandom']:
            self.soonRandomCheckBox.setChecked(True)

        if self.settings['schedLaterRandom']:
            self.laterRandomCheckBox.setChecked(True)

        self.soonIntegerEditBox.setText(str(self.settings['schedSoonInt']))
        self.laterIntegerEditBox.setText(str(self.settings['schedLaterInt']))

        soonLayout = QHBoxLayout()
        soonLayout.addWidget(soonLabel)
        soonLayout.addStretch()
        soonLayout.addWidget(self.soonIntegerEditBox)
        soonLayout.addWidget(self.soonPercentButton)
        soonLayout.addWidget(soonPositionButton)
        soonLayout.addWidget(self.soonRandomCheckBox)

        laterLayout = QHBoxLayout()
        laterLayout.addWidget(laterLabel)
        laterLayout.addStretch()
        laterLayout.addWidget(self.laterIntegerEditBox)
        laterLayout.addWidget(self.laterPercentButton)
        laterLayout.addWidget(laterPositionButton)
        laterLayout.addWidget(self.laterRandomCheckBox)

        soonButtonGroup = QButtonGroup(soonLayout)
        soonButtonGroup.addButton(self.soonPercentButton)
        soonButtonGroup.addButton(soonPositionButton)

        laterButtonGroup = QButtonGroup(laterLayout)
        laterButtonGroup.addButton(self.laterPercentButton)
        laterButtonGroup.addButton(laterPositionButton)

        layout = QVBoxLayout()
        layout.addLayout(soonLayout)
        layout.addLayout(laterLayout)
        layout.addStretch()

        tab = QWidget()
        tab.setLayout(layout)

        return tab

    def createQuickKeysTab(self):
        destDeckLabel = QLabel('Destination Deck')
        noteTypeLabel = QLabel('Note Type')
        textFieldLabel = QLabel('Paste Text to Field')
        keyComboLabel = QLabel('Key Combination')

        self.quickKeysComboBox = QComboBox()
        self.quickKeysComboBox.addItem('')
        self.quickKeysComboBox.addItems(self.settings['quickKeys'].keys())
        self.quickKeysComboBox.currentIndexChanged.connect(
            self.updateQuickKeysTab)

        self.destDeckComboBox = QComboBox()
        self.noteTypeComboBox = QComboBox()
        self.textFieldComboBox = QComboBox()
        self.quickKeyEditExtractCheckBox = QCheckBox('Edit Extrated Note')
        self.quickKeyEditSourceCheckBox = QCheckBox('Edit Source Note')
        self.quickKeyPlainTextCheckBox = QCheckBox('Extract as Plain Text')

        self.ctrlKeyCheckBox = QCheckBox('Ctrl')
        self.shiftKeyCheckBox = QCheckBox('Shift')
        self.altKeyCheckBox = QCheckBox('Alt')
        self.regularKeyComboBox = QComboBox()
        self.regularKeyComboBox.addItem('')
        self.regularKeyComboBox.addItems(
            list('ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789'))

        destDeckLayout = QHBoxLayout()
        destDeckLayout.addWidget(destDeckLabel)
        destDeckLayout.addWidget(self.destDeckComboBox)

        noteTypeLayout = QHBoxLayout()
        noteTypeLayout.addWidget(noteTypeLabel)
        noteTypeLayout.addWidget(self.noteTypeComboBox)

        textFieldLayout = QHBoxLayout()
        textFieldLayout.addWidget(textFieldLabel)
        textFieldLayout.addWidget(self.textFieldComboBox)

        keyComboLayout = QHBoxLayout()
        keyComboLayout.addWidget(keyComboLabel)
        keyComboLayout.addStretch()
        keyComboLayout.addWidget(self.ctrlKeyCheckBox)
        keyComboLayout.addWidget(self.shiftKeyCheckBox)
        keyComboLayout.addWidget(self.altKeyCheckBox)
        keyComboLayout.addWidget(self.regularKeyComboBox)

        deckNames = sorted([d['name'] for d in mw.col.decks.all()])
        self.destDeckComboBox.addItem('')
        self.destDeckComboBox.addItems(deckNames)

        modelNames = sorted([m['name'] for m in mw.col.models.all()])
        self.noteTypeComboBox.addItem('')
        self.noteTypeComboBox.addItems(modelNames)
        self.noteTypeComboBox.currentIndexChanged.connect(self.updateFieldList)

        newButton = QPushButton('New')
        newButton.clicked.connect(self.clearQuickKeysTab)
        deleteButton = QPushButton('Delete')
        deleteButton.clicked.connect(self.deleteQuickKey)
        saveButton = QPushButton('Save')
        saveButton.clicked.connect(self.setQuickKey)

        buttonLayout = QHBoxLayout()
        buttonLayout.addStretch()
        buttonLayout.addWidget(newButton)
        buttonLayout.addWidget(deleteButton)
        buttonLayout.addWidget(saveButton)

        layout = QVBoxLayout()
        layout.addWidget(self.quickKeysComboBox)
        layout.addLayout(destDeckLayout)
        layout.addLayout(noteTypeLayout)
        layout.addLayout(textFieldLayout)
        layout.addLayout(keyComboLayout)
        layout.addWidget(self.quickKeyEditExtractCheckBox)
        layout.addWidget(self.quickKeyEditSourceCheckBox)
        layout.addWidget(self.quickKeyPlainTextCheckBox)
        layout.addLayout(buttonLayout)

        tab = QWidget()
        tab.setLayout(layout)

        return tab

    def updateQuickKeysTab(self):
        quickKey = self.quickKeysComboBox.currentText()
        if quickKey:
            model = self.settings['quickKeys'][quickKey]
            setComboBoxItem(self.destDeckComboBox, model['deckName'])
            setComboBoxItem(self.noteTypeComboBox, model['modelName'])
            setComboBoxItem(self.textFieldComboBox, model['fieldName'])
            self.ctrlKeyCheckBox.setChecked(model['ctrl'])
            self.shiftKeyCheckBox.setChecked(model['shift'])
            self.altKeyCheckBox.setChecked(model['alt'])
            setComboBoxItem(self.regularKeyComboBox, model['regularKey'])
            self.quickKeyEditExtractCheckBox.setChecked(model['editExtract'])
            self.quickKeyEditSourceCheckBox.setChecked(model['editSource'])
            self.quickKeyPlainTextCheckBox.setChecked(model['plainText'])
        else:
            self.clearQuickKeysTab()

    def updateFieldList(self):
        modelName = self.noteTypeComboBox.currentText()
        self.textFieldComboBox.clear()
        if modelName:
            model = mw.col.models.byName(modelName)
            fieldNames = [f['name'] for f in model['flds']]
            self.textFieldComboBox.addItems(fieldNames)

    def clearQuickKeysTab(self):
        self.quickKeysComboBox.setCurrentIndex(0)
        self.destDeckComboBox.setCurrentIndex(0)
        self.noteTypeComboBox.setCurrentIndex(0)
        self.textFieldComboBox.setCurrentIndex(0)
        self.ctrlKeyCheckBox.setChecked(False)
        self.shiftKeyCheckBox.setChecked(False)
        self.altKeyCheckBox.setChecked(False)
        self.regularKeyComboBox.setCurrentIndex(0)
        self.quickKeyEditExtractCheckBox.setChecked(False)
        self.quickKeyEditSourceCheckBox.setChecked(False)
        self.quickKeyPlainTextCheckBox.setChecked(False)

    def deleteQuickKey(self):
        quickKey = self.quickKeysComboBox.currentText()
        if quickKey:
            self.settings['quickKeys'].pop(quickKey)
            removeComboBoxItem(self.quickKeysComboBox, quickKey)
            self.clearQuickKeysTab()
            self.loadMenuItems()

    def setQuickKey(self):
        quickKey = {'deckName': self.destDeckComboBox.currentText(),
                    'modelName': self.noteTypeComboBox.currentText(),
                    'fieldName': self.textFieldComboBox.currentText(),
                    'ctrl': self.ctrlKeyCheckBox.isChecked(),
                    'shift': self.shiftKeyCheckBox.isChecked(),
                    'alt': self.altKeyCheckBox.isChecked(),
                    'regularKey': self.regularKeyComboBox.currentText(),
                    'bgColor': self.bgColorComboBox.currentText(),
                    'textColor': self.textColorComboBox.currentText(),
                    'editExtract': self.quickKeyEditExtractCheckBox.isChecked(),
                    'editSource': self.quickKeyEditSourceCheckBox.isChecked(),
                    'plainText': self.quickKeyPlainTextCheckBox.isChecked()}

        for k in ['deckName', 'modelName', 'regularKey']:
            if not quickKey[k]:
                showInfo('Please complete all settings. Destination deck,'
                         ' note type, and a letter or number for the key'
                         ' combination are required.')
                return

        keyCombo = ''
        if quickKey['ctrl']:
            keyCombo += 'Ctrl+'
        if quickKey['shift']:
            keyCombo += 'Shift+'
        if quickKey['alt']:
            keyCombo += 'Alt+'
        keyCombo += quickKey['regularKey']

        self.settings['quickKeys'][keyCombo] = quickKey
        self.loadMenuItems()

        showInfo('New shortcut added: %s' % keyCombo)

    def createZoomGroupBox(self):
        zoomStepLabel = QLabel('Zoom Step')
        zoomStepPercentLabel = QLabel('%')
        generalZoomLabel = QLabel('General Zoom')
        generalZoomPercentLabel = QLabel('%')

        self.zoomStepSpinBox = QSpinBox()
        self.zoomStepSpinBox.setMinimum(5)
        self.zoomStepSpinBox.setMaximum(100)
        self.zoomStepSpinBox.setSingleStep(5)
        zoomStepPercent = round(self.settings['zoomStep'] * 100)
        self.zoomStepSpinBox.setValue(zoomStepPercent)

        self.generalZoomSpinBox = QSpinBox()
        self.generalZoomSpinBox.setMinimum(10)
        self.generalZoomSpinBox.setMaximum(200)
        self.generalZoomSpinBox.setSingleStep(10)
        generalZoomPercent = round(self.settings['generalZoom'] * 100)
        self.generalZoomSpinBox.setValue(generalZoomPercent)

        zoomStepLayout = QHBoxLayout()
        zoomStepLayout.addWidget(zoomStepLabel)
        zoomStepLayout.addStretch()
        zoomStepLayout.addWidget(self.zoomStepSpinBox)
        zoomStepLayout.addWidget(zoomStepPercentLabel)

        generalZoomLayout = QHBoxLayout()
        generalZoomLayout.addWidget(generalZoomLabel)
        generalZoomLayout.addStretch()
        generalZoomLayout.addWidget(self.generalZoomSpinBox)
        generalZoomLayout.addWidget(generalZoomPercentLabel)

        layout = QVBoxLayout()
        layout.addLayout(zoomStepLayout)
        layout.addLayout(generalZoomLayout)
        layout.addStretch()

        groupBox = QGroupBox('Zoom')
        groupBox.setLayout(layout)

        return groupBox

    def createScrollGroupBox(self):
        lineStepLabel = QLabel('Line Step')
        lineStepPercentLabel = QLabel('%')
        pageStepLabel = QLabel('Page Step')
        pageStepPercentLabel = QLabel('%')

        self.lineStepSpinBox = QSpinBox()
        self.lineStepSpinBox.setMinimum(5)
        self.lineStepSpinBox.setMaximum(100)
        self.lineStepSpinBox.setSingleStep(5)
        self.lineStepSpinBox.setValue(
            round(self.settings['lineScrollFactor'] * 100))

        self.pageStepSpinBox = QSpinBox()
        self.pageStepSpinBox.setMinimum(5)
        self.pageStepSpinBox.setMaximum(100)
        self.pageStepSpinBox.setSingleStep(5)
        self.pageStepSpinBox.setValue(
            round(self.settings['pageScrollFactor'] * 100))

        lineStepLayout = QHBoxLayout()
        lineStepLayout.addWidget(lineStepLabel)
        lineStepLayout.addStretch()
        lineStepLayout.addWidget(self.lineStepSpinBox)
        lineStepLayout.addWidget(lineStepPercentLabel)

        pageStepLayout = QHBoxLayout()
        pageStepLayout.addWidget(pageStepLabel)
        pageStepLayout.addStretch()
        pageStepLayout.addWidget(self.pageStepSpinBox)
        pageStepLayout.addWidget(pageStepPercentLabel)

        layout = QVBoxLayout()
        layout.addLayout(lineStepLayout)
        layout.addLayout(pageStepLayout)
        layout.addStretch()

        groupBox = QGroupBox('Scroll')
        groupBox.setLayout(layout)

        return groupBox
Ejemplo n.º 43
0
    def _init_ui(self):

        # Styles
        self.setStyleSheet("""QRadioButton {
                max-width: 40px;
            }""")

        bold_font = QFont()
        bold_font.setBold(True)

        title_label = QLabel(self)
        title_label.setText("PyPass3")
        title_label.move(10, 0)
        title_label.setMinimumSize(300, 20)
        title_label.setFont(bold_font)

        length_label = QLabel(self)
        length_label.setText("Length")
        length_label.move(192, 185)
        length_label.setMinimumSize(200, 20)
        length_label.setFont(bold_font)

        main_label = QLabel(self)
        main_label.setText("Make robust secrets with random characters,\n"
                           "words, or numbers. Or choose number of dice\n"
                           "and rolls for words type passphrase. Defaults\n"
                           "to 5 dice and 5 rolls.\n")
        main_label.setMinimumSize(280, 100)
        main_label.move(10, 15)

        type_label = QLabel(self)
        type_label.setText("Secret type")
        type_label.move(10, 87)
        type_label.setFont(bold_font)

        dice_label = QLabel(self)
        dice_label.setText("Number of dice")
        dice_label.move(10, 138)
        dice_label.setMinimumSize(280, 20)
        dice_label.setFont(bold_font)

        rolls_label = QLabel(self)
        rolls_label.setText("Number of rolls")
        rolls_label.move(10, 190)
        rolls_label.setMinimumSize(280, 20)
        rolls_label.setFont(bold_font)

        self.textbox = QTextEdit(self)
        self.textbox.setMinimumSize(280, 100)
        self.textbox.move(10, 245)
        self.textbox.setFontFamily("Courier New")

        self.length_textline = QLineEdit(self)
        self.length_textline.setMinimumSize(100, 20)
        self.length_textline.move(190, 210)

        min_width = 125
        # max_width = 150

        # Add Generate button
        generate_btn = QPushButton('Generate', self)
        generate_btn.setToolTip('Click to generate secret')
        # generate_btn.clicked.connect(on_click)
        generate_btn.clicked.connect(self._on_click)
        generate_btn.move(10, 355)
        generate_btn.setMinimumWidth(min_width)

        # Add Quit button
        quit_btn = QPushButton('Quit', self)
        quit_btn.setToolTip('Quit this application')
        quit_btn.clicked.connect(exit)
        quit_btn.move(165, 355)
        quit_btn.setMinimumWidth(min_width)

        # Add Copy button
        copy_btn = QPushButton('Copy', self)
        copy_btn.setToolTip('Copy your secret')
        copy_btn.clicked.connect(self._copy_textbox)
        copy_btn.move(250, 320)
        copy_btn.setMaximumWidth(35)
        copy_btn.setMaximumHeight(20)
        copy_btn.setStyleSheet('font-size: 11px;')

        # Add Help button
        help_btn = QPushButton('Help', self)
        help_btn.setToolTip('Get help about this application')
        help_btn.clicked.connect(self._open_help)
        help_btn.move(240, 80)
        help_btn.setMaximumWidth(35)
        help_btn.setMaximumHeight(20)
        help_btn.setStyleSheet('font-size: 11px;')

        hr1 = QFrame(self)
        hr1.setFrameShape(QFrame.HLine)
        hr1.move(10, 125)
        hr1.setMinimumWidth(280)
        hr1.setStyleSheet("color: #d0d0d0;")

        hr2 = QFrame(self)
        hr2.setFrameShape(QFrame.HLine)
        hr2.move(10, 175)
        hr2.setMinimumWidth(100)
        hr2.setStyleSheet("color: #d0d0d0;")

        # Add secret type radio buttons
        self.words_radio_btn = QRadioButton('words', self)
        self.words_radio_btn.move(10, 110)
        self.words_radio_btn.clicked.connect(self._set_word_defaults)
        self.words_radio_btn.setStyleSheet('max-width: 80px;')

        self.mixed_radio_btn = QRadioButton('mixed', self)
        self.mixed_radio_btn.move(90, 110)
        self.mixed_radio_btn.clicked.connect(self._disabled_unused)
        self.mixed_radio_btn.setStyleSheet('max-width: 80px;')

        self.numbers_radio_btn = QRadioButton('numbers', self)
        self.numbers_radio_btn.move(170, 110)
        self.numbers_radio_btn.clicked.connect(self._disabled_unused)
        self.numbers_radio_btn.setStyleSheet('max-width: 100px;')

        # Add dice roll radio buttons
        self.num_dice4 = QRadioButton('4', self)
        self.num_dice4.move(10, 160)

        self.num_dice5 = QRadioButton('5', self)
        self.num_dice5.move(60, 160)

        self.num_rolls3 = QRadioButton('3', self)
        self.num_rolls3.move(10, 212)

        self.num_rolls4 = QRadioButton('4', self)
        self.num_rolls4.move(60, 212)

        self.num_rolls5 = QRadioButton('5', self)
        self.num_rolls5.move(110, 212)

        self.radio_type_group = QButtonGroup(self)
        self.radio_type_group.addButton(self.words_radio_btn)
        self.radio_type_group.addButton(self.mixed_radio_btn)
        self.radio_type_group.addButton(self.numbers_radio_btn)

        self.radio_dice_group = QButtonGroup(self)
        self.radio_dice_group.addButton(self.num_dice4)
        self.radio_dice_group.addButton(self.num_dice5)

        self.radio_rolls_group = QButtonGroup(self)
        self.radio_rolls_group.addButton(self.num_rolls3)
        self.radio_rolls_group.addButton(self.num_rolls4)
        self.radio_rolls_group.addButton(self.num_rolls5)

        self.setGeometry(100, 100, 300, 400)
        self.setWindowTitle('Password Generator')
        self.setWindowIcon(QIcon('../images/lock_icon_bkgrd.png'))
Ejemplo n.º 44
0
    def __init__(self, result_widget, parent):
        super(FindInFilesDialog, self).__init__(parent)
        self._find_thread = FindInFilesThread()
        self.setWindowTitle(translations.TR_FIND_IN_FILES)
        self.resize(400, 300)
        #MAIN LAYOUT
        main_vbox = QVBoxLayout(self)

        self.pattern_line_edit = QLineEdit()
        self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...")
        self.dir_name_root = None
        self.user_home = os.path.expanduser('~')
        self.dir_combo = QComboBox()
        self.dir_combo.addItem(self.user_home)
        self.dir_combo.setEditable(True)
        self.open_button = QPushButton(QIcon(":img/find"),
                                       translations.TR_OPEN)
        self.filters_line_edit = QLineEdit("*.py")
        self.filters_line_edit.setPlaceholderText("*.py")
        self.filters_line_edit.setCompleter(
            QCompleter([
                "*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS
            ]))
        self.replace_line = QLineEdit()
        self.replace_line.setEnabled(False)
        self.replace_line.setPlaceholderText(translations.TR_TEXT_FOR_REPLACE +
                                             "...")
        self.check_replace = QCheckBox(translations.TR_REPLACE)
        self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE)
        self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION)
        self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE)
        self.recursive_checkbox.setCheckState(Qt.Checked)
        self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE)
        self.phrase_radio.setChecked(True)
        self.words_radio = QRadioButton(
            translations.TR_SEARCH_FOR_ALL_THE_WORDS)
        self.find_button = QPushButton(translations.TR_FIND + "!")
        self.find_button.setMaximumWidth(150)
        self.cancel_button = QPushButton(translations.TR_CANCEL)
        self.cancel_button.setMaximumWidth(150)
        self.result_widget = result_widget

        hbox = QHBoxLayout()
        hbox.addWidget(self.find_button)
        hbox.addWidget(self.cancel_button)

        #main section
        find_group_box = QGroupBox(translations.TR_MAIN)
        grid = QGridLayout()
        grid.addWidget(QLabel(translations.TR_TEXT), 0, 0)
        grid.addWidget(self.pattern_line_edit, 0, 1)
        grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0)
        grid.addWidget(self.dir_combo, 1, 1)
        grid.addWidget(self.open_button, 1, 2)
        grid.addWidget(QLabel(translations.TR_FILTER), 2, 0)
        grid.addWidget(self.filters_line_edit, 2, 1)
        grid.addWidget(self.check_replace, 3, 0)
        grid.addWidget(self.replace_line, 3, 1)

        find_group_box.setLayout(grid)
        #add main section to MAIN LAYOUT
        main_vbox.addWidget(find_group_box)

        #options sections
        options_group_box = QGroupBox(translations.TR_OPTIONS)
        gridOptions = QGridLayout()
        gridOptions.addWidget(self.case_checkbox, 0, 0)
        gridOptions.addWidget(self.type_checkbox, 1, 0)
        gridOptions.addWidget(self.recursive_checkbox, 2, 0)
        gridOptions.addWidget(self.phrase_radio, 0, 1)
        gridOptions.addWidget(self.words_radio, 1, 1)

        options_group_box.setLayout(gridOptions)
        #add options sections to MAIN LAYOUT
        main_vbox.addWidget(options_group_box)

        #add buttons to MAIN LAYOUT
        main_vbox.addLayout(hbox)

        #Focus
        self.pattern_line_edit.setFocus()
        self.open_button.setFocusPolicy(Qt.NoFocus)

        #signal
        self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
        self.connect(self.find_button, SIGNAL("clicked()"),
                     self._find_in_files)
        self.connect(self.cancel_button, SIGNAL("clicked()"),
                     self._kill_thread)
        self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
                     self._found_match)
        self.connect(self._find_thread, SIGNAL("finished()"),
                     self._find_thread_finished)
        self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
                     self._change_radio_enabled)
        self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
                     self._replace_activated)
        self.connect(self.words_radio, SIGNAL("clicked(bool)"),
                     self._words_radio_pressed)
Ejemplo n.º 45
0
class FindInFilesDialog(QDialog):
    """Dialog to configure and trigger the search in the files."""
    def __init__(self, result_widget, parent):
        super(FindInFilesDialog, self).__init__(parent)
        self._find_thread = FindInFilesThread()
        self.setWindowTitle(translations.TR_FIND_IN_FILES)
        self.resize(400, 300)
        #MAIN LAYOUT
        main_vbox = QVBoxLayout(self)

        self.pattern_line_edit = QLineEdit()
        self.pattern_line_edit.setPlaceholderText(translations.TR_FIND + "...")
        self.dir_name_root = None
        self.user_home = os.path.expanduser('~')
        self.dir_combo = QComboBox()
        self.dir_combo.addItem(self.user_home)
        self.dir_combo.setEditable(True)
        self.open_button = QPushButton(QIcon(":img/find"),
                                       translations.TR_OPEN)
        self.filters_line_edit = QLineEdit("*.py")
        self.filters_line_edit.setPlaceholderText("*.py")
        self.filters_line_edit.setCompleter(
            QCompleter([
                "*{}".format(item) for item in settings.SUPPORTED_EXTENSIONS
            ]))
        self.replace_line = QLineEdit()
        self.replace_line.setEnabled(False)
        self.replace_line.setPlaceholderText(translations.TR_TEXT_FOR_REPLACE +
                                             "...")
        self.check_replace = QCheckBox(translations.TR_REPLACE)
        self.case_checkbox = QCheckBox(translations.TR_CASE_SENSITIVE)
        self.type_checkbox = QCheckBox(translations.TR_REGULAR_EXPRESSION)
        self.recursive_checkbox = QCheckBox(translations.TR_RECURSIVE)
        self.recursive_checkbox.setCheckState(Qt.Checked)
        self.phrase_radio = QRadioButton(translations.TR_SEARCH_BY_PHRASE)
        self.phrase_radio.setChecked(True)
        self.words_radio = QRadioButton(
            translations.TR_SEARCH_FOR_ALL_THE_WORDS)
        self.find_button = QPushButton(translations.TR_FIND + "!")
        self.find_button.setMaximumWidth(150)
        self.cancel_button = QPushButton(translations.TR_CANCEL)
        self.cancel_button.setMaximumWidth(150)
        self.result_widget = result_widget

        hbox = QHBoxLayout()
        hbox.addWidget(self.find_button)
        hbox.addWidget(self.cancel_button)

        #main section
        find_group_box = QGroupBox(translations.TR_MAIN)
        grid = QGridLayout()
        grid.addWidget(QLabel(translations.TR_TEXT), 0, 0)
        grid.addWidget(self.pattern_line_edit, 0, 1)
        grid.addWidget(QLabel(translations.TR_DIRECTORY), 1, 0)
        grid.addWidget(self.dir_combo, 1, 1)
        grid.addWidget(self.open_button, 1, 2)
        grid.addWidget(QLabel(translations.TR_FILTER), 2, 0)
        grid.addWidget(self.filters_line_edit, 2, 1)
        grid.addWidget(self.check_replace, 3, 0)
        grid.addWidget(self.replace_line, 3, 1)

        find_group_box.setLayout(grid)
        #add main section to MAIN LAYOUT
        main_vbox.addWidget(find_group_box)

        #options sections
        options_group_box = QGroupBox(translations.TR_OPTIONS)
        gridOptions = QGridLayout()
        gridOptions.addWidget(self.case_checkbox, 0, 0)
        gridOptions.addWidget(self.type_checkbox, 1, 0)
        gridOptions.addWidget(self.recursive_checkbox, 2, 0)
        gridOptions.addWidget(self.phrase_radio, 0, 1)
        gridOptions.addWidget(self.words_radio, 1, 1)

        options_group_box.setLayout(gridOptions)
        #add options sections to MAIN LAYOUT
        main_vbox.addWidget(options_group_box)

        #add buttons to MAIN LAYOUT
        main_vbox.addLayout(hbox)

        #Focus
        self.pattern_line_edit.setFocus()
        self.open_button.setFocusPolicy(Qt.NoFocus)

        #signal
        self.connect(self.open_button, SIGNAL("clicked()"), self._select_dir)
        self.connect(self.find_button, SIGNAL("clicked()"),
                     self._find_in_files)
        self.connect(self.cancel_button, SIGNAL("clicked()"),
                     self._kill_thread)
        self.connect(self._find_thread, SIGNAL("found_pattern(PyQt_PyObject)"),
                     self._found_match)
        self.connect(self._find_thread, SIGNAL("finished()"),
                     self._find_thread_finished)
        self.connect(self.type_checkbox, SIGNAL("stateChanged(int)"),
                     self._change_radio_enabled)
        self.connect(self.check_replace, SIGNAL("stateChanged(int)"),
                     self._replace_activated)
        self.connect(self.words_radio, SIGNAL("clicked(bool)"),
                     self._words_radio_pressed)

    def _replace_activated(self):
        """If replace is activated, display the replace widgets."""
        self.replace_line.setEnabled(self.check_replace.isChecked())
        self.phrase_radio.setChecked(True)

    def _words_radio_pressed(self, value):
        """If search by independent words is activated, replace is not."""
        self.replace_line.setEnabled(not value)
        self.check_replace.setChecked(not value)
        self.words_radio.setChecked(True)

    def _change_radio_enabled(self, val):
        """Control the state of the radio buttons."""
        enabled = not self.type_checkbox.isChecked()
        self.phrase_radio.setEnabled(enabled)
        self.words_radio.setEnabled(enabled)

    def show(self, actual_project=None, actual=None):
        """Display the dialog and load the projects."""
        self.dir_combo.clear()
        self.dir_name_root = actual_project if \
            actual_project else [self.user_home]
        self.dir_combo.addItems(self.dir_name_root)
        if actual:
            index = self.dir_combo.findText(actual)
            self.dir_combo.setCurrentIndex(index)
        super(FindInFilesDialog, self).show()
        self.pattern_line_edit.setFocus()

    def reject(self):
        """Close the dialog and hide the tools dock."""
        self._kill_thread()
        tools_dock = IDE.get_service('tools_dock')
        if tools_dock:
            tools_dock.hide()
        super(FindInFilesDialog, self).reject()

    def _find_thread_finished(self):
        """Wait on thread finished."""
        self.emit(SIGNAL("finished()"))
        self._find_thread.wait()

    def _select_dir(self):
        """When a new folder is selected, add to the combo if needed."""
        dir_name = QFileDialog.getExistingDirectory(
            self, translations.TR_OPEN, self.dir_combo.currentText(),
            QFileDialog.ShowDirsOnly)
        index = self.dir_combo.findText(dir_name)
        if index >= 0:
            self.dir_combo.setCurrentIndex(index)
        else:
            self.dir_combo.insertItem(0, dir_name)
            self.dir_combo.setCurrentIndex(0)

    def _found_match(self, result):
        """Update the tree for each match found."""
        file_name = result[0]
        items = result[1]
        self.result_widget.update_result(self.dir_combo.currentText(),
                                         file_name, items)

    def _kill_thread(self):
        """Kill the thread."""
        if self._find_thread.isRunning():
            self._find_thread.cancel()
        self.accept()

    def _find_in_files(self):
        """Trigger the search on the files."""
        self.emit(SIGNAL("findStarted()"))
        self._kill_thread()
        self.result_widget.clear()
        pattern = self.pattern_line_edit.text()
        dir_name = self.dir_combo.currentText()

        filters = re.split("[,;]", self.filters_line_edit.text())

        #remove the spaces in the words Ex. (" *.foo"--> "*.foo")
        filters = [f.strip() for f in filters]
        case_sensitive = self.case_checkbox.isChecked()
        type_ = QRegExp.RegExp if \
            self.type_checkbox.isChecked() else QRegExp.FixedString
        recursive = self.recursive_checkbox.isChecked()
        by_phrase = True
        if self.phrase_radio.isChecked() or self.type_checkbox.isChecked():
            regExp = QRegExp(pattern, case_sensitive, type_)
        elif self.words_radio.isChecked():
            by_phrase = False
            type_ = QRegExp.RegExp
            pattern = '|'.join([word.strip() for word in pattern.split()])
            regExp = QRegExp(pattern, case_sensitive, type_)
        #save a reference to the root directory where we find
        self.dir_name_root = dir_name
        self._find_thread.find_in_files(dir_name, filters, regExp, recursive,
                                        by_phrase)
Ejemplo n.º 46
0
    def contFill(self, a):

        sid = a
        data = self.pullStudents(a)
        self.resize(430, 530)

        #self.tabz = QTabWidget(self)
        self.tabz.clear()

        self.tab1 = QWidget(self)
        self.tab2 = QWidget(self)
        self.tab3 = QWidget(self)

        self.schno = QLabel("School Number")
        self.schnoData = QLineEdit()
        self.schnoData.setObjectName("schno")
        if (data['schno'] and len(data['schno']) > 1):
            self.schnoData.setText(data['schno'])
        else:
            self.schnoData.setPlaceholderText("00000000")

        self.surname = QLabel("Surname")
        self.surnameData = QLineEdit()
        self.surnameData.setObjectName("surname")
        if (data['surname'] and len(data['surname']) > 1):
            tx = data['surname']
            self.surnameData.setText(tx.title())
        else:
            self.surnameData.setPlaceholderText("Surname")

        self.firstname = QLabel("Firstname")
        self.firstnameData = QLineEdit()
        self.firstnameData.setObjectName("firstname")
        if (data['firstname'] and len(data['firstname'])):
            tx = data['firstname']
            self.firstnameData.setText(tx.title())
        else:
            self.firstnameData.setPlaceholderText("Firstname")

        self.middlename = QLabel("Middlename")
        self.middlenameData = QLineEdit()
        self.middlenameData.setObjectName("middlename")
        if (data['othername'] and len(data['othername']) > 1):
            tx = data['othername']
            self.middlenameData.setText(tx.title())
        else:
            self.middlenameData.setPlaceholderText("othername")

        self.soo = QLabel("State/Region of Origin")
        self.sooData = QLineEdit()
        self.sooData.setObjectName("soo")
        if (data['soo'] and len(data['soo']) > 1):
            tx = data['soo']
            self.sooData.setText(tx.title())
        else:
            self.sooData.setPlaceholderText("Lagos")

        self.lga = QLabel("LGA/District")
        self.lgaData = QLineEdit()
        self.lgaData.setObjectName("lga")
        if (data['lga'] and len(data['lga'])):
            tx = data['lga']
            self.lgaData.setText(tx.title())
        else:
            self.lgaData.setPlaceholderText("Ikeja")

        self.addr = QLabel("House Address")
        self.addrData = QTextEdit()
        self.addrData.setObjectName("addr")
        if (data['addr'] and len(data['addr'])):
            tx = data['addr']
            self.addrData.setText(tx)
        else:
            pass

        self.dob = QLabel("Date of Birth")
        self.dobData = QDateEdit()
        self.dobData.setObjectName("dob")
        tx = QDate.fromString(data['dob'], 'yyyy-MM-dd')
        self.dobData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.admit = QLabel("Date Admitted")
        self.admitData = QDateEdit()
        self.admitData.setObjectName("admit")
        tx = QDate.fromString(data['admit'], 'yyyy-MM-dd')
        self.admitData.setDate(QDate(tx.year(), tx.month(), tx.day()))

        self.pb4 = QPushButton()
        self.pb4.setObjectName("Submit")
        self.pb4.setText("Submit")

        self.pb5 = QPushButton()
        self.pb5.setObjectName("Cancel")
        self.pb5.setText("Cancel")

        hbo = QHBoxLayout()
        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        if (data['gender'] == 'Male'):
            self.r1.setChecked(True)
        elif (data['gender'] == 'Female'):
            self.r2.setChecked(True)

        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout = QFormLayout()
        Formlayout.addRow(self.schno, self.schnoData)
        Formlayout.addRow(self.surname, self.surnameData)
        Formlayout.addRow(self.firstname, self.firstnameData)
        Formlayout.addRow(self.middlename, self.middlenameData)
        Formlayout.addRow(self.gender, hbo)
        Formlayout.addRow(self.dob, self.dobData)
        Formlayout.addRow(self.admit, self.admitData)
        Formlayout.addRow(self.soo, self.sooData)
        Formlayout.addRow(self.lga, self.lgaData)
        Formlayout.addRow(self.addr, self.addrData)

        grid = QGridLayout()
        grid.addWidget(self.pb1, 0, 1)
        grid.addWidget(self.pb, 0, 0)

        groupBox = QGroupBox('BIODATA')
        groupBox.setLayout(Formlayout)

        vbox = QVBoxLayout()
        vbox.addWidget(groupBox)
        vbox.addStretch()
        vbox.addLayout(grid)

        #self.setLayout(vbox)
        self.connect(self.pb4, SIGNAL("clicked()"),
                     lambda: self.button1_click(sid))
        self.connect(self.pb5, SIGNAL("clicked()"), self.close)
        self.tab1.setLayout(vbox)

        relations = [
            'Father', 'Mother', 'Aunt', 'Uncle', 'Grand Parent', 'Guardian',
            'Others'
        ]

        #first guardian details
        self.g1name = QLabel("First Guardian")
        self.g1Data = QLineEdit()
        self.g1Data.setObjectName("g1name")
        if (data['g1'] and len(data['g1']) > 1):
            tx = data['g1']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("Mr. Surname Lastname")

        self.g1rel = QLabel('Relationship')
        self.g1relData = QComboBox()
        self.g1relData.addItems(relations)
        if data['g1rel'] and len(data['g1rel']) > 0:
            index1 = self.g1relData.findText(data['g1rel'],
                                             Qt.QtMatchFixedString)
            if index1 >= 0:
                self.g1relData.setCurrentIndex(index1)

        self.g1p1 = QLabel("Phone Number")
        self.g1p1Data = QLineEdit()
        self.g1p1Data.setObjectName("g1p1")
        if (data['g1p1'] and len(data['g1p1']) > 1):
            tx = data['g1p1']
            self.g1p1Data.setText(tx.title())
        else:
            self.g1p1Data.setPlaceholderText("08000000000")

        self.g1p2 = QLabel("Alt. Phone Number")
        self.g1p2Data = QLineEdit()
        self.g1p2Data.setObjectName("g1p2")
        if (data['g1p2'] and len(data['g1p2']) > 1):
            tx = data['g1p2']
            self.g1p2Data.setText(tx.title())
        else:
            self.g1p2Data.setPlaceholderText("08000000000")

        self.g1email = QLabel("Email")
        self.g1emailData = QLineEdit()
        self.g1emailData.setObjectName("g1email")
        if (data['g1email'] and len(data['g1email']) > 1):
            tx = data['g1email']
            self.g1Data.setText(tx.title())
        else:
            self.g1Data.setPlaceholderText("*****@*****.**")

        self.g1addr = QLabel("Address")
        self.g1addrData = QTextEdit()
        self.g1addrData.setObjectName("g1add")
        if (data['g1addr'] and len(data['g1addr']) > 1):
            tx = data['g1addr']
            self.g1Data.setText(tx.title())
        else:
            pass

        #second guardian details
        self.g2name = QLabel("Second Guardian")
        self.g2Data = QLineEdit()
        self.g2Data.setObjectName("g2name")
        if (data['g2'] and len(data['g2']) > 1):
            tx = data['g2']
            self.g2Data.setText(tx.title())
        else:
            self.g2Data.setPlaceholderText("Title. Surname Lastname")

        self.g2rel = QLabel('Relationship')
        self.g2relData = QComboBox()
        self.g2relData.addItems(relations)
        if data['g2rel'] and len(data['g2rel']) > 0:
            index2 = self.g2relData.findText(data['g2rel'],
                                             Qt.QtMatchFixedString)
            if index2 >= 0:
                self.g2relData.setCurrentIndex(index2)

        self.g2p1 = QLabel("Phone Number")
        self.g2p1Data = QLineEdit()
        self.g2p1Data.setObjectName("g2p1")
        if (data['g2p1'] and len(data['g2p1']) > 1):
            tx = data['g2p1']
            self.g2p1Data.setText(tx.title())
        else:
            self.g2p1Data.setPlaceholderText("08000000000")

        self.g2p2 = QLabel("Alt. Phone Number")
        self.g2p2Data = QLineEdit()
        self.g2p2Data.setObjectName("g2p2")
        if (data['g2p2'] and len(data['g2p2']) > 1):
            tx = data['g2p2']
            self.g2p2Data.setText(tx.title())
        else:
            self.g2p2Data.setPlaceholderText("0800000000")

        self.g2email = QLabel("Email")
        self.g2emailData = QLineEdit()
        self.g2emailData.setObjectName("g2email")
        if (data['g2email'] and len(data['g2email']) > 1):
            tx = data['g2email']
            self.g2emailData.setText(tx.title())
        else:
            self.g2emailData.setPlaceholderText("*****@*****.**")

        self.g2addr = QLabel("Address")
        self.g2addrData = QTextEdit()
        self.g2addrData.setObjectName("g2add")
        if (data['g2addr'] and len(data['g2addr']) > 1):
            tx = data['g2addr']
            self.g2Data.setText(tx.title())
        else:
            pass

        self.pb = QPushButton()
        self.pb.setObjectName("Submit")
        self.pb.setText("Submit")

        self.pb1 = QPushButton()
        self.pb1.setObjectName("Cancel")
        self.pb1.setText("Cancel")

        hbo = QHBoxLayout()

        self.gender = QLabel('Gender')
        self.r1 = QRadioButton('Male')
        self.r2 = QRadioButton('Female')
        hbo.addWidget(self.r1)
        hbo.addWidget(self.r2)

        Formlayout1 = QFormLayout()
        Formlayout1.addRow(self.g1name, self.g1Data)
        Formlayout1.addRow(self.g1rel, self.g1relData)
        Formlayout1.addRow(self.g1p1, self.g1p1Data)
        Formlayout1.addRow(self.g1p2, self.g1p2Data)
        Formlayout1.addRow(self.g1email, self.g1emailData)
        Formlayout1.addRow(self.g1addr, self.g1addrData)

        Formlayout2 = QFormLayout()
        Formlayout2.addRow(self.g2name, self.g2Data)
        Formlayout2.addRow(self.g2rel, self.g2relData)
        Formlayout2.addRow(self.g2p1, self.g2p1Data)
        Formlayout2.addRow(self.g2p2, self.g2p2Data)
        Formlayout2.addRow(self.g2email, self.g2emailData)
        Formlayout2.addRow(self.g2addr, self.g2addrData)

        grid1 = QGridLayout()
        grid1.addWidget(self.pb, 0, 0)
        grid1.addWidget(self.pb1, 0, 1)

        hbox1 = QHBoxLayout()
        hbox1.addLayout(Formlayout1)
        hbox1.addStretch()
        hbox1.addLayout(Formlayout2)

        groupBox2 = QGroupBox('GUARDIAN')
        groupBox2.setLayout(hbox1)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(groupBox2)
        vbox1.addStretch()
        vbox1.addLayout(grid1)

        self.tab2.setLayout(vbox1)

        #photo
        picstyle = QSize(120, 180)
        picstyle1 = Qt.KeepAspectRatio

        self.pic1Lbl = QLabel('YEAR 1 & 2')
        self.pic2Lbl = QLabel('YEAR 3 & 4')
        self.pic3Lbl = QLabel('YEAR 5 & 6')

        self.pic1 = QLabel()
        pixmap1 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic1.setPixmap(pixmap1)

        self.pic2 = QLabel()
        pixmap2 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic2.setPixmap(pixmap2)

        self.pic3 = QLabel()
        pixmap3 = QPixmap('img/studentz.png').scaled(picstyle, picstyle1)
        self.pic3.setPixmap(pixmap3)

        self.picBtn1 = QPushButton('Select Image')
        self.picBtn1.clicked.connect(self.getFilez)

        self.picBtn2 = QPushButton('Select Image')
        self.picBtn2.clicked.connect(self.getFilez)

        self.picBtn3 = QPushButton('Select Image')
        self.picBtn3.clicked.connect(self.getFilez)

        self.pic1Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic2Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.pic3Lbl.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        self.picBtn1.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn2.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        self.picBtn3.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)

        h1pic = QVBoxLayout()
        h2pic = QVBoxLayout()
        h3pic = QVBoxLayout()
        vpic = QHBoxLayout()

        h1pic.addWidget(self.pic1Lbl)
        h1pic.addStretch(0)
        h1pic.addWidget(self.pic1)
        h1pic.addStretch(0)
        h1pic.addWidget(self.picBtn1)
        h1pic.setContentsMargins(0, 0, 0, 0)
        h1pic.setSpacing(0)
        h1pic.setMargin(0)

        h2pic.addWidget(self.pic2Lbl)
        h2pic.addStretch(0)
        h2pic.addWidget(self.pic2)
        h2pic.addStretch(0)
        h2pic.addWidget(self.picBtn2)
        h2pic.setContentsMargins(0, 0, 0, 0)
        h2pic.setSpacing(0)
        h2pic.setMargin(0)

        h3pic.addWidget(self.pic3Lbl)
        h3pic.addStretch(0)
        h3pic.addWidget(self.pic3)
        h3pic.addStretch(0)
        h3pic.addWidget(self.picBtn3)
        h3pic.setContentsMargins(0, 0, 0, 0)
        h3pic.setSpacing(0)
        h3pic.setMargin(0)

        vpic.addLayout(h1pic)
        vpic.addStretch(0)
        vpic.addLayout(h2pic)
        vpic.addStretch(0)
        vpic.addLayout(h3pic)
        vpic.setSpacing(0)
        vpic.setMargin(0)
        vpic.setContentsMargins(0, 0, 0, 0)

        self.tab3.setLayout(vpic)
        self.tab3.resize(100, 100)
        #self.tab3.setStyleSheet("background-color: red; margin:5px; border:1px solid red;")

        self.tabz.addTab(self.tab1, 'Bio-Data')
        self.tabz.addTab(self.tab2, 'Contact Details')
        self.tabz.addTab(self.tab3, 'Passports')

        self.setWindowTitle("Add Student Data")
        self.show()
Ejemplo n.º 47
0
class ApplicationWindow(QMainWindow):
    def __init__(self):

        super(ApplicationWindow, self).__init__()

        self._init_ui()
        self._set_defaults()

    def _init_ui(self):

        # Styles
        self.setStyleSheet("""QRadioButton {
                max-width: 40px;
            }""")

        bold_font = QFont()
        bold_font.setBold(True)

        title_label = QLabel(self)
        title_label.setText("PyPass3")
        title_label.move(10, 0)
        title_label.setMinimumSize(300, 20)
        title_label.setFont(bold_font)

        length_label = QLabel(self)
        length_label.setText("Length")
        length_label.move(192, 185)
        length_label.setMinimumSize(200, 20)
        length_label.setFont(bold_font)

        main_label = QLabel(self)
        main_label.setText("Make robust secrets with random characters,\n"
                           "words, or numbers. Or choose number of dice\n"
                           "and rolls for words type passphrase. Defaults\n"
                           "to 5 dice and 5 rolls.\n")
        main_label.setMinimumSize(280, 100)
        main_label.move(10, 15)

        type_label = QLabel(self)
        type_label.setText("Secret type")
        type_label.move(10, 87)
        type_label.setFont(bold_font)

        dice_label = QLabel(self)
        dice_label.setText("Number of dice")
        dice_label.move(10, 138)
        dice_label.setMinimumSize(280, 20)
        dice_label.setFont(bold_font)

        rolls_label = QLabel(self)
        rolls_label.setText("Number of rolls")
        rolls_label.move(10, 190)
        rolls_label.setMinimumSize(280, 20)
        rolls_label.setFont(bold_font)

        self.textbox = QTextEdit(self)
        self.textbox.setMinimumSize(280, 100)
        self.textbox.move(10, 245)
        self.textbox.setFontFamily("Courier New")

        self.length_textline = QLineEdit(self)
        self.length_textline.setMinimumSize(100, 20)
        self.length_textline.move(190, 210)

        min_width = 125
        # max_width = 150

        # Add Generate button
        generate_btn = QPushButton('Generate', self)
        generate_btn.setToolTip('Click to generate secret')
        # generate_btn.clicked.connect(on_click)
        generate_btn.clicked.connect(self._on_click)
        generate_btn.move(10, 355)
        generate_btn.setMinimumWidth(min_width)

        # Add Quit button
        quit_btn = QPushButton('Quit', self)
        quit_btn.setToolTip('Quit this application')
        quit_btn.clicked.connect(exit)
        quit_btn.move(165, 355)
        quit_btn.setMinimumWidth(min_width)

        # Add Copy button
        copy_btn = QPushButton('Copy', self)
        copy_btn.setToolTip('Copy your secret')
        copy_btn.clicked.connect(self._copy_textbox)
        copy_btn.move(250, 320)
        copy_btn.setMaximumWidth(35)
        copy_btn.setMaximumHeight(20)
        copy_btn.setStyleSheet('font-size: 11px;')

        # Add Help button
        help_btn = QPushButton('Help', self)
        help_btn.setToolTip('Get help about this application')
        help_btn.clicked.connect(self._open_help)
        help_btn.move(240, 80)
        help_btn.setMaximumWidth(35)
        help_btn.setMaximumHeight(20)
        help_btn.setStyleSheet('font-size: 11px;')

        hr1 = QFrame(self)
        hr1.setFrameShape(QFrame.HLine)
        hr1.move(10, 125)
        hr1.setMinimumWidth(280)
        hr1.setStyleSheet("color: #d0d0d0;")

        hr2 = QFrame(self)
        hr2.setFrameShape(QFrame.HLine)
        hr2.move(10, 175)
        hr2.setMinimumWidth(100)
        hr2.setStyleSheet("color: #d0d0d0;")

        # Add secret type radio buttons
        self.words_radio_btn = QRadioButton('words', self)
        self.words_radio_btn.move(10, 110)
        self.words_radio_btn.clicked.connect(self._set_word_defaults)
        self.words_radio_btn.setStyleSheet('max-width: 80px;')

        self.mixed_radio_btn = QRadioButton('mixed', self)
        self.mixed_radio_btn.move(90, 110)
        self.mixed_radio_btn.clicked.connect(self._disabled_unused)
        self.mixed_radio_btn.setStyleSheet('max-width: 80px;')

        self.numbers_radio_btn = QRadioButton('numbers', self)
        self.numbers_radio_btn.move(170, 110)
        self.numbers_radio_btn.clicked.connect(self._disabled_unused)
        self.numbers_radio_btn.setStyleSheet('max-width: 100px;')

        # Add dice roll radio buttons
        self.num_dice4 = QRadioButton('4', self)
        self.num_dice4.move(10, 160)

        self.num_dice5 = QRadioButton('5', self)
        self.num_dice5.move(60, 160)

        self.num_rolls3 = QRadioButton('3', self)
        self.num_rolls3.move(10, 212)

        self.num_rolls4 = QRadioButton('4', self)
        self.num_rolls4.move(60, 212)

        self.num_rolls5 = QRadioButton('5', self)
        self.num_rolls5.move(110, 212)

        self.radio_type_group = QButtonGroup(self)
        self.radio_type_group.addButton(self.words_radio_btn)
        self.radio_type_group.addButton(self.mixed_radio_btn)
        self.radio_type_group.addButton(self.numbers_radio_btn)

        self.radio_dice_group = QButtonGroup(self)
        self.radio_dice_group.addButton(self.num_dice4)
        self.radio_dice_group.addButton(self.num_dice5)

        self.radio_rolls_group = QButtonGroup(self)
        self.radio_rolls_group.addButton(self.num_rolls3)
        self.radio_rolls_group.addButton(self.num_rolls4)
        self.radio_rolls_group.addButton(self.num_rolls5)

        self.setGeometry(100, 100, 300, 400)
        self.setWindowTitle('Password Generator')
        self.setWindowIcon(QIcon('../images/lock_icon_bkgrd.png'))

    def _set_defaults(self):

        self.words_radio_btn.setChecked(True)
        self.num_dice5.setChecked(True)
        self.num_rolls5.setChecked(True)
        self.length_textline.setText('')

    def _run_generate(self):

        logging.info('[{0}]\n{1}'.format(utils.get_timestamp(),
                                         self._get_args()))

        return generate_secret(int(self._get_args()['number_rolls']),
                               int(self._get_args()['number_dice']),
                               int(self._get_args()['how_many']),
                               str(self._get_args()['output_type']),
                               int(self._get_args()['password_length']))

        # def generate_secret(number_rolls: int = 5, number_dice: int = 5,
        #                       how_many: int = 1, output_type: str = 'words',
        #                       password_length: int = 20)

        # output_type=self._get_args()['output_type'],
        # password_length=int(self._get_args()['password_length']),
        # number_dice=int(self._get_args()['number_dice']),
        # number_rolls=int(self._get_args()['number_rolls'])

    def _on_click(self):

        self.textbox.setFontFamily("Courier New")

        return self.textbox.setText(self._run_generate())

    def _get_args(self):

        args = {'password_length': 20, 'how_many': 1}

        # Type
        if self.numbers_radio_btn.isChecked():
            args['output_type'] = self.numbers_radio_btn.text()

        elif self.mixed_radio_btn.isChecked():
            args['output_type'] = self.mixed_radio_btn.text()

        else:
            args['output_type'] = self.words_radio_btn.text()

        # Length
        if self.length_textline.text():
            args['password_length'] = self.length_textline.text()

        # Dice
        if self.num_dice4.isChecked():
            args['number_dice'] = self.num_dice4.text()

        else:
            args['number_dice'] = self.num_dice5.text()

        # Rolls
        if self.num_rolls3.isChecked():
            args['number_rolls'] = self.num_rolls3.text()

        elif self.num_rolls4.isChecked():
            args['number_rolls'] = self.num_rolls4.text()

        else:
            args['number_rolls'] = self.num_rolls5.text()

        return args

    def _disabled_unused(self):

        tmp_text = self.length_textline.text()

        if tmp_text:
            self.length_textline.setText(tmp_text)
        else:
            self.length_textline.setText('20')

        self.radio_dice_group.setExclusive(False)
        self.radio_rolls_group.setExclusive(False)

        self.num_dice4.setChecked(False)
        self.num_dice4.setCheckable(False)
        self.num_dice4.setEnabled(False)

        self.num_dice5.setChecked(False)
        self.num_dice5.setCheckable(False)
        self.num_dice5.setEnabled(False)

        self.num_rolls3.setChecked(False)
        self.num_rolls3.setCheckable(False)
        self.num_rolls3.setEnabled(False)

        self.num_rolls4.setChecked(False)
        self.num_rolls4.setCheckable(False)
        self.num_rolls4.setEnabled(False)

        self.num_rolls5.setChecked(False)
        self.num_rolls5.setCheckable(False)
        self.num_rolls5.setEnabled(False)

        self.radio_dice_group.setExclusive(True)
        self.radio_rolls_group.setExclusive(True)

    def _set_word_defaults(self):

        self.length_textline.setText('')

        self.num_dice4.setCheckable(True)
        self.num_dice4.setEnabled(True)

        self.num_dice5.setCheckable(True)
        self.num_dice5.setEnabled(True)

        self.num_rolls3.setCheckable(True)
        self.num_rolls3.setEnabled(True)

        self.num_rolls4.setCheckable(True)
        self.num_rolls4.setEnabled(True)

        self.num_rolls5.setCheckable(True)
        self.num_rolls5.setEnabled(True)

        self.num_dice5.setChecked(True)
        self.num_rolls5.setChecked(True)

    def _copy_textbox(self):

        self.textbox.selectAll()
        self.textbox.copy()

    def _open_help(self):

        message = QMessageBox(self)

        with open('../assets/help/_main.txt', 'r') as help_text:
            message.setText(help_text.read())

        message.setIcon(QMessageBox.Question)

        with open('../assets/help/_inform.txt', 'r') as help_inform:
            message.setInformativeText(help_inform.read())

        message.setWindowTitle('PyPass3 Help')
        message.setStandardButtons(QMessageBox.Close)
        message.exec_()
Ejemplo n.º 48
0
class SkinsTab(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        vbox = QVBoxLayout(self)

        #Top Bar
        hbox = QHBoxLayout()
        self.radioDefault = QRadioButton("Default Skin")
        self.radioCustom = QRadioButton("Custom")
        self.comboSkins = QComboBox()
        self.skins = loader.load_gui_skins()
        for item in self.skins:
            self.comboSkins.addItem(item)
        hbox.addWidget(self.radioDefault)
        hbox.addWidget(self.radioCustom)
        hbox.addWidget(self.comboSkins)
        #Text Area
        self.txtStyle = QPlainTextEdit()
        self.txtStyle.setReadOnly(True)

        #Settings
        settings = QSettings()
        settings.beginGroup('preferences')
        settings.beginGroup('skins')
        if settings.value('default', True).toBool():
            self.radioDefault.setChecked(True)
            self.comboSkins.setEnabled(False)
        else:
            self.radioCustom.setChecked(True)
            index = self.comboSkins.findText(
                settings.value('selectedSkin', '').toString())
            self.comboSkins.setCurrentIndex(index)
            content = self.skins[str(self.comboSkins.currentText())]
            self.txtStyle.setPlainText(content)
        settings.endGroup()
        settings.endGroup()

        vbox.addLayout(hbox)
        vbox.addWidget(self.txtStyle)
        vbox.addWidget(QLabel('Requires restart the IDE'))

        #Signals
        self.connect(self.radioDefault, SIGNAL("clicked()"),
                     self._default_clicked)
        self.connect(self.radioCustom, SIGNAL("clicked()"),
                     self._custom_clicked)

    def _default_clicked(self):
        self.comboSkins.setEnabled(False)
        self.txtStyle.setPlainText('')

    def _custom_clicked(self):
        self.comboSkins.setEnabled(True)
        content = self.skins[str(self.comboSkins.currentText())]
        self.txtStyle.setPlainText(content)

    def save(self):
        settings = QSettings()
        settings.beginGroup('preferences')
        settings.beginGroup('skins')
        settings.setValue('default', self.radioDefault.isChecked())
        settings.setValue('selectedSkin', self.comboSkins.currentText())
        settings.endGroup()
        settings.endGroup()
Ejemplo n.º 49
0
    def Elem_init(self):

        self.SW_Main = QStackedWidget(self)

        self.SW_Tab1 = QWidget(self.SW_Main)
        self.SW_Tab2 = QWidget(self.SW_Main)

        self.GB_LeftSide = QGroupBox(self.SW_Tab1)
        self.GB_RightSide = QGroupBox(self.SW_Tab1)
        self.BottomWidget = QtGui.QWidget(self.SW_Tab1)

        self.Wid_LayVer_LeftSide = QtGui.QWidget(self.GB_LeftSide)
        self.L_ImageLeft = QtGui.QLabel(self.Wid_LayVer_LeftSide)

        self.GB_Options_LB = QtGui.QGroupBox(self.GB_LeftSide)

        self.L_NodeNumber = QtGui.QLabel(self.GB_Options_LB)
        self.L_zoom = QtGui.QLabel(self.GB_Options_LB)
        self.SB_NodeNumber = QtGui.QSpinBox(self.GB_Options_LB)
        self.DSB_Zoom = QtGui.QDoubleSpinBox(self.GB_Options_LB)
        self.L_GeoT = QtGui.QLabel(self.GB_Options_LB)
        self.L_GeoPos = QtGui.QLabel(self.GB_Options_LB)

        self.ImageLeft = QtGui.QPixmap(Paths["Screenshot"])

        self.Wid_LayVer_RightSide = QtGui.QWidget(self.GB_RightSide)

        self.B_ImportPos = QtGui.QPushButton(self.Wid_LayVer_RightSide)
        self.Web = QWebView(self.Wid_LayVer_RightSide)

        self.B_Help = QtGui.QPushButton(self.BottomWidget)
        self.B_Next = QtGui.QPushButton(self.BottomWidget)
        self.B_Cancel = QtGui.QPushButton(self.BottomWidget)
        self.L_ImageLogo = QtGui.QLabel(self.BottomWidget)

        self.ImageLogo = QtGui.QPixmap(Paths["Logo"])

        self.BG_Transform = QtGui.QGroupBox(self.SW_Tab2)
        self.BottomWidget_T2 = QtGui.QWidget(self.SW_Tab2)

        self.GB_Opt_T2 = QtGui.QGroupBox(self.SW_Tab2)

        self.SB_NodeNumber_T2 = QtGui.QSpinBox(self.GB_Opt_T2)
        self.DSB_Factor_T2 = QtGui.QDoubleSpinBox(self.GB_Opt_T2)
        self.L_Factor_T2 = QtGui.QLabel(self.GB_Opt_T2)
        self.L_NodeNumber_T2 = QtGui.QLabel(self.GB_Opt_T2)

        self.RB_prj = QRadioButton(self.BG_Transform)
        self.RB_regression = QRadioButton(self.BG_Transform)
        self.RB_partiall = QRadioButton(self.BG_Transform)

        self.B_Help_T2 = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Back = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Calculate = QtGui.QPushButton(self.BottomWidget_T2)
        self.B_Cancel_T2 = QtGui.QPushButton(self.BottomWidget_T2)
        self.L_ImageLogo_T2 = QtGui.QLabel(self.BottomWidget_T2)

        self.LayGrid_Main = QtGui.QGridLayout()
        self.LayVer_LeftSide = QtGui.QVBoxLayout()
        self.LayVer_RightSide = QtGui.QVBoxLayout()
        self.LayGrid_Bottom = QtGui.QGridLayout()
        self.LayGrid_Opt = QtGui.QGridLayout()
        self.LayVer_Main_T2 = QtGui.QVBoxLayout()
        self.Lay_Transform = QVBoxLayout()
        self.LayGrid_Bottom_T2 = QtGui.QGridLayout()
        self.BL_Lay_Transform = QtGui.QVBoxLayout()

        self.LayHor_Opt_T2 = QtGui.QHBoxLayout()

        self.V_NodeFilter = Visum.Filters.NodeFilter()
        self.V_LinkFilter = Visum.Filters.LinkFilter()
Ejemplo n.º 50
0
        class LabelDistributionOptionsDlg(QDialog):
            """
            A little dialog to let the user specify how the labels should be
            distributed from the current stages to the other stages.
            """
            def __init__(self, source_stage_index, num_stages, *args,
                         **kwargs):
                super(LabelDistributionOptionsDlg,
                      self).__init__(*args, **kwargs)

                from PyQt4.QtCore import Qt
                from PyQt4.QtGui import QGroupBox, QCheckBox, QRadioButton, QDialogButtonBox

                self.setWindowTitle(
                    "Distributing from Stage {}".format(source_stage_index +
                                                        1))

                self.stage_checkboxes = []
                for stage_index in range(1, num_stages + 1):
                    self.stage_checkboxes.append(
                        QCheckBox("Stage {}".format(stage_index)))

                # By default, send labels back into the current stage, at least.
                self.stage_checkboxes[source_stage_index].setChecked(True)

                stage_selection_layout = QVBoxLayout()
                for checkbox in self.stage_checkboxes:
                    stage_selection_layout.addWidget(checkbox)

                stage_selection_groupbox = QGroupBox(
                    "Send labels from Stage {} to:".format(source_stage_index +
                                                           1), self)
                stage_selection_groupbox.setLayout(stage_selection_layout)

                self.copy_button = QRadioButton("Copy", self)
                self.partition_button = QRadioButton("Partition", self)
                self.partition_button.setChecked(True)
                distribution_mode_layout = QVBoxLayout()
                distribution_mode_layout.addWidget(self.copy_button)
                distribution_mode_layout.addWidget(self.partition_button)

                distribution_mode_group = QGroupBox("Distribution Mode", self)
                distribution_mode_group.setLayout(distribution_mode_layout)

                buttonbox = QDialogButtonBox(Qt.Horizontal, parent=self)
                buttonbox.setStandardButtons(QDialogButtonBox.Ok
                                             | QDialogButtonBox.Cancel)
                buttonbox.accepted.connect(self.accept)
                buttonbox.rejected.connect(self.reject)

                dlg_layout = QVBoxLayout()
                dlg_layout.addWidget(stage_selection_groupbox)
                dlg_layout.addWidget(distribution_mode_group)
                dlg_layout.addWidget(buttonbox)
                self.setLayout(dlg_layout)

            def distribution_mode(self):
                if self.copy_button.isChecked():
                    return "copy"
                if self.partition_button.isChecked():
                    return "partition"
                assert False, "Shouldn't get here."

            def destination_stages(self):
                """
                Return the list of stage_indexes (0-based) that the user checked.
                """
                return [
                    i for i, box in enumerate(self.stage_checkboxes)
                    if box.isChecked()
                ]
Ejemplo n.º 51
0
    def createWidgets(self):
        """
        """
        qcCredGroup = QGroupBox(self.tr("HP ALM server credentials"))
        self.hpCredLogin = QLineEdit()
        self.hpCredPwd = QLineEdit()
        self.hpCredPwd.setEchoMode(QLineEdit.Password)
        qcCredLayout = QGridLayout()
        qcCredLayout.addWidget(QLabel("Login"), 0, 0)
        qcCredLayout.addWidget(self.hpCredLogin, 0, 1)
        qcCredLayout.addWidget(QLabel("Password"), 1, 0)
        qcCredLayout.addWidget(self.hpCredPwd, 1, 1)
        qcCredGroup.setLayout(qcCredLayout)

        qcSvrGroup = QGroupBox(self.tr("HP ALM server informations"))
        self.hpSvrURL = QLineEdit()
        self.hpSvrDomain = QLineEdit()
        self.hpSvrProject = QLineEdit()

        self.comAPI = QRadioButton("COM")
        self.comAPI.setChecked(False)
        self.comAPI.setEnabled(False)

        self.restAPI = QRadioButton("REST")
        self.restAPI.setChecked(True)

        layoutApi = QHBoxLayout()
        layoutApi.addWidget(self.comAPI)
        layoutApi.addWidget(self.restAPI)

        qcSvrLayout = QGridLayout()
        qcSvrLayout.addWidget(QLabel("URL"), 0, 0)
        qcSvrLayout.addWidget(self.hpSvrURL, 0, 1)
        qcSvrLayout.addWidget(QLabel("Domain"), 1, 0)
        qcSvrLayout.addWidget(self.hpSvrDomain, 1, 1)
        qcSvrLayout.addWidget(QLabel("Project"), 2, 0)
        qcSvrLayout.addWidget(self.hpSvrProject, 2, 1)
        qcSvrLayout.addWidget(QLabel("API"), 3, 0)
        qcSvrLayout.addLayout(layoutApi, 3, 1)

        qcSvrGroup.setLayout(qcSvrLayout)

        # begin export result settings
        qcExportResultGroup = QGroupBox(self.tr("Export results"))
        self.ignoreTcCheckBox = QCheckBox(self.tr("Ignore testcase(s)"))
        self.ignoreUncompleteCheckBox = QCheckBox(
            self.tr("Ignore uncomplete test(s)"))
        self.addFoldersTlCheckBox = QCheckBox(
            self.tr("Create missing folders in test lab"))
        self.addTestsetCheckBox = QCheckBox(
            self.tr("Create testset if missing in test lab"))
        self.addTestinstanceCheckBox = QCheckBox(
            self.tr("Create test instance in test set"))
        self.cfgsTestsetTable = DesignPage.ConfigsTableView(self,
                                                            core=self.core())
        qcExportResultLayout = QVBoxLayout()
        qcExportResultLayout.addWidget(self.ignoreTcCheckBox)
        qcExportResultLayout.addWidget(self.ignoreUncompleteCheckBox)
        qcExportResultLayout.addWidget(self.addFoldersTlCheckBox)
        qcExportResultLayout.addWidget(self.addTestsetCheckBox)
        qcExportResultLayout.addWidget(self.addTestinstanceCheckBox)
        qcExportResultLayout.addWidget(QLabel("Custom TestSet Fields"))
        qcExportResultLayout.addWidget(self.cfgsTestsetTable)
        qcExportResultLayout.addStretch(1)
        qcExportResultGroup.setLayout(qcExportResultLayout)
        # end

        # begin export test settings
        qcExportGroup = QGroupBox(self.tr("Export tests"))

        self.mergeCheckBox = QCheckBox(self.tr("Merge all tests in one"))
        self.mergeStepsCheckBox = QCheckBox(self.tr("Merge all steps in one"))
        self.showTcNameCheckBox = QCheckBox(
            self.tr("Load with original test name"))
        self.replaceTcCheckBox = QCheckBox(
            self.tr("Replace testcase with testname"))
        self.addFoldersTpCheckBox = QCheckBox(
            self.tr("Create missing folders in test plan"))
        self.overwriteTcCheckBox = QCheckBox(
            self.tr("Overwrite testcases in test plan"))
        self.cfgsTable = DesignPage.ConfigsTableView(self, core=self.core())

        qcExportLayout = QGridLayout()
        qcExportLayout.addWidget(self.mergeCheckBox, 0, 0)
        qcExportLayout.addWidget(self.mergeStepsCheckBox, 1, 0)
        qcExportLayout.addWidget(self.showTcNameCheckBox, 2, 0)
        qcExportLayout.addWidget(self.replaceTcCheckBox, 3, 0)
        qcExportLayout.addWidget(self.addFoldersTpCheckBox, 4, 0)
        qcExportLayout.addWidget(self.overwriteTcCheckBox, 5, 0)
        qcExportLayout.addWidget(QLabel("Custom Test Fields"), 6, 0)
        qcExportLayout.addWidget(self.cfgsTable, 7, 0)
        qcExportGroup.setLayout(qcExportLayout)
        # end

        layoutCtrls = QHBoxLayout()
        self.saveButton = QPushButton(self.tr("Save Settings"), self)
        self.testButton = QPushButton(self.tr("Test Connection"), self)
        layoutCtrls.addWidget(self.saveButton)
        layoutCtrls.addWidget(self.testButton)

        mainLayout = QGridLayout()
        mainLayout.addWidget(qcSvrGroup, 0, 0)
        mainLayout.addWidget(qcCredGroup, 0, 1)
        mainLayout.addWidget(qcExportGroup, 2, 0)
        mainLayout.addWidget(qcExportResultGroup, 2, 1)
        mainLayout.addLayout(layoutCtrls, 3, 1)
        self.setLayout(mainLayout)
Ejemplo n.º 52
0
    def create_layout(self):
        cancel_box = QHBoxLayout()
        cancel_box.addWidget(self.close_button)

        grid1 = QGridLayout()
        grid2 = QGridLayout()

        #-----------------------------------------
        # setup
        self.radio_rectangular = QRadioButton('Rectangular')
        self.radio_cylindrical = QRadioButton('Cylindrical')
        self.radio_spherical = QRadioButton('Spherical')

        coord_type_layout = QHBoxLayout()
        coord_type_layout.addWidget(self.radio_rectangular)
        coord_type_layout.addWidget(self.radio_cylindrical)
        coord_type_layout.addWidget(self.radio_spherical)

        location_layout = QHBoxLayout()
        location_layout.addWidget(self.location_x_edit)
        location_layout.addWidget(self.location_y_edit)
        location_layout.addWidget(self.location_z_edit)

        checkboxs = QButtonGroup(self)
        checkboxs.addButton(self.checkbox_show)
        checkboxs.addButton(self.checkbox_hide)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(self.checkbox_show)
        vbox1.addWidget(self.checkbox_hide)
        #vbox1.addLayout(checkboxs)

        #-----------------------------------------
        irow = 0
        grid1.addWidget(self.all_nodes_header, irow, 0)
        irow += 1

        grid1.addWidget(self.color, irow, 0)
        grid1.addWidget(self.color_edit, irow, 1)
        irow += 1

        grid1.addWidget(self.opacity, irow, 0)
        grid1.addWidget(self.opacity_edit, irow, 1)
        irow += 1

        grid1.addWidget(self.point_size, irow, 0)
        grid1.addWidget(self.point_size_edit, irow, 1)
        irow += 1

        #-----------------------------------------
        irow = 0
        grid2.addWidget(self.nodes_header, irow, 0)
        irow += 1

        grid2.addWidget(self.name, irow, 0)
        grid2.addWidget(self.name_edit, irow, 1)
        irow += 1

        grid2.addWidget(self.description, irow, 0)
        grid2.addWidget(self.description_edit, irow, 1)
        irow += 1

        #|  All Nodes:            |
        #|    Color     red       |
        #|    PointSize 3         |
        #|    Opacity   0.3       |
        #|    Show/Hide           |
        #|                        |
        #|  Name        LEwingTip |
        #|  Location    X Y Z     |
        #|  Coord       0         |
        #|  CoordType   R, C, S   |
        #|                        |
        #|   Previous     Next    |
        grid2.addWidget(self.coord, irow, 0)
        grid2.addWidget(self.coord_edit, irow, 1)
        irow += 1

        grid2.addWidget(self.coord_type, irow, 0)
        grid2.addLayout(coord_type_layout, irow, 1)
        irow += 1

        grid2.addWidget(self.location, irow, 0)
        grid2.addLayout(location_layout, irow, 1)
        irow += 1

        #------------------------------------

        vbox = QVBoxLayout()
        vbox.addLayout(grid1)
        vbox.addLayout(vbox1)
        vbox.addStretch()
        vbox.addWidget(self.table)

        vbox.addLayout(grid2)
        vbox.addStretch()
        #vbox.addWidget(self.check_apply)
        vbox.addLayout(cancel_box)
        self.setLayout(vbox)
Ejemplo n.º 53
0
    def __init__(self, parent, text):
        QWidget.__init__(self, parent)
        
        self.text_editor = QTextEdit(self)
        self.text_editor.setText(text)
        self.text_editor.setReadOnly(True)
        
        # Type frame
        type_layout = QHBoxLayout()
        type_label = QLabel(translate("ImportWizard", "Import as"))
        type_layout.addWidget(type_label)
        data_btn = QRadioButton(translate("ImportWizard", "data"))
        data_btn.setChecked(True)
        self._as_data= True
        type_layout.addWidget(data_btn)
        code_btn = QRadioButton(translate("ImportWizard", "code"))
        self._as_code = False
        type_layout.addWidget(code_btn)        
        txt_btn = QRadioButton(translate("ImportWizard", "text"))
        type_layout.addWidget(txt_btn)
        h_spacer = QSpacerItem(40, 20,
                               QSizePolicy.Expanding, QSizePolicy.Minimum)
        type_layout.addItem(h_spacer)        
        type_frame = QFrame()
        type_frame.setLayout(type_layout)
        
        # Opts frame
        opts_layout = QHBoxLayout()
        
        self.trnsp_box = QCheckBox(translate("ImportWizard", "Transpose"))
        #self.trnsp_box.setEnabled(False)
        opts_layout.addWidget(self.trnsp_box)
        
        h_spacer = QSpacerItem(40, 20,
                               QSizePolicy.Expanding, QSizePolicy.Minimum)
        opts_layout.addItem(h_spacer)
        
        grid_layout = QGridLayout()
        grid_layout.setSpacing(0)
        
        col_label = QLabel(translate("ImportWizard", "Column separator:"))
        grid_layout.addWidget(col_label,0,0)
        col_w = QWidget()
        col_btn_layout = QHBoxLayout()
        self.tab_btn = QRadioButton(translate("ImportWizard", "Tab"))
        self.tab_btn.setChecked(True)
        col_btn_layout.addWidget(self.tab_btn)
        other_btn_col = QRadioButton(translate("ImportWizard", "other"))
        col_btn_layout.addWidget(other_btn_col)
        col_w.setLayout(col_btn_layout)
        grid_layout.addWidget(col_w,0,1)
        self.line_edt = QLineEdit(",")
        self.line_edt.setMaximumWidth(30)
        self.line_edt.setEnabled(False)
        self.connect(other_btn_col, SIGNAL("toggled(bool)"),
                     self.line_edt, SLOT("setEnabled(bool)"))
        grid_layout.addWidget(self.line_edt,0,2)

        row_label = QLabel(translate("ImportWizard", "Row separator:"))
        grid_layout.addWidget(row_label,1,0)
        row_w = QWidget()
        row_btn_layout = QHBoxLayout()
        self.eol_btn = QRadioButton(translate("ImportWizard", "EOL"))
        self.eol_btn.setChecked(True)
        row_btn_layout.addWidget(self.eol_btn)
        other_btn_row = QRadioButton(translate("ImportWizard", "other"))
        row_btn_layout.addWidget(other_btn_row)
        row_w.setLayout(row_btn_layout)
        grid_layout.addWidget(row_w,1,1)
        self.line_edt_row = QLineEdit(";")
        self.line_edt_row.setMaximumWidth(30)
        self.line_edt_row.setEnabled(False)
        self.connect(other_btn_row, SIGNAL("toggled(bool)"),
                     self.line_edt_row, SLOT("setEnabled(bool)"))
        grid_layout.addWidget(self.line_edt_row,1,2)

        opts_layout.addLayout(grid_layout)
        
        opts_frame = QFrame()
        opts_frame.setLayout(opts_layout)
        
        self.connect(data_btn, SIGNAL("toggled(bool)"),
                     opts_frame, SLOT("setEnabled(bool)"))
        self.connect(data_btn, SIGNAL("toggled(bool)"),
                     self, SLOT("set_as_data(bool)"))
        self.connect(code_btn, SIGNAL("toggled(bool)"),
                     self, SLOT("set_as_code(bool)"))
#        self.connect(txt_btn, SIGNAL("toggled(bool)"),
#                     self, SLOT("is_text(bool)"))

        # Final layout
        layout = QVBoxLayout()
        layout.addWidget(type_frame)
        layout.addWidget(self.text_editor)
        layout.addWidget(opts_frame)
        self.setLayout(layout)
Ejemplo n.º 54
0
class ParallelOptimization(OWWidget):
    resultListList = [50, 100, 200, 500, 1000]
    qualityMeasure = [
        "Classification accuracy", "Average correct", "Brier score"
    ]
    testingMethod = [
        "Leave one out", "10-fold cross validation", "Test on learning set"
    ]

    settingsList = [
        "attributeCount", "fileBuffer", "lastSaveDirName",
        "optimizationMeasure", "numberOfAttributes", "orderAllAttributes",
        "optimizationMeasure"
    ]

    def __init__(self, parallelWidget, parent=None, signalManager=None):
        OWWidget.__init__(self, parent, signalManager,
                          "Parallel Optimization Dialog", False)
        self.setCaption("Parallel Optimization Dialog")
        self.parallelWidget = parallelWidget

        self.optimizationMeasure = 0
        self.attributeCount = 5
        self.numberOfAttributes = 6
        self.fileName = ""
        self.lastSaveDirName = os.getcwd() + "/"
        self.fileBuffer = []
        self.projections = []
        self.allResults = []
        self.canOptimize = 0
        self.orderAllAttributes = 1  # do we wish to order all attributes or find just an interesting subset
        self.worstVal = -1  # used in heuristics to stop the search in uninteresting parts of the graph

        self.loadSettings()

        self.measureBox = OWGUI.radioButtonsInBox(
            self.controlArea,
            self,
            "optimizationMeasure", ["Correlation", "VizRank"],
            box="Select optimization measure",
            callback=self.updateGUI)
        self.vizrankSettingsBox = OWGUI.widgetBox(self.controlArea,
                                                  "VizRank settings")
        self.optimizeBox = OWGUI.widgetBox(self.controlArea, "Optimize")
        self.manageBox = OWGUI.widgetBox(self.controlArea, "Manage results")
        self.resultsBox = OWGUI.widgetBox(self.mainArea, "Results")

        self.resultList = OWGUI.listBox(self.resultsBox, self)
        self.resultList.setMinimumSize(200, 200)
        self.connect(self.resultList, SIGNAL("itemSelectionChanged()"),
                     self.showSelectedAttributes)

        # remove non-existing files
        names = []
        for i in range(len(self.fileBuffer) - 1, -1, -1):
            (short, longName) = self.fileBuffer[i]
            if not os.path.exists(longName):
                self.fileBuffer.remove((short, longName))
            else:
                names.append(short)
        names.append("(None)")
        self.fileName = "(None)"

        self.hbox1 = OWGUI.widgetBox(self.vizrankSettingsBox,
                                     "VizRank projections file",
                                     orientation="horizontal")
        self.vizrankFileCombo = OWGUI.comboBox(
            self.hbox1,
            self,
            "fileName",
            items=names,
            tooltip=
            "File that contains information about interestingness of scatterplots\n"
            "generated by VizRank method in scatterplot widget",
            callback=self.changeProjectionFile,
            sendSelectedValue=1,
            valueType=str)
        self.browseButton = OWGUI.button(self.hbox1,
                                         self,
                                         "...",
                                         callback=self.loadProjections)
        self.browseButton.setMaximumWidth(20)

        self.resultsInfoBox = OWGUI.widgetBox(self.vizrankSettingsBox,
                                              "VizRank parameters")
        self.kNeighborsLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                 "Number of neighbors (k):")
        self.percentDataUsedLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                      "Percent of data used:")
        self.testingMethodLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                    "Testing method used:")
        self.qualityMeasureLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                     "Quality measure used:")

        self.allAttributesRadio = QRadioButton("Order all attributes",
                                               self.optimizeBox)
        self.optimizeBox.layout().addWidget(self.allAttributesRadio)
        self.connect(self.allAttributesRadio, SIGNAL("clicked()"),
                     self.setAllAttributeRadio)
        box = OWGUI.widgetBox(self.optimizeBox, orientation="horizontal")
        self.subsetAttributeRadio = QRadioButton("Find subsets of", box)
        box.layout().addWidget(self.subsetAttributeRadio)
        self.connect(self.subsetAttributeRadio, SIGNAL("clicked()"),
                     self.setSubsetAttributeRadio)
        self.subsetAttributeEdit = OWGUI.lineEdit(box,
                                                  self,
                                                  "numberOfAttributes",
                                                  valueType=int)
        self.subsetAttributeEdit.setMaximumWidth(30)
        OWGUI.widgetLabel(box, "attributes")

        self.startOptimizationButton = OWGUI.button(
            self.optimizeBox,
            self,
            "Start Optimization",
            callback=self.startOptimization)
        f = self.startOptimizationButton.font()
        f.setBold(1)
        self.startOptimizationButton.setFont(f)
        self.stopOptimizationButton = OWGUI.button(
            self.optimizeBox,
            self,
            "Stop Evaluation",
            callback=self.stopOptimizationClick)
        self.stopOptimizationButton.setFont(f)
        self.stopOptimizationButton.hide()
        self.connect(self.stopOptimizationButton, SIGNAL("clicked()"),
                     self.stopOptimizationClick)

        self.clearButton = OWGUI.button(self.manageBox, self, "Clear Results",
                                        self.clearResults)
        self.loadButton = OWGUI.button(self.manageBox, self, "Load",
                                       self.loadResults)
        self.saveButton = OWGUI.button(self.manageBox, self, "Save",
                                       self.saveResults)
        self.closeButton = OWGUI.button(self.manageBox, self, "Close Dialog",
                                        self.hide)

        self.changeProjectionFile()
        self.updateGUI()
        if self.orderAllAttributes:
            self.setAllAttributeRadio()
        else:
            self.setSubsetAttributeRadio()

    def updateGUI(self):
        self.vizrankSettingsBox.setEnabled(self.optimizationMeasure)

    # if user clicks new attribute list in optimization dialog, we update shown attributes
    def showSelectedAttributes(self):
        attrList = self.getSelectedAttributes()
        if not attrList: return

        self.parallelWidget.setShownAttributeList(attrList)
        self.parallelWidget.graph.removeAllSelections()

        self.parallelWidget.middleLabels = (self.optimizationMeasure == VIZRANK
                                            and "VizRank") or "Correlations"
        self.parallelWidget.updateGraph()

    def setAllAttributeRadio(self):
        self.orderAllAttributes = 1
        self.allAttributesRadio.setChecked(1)
        self.subsetAttributeRadio.setChecked(0)
        self.subsetAttributeEdit.setEnabled(0)

    def setSubsetAttributeRadio(self):
        self.orderAllAttributes = 0
        self.allAttributesRadio.setChecked(0)
        self.subsetAttributeRadio.setChecked(1)
        self.subsetAttributeEdit.setEnabled(1)

    # return list of selected attributes
    def getSelectedAttributes(self):
        if self.resultList.count() == 0 or self.allResults == []:
            return None
        return self.allResults[self.resultList.currentRow()][1]

    # called when optimization is in progress
    def canContinueOptimization(self):
        return self.canOptimize

    def getWorstVal(self):
        return self.worstVal

    def stopOptimizationClick(self):
        self.canOptimize = 0

    # get vizrank value for attributes attr1 and attr2
    def getVizRankVal(self, attr1, attr2):
        if not self.projections: return None
        for (val, [a1, a2]) in self.projections:
            if (attr1 == a1 and attr2 == a2) or (attr1 == a2 and attr2 == a1):
                return val
        return None

    def changeProjectionFile(self):
        for (short_name, long_name) in self.fileBuffer:
            if short_name == self.fileName:
                self.loadProjections(long_name)
                return

    # load projections from a file
    def loadProjections(self, name=None):
        self.projections = []
        self.kNeighborsLabel.setText("Number of neighbors (k): ")
        self.percentDataUsedLabel.setText("Percent of data used:")
        self.testingMethodLabel.setText("Testing method used:")
        self.qualityMeasureLabel.setText("Quality measure used:")

        if name is None:
            name = unicode(
                QFileDialog.getOpenFileName(
                    self, "Open Projections", self.lastSaveDirName,
                    "Interesting projections (*.proj)"))
            if name == "":
                return

        dirName, shortFileName = os.path.split(name)
        self.lastSaveDirName = dirName

        projection_file = open(name, "rt")
        settings = eval(projection_file.readline()[:-1])
        if settings.has_key("parentName") and settings["parentName"].lower(
        ) != "scatterplot":
            QMessageBox.critical(
                None, "Optimization Dialog",
                'Unable to load projection file. Only projection file generated by scatterplot is compatible. \n'
                'This file was created using %s method' %
                (settings["parentName"]), QMessageBox.Ok)
            projection_file.close()
            return

        if type(
                eval(projection_file.readline()[:-1])
        ) != list:  # second line must contain a list of classes that we tried to separate
            QMessageBox.critical(
                None, 'Old version of projection file',
                'This file was saved with an older version of k-NN Optimization Dialog. The new version of dialog offers \n'
                'some additional functionality and therefore you have to compute the projection quality again.',
                QMessageBox.Ok)
            projection_file.close()
            return

        try:
            line = projection_file.readline()[:-1]
            (acc, other_results, lenTable, attrList, tryIndex,
             strList) = eval(line)
            if len(attrList) != 2:
                QMessageBox.information(
                    self, "Incorrect file",
                    "File should contain projections with 2 attributes!",
                    QMessageBox.Ok)
                projection_file.close()
                return

            while line != "":
                (acc, other_results, lenTable, attrList, tryIndex,
                 strList) = eval(line)
                self.projections += [(acc, attrList)]
                line = projection_file.readline()[:-1]
        except:
            self.projections = []
            projection_file.close()
            QMessageBox.information(self, "Incorrect file",
                                    "Incorrect file format!", QMessageBox.Ok)
            return

        projection_file.close()

        if (shortFileName, name) in self.fileBuffer:
            self.fileBuffer.remove((shortFileName, name))

        self.fileBuffer.insert(0, (shortFileName, name))

        if len(self.fileBuffer) > 10:
            self.fileBuffer.remove(self.fileBuffer[-1])

        self.vizrankFileCombo.clear()
        for i in range(len(self.fileBuffer)):
            self.vizrankFileCombo.addItem(self.fileBuffer[i][0])
        self.fileName = shortFileName

        self.kNeighborsLabel.setText("Number of neighbors (k): " +
                                     str(settings["kValue"]))
        self.percentDataUsedLabel.setText("Percent of data used: " + "%d %%" %
                                          (settings["percentDataUsed"]))
        self.testingMethodLabel.setText(
            "Testing method used: " +
            self.testingMethod[settings["testingMethod"]])
        self.qualityMeasureLabel.setText(
            "Quality measure used: " +
            self.qualityMeasure[settings["qualityMeasure"]])

    def addProjection(self, val, attrList):
        index = self.findTargetIndex(val)
        self.allResults.insert(index, (val, attrList))
        self.resultList.insertItem(index, "%.3f - %s" % (val, str(attrList)))

    def findTargetIndex(self, accuracy):
        # use bisection to find correct index
        top = 0
        bottom = len(self.allResults)

        while (bottom - top) > 1:
            mid = (bottom + top) / 2
            if max(accuracy, self.allResults[mid][0]) == accuracy:
                bottom = mid
            else:
                top = mid

        if len(self.allResults) == 0: return 0
        if max(accuracy, self.allResults[top][0]) == accuracy:
            return top
        else:
            return bottom

    def startOptimization(self):
        self.clearResults()
        if self.parallelWidget.data is None: return

        if self.optimizationMeasure == VIZRANK and self.fileName == "":
            QMessageBox.information(
                self, "No projection file",
                "If you wish to optimize using VizRank you first have to load a projection file \n"
                "created by VizRank using Scatterplot widget.", QMessageBox.Ok)
            return
        if self.parallelWidget.data is None:
            QMessageBox.information(
                self, "Missing data set",
                "A data set has to be loaded in order to perform optimization.",
                QMessageBox.Ok)
            return

        attrInfo = []
        self.progressBarInit()
        if self.optimizationMeasure == CORRELATION:
            attrList = [
                attr.name
                for attr in self.parallelWidget.data.domain.attributes
            ]
            self.startOptimizationButton.hide()
            self.stopOptimizationButton.show()
            self.canOptimize = 1

            class StopOptimizationException(Exception):
                pass

            def progressSetWithStop(value):
                if not self.canContinueOptimization():
                    raise StopOptimizationException()
                else:
                    self.progressBarSet(value * 0.9)

            try:
                attrInfo = orngVisFuncts.computeCorrelationBetweenAttributes(
                    self.parallelWidget.data,
                    attrList,
                    progressCallback=progressSetWithStop)
            except StopOptimizationException:
                attrInfo = []
                self.startOptimizationButton.show()
                self.stopOptimizationButton.hide()

        elif self.optimizationMeasure == VIZRANK:
            for (val, [a1, a2]) in self.projections:
                attrInfo.append((val, a1, a2))

            # check if all attributes in loaded projection file are actually present in this data set
            attrs = [
                attr.name
                for attr in self.parallelWidget.data.domain.attributes
            ]
            for (v, a1, a2) in attrInfo:
                if a1 not in attrs:
                    print "attribute " + a1 + " was not found in the data set. " \
                                              "You probably loaded wrong file with VizRank projections."
                    return
                if a2 not in attrs:
                    print "attribute " + a2 + " was not found in the data set. " \
                                              "You probably loaded wrong file with VizRank projections."
                    return

        if len(attrInfo) == 0:
            print "len(attrInfo) == 0. No attribute pairs. Unable to optimize."
            return

        self.worstVal = -1
        self.canOptimize = 1
        self.startOptimizationButton.hide()
        self.stopOptimizationButton.show()
        #qApp.processEvents()        # allow processing of other events

        if self.orderAllAttributes:
            orngVisFuncts.optimizeAttributeOrder(
                attrInfo, len(self.parallelWidget.data.domain.attributes),
                self, qApp)
        else:
            orngVisFuncts.optimizeAttributeOrder(attrInfo,
                                                 self.numberOfAttributes, self,
                                                 qApp)

        self.stopOptimizationButton.hide()
        self.startOptimizationButton.show()

        self.progressBarFinished()

    # ################################
    # MANAGE RESULTS
    def updateShownProjections(self, *args):
        self.resultList.clear()
        for i in range(len(self.allResults)):
            self.resultList.addItem(
                "%.2f - %s" %
                (self.allResults[i][0], str(self.allResults[i][1])), i)
        if self.resultList.count() > 0: self.resultList.setCurrentRow(0)

    def clearResults(self):
        self.allResults = []
        self.resultList.clear()

    def saveResults(self, filename=None):
        if filename is None:
            filename = ""
            datasetName = getattr(self.parallelWidget.graph.rawData, "name",
                                  "")
            if datasetName != "":
                filename = os.path.splitext(os.path.split(datasetName)[1])[0]
            if self.optimizationMeasure == CORRELATION:
                filename += " - " + "correlation"
            else:
                filename += " - " + "vizrank"

            name = unicode(
                QFileDialog.getSaveFileName(
                    self, "Save Parallel Projections",
                    os.path.join(self.lastSaveDirName, filename),
                    "Parallel projections (*.papr)"))
            if name == "":
                return
        else:
            name = filename

        # take care of extension
        if os.path.splitext(name)[1] != ".papr": name += ".papr"

        dirName, shortFileName = os.path.split(name)
        self.lastSaveDirName = dirName

        # open, write and save file
        result_file = open(name, "wt")
        for val in self.allResults:
            result_file.write(str(val) + "\n")
        result_file.close()

    def loadResults(self):
        self.clearResults()

        name = unicode(
            QFileDialog.getOpenFileName(self, "Open Parallel Projections",
                                        self.lastSaveDirName,
                                        "Parallel projections (*.papr)"))
        if name == "": return

        dirName, shortFileName = os.path.split(name)
        self.lastSaveDirName = dirName

        file = open(name, "rt")
        line = file.readline()[:-1]
        ind = 0
        while line != "":
            (val, attrList) = eval(line)
            self.allResults.insert(ind, (val, attrList))
            self.resultList.addItem("%.2f - %s" % (val, str(attrList)), ind)
            line = file.readline()[:-1]
            ind += 1
        file.close()
Ejemplo n.º 55
0
class EditNodeProperties(QDialog):
    def __init__(self, data, win_parent=None):
        """
        +-----------------+
        | Edit Node Props |
        +-----------------+------+
        |  LEwingTip             |
        |  Node2                 |
        |  Node3                 |
        |  Node4                 |
        |                        |
        |  All Nodes:            |
        |    Color     red       |
        |    PointSize 3         |
        |    Opacity   0.3       |
        |    Show/Hide           |
        |                        |
        |  Name        LEwingTip |
        |  Location    X Y Z     |
        |  Coord       0         |
        |  CoordType   R, C, S   |
        |                        |
        |   Previous     Next    |
        |                        |
        |          Close         |
        +------------------------+
        """
        QDialog.__init__(self, win_parent)
        self.setWindowTitle('Edit Node Properties')

        #default
        self.win_parent = win_parent
        self.out_data = data

        point_properties = data['point_properties']
        print(point_properties)
        #name = point_properties.name
        point_size = point_properties.point_size
        opacity = point_properties.opacity
        color = point_properties.color
        show = point_properties.is_visible

        self.points = data['points']

        self.keys = sorted(self.points.keys())
        keys = self.keys
        #nrows = len(keys)

        active_point = data['active_point']
        #self.active_key = keys[0]
        self.active_key = active_point
        name = self.active_key
        description = self.points[self.active_key][0]

        self._use_old_table = False
        items = ['Node %i' % val for val in keys]
        header_labels = ['Nodes']
        table_model = Model(items, header_labels, self)
        view = CustomQTableView(self)  #Call your custom QTableView here
        view.setModel(table_model)
        if qt_version in [4, 'pyside']:
            view.horizontalHeader().setResizeMode(QHeaderView.Stretch)
        else:
            view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.table = view

        #self.representation = actor_obj.representation
        #print('rep =', self.representation)

        table = self.table
        #headers = [QtCore.QString('Groups')]

        header = table.horizontalHeader()
        header.setStretchLastSection(True)

        #----------------------------------------------
        #self._default_is_apply = False

        self.color = QLabel("Color:")
        self.color_edit = QPushButton()
        #self.color_edit.setFlat(True)

        color = self.out_data['point_properties'].color
        opacity = self.out_data['point_properties'].opacity
        show = self.out_data['point_properties'].is_visible
        #color = self.out_data[self.active_key].color
        qcolor = QColor()
        qcolor.setRgb(*color)
        #print('color =%s' % str(color))
        palette = QPalette(
            self.color_edit.palette())  # make a copy of the palette
        #palette.setColor(QPalette.Active, QPalette.Base, \
        #qcolor)
        palette.setColor(QPalette.Background, 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.all_nodes_header = QLabel("All Nodes:")
        self.point_size = QLabel("Point Size:")
        self.point_size_edit = QSpinBox(self)
        self.point_size_edit.setRange(1, 10)
        self.point_size_edit.setSingleStep(1)
        self.point_size_edit.setValue(point_size)

        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)

        # show/hide
        self.checkbox_show = QCheckBox("Show")
        self.checkbox_hide = QCheckBox("Hide")
        self.checkbox_show.setChecked(show)
        self.checkbox_hide.setChecked(not show)

        #----------------------------------------------
        self.nodes_header = QLabel("Single Node:")
        self.name = QLabel("ID:")
        self.name_edit = QLineEdit('Node %i' % name)
        self.name_edit.setDisabled(True)

        self.description = QLabel("Description:")
        self.description_edit = QLineEdit(str(description))
        #self.description_edit.setDisabled(True)

        location_x = 0.1
        location_y = 0.1
        location_z = 0.1
        self.location = QLabel("Location:")
        self.location_x_edit = QDoubleSpinBox(self)
        self.location_y_edit = QDoubleSpinBox(self)
        self.location_z_edit = QDoubleSpinBox(self)
        #self.location_x_edit.setDecimals(1)
        delta_x = abs(location_x) / 100. if location_x != 0.0 else 0.1
        delta_y = abs(location_y) / 100. if location_y != 0.0 else 0.1
        delta_z = abs(location_z) / 100. if location_z != 0.0 else 0.1
        self.location_x_edit.setSingleStep(delta_x)
        self.location_y_edit.setSingleStep(delta_y)
        self.location_z_edit.setSingleStep(delta_z)
        self.location_x_edit.setValue(location_x)
        self.location_y_edit.setValue(location_y)
        self.location_z_edit.setValue(location_z)

        self.coord = QLabel("Coord:")
        self.coord_edit = QSpinBox(self)
        self.coord_edit.setRange(0, 99999999)
        #self.coord_edit.setSingleStep(1)
        self.coord_edit.setValue(0)

        self.coord_type = QLabel("Coord Type:")
        #----------------------------------------------

        # closing
        #if self._default_is_apply:
        #self.apply_button.setDisabled(True)

        self.close_button = QPushButton("Close")

        self.create_layout()
        self.set_connections()

    def update_active_key(self, index):
        name = self.active_key
        old_obj = self.out_data['points'][name]
        #self.active_key
        #self.points[self.active_key]
        old_obj[0] = str(self.description_edit.text())
        #old_obj.coord = self.description_edit.value()
        #old_obj.description = self.description_edit.value()
        #old_obj.description = self.description_edit.value()

        str_name = str(index.data().toString())
        name = int(str_name[5:])
        #i = self.keys.index(self.active_key)

        self.active_key = name
        point = self.points[self.active_key]

        #1  : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        self.name_edit.setText(str(self.active_key))
        self.description_edit.setText(point[0])

        self.coord_edit.setValue(point[1])
        if point[2] == 'R':
            self.radio_rectangular.setChecked(True)
        elif point[2] == 'C':
            self.radio_cylindrical.setChecked(True)
        elif point[2] == 'S':
            self.radio_spherical.setChecked(True)

        self.location_x_edit.setValue(point[3])
        self.location_y_edit.setValue(point[4])
        self.location_z_edit.setValue(point[5])
        #obj = self.out_data[name]
        #point_size = obj.point_size
        #opacity = obj.opacity
        #representation = obj.representation
        #is_visible = obj.is_visible

        #self.opacity_edit.setValue(opacity)
        #self.checkbox_show.setChecked(is_visible)
        #self.checkbox_hide.setChecked(not is_visible)

    #def on_name_select(self):
    #print('on_name_select')
    #return

    def create_layout(self):
        cancel_box = QHBoxLayout()
        cancel_box.addWidget(self.close_button)

        grid1 = QGridLayout()
        grid2 = QGridLayout()

        #-----------------------------------------
        # setup
        self.radio_rectangular = QRadioButton('Rectangular')
        self.radio_cylindrical = QRadioButton('Cylindrical')
        self.radio_spherical = QRadioButton('Spherical')

        coord_type_layout = QHBoxLayout()
        coord_type_layout.addWidget(self.radio_rectangular)
        coord_type_layout.addWidget(self.radio_cylindrical)
        coord_type_layout.addWidget(self.radio_spherical)

        location_layout = QHBoxLayout()
        location_layout.addWidget(self.location_x_edit)
        location_layout.addWidget(self.location_y_edit)
        location_layout.addWidget(self.location_z_edit)

        checkboxs = QButtonGroup(self)
        checkboxs.addButton(self.checkbox_show)
        checkboxs.addButton(self.checkbox_hide)

        vbox1 = QVBoxLayout()
        vbox1.addWidget(self.checkbox_show)
        vbox1.addWidget(self.checkbox_hide)
        #vbox1.addLayout(checkboxs)

        #-----------------------------------------
        irow = 0
        grid1.addWidget(self.all_nodes_header, irow, 0)
        irow += 1

        grid1.addWidget(self.color, irow, 0)
        grid1.addWidget(self.color_edit, irow, 1)
        irow += 1

        grid1.addWidget(self.opacity, irow, 0)
        grid1.addWidget(self.opacity_edit, irow, 1)
        irow += 1

        grid1.addWidget(self.point_size, irow, 0)
        grid1.addWidget(self.point_size_edit, irow, 1)
        irow += 1

        #-----------------------------------------
        irow = 0
        grid2.addWidget(self.nodes_header, irow, 0)
        irow += 1

        grid2.addWidget(self.name, irow, 0)
        grid2.addWidget(self.name_edit, irow, 1)
        irow += 1

        grid2.addWidget(self.description, irow, 0)
        grid2.addWidget(self.description_edit, irow, 1)
        irow += 1

        #|  All Nodes:            |
        #|    Color     red       |
        #|    PointSize 3         |
        #|    Opacity   0.3       |
        #|    Show/Hide           |
        #|                        |
        #|  Name        LEwingTip |
        #|  Location    X Y Z     |
        #|  Coord       0         |
        #|  CoordType   R, C, S   |
        #|                        |
        #|   Previous     Next    |
        grid2.addWidget(self.coord, irow, 0)
        grid2.addWidget(self.coord_edit, irow, 1)
        irow += 1

        grid2.addWidget(self.coord_type, irow, 0)
        grid2.addLayout(coord_type_layout, irow, 1)
        irow += 1

        grid2.addWidget(self.location, irow, 0)
        grid2.addLayout(location_layout, irow, 1)
        irow += 1

        #------------------------------------

        vbox = QVBoxLayout()
        vbox.addLayout(grid1)
        vbox.addLayout(vbox1)
        vbox.addStretch()
        vbox.addWidget(self.table)

        vbox.addLayout(grid2)
        vbox.addStretch()
        #vbox.addWidget(self.check_apply)
        vbox.addLayout(cancel_box)
        self.setLayout(vbox)

    def set_connections(self):
        if qt_version == 4:
            self.connect(self.opacity_edit, QtCore.SIGNAL('clicked()'),
                         self.on_opacity)
            self.connect(self.point_size, QtCore.SIGNAL('clicked()'),
                         self.on_point_size)
            self.connect(self.color_edit, QtCore.SIGNAL('clicked()'),
                         self.on_color)
            self.connect(self.checkbox_show, QtCore.SIGNAL('clicked()'),
                         self.on_show)
            self.connect(self.checkbox_hide, QtCore.SIGNAL('clicked()'),
                         self.on_hide)

            self.connect(self.description_edit,
                         QtCore.SIGNAL("valueChanged(int)"),
                         self.on_description)
            self.connect(self.coord_edit, QtCore.SIGNAL("valueChanged(int)"),
                         self.on_coord)
            self.connect(self.radio_rectangular, QtCore.SIGNAL('clicked()'),
                         self.on_coord_type)
            self.connect(self.radio_cylindrical, QtCore.SIGNAL('clicked()'),
                         self.on_coord_type)
            self.connect(self.radio_spherical, QtCore.SIGNAL('clicked()'),
                         self.on_coord_type)

            self.connect(self.location_x_edit, QtCore.SIGNAL('clicked()'),
                         self.on_location_x)
            self.connect(self.location_y_edit, QtCore.SIGNAL('clicked()'),
                         self.on_location_y)
            self.connect(self.location_z_edit, QtCore.SIGNAL('clicked()'),
                         self.on_location_z)

            self.connect(self.close_button, QtCore.SIGNAL('clicked()'),
                         self.on_close)

            #self.connect(self.check_apply, QtCore.SIGNAL('clicked()'), self.on_check_apply)

            #self.connect(self.apply_button, QtCore.SIGNAL('clicked()'), self.on_apply)
            #self.connect(self.ok_button, QtCore.SIGNAL('clicked()'), self.on_ok)
            #self.connect(self.close_button, QtCore.SIGNAL('clicked()'), self.on_close)
        else:
            pass
            #self.opacity_edit.clicked.connect(self.on_opacity)
            #self.point_size.clicked.connect(self.on_point_size)
            #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.description_edit.valueChanged.connect(self.on_description)
            #self.coord_edit.valueChanged.connect(self.on_coord)
            #self.radio_rectangular.clicked.connect(self.on_coord_type)
            #self.radio_cylindrical.clicked.connect(self.on_coord_type)
            #self.radio_spherical.clicked.connect(self.on_coord_type)

            #self.location_x_edit.clicked.connect(self.on_location_x)
            #self.location_y_edit.clicked.connect(self.on_location_y)
            #self.location_z_edit.clicked.connect(self.on_location_z)
            self.close_button.clicked.connect(self.on_close)

    def on_color(self):
        obj = self.out_data['point_properties']
        rgb_color_ints = obj.color

        msg = 'Points'
        col = QColorDialog.getColor(QColor(*rgb_color_ints), self,
                                    "Choose a %s color" % msg)
        if col.isValid():
            color = col.getRgbF()[:3]
            obj.color = color
            #print('new_color =', color)
            self.color_edit.setStyleSheet(
                "QPushButton {"
                "background-color: rgb(%s, %s, %s);" % tuple(obj.color) +
                #"border:1px solid rgb(255, 170, 255); "
                "}")

    def on_show(self):
        is_checked = self.checkbox_show.isChecked()
        self.out_data['point_properties'].is_visible = is_checked

    def on_hide(self):
        is_checked = self.checkbox_hide.isChecked()
        self.out_data['point_properties'].is_visible = not is_checked

    def on_point_size(self):
        point_size = self.point_size_edit.value()
        self.out_data['point_properties'].point_size = point_size

    def on_opacity(self):
        opacity = self.opacity_edit.value()
        self.out_data['point_properties'].opacity = opacity

    def on_description(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        description = self.description_edit.value()
        self.out_data['points'][name][0] = description

    def on_coord(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        coord_id = self.coord_edit.value()
        self.out_data['points'][name][1] = coord_id

    def on_coord_type(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        if self.radio_rectangular.isChecked():
            coord_type = 'R'
        elif self.radio_cylindrical.isChecked():
            coord_type = 'C'
        elif self.radio_spherical.isChecked():
            coord_type = 'S'
        else:
            raise NotImplementedError()
        self.out_data['points'][name][2] = coord_type

    def on_location_x(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        value = self.coord_edit.value()
        self.out_data['points'][name][3] = value

    def on_location_y(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        value = self.coord_edit.value()
        self.out_data['points'][name][4] = value

    def on_location_z(self):
        #1 : ['LERoot', 0, 'R', 1.0, 2.0, 3.0],
        name = self.active_key
        value = self.coord_edit.value()
        self.out_data['points'][name][5] = value

    def closeEvent(self, event):
        event.accept()

    #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.point_size = self.point_size_edit.value()
        old_obj.opacity = self.opacity_edit.value()
        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

    def on_apply(self):
        passed = self.on_validate()
        if passed:
            self.win_parent.on_update_gui_nodes(self.out_data)
        return passed

    def on_ok(self):
        passed = self.on_apply()
        if passed:
            self.close()
            #self.destroy()

    def on_close(self):
        self.out_data['clicked_close'] = True
        self.close()
Ejemplo n.º 56
0
class ContentsWidget(QWidget):
    """Import wizard contents widget"""
    def __init__(self, parent, text):
        QWidget.__init__(self, parent)
        
        self.text_editor = QTextEdit(self)
        self.text_editor.setText(text)
        self.text_editor.setReadOnly(True)
        
        # Type frame
        type_layout = QHBoxLayout()
        type_label = QLabel(translate("ImportWizard", "Import as"))
        type_layout.addWidget(type_label)
        data_btn = QRadioButton(translate("ImportWizard", "data"))
        data_btn.setChecked(True)
        self._as_data= True
        type_layout.addWidget(data_btn)
        code_btn = QRadioButton(translate("ImportWizard", "code"))
        self._as_code = False
        type_layout.addWidget(code_btn)        
        txt_btn = QRadioButton(translate("ImportWizard", "text"))
        type_layout.addWidget(txt_btn)
        h_spacer = QSpacerItem(40, 20,
                               QSizePolicy.Expanding, QSizePolicy.Minimum)
        type_layout.addItem(h_spacer)        
        type_frame = QFrame()
        type_frame.setLayout(type_layout)
        
        # Opts frame
        opts_layout = QHBoxLayout()
        
        self.trnsp_box = QCheckBox(translate("ImportWizard", "Transpose"))
        #self.trnsp_box.setEnabled(False)
        opts_layout.addWidget(self.trnsp_box)
        
        h_spacer = QSpacerItem(40, 20,
                               QSizePolicy.Expanding, QSizePolicy.Minimum)
        opts_layout.addItem(h_spacer)
        
        grid_layout = QGridLayout()
        grid_layout.setSpacing(0)
        
        col_label = QLabel(translate("ImportWizard", "Column separator:"))
        grid_layout.addWidget(col_label,0,0)
        col_w = QWidget()
        col_btn_layout = QHBoxLayout()
        self.tab_btn = QRadioButton(translate("ImportWizard", "Tab"))
        self.tab_btn.setChecked(True)
        col_btn_layout.addWidget(self.tab_btn)
        other_btn_col = QRadioButton(translate("ImportWizard", "other"))
        col_btn_layout.addWidget(other_btn_col)
        col_w.setLayout(col_btn_layout)
        grid_layout.addWidget(col_w,0,1)
        self.line_edt = QLineEdit(",")
        self.line_edt.setMaximumWidth(30)
        self.line_edt.setEnabled(False)
        self.connect(other_btn_col, SIGNAL("toggled(bool)"),
                     self.line_edt, SLOT("setEnabled(bool)"))
        grid_layout.addWidget(self.line_edt,0,2)

        row_label = QLabel(translate("ImportWizard", "Row separator:"))
        grid_layout.addWidget(row_label,1,0)
        row_w = QWidget()
        row_btn_layout = QHBoxLayout()
        self.eol_btn = QRadioButton(translate("ImportWizard", "EOL"))
        self.eol_btn.setChecked(True)
        row_btn_layout.addWidget(self.eol_btn)
        other_btn_row = QRadioButton(translate("ImportWizard", "other"))
        row_btn_layout.addWidget(other_btn_row)
        row_w.setLayout(row_btn_layout)
        grid_layout.addWidget(row_w,1,1)
        self.line_edt_row = QLineEdit(";")
        self.line_edt_row.setMaximumWidth(30)
        self.line_edt_row.setEnabled(False)
        self.connect(other_btn_row, SIGNAL("toggled(bool)"),
                     self.line_edt_row, SLOT("setEnabled(bool)"))
        grid_layout.addWidget(self.line_edt_row,1,2)

        opts_layout.addLayout(grid_layout)
        
        opts_frame = QFrame()
        opts_frame.setLayout(opts_layout)
        
        self.connect(data_btn, SIGNAL("toggled(bool)"),
                     opts_frame, SLOT("setEnabled(bool)"))
        self.connect(data_btn, SIGNAL("toggled(bool)"),
                     self, SLOT("set_as_data(bool)"))
        self.connect(code_btn, SIGNAL("toggled(bool)"),
                     self, SLOT("set_as_code(bool)"))
#        self.connect(txt_btn, SIGNAL("toggled(bool)"),
#                     self, SLOT("is_text(bool)"))

        # Final layout
        layout = QVBoxLayout()
        layout.addWidget(type_frame)
        layout.addWidget(self.text_editor)
        layout.addWidget(opts_frame)
        self.setLayout(layout)

    def get_as_data(self):
        """Return if data type conversion"""
        return self._as_data
    
    def get_as_code(self):
        """Return if code type conversion"""
        return self._as_code
    
    def get_as_num(self):
        """Return if numeric type conversion"""
        return self._as_num

    def get_col_sep(self):
        """Return the column separator"""
        if self.tab_btn.isChecked():
            return u"\t"
        return unicode(self.line_edt.text())
    
    def get_row_sep(self):
        """Return the row separator"""
        if self.eol_btn.isChecked():
            return u"\n"
        return unicode(self.line_edt_row.text())

    @pyqtSignature("bool")
    def set_as_data(self, as_data):
        """Set if data type conversion"""
        self._as_data = as_data
        self.emit(SIGNAL("asDataChanged(bool)"), as_data)

    @pyqtSignature("bool")
    def set_as_code(self, as_code):
        """Set if code type conversion"""
        self._as_code = as_code
Ejemplo n.º 57
0
    def __init__(self, parent=None, conflictCallback=None, *cbArgs):
        """conflictCallback is a optional method called when a shortcut is changed.
        
        cbArgs is optional arguments of the conflictCallback method.
        it should return the name of the potential conflict or a null value """

        super(ShortcutEditDialog, self).__init__(parent)
        self.conflictCallback = conflictCallback
        self.cbArgs = cbArgs
        self.setMinimumWidth(400)
        # create gui

        layout = QVBoxLayout()
        layout.setSpacing(10)
        self.setLayout(layout)

        top = QHBoxLayout()
        top.setSpacing(4)
        p = self.toppixmap = QLabel()
        l = self.toplabel = QLabel()
        top.addWidget(p)
        top.addWidget(l, 1)
        layout.addLayout(top)
        grid = QGridLayout()
        grid.setSpacing(4)
        grid.setColumnStretch(1, 2)
        layout.addLayout(grid)

        self.buttonDefault = QRadioButton(
            self, toggled=self.slotButtonDefaultToggled)
        self.buttonNone = QRadioButton(self)
        self.lconflictDefault = QLabel('test')
        self.lconflictDefault.setStyleSheet("color : red;")
        self.lconflictDefault.setVisible(False)
        self.buttonCustom = QRadioButton(self)
        grid.addWidget(self.buttonDefault, 0, 0, 1, 2)
        grid.addWidget(self.lconflictDefault, 1, 0, 1, 2)
        grid.addWidget(self.buttonNone, 2, 0, 1, 2)
        grid.addWidget(self.buttonCustom, 3, 0, 1, 2)

        self.keybuttons = []
        self.keylabels = []
        self.conflictlabels = []
        for num in range(4):
            l = QLabel(self)
            l.setStyleSheet("margin-left: 2em;")
            l.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
            b = KeySequenceWidget(self, num)
            b.keySequenceChanged.connect(self.slotKeySequenceChanged)
            l.setBuddy(b)
            self.keylabels.append(l)
            self.keybuttons.append(b)
            grid.addWidget(l, num + 4 + num, 0)
            grid.addWidget(b, num + 4 + num, 1)
            lconflict = QLabel()
            lconflict.setStyleSheet("color : red;")
            self.conflictlabels.append(lconflict)
            lconflict.setVisible(False)
            grid.addWidget(lconflict, num + 5 + num, 0, 1, 2, Qt.AlignHCenter)

        layout.addWidget(Separator(self))

        b = QDialogButtonBox(self)
        b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        layout.addWidget(b)
        b.accepted.connect(self.accept)
        b.rejected.connect(self.reject)
        app.translateUI(self)
Ejemplo n.º 58
0
class ShortcutEditDialog(QDialog):
    """A modal dialog to view and/or edit keyboard shortcuts."""
    def __init__(self, parent=None, conflictCallback=None, *cbArgs):
        """conflictCallback is a optional method called when a shortcut is changed.
        
        cbArgs is optional arguments of the conflictCallback method.
        it should return the name of the potential conflict or a null value """

        super(ShortcutEditDialog, self).__init__(parent)
        self.conflictCallback = conflictCallback
        self.cbArgs = cbArgs
        self.setMinimumWidth(400)
        # create gui

        layout = QVBoxLayout()
        layout.setSpacing(10)
        self.setLayout(layout)

        top = QHBoxLayout()
        top.setSpacing(4)
        p = self.toppixmap = QLabel()
        l = self.toplabel = QLabel()
        top.addWidget(p)
        top.addWidget(l, 1)
        layout.addLayout(top)
        grid = QGridLayout()
        grid.setSpacing(4)
        grid.setColumnStretch(1, 2)
        layout.addLayout(grid)

        self.buttonDefault = QRadioButton(
            self, toggled=self.slotButtonDefaultToggled)
        self.buttonNone = QRadioButton(self)
        self.lconflictDefault = QLabel('test')
        self.lconflictDefault.setStyleSheet("color : red;")
        self.lconflictDefault.setVisible(False)
        self.buttonCustom = QRadioButton(self)
        grid.addWidget(self.buttonDefault, 0, 0, 1, 2)
        grid.addWidget(self.lconflictDefault, 1, 0, 1, 2)
        grid.addWidget(self.buttonNone, 2, 0, 1, 2)
        grid.addWidget(self.buttonCustom, 3, 0, 1, 2)

        self.keybuttons = []
        self.keylabels = []
        self.conflictlabels = []
        for num in range(4):
            l = QLabel(self)
            l.setStyleSheet("margin-left: 2em;")
            l.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
            b = KeySequenceWidget(self, num)
            b.keySequenceChanged.connect(self.slotKeySequenceChanged)
            l.setBuddy(b)
            self.keylabels.append(l)
            self.keybuttons.append(b)
            grid.addWidget(l, num + 4 + num, 0)
            grid.addWidget(b, num + 4 + num, 1)
            lconflict = QLabel()
            lconflict.setStyleSheet("color : red;")
            self.conflictlabels.append(lconflict)
            lconflict.setVisible(False)
            grid.addWidget(lconflict, num + 5 + num, 0, 1, 2, Qt.AlignHCenter)

        layout.addWidget(Separator(self))

        b = QDialogButtonBox(self)
        b.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        layout.addWidget(b)
        b.accepted.connect(self.accept)
        b.rejected.connect(self.reject)
        app.translateUI(self)

    def translateUI(self):
        self.setWindowTitle(app.caption(_("window title", "Edit Shortcut")))
        self.buttonNone.setText(_("&No shortcut"))
        self.buttonCustom.setText(_("Use a &custom shortcut:"))
        for num in range(4):
            self.keylabels[num].setText(
                _("Alternative #{num}:").format(
                    num=num) if num else _("Primary shortcut:"))

    def slotKeySequenceChanged(self, num):
        """Called when one of the keysequence buttons has changed."""
        self.checkConflict(num)
        self.buttonCustom.setChecked(True)

    def slotButtonDefaultToggled(self, val):
        if self.conflictCallback is not None:
            if not val:
                self.lconflictDefault.setVisible(False)
            else:
                if self._default:
                    conflictList = []
                    for s in self._default:
                        conflictName = self.conflictCallback(s, *self.cbArgs)
                        if conflictName:
                            conflictList.append(conflictName)
                    if conflictList:
                        text = _("Conflict with: {name}").format(
                            name="<b>{0}</b>".format(', '.join(conflictList)))
                        self.lconflictDefault.setText(text)
                        self.lconflictDefault.setVisible(True)
            QTimer.singleShot(0, self.adjustSize)

    def checkConflict(self, num):
        if self.conflictCallback is not None:
            conflictName = self.conflictCallback(
                self.keybuttons[num].shortcut(), *self.cbArgs)
            if conflictName:
                text = _("Conflict with: {name}").format(
                    name="<b>{0}</b>".format(conflictName))
                self.conflictlabels[num].setText(text)
                self.conflictlabels[num].setVisible(True)
            else:
                self.conflictlabels[num].setVisible(False)
            QTimer.singleShot(0, self.adjustSize)

    def editAction(self, action, default=None):
        # load the action
        self._action = action
        self._default = default
        self.toplabel.setText('<p>{0}</p>'.format(
            _("Here you can edit the shortcuts for {name}").format(
                name='<br/><b>{0}</b>:'.format(action.text()))))
        self.toppixmap.setPixmap(action.icon().pixmap(32))
        shortcuts = action.shortcuts()
        self.buttonDefault.setVisible(bool(default))
        if default is not None and shortcuts == default:
            self.buttonDefault.setChecked(True)
        else:
            if shortcuts:
                self.buttonCustom.setChecked(True)
                for num, key in enumerate(shortcuts[:4]):
                    self.keybuttons[num].setShortcut(key)
                    self.checkConflict(num)
            else:
                self.buttonNone.setChecked(True)

        if default:
            ds = "; ".join(
                key.toString(QKeySequence.NativeText) for key in default)
        else:
            ds = _("no keyboard shortcut", "none")
        self.buttonDefault.setText(
            _("Use &default shortcut ({name})").format(name=ds))
        return self.exec_()

    def done(self, result):
        if result:
            shortcuts = []
            if self.buttonDefault.isChecked():
                shortcuts = self._default
            elif self.buttonCustom.isChecked():
                for num in range(4):
                    seq = self.keybuttons[num].shortcut()
                    if not seq.isEmpty():
                        shortcuts.append(seq)
            self._action.setShortcuts(shortcuts)
        super(ShortcutEditDialog, self).done(result)
Ejemplo n.º 59
0
    def __init__(self, parallelWidget, parent=None, signalManager=None):
        OWWidget.__init__(self, parent, signalManager,
                          "Parallel Optimization Dialog", False)
        self.setCaption("Parallel Optimization Dialog")
        self.parallelWidget = parallelWidget

        self.optimizationMeasure = 0
        self.attributeCount = 5
        self.numberOfAttributes = 6
        self.fileName = ""
        self.lastSaveDirName = os.getcwd() + "/"
        self.fileBuffer = []
        self.projections = []
        self.allResults = []
        self.canOptimize = 0
        self.orderAllAttributes = 1  # do we wish to order all attributes or find just an interesting subset
        self.worstVal = -1  # used in heuristics to stop the search in uninteresting parts of the graph

        self.loadSettings()

        self.measureBox = OWGUI.radioButtonsInBox(
            self.controlArea,
            self,
            "optimizationMeasure", ["Correlation", "VizRank"],
            box="Select optimization measure",
            callback=self.updateGUI)
        self.vizrankSettingsBox = OWGUI.widgetBox(self.controlArea,
                                                  "VizRank settings")
        self.optimizeBox = OWGUI.widgetBox(self.controlArea, "Optimize")
        self.manageBox = OWGUI.widgetBox(self.controlArea, "Manage results")
        self.resultsBox = OWGUI.widgetBox(self.mainArea, "Results")

        self.resultList = OWGUI.listBox(self.resultsBox, self)
        self.resultList.setMinimumSize(200, 200)
        self.connect(self.resultList, SIGNAL("itemSelectionChanged()"),
                     self.showSelectedAttributes)

        # remove non-existing files
        names = []
        for i in range(len(self.fileBuffer) - 1, -1, -1):
            (short, longName) = self.fileBuffer[i]
            if not os.path.exists(longName):
                self.fileBuffer.remove((short, longName))
            else:
                names.append(short)
        names.append("(None)")
        self.fileName = "(None)"

        self.hbox1 = OWGUI.widgetBox(self.vizrankSettingsBox,
                                     "VizRank projections file",
                                     orientation="horizontal")
        self.vizrankFileCombo = OWGUI.comboBox(
            self.hbox1,
            self,
            "fileName",
            items=names,
            tooltip=
            "File that contains information about interestingness of scatterplots\n"
            "generated by VizRank method in scatterplot widget",
            callback=self.changeProjectionFile,
            sendSelectedValue=1,
            valueType=str)
        self.browseButton = OWGUI.button(self.hbox1,
                                         self,
                                         "...",
                                         callback=self.loadProjections)
        self.browseButton.setMaximumWidth(20)

        self.resultsInfoBox = OWGUI.widgetBox(self.vizrankSettingsBox,
                                              "VizRank parameters")
        self.kNeighborsLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                 "Number of neighbors (k):")
        self.percentDataUsedLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                      "Percent of data used:")
        self.testingMethodLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                    "Testing method used:")
        self.qualityMeasureLabel = OWGUI.widgetLabel(self.resultsInfoBox,
                                                     "Quality measure used:")

        self.allAttributesRadio = QRadioButton("Order all attributes",
                                               self.optimizeBox)
        self.optimizeBox.layout().addWidget(self.allAttributesRadio)
        self.connect(self.allAttributesRadio, SIGNAL("clicked()"),
                     self.setAllAttributeRadio)
        box = OWGUI.widgetBox(self.optimizeBox, orientation="horizontal")
        self.subsetAttributeRadio = QRadioButton("Find subsets of", box)
        box.layout().addWidget(self.subsetAttributeRadio)
        self.connect(self.subsetAttributeRadio, SIGNAL("clicked()"),
                     self.setSubsetAttributeRadio)
        self.subsetAttributeEdit = OWGUI.lineEdit(box,
                                                  self,
                                                  "numberOfAttributes",
                                                  valueType=int)
        self.subsetAttributeEdit.setMaximumWidth(30)
        OWGUI.widgetLabel(box, "attributes")

        self.startOptimizationButton = OWGUI.button(
            self.optimizeBox,
            self,
            "Start Optimization",
            callback=self.startOptimization)
        f = self.startOptimizationButton.font()
        f.setBold(1)
        self.startOptimizationButton.setFont(f)
        self.stopOptimizationButton = OWGUI.button(
            self.optimizeBox,
            self,
            "Stop Evaluation",
            callback=self.stopOptimizationClick)
        self.stopOptimizationButton.setFont(f)
        self.stopOptimizationButton.hide()
        self.connect(self.stopOptimizationButton, SIGNAL("clicked()"),
                     self.stopOptimizationClick)

        self.clearButton = OWGUI.button(self.manageBox, self, "Clear Results",
                                        self.clearResults)
        self.loadButton = OWGUI.button(self.manageBox, self, "Load",
                                       self.loadResults)
        self.saveButton = OWGUI.button(self.manageBox, self, "Save",
                                       self.saveResults)
        self.closeButton = OWGUI.button(self.manageBox, self, "Close Dialog",
                                        self.hide)

        self.changeProjectionFile()
        self.updateGUI()
        if self.orderAllAttributes:
            self.setAllAttributeRadio()
        else:
            self.setSubsetAttributeRadio()
Ejemplo n.º 60
0
class CADOptionsToolbar_ModifyOffset(CADOptionsToolbar):
    def __init__(self, layerType):
        super(CADOptionsToolbar_ModifyOffset, self).__init__()

        self.segmentChoice = QRadioButton(
            tr(u"Segment"))
        self.segmentChoice.setChecked(Qt.Checked)
        self.featureChoice = QRadioButton(
            tr(u"Feature"))
        self.optionsToolBar.addWidget(self.segmentChoice)
        self.optionsToolBar.addWidget(self.featureChoice)

        if layerType == QGis.Polygon:
            self.segmentChoice.setChecked(Qt.Unchecked)
            self.featureChoice.setChecked(Qt.Checked)
            self.segmentChoice.setEnabled(False)
            self.featureChoice.setEnabled(False)
        elif layerType == QGis.Line:
            self.segmentChoice.setEnabled(True)
            self.featureChoice.setEnabled(True)