def __init__(self, parent = None, 
              completionMode = QCompleter.PopupCompletion, 
              showHidden = False):
     """
     Constructor
     
     @param parent parent widget of the completer (QWidget)
     @keyparam completionMode completion mode of the 
         completer (QCompleter.CompletionMode)
     @keyparam showHidden flag indicating to show hidden entries as well (boolean)
     """
     QCompleter.__init__(self, parent)
     self.__model = QFileSystemModel(self)
     if showHidden:
         self.__model.setFilter(\
             QDir.Filters(QDir.Drives | QDir.AllDirs | QDir.Hidden))
     else:
         self.__model.setFilter(\
             QDir.Filters(QDir.Drives | QDir.AllDirs))
     self.setModel(self.__model)
     self.setCompletionMode(completionMode)
     if isWindowsPlatform():
         self.setCaseSensitivity(Qt.CaseInsensitive)
     if parent:
         parent.setCompleter(self)
예제 #2
0
    def __init__(self):
        WizardPage.__init__(self)
        self.fetch_config = None
        self.app_model = QStringListModel(
            REGISTRY.names(
                lambda klass: not getattr(klass, 'disable_in_gui', None)))
        self.ui.app_combo.setModel(self.app_model)
        if mozinfo.bits == 64:
            if mozinfo.os == 'mac':
                self.bits_model = QStringListModel(['64'])
                bits_index = 0
            else:
                self.bits_model = QStringListModel(['32', '64'])
                bits_index = 1
        elif mozinfo.bits == 32:
            self.bits_model = QStringListModel(['32'])
            bits_index = 0
        self.ui.bits_combo.setModel(self.bits_model)
        self.ui.bits_combo.setCurrentIndex(bits_index)
        self.build_type_model = QStringListModel()

        self.ui.app_combo.currentIndexChanged.connect(self._set_fetch_config)
        self.ui.bits_combo.currentIndexChanged.connect(self._set_fetch_config)
        self.ui.app_combo.setCurrentIndex(
            self.ui.app_combo.findText("firefox"))

        completer = QCompleter()
        completer.setModel(QStringListModel(branches.get_branches(
                                              include_aliases=True), self))
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        self.ui.repository.setCompleter(completer)
예제 #3
0
    def handle_login(self):
        identifier = self.db.check_user_password(self.ui.usernameEdit.text(), self.ui.passwordEdit.text())
        # if the username and password are found in the database, allow the user to edit the other widgets
        if identifier:
            self.widget_dict = {self.ui.usernameEdit: False,
                                self.ui.passwordEdit: False,
                                self.ui.loginButton: False,
                                self.ui.cancelButton: False,
                                self.ui.enviroTree: True,
                                self.ui.aEdit: True,
                                self.ui.bEdit: True,
                                self.ui.cEdit: True,
                                self.ui.uncertEdit: True,
                                self.ui.dateEdit: True,
                                self.ui.applyButton: True}

            # Set up auto completion for the date field
            dateList = QtCore.QStringList([datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d")])
            dateEditCompleter = QCompleter(dateList)
            dateEditCompleter.setCompletionMode(QCompleter.InlineCompletion)
            self.ui.dateEdit.setCompleter(dateEditCompleter)

            self.update_widgets()
        # if the user/pass aren't found,
        else:
            ErrorMessage('Login Failed')
예제 #4
0
class MyLineEdit(Plasma.LineEdit):

    """Custom LineEdit for Pylou."""

    def __init__(self, *args):
        """Init class."""
        Plasma.LineEdit.__init__(self, *args)
        self.nativeWidget().setClearButtonShown(True)
        self.nativeWidget().setPlaceholderText("Type to Search...")
        self.nativeWidget().setToolTip("""<p>Type and press ENTER:to Search<br>
        UP-DOWN: History navigation<br>Search Empty Query: Clear out""")
        self.completer = QCompleter(tuple(sorted(set(
            [_ for _ in listdir(path.expanduser("~")) if not _.startswith(".")]
        ))), self.nativeWidget())
        self.completer.setCompletionMode(QCompleter.InlineCompletion)
        self.completer.setCaseSensitivity(0)  # Qt.CaseInsensitive
        self.nativeWidget().setCompleter(self.completer)

    def event(self, event):
        """Override to enable History Navigation."""
        # Qt.Key_Up
        if event.type() == QEvent.KeyPress and event.key() == 0x01000013:
            self.emit(SIGNAL("keyUPPressed"))
            return True
        # Qt.Key_Down
        if event.type() == QEvent.KeyPress and event.key() == 0x01000015:
            self.emit(SIGNAL("keyDownPressed"))
            return True
        return Plasma.LineEdit.event(self, event)
    def __init__(self, parent):
        super(ProjectData, self).__init__()
        self._parent = parent
        grid = QGridLayout(self)
        grid.addWidget(QLabel(translations.TR_PROJECT_NAME), 0, 0)
        self.name = QLineEdit()
        if not len(self._parent.project.name):
            self.name.setText(file_manager.get_basename(
                self._parent.project.path))
        else:
            self.name.setText(self._parent.project.name)
        grid.addWidget(self.name, 0, 1)
        grid.addWidget(QLabel(translations.TR_PROJECT_LOCATION), 1, 0)
        self.txtPath = QLineEdit()
        self.txtPath.setReadOnly(True)
        self.txtPath.setText(self._parent.project.path)
        grid.addWidget(self.txtPath, 1, 1)
        grid.addWidget(QLabel(translations.TR_PROJECT_TYPE), 2, 0)
        self.txtType = QLineEdit()
        completer = QCompleter(sorted(settings.PROJECT_TYPES))
        completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.txtType.setCompleter(completer)
        self.txtType.setPlaceholderText("python")
        self.txtType.setText(self._parent.project.project_type)
        grid.addWidget(self.txtType, 2, 1)
        grid.addWidget(QLabel(translations.TR_PROJECT_DESCRIPTION), 3, 0)
        self.description = QPlainTextEdit()
        self.description.setPlainText(self._parent.project.description)
        grid.addWidget(self.description, 3, 1)
        grid.addWidget(QLabel(translations.TR_PROJECT_URL), 4, 0)
        self.url = QLineEdit()
        self.url.setText(self._parent.project.url)
        self.url.setPlaceholderText('https://www.{}.com'.format(getuser()))
        grid.addWidget(self.url, 4, 1)
        grid.addWidget(QLabel(translations.TR_PROJECT_LICENSE), 5, 0)
        self.cboLicense = QComboBox()
        self.cboLicense.addItems(LICENCES)
        self.cboLicense.setCurrentIndex(12)
        index = self.cboLicense.findText(self._parent.project.license)
        self.cboLicense.setCurrentIndex(index)
        grid.addWidget(self.cboLicense, 5, 1)

        self.txtExtensions = QLineEdit()
        self.txtExtensions.setText(', '.join(self._parent.project.extensions))
        grid.addWidget(QLabel(translations.TR_PROJECT_EXTENSIONS), 6, 0)
        grid.addWidget(self.txtExtensions, 6, 1)

        grid.addWidget(QLabel(translations.TR_PROJECT_INDENTATION), 7, 0)
        self.spinIndentation = QSpinBox()
        self.spinIndentation.setValue(self._parent.project.indentation)
        self.spinIndentation.setRange(2, 10)
        self.spinIndentation.setValue(4)
        self.spinIndentation.setSingleStep(2)
        grid.addWidget(self.spinIndentation, 7, 1)
        self.checkUseTabs = QComboBox()
        self.checkUseTabs.addItems([
            translations.TR_PREFERENCES_EDITOR_CONFIG_SPACES.capitalize(),
            translations.TR_PREFERENCES_EDITOR_CONFIG_TABS.capitalize()])
        self.checkUseTabs.setCurrentIndex(int(self._parent.project.use_tabs))
        grid.addWidget(self.checkUseTabs, 7, 2)
예제 #6
0
    def __init__(self, table_p, parent, product=None, *args, **kwargs):
        QDialog.__init__(self, parent, *args, **kwargs)

        self.table_p = table_p
        self.prod = product
        self.parent = parent
        self.filename = "Parcourire ..."
        self.path_filename = None

        if self.prod:
            self.title = u"Modification de l'article {}".format(self.prod.name)
            self.succes_msg = u"L'article <b>%s</b> a été mise à jour" % self.prod.name
            try:
                self.filename = self.prod.file_join.file_name
            except:
                pass
        else:
            self.succes_msg = u"L'article a été bien enregistré"
            self.title = u"Ajout de nouvel article"
            self.prod = Product()

        self.setWindowTitle(self.title)

        # self.code = LineEdit(self.prod.code)
        self.name_field = LineEdit(self.prod.name)
        try:
            self.category_name = Category.select().where(
                Category.name == self.prod.category.name).get().name
        except:
            self.category_name = ""
        self.category_field = LineEdit(self.category_name)

        self.number_parts_box_field = IntLineEdit(
            str(self.prod.number_parts_box))
        self.number_parts_box_field.setValidator(QIntValidator())

        completion_values = [catg.name for catg in Category.all()]
        completer = QCompleter(completion_values, parent=self)
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.category_field.setCompleter(completer)

        vbox = QVBoxLayout()
        formbox = QFormLayout()
        formbox.addRow(FLabel(u"Nom"), self.name_field)
        formbox.addRow(FLabel(u"Categorie"), self.category_field)
        # formbox.addRow(
        #     FLabel(u"Quantité (carton)"), self.number_parts_box_field)
        self.butt_parco = QPushButton(
            QIcon.fromTheme('document-open', QIcon('')), self.filename)
        self.butt_parco.clicked.connect(self.import_image)
        butt_cancel = Warning_btt(u"Annuler")
        butt_cancel.clicked.connect(self.cancel)
        # formbox.addRow(FLabel(u"Image"), self.butt_parco)
        butt = Button_save(u"&Enregistrer")
        butt.clicked.connect(self.add_or_edit_prod)
        formbox.addRow(butt_cancel, butt)

        vbox.addLayout(formbox)
        self.setLayout(vbox)
예제 #7
0
class FileSystemOpener(QWidget):

    def __init__(self):
        QWidget.__init__(self)
        hbox = QHBoxLayout(self)
        hbox.setContentsMargins(0, 0, 0, 0)
        self.btnClose = QPushButton(
            self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
        self.completer = QCompleter(self)
        self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
        fileModel = QFileSystemModel(self.completer)
        fileModel.setRootPath("")
        self.completer.setModel(fileModel)
        self.pathLine.setCompleter(self.completer)
        self.btnOpen = QPushButton(
            self.style().standardIcon(QStyle.SP_ArrowRight), 'Open!')
        hbox.addWidget(self.btnClose)
        hbox.addWidget(QLabel(self.tr("Path:")))
        hbox.addWidget(self.pathLine)
        hbox.addWidget(self.btnOpen)

        self.connect(self.pathLine, SIGNAL("returnPressed()"),
            self._open_file)
        self.connect(self.btnOpen, SIGNAL("clicked()"),
            self._open_file)

    def _open_file(self):
        path = self.pathLine.text()
        main_container.MainContainer().open_file(path)
        self.emit(SIGNAL("requestHide()"))

    def showEvent(self, event):
        super(FileSystemOpener, self).showEvent(event)
        self.pathLine.selectAll()
예제 #8
0
    def __init__(self):
        WizardPage.__init__(self)
        self.fetch_config = None
        self.app_model = QStringListModel(
            REGISTRY.names(
                lambda klass: not getattr(klass, 'disable_in_gui', None)))
        self.ui.app_combo.setModel(self.app_model)
        if mozinfo.bits == 64:
            if mozinfo.os == 'mac':
                self.bits_model = QStringListModel(['64'])
                bits_index = 0
            else:
                self.bits_model = QStringListModel(['32', '64'])
                bits_index = 1
        elif mozinfo.bits == 32:
            self.bits_model = QStringListModel(['32'])
            bits_index = 0
        self.ui.bits_combo.setModel(self.bits_model)
        self.ui.bits_combo.setCurrentIndex(bits_index)
        self.build_type_model = QStringListModel()

        self.ui.app_combo.currentIndexChanged.connect(self._set_fetch_config)
        self.ui.bits_combo.currentIndexChanged.connect(self._set_fetch_config)
        self.ui.app_combo.setCurrentIndex(
            self.ui.app_combo.findText("firefox"))

        self.ui.repository.textChanged.connect(self._on_repo_changed)

        completer = QCompleter(sorted(get_branches()), self)
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        self.ui.repository.setCompleter(completer)
        QApplication.instance().focusChanged.connect(self._on_focus_changed)
예제 #9
0
 def complete( self, rect ):
     " Brings the completer up "
     rect.setWidth( self.__width )
     self.__rect = rect
     QCompleter.complete( self, rect )
     self.__selectFirst()
     return
예제 #10
0
    def __init__(self, editor, project):
        QCompleter.__init__(self)

        self.icons = {'function': QIcon(resources.images['function']),
            'instance': QIcon(resources.images['attribute']),
            'module': QIcon(resources.images['module']),
            'class': QIcon(resources.images['class'])}

        self._editor = editor
        self._fromProject = False
        if project is not None:
            if type(project) is str:
                project = rope.base.project.Project(project, None, '.ninjaproject')
            self._project = project
            self._fromProject = True
        else:
            self._project = rope.base.project.get_no_project()
        self.setWidget(self._editor)
        self.popupView = QListWidget()
        self.popupView.setAlternatingRowColors(True)
        self.popupView.setWordWrap(False)
        self.setPopup(self.popupView)
        self.setCompletionMode(QCompleter.PopupCompletion)
        self.setCaseSensitivity(Qt.CaseInsensitive)

        self.connect(self, SIGNAL("activated(QString)"), self.insert_completion)
예제 #11
0
	def __init__(self, parent=None, language=None, tokens=None):
		"""
		Initializes the class.

		:param parent: Object parent.
		:type parent: QObject
		:param language: Language name.
		:type language: unicode
		:param tokens: Completer tokens list.
		:type tokens: tuple or list
		"""

		LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))

		# --- Setting class attributes. ---
		self.__language = None
		self.language = language

		self.__setCache(tokens)

		QCompleter.__init__(self,
		DefaultCompleter._DefaultCompleter__tokens[self.__language], parent)

		self.setCaseSensitivity(Qt.CaseSensitive)
		self.setCompletionMode(QCompleter.PopupCompletion)
예제 #12
0
    def __init__(self, parent):
        super(ProjectData, self).__init__()
        self._parent = parent
        grid = QGridLayout(self)
        grid.addWidget(QLabel(self.tr("Name:")), 0, 0)
        self.name = QLineEdit()
        if self._parent._item.name == '':
            self.name.setText(file_manager.get_basename(
                self._parent._item.path))
        else:
            self.name.setText(self._parent._item.name)
        grid.addWidget(self.name, 0, 1)
        grid.addWidget(QLabel(self.tr("Project Type:")), 1, 0)
        self.txtType = QLineEdit()
        completer = QCompleter(sorted(settings.PROJECT_TYPES))
        completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.txtType.setCompleter(completer)
        self.txtType.setText(self._parent._item.projectType)
        grid.addWidget(self.txtType, 1, 1)
        grid.addWidget(QLabel(self.tr("Description:")), 2, 0)
        self.description = QPlainTextEdit()
        self.description.setPlainText(self._parent._item.description)
        grid.addWidget(self.description, 2, 1)
        grid.addWidget(QLabel(self.tr("URL:")), 3, 0)
        self.url = QLineEdit()
        self.url.setText(self._parent._item.url)
        grid.addWidget(self.url, 3, 1)
        grid.addWidget(QLabel(self.tr("Licence:")), 4, 0)
        self.cboLicense = QComboBox()
        self.cboLicense.addItem('Apache License 2.0')
        self.cboLicense.addItem('Artistic License/GPL')
        self.cboLicense.addItem('Eclipse Public License 1.0')
        self.cboLicense.addItem('GNU General Public License v2')
        self.cboLicense.addItem('GNU General Public License v3')
        self.cboLicense.addItem('GNU Lesser General Public License')
        self.cboLicense.addItem('MIT License')
        self.cboLicense.addItem('Mozilla Public License 1.1')
        self.cboLicense.addItem('New BSD License')
        self.cboLicense.addItem('Other Open Source')
        self.cboLicense.addItem('Other')
        self.cboLicense.setCurrentIndex(4)
        index = self.cboLicense.findText(self._parent._item.license)
        self.cboLicense.setCurrentIndex(index)
        grid.addWidget(self.cboLicense, 4, 1)

        self.txtExtensions = QLineEdit()
        self.txtExtensions.setText(', '.join(self._parent._item.extensions))
        grid.addWidget(QLabel(self.tr("Supported Extensions:")), 5, 0)
        grid.addWidget(self.txtExtensions, 5, 1)

        grid.addWidget(QLabel(self.tr("Indentation: ")), 6, 0)
        self.spinIndentation = QSpinBox()
        self.spinIndentation.setValue(self._parent._item.indentation)
        self.spinIndentation.setMinimum(1)
        grid.addWidget(self.spinIndentation, 6, 1)
        self.checkUseTabs = QCheckBox(self.tr("Use Tabs."))
        self.checkUseTabs.setChecked(self._parent._item.useTabs)
        grid.addWidget(self.checkUseTabs, 6, 2)
예제 #13
0
 def complete(self, cr, results):
     self.popupView.clear()
     model = self.obtain_model_items(results)
     self.setModel(model)
     self.popup().setCurrentIndex(model.index(0, 0))
     cr.setWidth(self.popup().sizeHintForColumn(0) \
         + self.popup().verticalScrollBar().sizeHint().width() + 10)
     self.popupView.updateGeometries()
     QCompleter.complete(self, cr)
예제 #14
0
    def __init__(self,parent=None):
        super(QtGui.QLineEdit, self).__init__(parent)

        model = QStringListModel()
        completer = QCompleter()
        completer.setModel(model)
        model.setStringList(cmd.cmdset)

        self.setCompleter(completer)
예제 #15
0
class ManualInstallWidget(QWidget):

    def __init__(self, parent):
        super(ManualInstallWidget, self).__init__()
        self._parent = parent
        vbox = QVBoxLayout(self)
        form = QFormLayout()
        self._txtName = QLineEdit()
        self._txtName.setPlaceholderText('my_plugin')
        self._txtVersion = QLineEdit()
        self._txtVersion.setPlaceholderText('0.1')
        form.addRow(self.tr("Plugin Name:"), self._txtName)
        form.addRow(self.tr("Plugin Version:"), self._txtVersion)
        vbox.addLayout(form)
        hPath = QHBoxLayout()
        self._txtFilePath = QLineEdit()
        self._txtFilePath.setPlaceholderText(os.path.join(
            os.path.expanduser('~'), 'full', 'path', 'to', 'plugin.zip'))
        self._btnFilePath = QPushButton(QIcon(":img/open"), '')
        self.completer, self.dirs = QCompleter(self), QDirModel(self)
        self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
        self.completer.setModel(self.dirs)
        self._txtFilePath.setCompleter(self.completer)
        hPath.addWidget(QLabel(self.tr("Plugin File:")))
        hPath.addWidget(self._txtFilePath)
        hPath.addWidget(self._btnFilePath)
        vbox.addLayout(hPath)
        vbox.addSpacerItem(QSpacerItem(0, 1, QSizePolicy.Expanding,
            QSizePolicy.Expanding))

        hbox = QHBoxLayout()
        hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
        self._btnInstall = QPushButton(self.tr("Install"))
        hbox.addWidget(self._btnInstall)
        vbox.addLayout(hbox)

        #Signals
        self.connect(self._btnFilePath,
            SIGNAL("clicked()"), self._load_plugin_path)
        self.connect(self._btnInstall, SIGNAL("clicked()"),
            self.install_plugin)

    def _load_plugin_path(self):
        path = QFileDialog.getOpenFileName(self, self.tr("Select Plugin Path"))
        if path:
            self._txtFilePath.setText(path)

    def install_plugin(self):
        if self._txtFilePath.text() and self._txtName.text():
            plug = []
            plug.append(self._txtName.text())
            plug.append(self._txtVersion.text())
            plug.append('')
            plug.append('')
            plug.append('')
            plug.append(self._txtFilePath.text())
            self._parent.install_plugins_manually([plug])
예제 #16
0
 def complete(self, cr, results):
     proposals = []
     proposals += results.get('modules', [])
     proposals += results.get('classes', [])
     proposals += results.get('attributes', [])
     proposals += results.get('functions', [])
     self.model().setStringList(proposals)
     self.popup().setCurrentIndex(self.model().index(0, 0))
     cr.setWidth(self.popup().sizeHintForColumn(0)
         + self.popup().verticalScrollBar().sizeHint().width() + 10)
     QCompleter.complete(self, cr)
예제 #17
0
파일: completer.py 프로젝트: halbbob/dff
 def __init__(self):
     QCompleter.__init__(self)
     self.vfs = vfs()
     self.__model = CompleterModel()
     self.currentNode = self.vfs.getnode("/")
     self.currentPath = self.currentNode
     self.setCompletionPrefix(QString.fromUtf8(self.currentNode.absolute()))
     self.__model.setRootPath(self.currentNode)
     self.__model.setCurrentPath("/")
     self.setModel(self.__model)
     QObject.connect(self, SIGNAL("activated(const QString &)"), self.updatePath)
예제 #18
0
	def moveToShotsPage(self):
		self.getProjectsBanner()
		self.slideView(self.ui.ShotInfoPage, "right")
		# Set the model for the presets
		# If no current project is set, send error
		if not self.ui.ProjectsEDIT.currentProject:
			pass
		else:
			shotGroupModel = ShotGroupModel(self.ui.ProjectsEDIT.currentProject)
			completer = QCompleter()
			self.ui.ShotGroupEDIT.setCompleter(completer)
			completer.setModel(shotGroupModel)
예제 #19
0
    def __init__(self, editor):
        QCompleter.__init__(self, [], editor)
        self._editor = editor

        self.setWidget(editor)
        self.setCompletionMode(QCompleter.PopupCompletion)
        self.setCaseSensitivity(Qt.CaseInsensitive)

        self.cc = code_completion.CodeCompletion()
        self.completion_results = []

        self.connect(self, SIGNAL("activated(const QString&)"), self.insert_completion)
예제 #20
0
    def __init__( self, parent = None, strings = None,
                  completionMode = QCompleter.PopupCompletion ):

        if strings is None:
            strings = []
        QCompleter.__init__( self, parent )
        self.__model = QStringListModel( strings, parent )
        self.setModel( self.__model )
        self.setCompletionMode( completionMode )

        if parent:
            parent.setCompleter( self )
        return
예제 #21
0
    def __init__(self, editor):
        QCompleter.__init__(self)

        self.setWidget(editor)
        self.popupView = QListWidget()
        self.popupView.setAlternatingRowColors(True)
        self.popupView.setWordWrap(False)
        self.setPopup(self.popupView)
        self.setCompletionMode(QCompleter.PopupCompletion)
        self.setCaseSensitivity(Qt.CaseInsensitive)

        self.connect(self.popupView, SIGNAL("itemClicked(QListWidgetItem*)"),
            self.insert_completion)
예제 #22
0
    def __init__( self, parent = None ):
        QCompleter.__init__( self, parent )
        self.setCompletionMode( QCompleter.PopupCompletion )

        self.__width = -1
        self.__rect = None
        self.__model = None

        self.setWidget( parent )
        self.setCaseSensitivity( Qt.CaseInsensitive )
        self.setWrapAround( False )

        self.highlighted[QModelIndex].connect( self.__onHighlighted )
        return
예제 #23
0
    def __init__( self, parent ):
        '''
        Constructor
        '''
        super( FrmFactura, self ).__init__( parent )
        self.readOnly = True
        self.recibo = None

        self.clientesModel = QSqlQueryModel()

#       las acciones deberian de estar ocultas
        self.actionSave.setVisible( False )
        self.actionCancel.setVisible( False )
#        El modelo principal
        self.navmodel = QSqlQueryModel( self )
#        El modelo que filtra a self.navmodel
        self.navproxymodel = QSortFilterProxyModel( self )
        self.navproxymodel.setSourceModel( self.navmodel )
        self.navproxymodel.setFilterKeyColumn( -1 )
        self.navproxymodel.setFilterCaseSensitivity ( Qt.CaseInsensitive )
#        Este es el modelo con los datos de la con los detalles
        self.detailsmodel = QSqlQueryModel( self )
        self.detailsproxymodel = QSortFilterProxyModel( self )
        self.detailsproxymodel.setSourceModel( self.detailsmodel )
        #inicializando el documento
        self.editmodel = None
        self.lblanulado.setHidden( True )
        self.toolBar.removeAction( self.actionAnular )
        self.toolBar.addAction( self.actionAnular )
        self.recibo = None

        self.cargarRecibos()

        self.existenciaModel = QSqlQueryModel()
        self.vendedoresModel = QSqlQueryModel()
        self.bodegasModel = QSqlQueryModel()

        self.anulable = 2
        """
        @ivar: Si la factura actual se puede anular o no
        @type: int
        """

        self.tabledetails.setOrder( 1, 3 )

        self.completer = QCompleter()
        self.completerVendedor = QCompleter()

        QTimer.singleShot( 0, self.loadModels )
예제 #24
0
    def __init__( self ,tipopersona, parent ):
        '''
        Constructor
        '''
        super( dlgPersona, self ).__init__( parent )
        self.setupUi(self)

#        self.tableview.addActions( ( self.actionEdit, self.actionNew ) )
        self.idtipopersona = tipopersona
        self.table = ""
        self.backmodel = QSqlQueryModel()
        self.database = parent.database

        self.filtermodel = QSortFilterProxyModel( self )
        self.filtermodel.setSourceModel( self.backmodel )
        self.filtermodel.setDynamicSortFilter( True )
        self.filtermodel.setFilterKeyColumn( -1 )
        self.filtermodel.setFilterCaseSensitivity( Qt.CaseInsensitive )
        
        self.paisesModel = QSqlQueryModel()
        self.cbpais.setModel( self.paisesModel )
        self.cbpais.setCurrentIndex( -1 )
        self.cbpais.setFocus()
        self.cbpais.setModelColumn( 1 )
        self.paisescompleter = QCompleter()
        self.paisescompleter.setCaseSensitivity( Qt.CaseInsensitive )
        self.paisescompleter.setModel( self.paisesModel )
        self.paisescompleter.setCompletionColumn( 1 )
        self.cbpais.setCompleter( self.paisescompleter )      


        self.proveedoresModel = QSqlQueryModel()
        self.cbproveedor.setModel( self.proveedoresModel )
        self.cbproveedor.setCurrentIndex( -1 )
        self.cbproveedor.setFocus()
        self.cbproveedor.setModelColumn( 1 )
        self.proveedorcompleter = QCompleter()
        self.proveedorcompleter.setCaseSensitivity( Qt.CaseInsensitive )
        self.proveedorcompleter.setModel( self.proveedoresModel )
        self.proveedorcompleter.setCompletionColumn( 1 )
        self.cbproveedor.setCompleter( self.proveedorcompleter ) 


#        self.tableview.setModel(self.filtermodel)
        self.cbsexo.setCurrentIndex(-1)
        self.txtnombre.setFocus()
        self.setReadOnly(True)
        QTimer.singleShot( 0, self.updateModels )
예제 #25
0
 def __init__(self, parent=None):
     QtCore.QThread.__init__(self)
     QtGui.QWidget.__init__(self, parent)
     self.ui = Ui_Form()
     self.ui.setupUi(self)
     QtCore.QObject.connect(self.ui.pushButton, QtCore.SIGNAL("clicked()"), self.filebrower) #for input file
     QtCore.QObject.connect(self.ui.pushButton_2, QtCore.SIGNAL("clicked()"), self.submit) #submit
     QtCore.QObject.connect(self.ui.pushButton_3, QtCore.SIGNAL("clicked()"), self.reset) #reset
     QtCore.QObject.connect(self.ui.pushButton_4, QtCore.SIGNAL("clicked()"), self.add_taxid1) #add taxid to include
     QtCore.QObject.connect(self.ui.pushButton_5, QtCore.SIGNAL("clicked()"), self.add_taxid2) #add taxid to exclude
     QtCore.QObject.connect(self.ui.pushButton_6, QtCore.SIGNAL("clicked()"), self.advance) #add taxid to exclude
     self.ui.progressBar.hide()
     self.ui.progressBar.setProperty("value", 0)
     self.ui.lineEdit_add3 = QtGui.QLineEdit(self.ui.groupBox_2)
     self.ui.lineEdit_add3.setGeometry(QtCore.QRect(70, 20, 281, 21))
     self.ui.lineEdit_add3.setObjectName("lineEdit_3")
     self.ui.lineEdit_add3.setText(QtGui.QApplication.translate("Form", "", None, QtGui.QApplication.UnicodeUTF8))
     completer = QCompleter()
     self.ui.lineEdit_add3.setCompleter(completer)
     model = QStringListModel()
     completer.setModel(model)
     completer.setModelSorting(QCompleter.CaseInsensitivelySortedModel)
     Expar.get_data(model)
     self.ui.lineEdit_add2 = QtGui.QLineEdit(self.ui.groupBox_4)
     self.ui.lineEdit_add2.setGeometry(QtCore.QRect(70, 19, 281, 21))
     self.ui.lineEdit_add2.setObjectName("lineEdit_2")
     self.ui.lineEdit_add2.setText(QtGui.QApplication.translate("Form", "", None, QtGui.QApplication.UnicodeUTF8))
     completer = QCompleter()
     self.ui.lineEdit_add2.setCompleter(completer)
     model = QStringListModel()
     completer.setModel(model)
     completer.setModelSorting(QCompleter.CaseInsensitivelySortedModel)
     Expar.get_data(model)
     self.dbdir=os.path.join(os.path.expanduser("~"),".pyqtodo")
     self.dbfile=os.path.join(self.dbdir,str(int(time.time()))+"tasks.sqlite")
     if not os.path.isdir(self.dbdir):
         os.mkdir(self.dbdir)
         # Set up the Elixir internal thingamajigs
     elixir.metadata.bind = "sqlite:///%s"%self.dbfile
     elixir.setup_all()
     if not os.path.exists(self.dbfile):
         elixir.create_all()
     global saveData
     if elixir.__version__ < "0.6":
         saveData=elixir.session.flush
     else:
         saveData=elixir.session.commit
     saveData()
예제 #26
0
    def __init__(self, model, parent=None, showTable=False):
        super(SearchPanel, self).__init__(parent)

        self.tabla = None
        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)
        #        self.setModel( model )
        self.setEditable(True)
        self.completer = QCompleter(self)
        # always show all completions
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.showTable = showTable

        if model != None:
            self.setModel(model)
        #        self.pFilterModel.setSourceModel( model );

        self.completer.setModel(self.pFilterModel)
        self.completerTable = SearchPanelView()
        self.completer.setPopup(self.completerTable)
        # Mostrar el Popup en forma de Tabla
        if self.showTable:
            self.tabla = SearchPanelView()
            self.setView(self.tabla)

        self.setCompleter(self.completer)

        self.setColumn(1)

        self.lineEdit().textEdited[unicode].connect(
            self.pFilterModel.setFilterFixedString if not showTable else self.pFilterModel.setFilterWildcard
        )
예제 #27
0
    def __init__( self ):
        '''
        Constructor
        '''
        super( tbFactura, self ).__init__(  )

# ESTABLECER LA INTERFAZ AL FORMULARIO
        self.setupUi(self)
# VALIDADOR DE MODO DE EDICION
        self.readOnly = True
        self.editmodel = None
#ESTABLECER LA FECHA INICIAL , (establecida al dia de mañana)
        self.categoriesview.headers = ["Descripcion", "Precio", "Unidades","Existencia","","",""]

# Crear el modelo para cargar catalogo de clientes
        self.clientesModel = QSqlQueryModel()
# Crear lista de autocompletado para el combo de clientes
        self.clienteCompleter = QCompleter()     
# Modelo que carga el catalogo de productos
        self.existenciaModel = QSqlQueryModel()

# Establecer todos los controles en modo de edicion
        self.setControls( False )
# Crear la conexion a la base de datos
        self.database = QSqlDatabase.database()

        
        
        self.vistaprevia = False
        
# Cargar los modelos del modo de edicion
        self.updateEditModels()
        self.parent = self.parent()
예제 #28
0
 def __init__(self,iface):
     self.iface = iface
     QDockWidget.__init__(self)
     self.setupUi(self)
     self.iface.addDockWidget(Qt.BottomDockWidgetArea,self)
     self.canvas = self.iface.mapCanvas()
     
     self.rb = QgsRubberBand(self.canvas, QGis.Point)
     self.rb.setColor(QColor( 255, 0, 0, 150 ))
     self.searchCacheLimit = 1000
     
     self.wgs84 = QgsCoordinateReferenceSystem()
     self.wgs84.createFromSrid(4326)
     self.proj = self.canvas.mapRenderer().destinationCrs()
     self.transform = QgsCoordinateTransform(self.wgs84, self.proj)
     
     self.bSearch.clicked.connect(self.startSearch)
     self.eOutput.currentItemChanged.connect(self.itemChanged)
     self.eOutput.clickedOutsideOfItems.connect(self.itemChanged)
     self.eText.cleared.connect(self.clearEdit)
     self.canvas.mapRenderer().destinationSrsChanged.connect(self.crsChanged)
     self.iface.newProjectCreated.connect(self.clearEdit)
     self.iface.projectRead.connect(self.clearEdit)
     self.cbCenter.stateChanged.connect(self.autocenter)
     
     db = cacheDB()
     self.autocompleteList = db.getAutocompleteList()
     db.closeConnection()
     self.completer = QCompleter(self.autocompleteList)
     self.completer.setCaseSensitivity(Qt.CaseInsensitive)
     self.eText.setCompleter(self.completer)
 def __init__(self, parent = None, strings = QStringList(),
              completionMode = QCompleter.PopupCompletion):
     """
     Constructor
     
     @param parent parent widget of the completer (QWidget)
     @param strings list of string to load into the completer (QStringList)
     @keyparam completionMode completion mode of the 
         completer (QCompleter.CompletionMode)
     """
     QCompleter.__init__(self, parent)
     self.__model = QStringListModel(strings, parent)
     self.setModel(self.__model)
     self.setCompletionMode(completionMode)
     if parent:
         parent.setCompleter(self)
예제 #30
0
    def __init__(
        self, parent=None, uiSearchImage=None, uiSearchClickedImage=None, uiClearImage=None, uiClearClickedImage=None
    ):
        """
		Initializes the class.

		:param parent: Widget parent.
		:type parent: QObject
		:param uiSearchImage: Search button image path.
		:type uiSearchImage: str
		:param uiSearchClickedImage: Search button clicked image path.
		:type uiSearchClickedImage: str
		:param uiClearImage: Clear button image path.
		:type uiClearImage: str
		:param uiClearClickedImage: Clear button clicked image path.
		:type uiClearClickedImage: str
		"""

        LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))

        QLineEdit.__init__(self, parent)

        # --- Setting class attributes. ---
        self.__uiSearchImage = None
        self.uiSearchImage = uiSearchImage or umbra.ui.common.getResourcePath("images/Search_Glass.png")
        self.__uiSearchClickedImage = None
        self.uiSearchClickedImage = uiSearchClickedImage or umbra.ui.common.getResourcePath(
            "images/Search_Glass_Clicked.png"
        )
        self.__uiClearImage = None
        self.uiClearImage = uiClearImage or umbra.ui.common.getResourcePath("images/Search_Clear.png")
        self.__uiClearClickedImage = None
        self.uiClearClickedImage = uiClearClickedImage or umbra.ui.common.getResourcePath(
            "images/Search_Clear_Clicked.png"
        )

        self.__searchActiveLabel = Active_QLabel(
            self, QPixmap(self.__uiSearchImage), QPixmap(self.__uiSearchImage), QPixmap(self.__uiSearchClickedImage)
        )
        self.__searchActiveLabel.setObjectName("Search_Field_activeLabel")
        self.__searchActiveLabel.showEvent = lambda event: reduce(
            lambda *args: None, (self.__setStyleSheet(), Active_QLabel.showEvent(self.__searchActiveLabel, event))
        )
        self.__searchActiveLabel.hideEvent = lambda event: reduce(
            lambda *args: None, (self.__setStyleSheet(), Active_QLabel.hideEvent(self.__searchActiveLabel, event))
        )

        self.__clearButton = QToolButton(self)
        self.__clearButton.setObjectName("Clear_Field_button")

        self.__completer = QCompleter()
        self.setCompleter(self.__completer)
        self.__completerVisibleItemsCount = 16

        Search_QLineEdit.__initializeUi(self)
        self.__setClearButtonVisibility(self.text())

        # Signals / Slots.
        self.__clearButton.clicked.connect(self.clear)
        self.textChanged.connect(self.__setClearButtonVisibility)
예제 #31
0
    def __init__(self, parent=None):
        super(ExtendedComboBox, self).__init__(parent)

        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)

        # add a filter model to filter matching items
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.pFilterModel.setSourceModel(self.model())

        # add a completer, which uses the filter model
        self.completer = QCompleter(self.pFilterModel, self)
        # always show all (filtered) completions
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.setCompleter(self.completer)

        # connect signals
        self.lineEdit().textEdited[unicode].connect(
            self.pFilterModel.setFilterFixedString)
        self.completer.activated.connect(self.on_completer_activated)
        self.completer.selected.connect(self.on_completer_activated)
예제 #32
0
    def __init__(self):
        QPlainTextEdit.__init__(self)
        self.setWordWrapMode(QTextOption.NoWrap)
        self.setFont(QFont("monospace", 10))
        self.setCursorWidth(2)
        self.installEventFilter(self)

        self.cursorPositionChanged.connect(self.showHelp)

        self.completer = QCompleter(self)
        self.completer.setWidget(self)
        self.completer.setCaseSensitivity(Qt.CaseInsensitive)
        self.completer.activated.connect(self.insertCompletion)

        auto_complete = QShortcut(QKeySequence("Ctrl+Space"), self)
        auto_complete.activated.connect(self.activateCompleter)

        copy_line = QShortcut(QKeySequence("Ctrl+D"), self)
        copy_line.activated.connect(self.duplicateLine)

        select_fragment = QShortcut(QKeySequence("Ctrl+J"), self)
        select_fragment.activated.connect(self.selectFragment)
예제 #33
0
    def update_autocomplete_fields(self):
        self.titleList = QStringList(self.db.get_string_list("Title"))
        self.speakerList = QStringList(self.db.get_string_list("Speaker"))
        self.categoryList = QStringList(self.db.get_string_list("Category"))
        self.eventList = QStringList(self.db.get_string_list("Event"))
        self.roomList = QStringList(self.db.get_string_list("Room"))

        self.titleCompleter = QCompleter(self.titleList)
        self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.speakerCompleter = QCompleter(self.speakerList)
        self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.categoryCompleter = QCompleter(self.categoryList)
        self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.eventCompleter = QCompleter(self.eventList)
        self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.roomCompleter = QCompleter(self.roomList)
        self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive)

        self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter)
        self.talkDetailsWidget.presenterLineEdit.setCompleter(self.speakerCompleter)
        self.talkDetailsWidget.categoryLineEdit.setCompleter(self.categoryCompleter)
        self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter)
        self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter)
예제 #34
0
    def __init__(self):
        QWidget.__init__(self)
        hbox = QHBoxLayout(self)
        hbox.setContentsMargins(0, 0, 0, 0)
        self.btnClose = QPushButton(
            self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
        self.completer = QCompleter(self)
        self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
        fileModel = QFileSystemModel(self.completer)
        fileModel.setRootPath("")
        self.completer.setModel(fileModel)
        self.pathLine.setCompleter(self.completer)
        self.btnOpen = QPushButton(
            self.style().standardIcon(QStyle.SP_ArrowRight), 'Open!')
        hbox.addWidget(self.btnClose)
        hbox.addWidget(QLabel(self.tr("Path:")))
        hbox.addWidget(self.pathLine)
        hbox.addWidget(self.btnOpen)

        self.connect(self.pathLine, SIGNAL("returnPressed()"),
            self._open_file)
        self.connect(self.btnOpen, SIGNAL("clicked()"),
            self._open_file)
예제 #35
0
    def set_completer_widget(self, tablename, widget, field_id):
        """ Set autocomplete of widget @table_object + "_id"
            getting id's from selected @table_object
        """
        if not widget:
            return

        # Set SQL
        sql = ("SELECT DISTINCT(" + field_id + ")"
               " FROM " + self.schema_name + "." + tablename +""
               " ORDER BY "+ field_id + "")
        row = self.controller.get_rows(sql)
        for i in range(0, len(row)):
            aux = row[i]
            row[i] = str(aux[0])

        # Set completer and model: add autocomplete in the widget
        self.completer = QCompleter()
        self.completer.setCaseSensitivity(Qt.CaseInsensitive)
        widget.setCompleter(self.completer)
        model = QStringListModel()
        model.setStringList(row)
        self.completer.setModel(model)
예제 #36
0
def getText(
    parent=None,
    title="",
    message="",
    text="",
    icon=None,
    help=None,
    validate=None,
    regexp=None,
    wordWrap=True,
    complete=None,
):
    """Asks a string of text from the user.
    
    Arguments:
    
    parent: parent widget or None
    title: dialog window title (without appname)
    message: message, question
    text: pre-entered text in the line edit
    icon: which icon to show
    help: help page or name
    validate: a function that accepts text and returns whether it is valid.
    regexp: a regular expression string. If given it provides an alternate
        validation method using a QRegExpValidator.
    wordWrap: whether to word-wrap the message text (default: True).
    complete: a string list or QAbstractItemModel to provide completions.
    
    """
    dlg = widgets.dialog.TextDialog(parent,
                                    title=app.caption(title),
                                    message=message,
                                    icon=icon)
    dlg.setText(text)
    dlg.setMinimumWidth(320)
    dlg.messageLabel().setWordWrap(wordWrap)
    if help is not None:
        userguide.addButton(dlg.buttonBox(), help)
        dlg.setWindowModality(Qt.WindowModal)
    else:
        dlg.setWindowModality(Qt.ApplicationModal)
    if regexp:
        dlg.setValidateRegExp(regexp)
    elif validate:
        dlg.setValidateFunction(validate)
    if complete:
        c = QCompleter(complete, dlg.lineEdit())
        dlg.lineEdit().setCompleter(c)
    if dlg.exec_():
        return dlg.text()
예제 #37
0
def set_model_by_list(string_list, widget, proxy_model):
    """ Set the model according to the list """
    model = QStringListModel()
    model.setStringList(string_list)
    proxy_model.setSourceModel(model)
    proxy_model.setFilterKeyColumn(0)
    proxy_model_aux = QSortFilterProxyModel()
    proxy_model_aux.setSourceModel(model)
    proxy_model_aux.setFilterKeyColumn(0)
    widget.setModel(proxy_model_aux)
    widget.setModelColumn(0)
    completer = QCompleter()
    completer.setModel(proxy_model)
    completer.setCompletionColumn(0)
    completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
    widget.setCompleter(completer)
예제 #38
0
class FileSystemOpener(QWidget):
    """Widget to handle opening files through path write with completion."""
    def __init__(self):
        super(FileSystemOpener, self).__init__()
        hbox = QHBoxLayout(self)
        hbox.setContentsMargins(0, 0, 0, 0)
        self.btnClose = QPushButton(
            self.style().standardIcon(QStyle.SP_DialogCloseButton), '')
        self.btnClose
        self.completer = QCompleter(self)
        self.pathLine = ui_tools.LineEditTabCompleter(self.completer)
        fileModel = QFileSystemModel(self.completer)
        fileModel.setRootPath("")
        self.completer.setModel(fileModel)
        self.pathLine.setCompleter(self.completer)
        self.btnOpen = QPushButton(
            self.style().standardIcon(QStyle.SP_ArrowRight), 'Open!')
        hbox.addWidget(self.btnClose)
        hbox.addWidget(QLabel(self.trUtf8("Path:")))
        hbox.addWidget(self.pathLine)
        hbox.addWidget(self.btnOpen)

        self.connect(self.pathLine, SIGNAL("returnPressed()"), self._open_file)
        self.connect(self.btnOpen, SIGNAL("clicked()"), self._open_file)

    def _open_file(self):
        """Open the file selected."""
        path = self.pathLine.text()
        main_container = IDE.get_service("main_container")
        if main_container:
            main_container.open_file(path)
            self.emit(SIGNAL("requestHide()"))

    def showEvent(self, event):
        """Show the FileSystemOpener widget and select all the text."""
        super(FileSystemOpener, self).showEvent(event)
        self.pathLine.selectAll()
예제 #39
0
    def set_model_by_list(self, string_list, widget):

        model = QStringListModel()
        model.setStringList(string_list)
        self.proxy_model = QSortFilterProxyModel()
        self.proxy_model.setSourceModel(model)
        self.proxy_model.setFilterKeyColumn(0)
        proxy_model_aux = QSortFilterProxyModel()
        proxy_model_aux.setSourceModel(model)
        proxy_model_aux.setFilterKeyColumn(0)
        widget.setModel(proxy_model_aux)
        widget.setModelColumn(0)
        completer = QCompleter()
        completer.setModel(self.proxy_model)
        completer.setCompletionColumn(0)
        completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        widget.setCompleter(completer)
예제 #40
0
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)

        # Components
        self.path_edit = QLineEdit(self)
        self.path_edit.setReadOnly(True)

        self.button = QToolButton(self)
        self.button.setIcon(QIcon.fromTheme("document-open-folder"))

        # Completer
        completer = QCompleter(self)
        completer.setModel(QDirModel(completer))
        self.path_edit.setCompleter(completer)

        # Setup Widget
        self.setLayout(QHBoxLayout())
        self.layout().setMargin(0)
        self.layout().setSpacing(0)
        self.layout().addWidget(self.path_edit)
        self.layout().addWidget(self.button)

        # Actions
        self.connect(self.button, SIGNAL('clicked()'), self.selectPath)
예제 #41
0
 def __init__(self, max_tags, expiry_prefix=None, tag_list=None, parent=None, separator=",", show_datestamp=False):
     
     QWidget.__init__(self, parent)
     
     self.__completer_active = False
     self.__max_tags = max_tags
     self.__tag_separator = separator
     self.__tag_list = tag_list
     self.__parent = parent
     self.__tag_line = QLineEdit(self.__parent)
     #self.__tag_line = TagLineEdit(self.__parent)
     self.__show_datestamp = show_datestamp
     self.__datestamp_format = TsConstants.DATESTAMP_FORMAT_DAY
     self.__expiry_prefix = expiry_prefix
     
     ## flag, if the line should be checked of emptiness
     self.__check_not_empty = False
     self.__check_tag_limit = False
     
     self.__restricted_vocabulary = False
     
     ## the latest activated suggestion 
     self.__activated_text = None
     # value of the actual datestamp
     self.__datestamp = None
     self.__datestamp_hidden = False
     
     self.__completer = QCompleter(self.__tag_list, self);
     self.__completer.setCaseSensitivity(Qt.CaseInsensitive)
     self.__completer.setWidget(self.__tag_line)
     
     #self.__handle_datestamp()
     
     self.connect(self.__tag_line, SIGNAL("textChanged(QString)"), self.__text_changed_by_user)
     self.connect(self.__completer, SIGNAL("activated(QString)"), self.__text_activated)
     self.connect(self.__completer, SIGNAL("highlighted(QString)"), self.__text_highlighted)
예제 #42
0
    def __init__(self, model, parent=None, showTable=False):
        super(SearchPanel, self).__init__(parent)

        self.tabla = None
        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)
        #        self.setModel( model )
        self.setEditable(True)
        self.completer = QCompleter(self)
        # always show all completions
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.showTable = showTable

        if model != None:
            self.setModel(model)


#        self.pFilterModel.setSourceModel( model );

        self.completer.setModel(self.pFilterModel)
        self.completerTable = SearchPanelView()
        self.completer.setPopup(self.completerTable)
        #Mostrar el Popup en forma de Tabla
        if self.showTable:
            self.tabla = SearchPanelView()
            self.setView(self.tabla)

        self.setCompleter(self.completer)

        self.setColumn(1)

        self.lineEdit().textEdited[unicode].connect(
            self.pFilterModel.setFilterFixedString if not showTable else self.
            pFilterModel.setFilterWildcard)
예제 #43
0
class ExtendedCombo( QComboBox ):
    def __init__( self,  parent = None):
        super( ExtendedCombo, self ).__init__( parent )

        self.setFocusPolicy( Qt.StrongFocus )
        self.setEditable( True )
        self.completer = QCompleter( self )

        # always show all completions
        self.completer.setCompletionMode( QCompleter.UnfilteredPopupCompletion )
        self.pFilterModel = QSortFilterProxyModel( self )
        self.pFilterModel.setFilterCaseSensitivity( Qt.CaseInsensitive )

        self.completer.setPopup( self.view() )

        self.setCompleter( self.completer )

        self.lineEdit().textEdited[unicode].connect( self.pFilterModel.setFilterFixedString )
        self.completer.activated.connect(self.setTextIfCompleterIsClicked)

    def setModel( self, model ):
        super(ExtendedCombo, self).setModel( model )
        self.pFilterModel.setSourceModel( model )
        self.completer.setModel(self.pFilterModel)

    def setModelColumn( self, column ):
        self.completer.setCompletionColumn( column )
        self.pFilterModel.setFilterKeyColumn( column )
        super(ExtendedCombo, self).setModelColumn( column )


    def view( self ):
        return self.completer.popup()

    def index( self ):
        return self.currentIndex()

    def setTextIfCompleterIsClicked(self, text):
      if text:
        index = self.findText(text)
        self.setCurrentIndex(index)
예제 #44
0
    def init_nominatim_autofill(self):

        # Usefull to avoid duplicate if we add a new completer.
        self.lineEdit_nominatim.setCompleter(None)
        self.last_places = []

        if isfile(self.last_nominatim_places_filepath):
            for line in open(self.last_nominatim_places_filepath, 'r'):
                self.last_places.append(line.rstrip('\n'))

            nominatim_completer = QCompleter(self.last_places)
            self.lineEdit_nominatim.setCompleter(nominatim_completer)
            self.lineEdit_nominatim.completer().setCompletionMode(
                QCompleter.PopupCompletion)
        else:
            open(self.last_nominatim_places_filepath, 'a').close()
예제 #45
0
def complete(lineedit, key):
    """A convenience function that installs a completer on the QLineEdit.
    
    The key is the QSettings key used to store the completions persistently.
    By default, the function tries to add the text in the line edit to 
    the stored completions when the window() of the lineedit is a Dialog
    and its accepted signal is fired.
    
    Returned is a callable a signal can be connected to, that stores the text
    in the line edit in the completions. (You don't have to use that if your
    widget is in a QDialog that has an accepted() signal.)
    
    """
    m = model(key)
    c = QCompleter(m, lineedit)
    lineedit.setCompleter(c)

    def store(completer=weakref.ref(c)):
        """Stores the contents of the line edit in the completer's model.
        
        Does not keep a reference to any object.
        
        """
        c = completer()
        if c:
            model = c.model()
            lineedit = c.parent()
            if model and lineedit:
                text = lineedit.text().strip()
                if text:
                    model.addString(text)

    def connect():
        """Try to connect the store() function to the accepted() signal of the parent QDialog.
        
        Return True if that succeeds, else False.
        
        """
        dlg = lineedit.window()
        try:
            dlg.accepted.connect(store)
        except AttributeError:
            return False
        return True

    connect() or QTimer.singleShot(0, connect)
    return store
예제 #46
0
    def __init__(self):
        super(AddNewWord, self).__init__(None)

        self.setWindowTitle("AddNewWord")

        completer = QCompleter(self)
        self.string_list_model = QStringListModel(self)
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        completer.setModel(self.string_list_model)
        self.setCompleter(completer)
        self.connect(self, SIGNAL("editingFinished()"), self.editComplete)

        self.word_list = QStringList()
예제 #47
0
    def __init__(self):
        super(GeneralPreferences, self).__init__()
        grid = QGridLayout(self)
        grid.setSpacing(20)
        grid.setColumnStretch(1, 10)

        # directory auto completer
        completer = QCompleter(self)
        dirs = QDirModel(self)
        dirs.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
        completer.setModel(dirs)
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        completer.setCompletionMode(QCompleter.PopupCompletion)

        l = QLabel(
            u"<b>Ingresá el directorio donde descargar los videos...</b>")
        l.setTextFormat(Qt.RichText)
        grid.addWidget(l, 0, 0, 1, 2)

        grid.addWidget(QLabel(u"Descargar en:"), 1, 0, 2, 1)
        prv = config.get('downloaddir', '')
        self.downloaddir_entry = QLineEdit(prv)
        self.downloaddir_entry.setCompleter(completer)
        self.downloaddir_entry.setPlaceholderText(u'Ingresá un directorio')
        grid.addWidget(self.downloaddir_entry, 1, 1, 2, 2)

        self.downloaddir_buttn = QPushButton(u"Elegir un directorio")
        self.downloaddir_buttn.clicked.connect(self._choose_dir)
        grid.addWidget(self.downloaddir_buttn, 2, 1, 3, 2)

        self.autoreload_checkbox = QCheckBox(
            u"Recargar automáticamente la lista de episodios al iniciar")
        prv = config.get('autorefresh', False)
        self.autoreload_checkbox.setChecked(prv)
        grid.addWidget(self.autoreload_checkbox, 3, 0, 4, 2)

        self.shownotifs_checkbox = QCheckBox(
            u"Mostrar una notificación cuando termina cada descarga")
        prv = config.get('notification', True)
        self.shownotifs_checkbox.setChecked(prv)
        grid.addWidget(self.shownotifs_checkbox, 4, 0, 5, 2)
예제 #48
0
   def createEditor(self, parent, styleOption, index):
      if index.column() == 1:
         editor = QDateTimeEdit(parent)
         editor.setDisplayFormat(self.parent().currentDateFormat)
         editor.setCalendarPopup(True)
         return editor

      editor = QLineEdit(parent)
      # create a completer with the strings in the column as model
      allStrings = []
      for i in range(1, index.model().rowCount()):
         strItem = index.model().data(index.sibling(i, index.column()), Qt.EditRole)
         if strItem not in allStrings:
            allStrings.append(strItem)
      aS = [str(x.toString()) for x in allStrings]
      autoComplete = QCompleter(QStringList(",".join(aS)))
      editor.setCompleter(autoComplete)
      editor.editingFinished.connect(self.commitAndCloseEditor)
      return editor
예제 #49
0
class ExtendedComboBox(QComboBox):
    def __init__(self, parent=None):
        super(ExtendedComboBox, self).__init__(parent)

        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.pFilterModel.setSourceModel(self.model())
        self.completer = QCompleter(self.pFilterModel, self)
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.completer.popup().setStyleSheet('min-height: 150px')
        self.completer.popup().setAlternatingRowColors(True)
        self.setCompleter(self.completer)
        self.lineEdit().textEdited[unicode].connect(self.pFilterModel.setFilterFixedString)
예제 #50
0
    def openEditor(self, item):

        dlg = widgets.dialog.Dialog(self,
                                    _("Please enter a local path or a URL:"),
                                    app.caption("LilyPond Documentation"),
                                    icon=icons.get('lilypond-run'))
        urlreq = widgets.urlrequester.UrlRequester()
        urlreq.lineEdit.setCompleter(
            QCompleter([
                "http://lilypond.org/doc/v2.12/",
                "http://lilypond.org/doc/stable/",
                "http://lilypond.org/doc/latest/",
            ], urlreq.lineEdit))
        dlg.setMainWidget(urlreq)
        urlreq.setPath(item.text())
        urlreq.setMinimumWidth(320)
        urlreq.lineEdit.setFocus()
        if dlg.exec_():
            item.setText(urlreq.path())
            return True
        return False
예제 #51
0
    def __init__(self, fromSection, editorWidget, parent=None):
        QDialog.__init__(self, parent, Qt.Dialog)
        self.setWindowTitle('from ... import ...')
        self._editorWidget = editorWidget
        self._fromSection = fromSection

        hbox = QHBoxLayout(self)
        hbox.addWidget(QLabel('from'))
        self._lineFrom = QLineEdit()
        self._completer = QCompleter(fromSection)
        self._lineFrom.setCompleter(self._completer)
        hbox.addWidget(self._lineFrom)
        hbox.addWidget(QLabel('import'))
        self._lineImport = QLineEdit()
        hbox.addWidget(self._lineImport)
        self._btnAdd = QPushButton(self.tr('Add'))
        hbox.addWidget(self._btnAdd)

        self.connect(self._lineImport, SIGNAL("returnPressed()"),
                     self._add_import)
        self.connect(self._btnAdd, SIGNAL("clicked()"), self._add_import)
예제 #52
0
class ExtendedCombo(QComboBox):
    def __init__(self, parent=None):
        """Default constructor
        """
        super(ExtendedCombo, self).__init__(parent)

        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)

        # add a filter model to filter matching items
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.pFilterModel.setSourceModel(self.model())

        # add a completer, which uses the filter model
        self.completer = QCompleter(self.pFilterModel, self)
        # always show all (filtered) completions
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.setCompleter(self.completer)

        # connect signals
        self.lineEdit().textEdited[unicode].connect(
            self.pFilterModel.setFilterFixedString)
        self.completer.activated.connect(self.on_completer_activated)

    # on selection of an item from the completer, select the corresponding item from combobox
    def on_completer_activated(self, text):
        """
        """
        if text:
            index = self.findText(text)
            self.setCurrentIndex(index)

    # on model change, update the models of the filter and completer as well
    def setModel(self, model):
        """
        """
        super(ExtendedCombo, self).setModel(model)
        self.pFilterModel.setSourceModel(model)
        self.completer.setModel(self.pFilterModel)

    # on model column change, update the model column of the filter and completer as well
    def setModelColumn(self, column):
        """
        """
        self.completer.setCompletionColumn(column)
        self.pFilterModel.setFilterKeyColumn(column)
        super(ExtendedCombo, self).setModelColumn(column)
예제 #53
0
class ExtendedComboBox(QComboBox):
    def __init__(self, parent=None):
        super(ExtendedComboBox, self).__init__(parent)

        self.setFocusPolicy(Qt.StrongFocus)
        self.setEditable(True)
        self.setCurrentIndex(-1)
        # self.activated.connect(self.on_completer_activated)

        # add a filter model to filter matching items
        self.pFilterModel = QSortFilterProxyModel(self)
        self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
        self.pFilterModel.setSourceModel(self.model())

        # add a completer, which uses the filter model
        self.completer = QCompleter(self.pFilterModel, self)
        # always show all (filtered) completions
        self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
        self.setCompleter(self.completer)

        # connect signals
        # self.lineEdit().textEdited[unicode].connect(self.pFilterModel.setFilterFixedString)
        # self.completer.activated.connect(self.on_completer_activated)

    # # on selection of an item from the completer, select the corresponding item from combobox
    # def on_completer_activated(self, received):
    #
    #     if type( received ) != int:
    #         # index = self.findText(received)
    #         # self.setCurrentIndex(index)
    #         # print "Es el texto: %s & index: %s" % (self.itemText(index), index)
    #         print "Es el texto como viene: %s" % received
    #         return received
    #     else:
    #         print "Es el texto extraido del numero enviado: %s " % self.itemText(received)
    #         return self.itemText(received)

    # on model change, update the models of the filter and completer as well
    def setModel(self, model):
        super(ExtendedComboBox, self).setModel(model)
        self.pFilterModel.setSourceModel(model)
        self.completer.setModel(self.pFilterModel)

    # on model column change, update the model column of the filter and completer as well
    def setModelColumn(self, column):
        self.completer.setCompletionColumn(column)
        self.pFilterModel.setFilterKeyColumn(column)
        super(ExtendedComboBox, self).setModelColumn(column)
예제 #54
0
    def initForm(self):
        control_path = tools.getFileInSameDirectory(__file__, "textInput.ui")
        self._form = uic.loadUi(control_path)
        self.form.label.setText(self._label)
        self.form.lineEdit.setText(self._value)
        self.form.setToolTip(self.help)

        super(ControlText, self).initForm()

        self.form.label.setAccessibleName('ControlText-label')
        self.form.lineEdit.editingFinished.connect(self.finishEditing)
        self.form.lineEdit.keyPressEvent = self.__key_pressed
        self.form.lineEdit._autoCompleteList = []
        self.form.lineEdit._completer = QCompleter(parent=self.form.lineEdit)
        self.form.lineEdit._completer.setCaseSensitivity(0)
        self.form.lineEdit._autoCompleteModel = QStringListModel(
            self.form.lineEdit._autoCompleteList, parent=self.form.lineEdit)
        self.form.lineEdit._completer.setModel(
            self.form.lineEdit._autoCompleteModel)
        self.form.lineEdit.setCompleter(self.form.lineEdit._completer)
        self.form.lineEdit._changedFname = None
예제 #55
0
    def start(self, event):

        c = self.c

        # Create the callback to insert the selected completion.
        def completion_callback(completion, self=self):
            self.end(completion)

        # Create the completer.
        cpl = c.frame.top.completer = self.completer = QCompleter()
        cpl.setWidget(self.body)
        cpl.connect(cpl, QtCore.SIGNAL("activated(QString)"),
                    completion_callback)

        # Set the flag for the event filter: all keystrokes will go to cc.onKey.
        self.active = True
        self.ev_filter.ctagscompleter_active = True
        self.ev_filter.ctagscompleter_onKey = self.onKey

        # Show the completions.
        self.complete(event)
예제 #56
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)
예제 #57
0
class TalkEditorApp(FreeseerApp):
    '''Freeseer talk database editor main gui class'''
    def __init__(self, config, db):
        super(TalkEditorApp, self).__init__(config)

        self.db = db

        icon = QIcon()
        icon.addPixmap(QPixmap(':/freeseer/logo.png'), QIcon.Normal, QIcon.Off)
        self.setWindowIcon(icon)
        self.resize(960, 600)

        #
        # Setup Layout
        #
        self.mainWidget = QWidget()
        self.mainLayout = QVBoxLayout()
        self.mainWidget.setLayout(self.mainLayout)
        self.setCentralWidget(self.mainWidget)
        self.mainLayout.setAlignment(Qt.AlignTop)

        # Add custom widgets
        self.commandButtons = CommandButtons()
        self.tableView = QTableView()
        self.tableView.setSortingEnabled(True)
        self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.talkDetailsWidget = TalkDetailsWidget()
        self.importTalksWidget = ImportTalksWidget()
        self.newTalkWidget = NewTalkWidget()
        self.mainLayout.addWidget(self.importTalksWidget)
        #self.mainLayout.addLayout(self.titleLayout)
        self.mainLayout.addWidget(self.commandButtons)
        self.mainLayout.addWidget(self.tableView)
        self.mainLayout.addWidget(self.talkDetailsWidget)
        self.mainLayout.addWidget(self.importTalksWidget)
        # --- End Layout

        # Keep track of index of the most recently selected talk
        self.currentTalkIndex = QPersistentModelIndex()

        # Prompt user to "Continue Editing", "Discard Changes" or "Save Changes"
        self.savePromptBox = QMessageBox()
        self.savePromptBox.setWindowTitle("Unsaved Changes Exist")
        self.savePromptBox.setIcon(QMessageBox.Information)
        self.savePromptBox.setText(
            "The talk you were editing has unsaved changes.")
        self.continueButton = self.savePromptBox.addButton(
            "Continue Editing", QMessageBox.RejectRole)
        self.discardButton = self.savePromptBox.addButton(
            "Discard Changes", QMessageBox.DestructiveRole)
        self.saveButton = self.savePromptBox.addButton("Save Changes",
                                                       QMessageBox.AcceptRole)
        self.savePromptBox.setDefaultButton(self.saveButton)

        # Initialize geometry, to be used for restoring window positioning.
        self.geometry = None

        #
        # Setup Menubar
        #
        self.actionExportCsv = QAction(self)
        self.actionExportCsv.setObjectName('actionExportCsv')
        self.actionRemoveAll = QAction(self)
        self.actionRemoveAll.setObjectName('actionRemoveAll')

        # Actions
        self.menuFile.insertAction(self.actionExit, self.actionExportCsv)
        self.menuFile.insertAction(self.actionExit, self.actionRemoveAll)
        # --- End Menubar

        #
        # TableView Connections
        #
        self.connect(self.tableView, SIGNAL('activated(const QModelIndex)'),
                     self.click_talk)
        self.connect(self.tableView, SIGNAL('selected(const QModelIndex)'),
                     self.click_talk)
        self.connect(self.tableView, SIGNAL('clicked(const QModelIndex)'),
                     self.click_talk)

        # Import Widget
        self.connect(self.importTalksWidget.csvRadioButton,
                     SIGNAL('toggled(bool)'), self.toggle_import)
        self.connect(self.importTalksWidget.importButton, SIGNAL('clicked()'),
                     self.import_talks)
        self.connect(self.importTalksWidget.cancelButton, SIGNAL('clicked()'),
                     self.hide_import_talks_widget)
        self.importTalksWidget.setHidden(True)
        self.connect(self.importTalksWidget.csvFileSelectButton,
                     SIGNAL('clicked()'), self.csv_file_select)
        self.connect(self.importTalksWidget.csvLineEdit,
                     SIGNAL('returnPressed()'),
                     self.importTalksWidget.importButton.click)
        self.connect(self.importTalksWidget.rssLineEdit,
                     SIGNAL('returnPressed()'),
                     self.importTalksWidget.importButton.click)
        self.connect(self.actionExportCsv, SIGNAL('triggered()'),
                     self.export_talks_to_csv)
        self.connect(self.actionRemoveAll, SIGNAL('triggered()'),
                     self.confirm_reset)

        # Command Buttons
        self.connect(self.commandButtons.addButton, SIGNAL('clicked()'),
                     self.click_add_button)
        self.connect(self.commandButtons.removeButton, SIGNAL('clicked()'),
                     self.remove_talk)
        self.connect(self.commandButtons.removeAllButton, SIGNAL('clicked()'),
                     self.confirm_reset)
        self.connect(self.commandButtons.importButton, SIGNAL('clicked()'),
                     self.show_import_talks_widget)
        self.connect(self.commandButtons.exportButton, SIGNAL('clicked()'),
                     self.export_talks_to_csv)
        self.connect(self.commandButtons.searchButton, SIGNAL('clicked()'),
                     self.search_talks)
        self.connect(self.commandButtons.searchLineEdit,
                     SIGNAL('textEdited(QString)'), self.search_talks)
        self.connect(self.commandButtons.searchLineEdit,
                     SIGNAL('returnPressed()'), self.search_talks)

        # Talk Details Buttons
        self.connect(self.talkDetailsWidget.saveButton, SIGNAL('clicked()'),
                     self.update_talk)

        # Talk Details Widget
        self.connect(self.talkDetailsWidget.titleLineEdit,
                     SIGNAL('textEdited(const QString)'), self.enable_save)
        self.connect(self.talkDetailsWidget.presenterLineEdit,
                     SIGNAL('textEdited(const QString)'), self.enable_save)
        self.connect(self.talkDetailsWidget.categoryLineEdit,
                     SIGNAL('textEdited(const QString)'), self.enable_save)
        self.connect(self.talkDetailsWidget.eventLineEdit,
                     SIGNAL('textEdited(const QString)'), self.enable_save)
        self.connect(self.talkDetailsWidget.roomLineEdit,
                     SIGNAL('textEdited(const QString)'), self.enable_save)
        self.connect(self.talkDetailsWidget.descriptionTextEdit,
                     SIGNAL('modificationChanged(bool)'), self.enable_save)
        self.connect(self.talkDetailsWidget.dateEdit,
                     SIGNAL('dateChanged(const QDate)'), self.enable_save)
        self.connect(self.talkDetailsWidget.startTimeEdit,
                     SIGNAL('timeChanged(const QTime)'), self.enable_save)
        self.connect(self.talkDetailsWidget.endTimeEdit,
                     SIGNAL('timeChanged(const QTime)'), self.enable_save)

        # New Talk Widget
        self.newTalkWidget.connect(self.newTalkWidget.addButton,
                                   SIGNAL('clicked()'), self.add_talk)
        self.newTalkWidget.connect(self.newTalkWidget.cancelButton,
                                   SIGNAL('clicked()'),
                                   self.newTalkWidget.reject)

        # Load default language
        actions = self.menuLanguage.actions()
        for action in actions:
            if action.data().toString() == self.config.default_language:
                action.setChecked(True)
                self.translate(action)
                break

        # Load Talk Database
        self.load_presentations_model()

        # Setup Autocompletion
        self.update_autocomplete_fields()

        self.talkDetailsWidget.saveButton.setEnabled(False)

        # Select first item
        #self.tableView.setCurrentIndex(self.proxy.index(0,0))
        #self.talk_selected(self.proxy.index(0,0))

    #
    # Translation
    #
    def retranslate(self):
        self.setWindowTitle(
            self.app.translate("TalkEditorApp", "Freeseer Talk Editor"))

        #
        # Reusable Strings
        #
        self.confirmDBClearTitleString = self.app.translate(
            "TalkEditorApp", "Remove All Talks from Database")
        self.confirmDBClearQuestionString = self.app.translate(
            "TalkEditorApp", "Are you sure you want to clear the DB?")
        self.confirmTalkDetailsClearTitleString = self.app.translate(
            "TalkEditorApp", "Unsaved Data")
        self.confirmTalkDetailsClearQuestionString = self.app.translate(
            "TalkEditorApp", "Unsaved talk details will be lost. Continue?")
        # --- End Reusable Strings

        #
        # Menubar
        #
        self.actionExportCsv.setText(
            self.app.translate("TalkEditorApp", "&Export to CSV"))
        self.actionRemoveAll.setText(
            self.app.translate("TalkEditorApp", "&Remove All Talks"))

        # --- End Menubar

        #
        # TalkDetailsWidget
        #
        self.talkDetailsWidget.titleLabel.setText(
            self.app.translate("TalkEditorApp", "Title"))
        self.talkDetailsWidget.presenterLabel.setText(
            self.app.translate("TalkEditorApp", "Presenter"))
        self.talkDetailsWidget.categoryLabel.setText(
            self.app.translate("TalkEditorApp", "Category"))
        self.talkDetailsWidget.eventLabel.setText(
            self.app.translate("TalkEditorApp", "Event"))
        self.talkDetailsWidget.roomLabel.setText(
            self.app.translate("TalkEditorApp", "Room"))
        self.talkDetailsWidget.dateLabel.setText(
            self.app.translate("TalkEditorApp", "Date"))
        self.talkDetailsWidget.startTimeLabel.setText(
            self.app.translate("TalkEditorApp", "Start Time"))
        self.talkDetailsWidget.endTimeLabel.setText(
            self.app.translate("TalkEditorApp", "End Time"))
        # --- End TalkDetailsWidget

        #
        # Import Talks Widget Translations
        #
        self.importTalksWidget.rssRadioButton.setText(
            self.app.translate("TalkEditorApp", "RSS URL"))
        self.importTalksWidget.csvRadioButton.setText(
            self.app.translate("TalkEditorApp", "CSV File"))
        self.importTalksWidget.importButton.setText(
            self.app.translate("TalkEditorApp", "Import"))
        # --- End Talks Widget Translations

        #
        # Command Button Translations\
        #
        self.commandButtons.importButton.setText(
            self.app.translate("TalkEditorApp", "Import"))
        self.commandButtons.exportButton.setText(
            self.app.translate("TalkEditorApp", "Export"))
        self.commandButtons.addButton.setText(
            self.app.translate("TalkEditorApp", "Add New Talk"))
        self.commandButtons.removeButton.setText(
            self.app.translate("TalkEditorApp", "Remove"))
        self.commandButtons.removeAllButton.setText(
            self.app.translate("TalkEditorApp", "Remove All"))
        # --- End Command Butotn Translations

        #
        # Search Widget Translations
        #
        self.commandButtons.searchButton.setText(
            self.app.translate("TalkEditorApp", "Search"))
        # --- End Command Button Translations

    def load_presentations_model(self):
        # Load Presentation Model
        self.presentationModel = self.db.get_presentations_model()
        self.proxy = QSortFilterProxyModel()
        self.proxy.setSourceModel(self.presentationModel)
        self.tableView.setModel(self.proxy)
        self.proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)

        # Fill table whitespace.
        self.tableView.horizontalHeader().setStretchLastSection(False)
        self.tableView.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)

        # Hide the ID field
        self.tableView.setColumnHidden(0, True)

        # Map data to widgets
        self.mapper = QDataWidgetMapper()
        self.mapper.setModel(self.proxy)
        self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
        self.mapper.addMapping(self.talkDetailsWidget.titleLineEdit, 1)
        self.mapper.addMapping(self.talkDetailsWidget.presenterLineEdit, 2)
        self.mapper.addMapping(self.talkDetailsWidget.categoryLineEdit, 4)
        self.mapper.addMapping(self.talkDetailsWidget.eventLineEdit, 5)
        self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6)
        self.mapper.addMapping(self.talkDetailsWidget.descriptionTextEdit, 3)
        self.mapper.addMapping(self.talkDetailsWidget.dateEdit, 7)
        self.mapper.addMapping(self.talkDetailsWidget.startTimeEdit, 8)
        self.mapper.addMapping(self.talkDetailsWidget.endTimeEdit, 9)

        # Load StringLists
        self.titleList = QStringList(self.db.get_string_list("Title"))
        #self.speakerList = QStringList(self.db.get_speaker_list())
        #self.categoryList = QStringList(self.db.get_category_list())
        #self.eventList = QStringList(self.db.get_event_list())
        #self.roomList = QStringList(self.db.get_room_list())

        #Disble input
        self.talkDetailsWidget.disable_input_fields()

    def search_talks(self):
        # The default value is 0. If the value is -1, the keys will be read from all columns.
        self.proxy.setFilterKeyColumn(-1)
        self.proxy.setFilterFixedString(
            self.commandButtons.searchLineEdit.text())

    def show_save_prompt(self):
        """Prompts the user to save or discard changes, or continue editing."""
        self.savePromptBox.exec_()
        self.savePromptBox.setDefaultButton(self.saveButton)
        return self.savePromptBox.clickedButton()

    def click_talk(self, model):
        """Warns user if there are unsaved changes, and selects talk clicked by the user."""
        log.info("Selecting row %d", model.row())
        modelRow = model.row()
        if self.unsaved_details_exist():
            log.info("Unsaved changes exist in row %d",
                     self.currentTalkIndex.row())
            confirm = self.show_save_prompt()
            if confirm == self.saveButton:
                log.info("Saving changes in row %d...",
                         self.currentTalkIndex.row())
                self.tableView.selectRow(self.currentTalkIndex.row())
                self.update_talk()
                newModel = self.tableView.currentIndex().sibling(modelRow, 0)
                self.select_talk(newModel)
            elif confirm == self.discardButton:
                log.info("Discarding changes in row %d...",
                         self.currentTalkIndex.row())
                self.talk_selected(model)
            else:
                log.info("Continue editing row %d",
                         self.currentTalkIndex.row())
                self.tableView.selectRow(self.currentTalkIndex.row())
        else:
            self.talk_selected(model)

    def click_add_button(self):
        """Warns user if there are unsaved changes, and shows the New Talk window."""
        if self.unsaved_details_exist():
            log.info("Unsaved changes exist in row %d",
                     self.currentTalkIndex.row())
            confirm = self.show_save_prompt()
            if confirm == self.saveButton:
                log.info("Saving changes in row %d...",
                         self.currentTalkIndex.row())
                self.update_talk()
                self.show_new_talk_popup()
            elif confirm == self.discardButton:
                log.info("Discarding changes in row %d...",
                         self.currentTalkIndex.row())
                # Ensure that changes are discarded
                self.talk_selected(self.currentTalkIndex)
                self.show_new_talk_popup()
            else:
                log.info("Continue editing row %d",
                         self.currentTalkIndex.row())
        else:
            self.show_new_talk_popup()

    def talk_selected(self, model):
        self.mapper.setCurrentIndex(model.row())
        self.talkDetailsWidget.enable_input_fields()
        self.talkDetailsWidget.saveButton.setEnabled(False)
        self.currentTalkIndex = QPersistentModelIndex(model)

    def toggle_import(self):
        if self.importTalksWidget.csvRadioButton.isChecked():
            self.importTalksWidget.csvLineEdit.setEnabled(True)
            self.importTalksWidget.csvFileSelectButton.setEnabled(True)
            self.importTalksWidget.rssLineEdit.setEnabled(False)
        else:
            self.importTalksWidget.csvLineEdit.setEnabled(False)
            self.importTalksWidget.csvFileSelectButton.setEnabled(False)
            self.importTalksWidget.rssLineEdit.setEnabled(True)

    def show_import_talks_widget(self):
        self.commandButtons.setHidden(True)
        self.tableView.setHidden(True)
        self.talkDetailsWidget.setHidden(True)
        self.importTalksWidget.setHidden(False)

    def hide_import_talks_widget(self):
        self.commandButtons.setHidden(False)
        self.tableView.setHidden(False)
        self.talkDetailsWidget.setHidden(False)
        self.importTalksWidget.setHidden(True)

    def add_talk(self):
        """Adds a new talk to the database using data from the NewTalkWidget input fields"""
        presentation = self.create_presentation(
            self.newTalkWidget.talkDetailsWidget)

        if presentation:
            self.db.insert_presentation(presentation)
            self.newTalkWidget.accept()  # Close the dialog

    def update_talk(self):
        """Updates the currently selected talk using data from the TalkEditorApp input fields"""
        selected_talk = self.tableView.currentIndex()
        if selected_talk.row(
        ) >= 0:  # The tableView index begins at 0 and is -1 by default
            talk_id = selected_talk.sibling(selected_talk.row(),
                                            0).data().toString()
            presentation = self.create_presentation(self.talkDetailsWidget)

            if presentation:
                self.db.update_presentation(talk_id, presentation)
                self.apply_changes(selected_talk)
                self.talkDetailsWidget.saveButton.setEnabled(False)

    def create_presentation(self, talkDetailsWidget):
        """Creates and returns an instance of Presentation using data from the input fields"""
        date = talkDetailsWidget.dateEdit.date()
        startTime = talkDetailsWidget.startTimeEdit.time()
        endTime = talkDetailsWidget.endTimeEdit.time()

        title = unicode(talkDetailsWidget.titleLineEdit.text()).strip()
        if title:
            return Presentation(
                unicode(talkDetailsWidget.titleLineEdit.text()).strip(),
                unicode(talkDetailsWidget.presenterLineEdit.text()).strip(),
                unicode(talkDetailsWidget.descriptionTextEdit.toPlainText()).
                strip(),
                unicode(talkDetailsWidget.categoryLineEdit.text()).strip(),
                unicode(talkDetailsWidget.eventLineEdit.text()).strip(),
                unicode(talkDetailsWidget.roomLineEdit.text()).strip(),
                unicode(date.toString(Qt.ISODate)),
                unicode(startTime.toString(Qt.ISODate)),
                unicode(endTime.toString(Qt.ISODate)))

    def show_new_talk_popup(self):
        """Displays a modal dialog with a talk details view

        When Add is selected, a new talk is added to the database using the input field data.
        When Cancel is selected, no talk is added.
        """
        log.info('Opening Add Talk window...')
        self.clear_new_talk_fields()
        self.remove_new_talk_placeholder_text()
        self.newTalkWidget.talkDetailsWidget.titleLineEdit.setFocus()
        if self.newTalkWidget.exec_() == 1:
            self.apply_changes()
            self.talkDetailsWidget.disable_input_fields()
        else:
            log.info('No talk added...')

    def apply_changes(self, updated_talk=None):
        """Repopulates the model to display the effective changes

        Updates the autocomplete fields.
        Displays the updated model in the table view, and selects the newly updated/added talk.
        """
        self.presentationModel.select()
        self.select_talk(updated_talk)
        self.update_autocomplete_fields()

    def select_talk(self, talk=None):
        """Selects the given talk in the table view

        If no talk is given, the last row in the table view is selected.
        """
        if talk:
            row = talk.row()
            column = talk.column()
        else:
            row = self.presentationModel.rowCount() - 1  # Select last row
            column = 0

        self.tableView.selectRow(row)
        self.tableView.setCurrentIndex(self.proxy.index(row, column))
        self.talk_selected(self.proxy.index(row, column))

    def remove_talk(self):
        try:
            rows_selected = self.tableView.selectionModel().selectedRows()
        except:
            return

        # Reversed because rows in list change position once row is removed
        for row in reversed(rows_selected):
            self.presentationModel.removeRow(row.row())
        self.talkDetailsWidget.clear_input_fields()
        self.talkDetailsWidget.disable_input_fields()

    def load_talk(self):
        try:
            self.tableView.currentIndex().row()
        except:
            return

        self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6)
        self.presentationModel.select()

    def reset(self):
        self.db.clear_database()
        self.presentationModel.select()
        self.talkDetailsWidget.clear_input_fields()
        self.talkDetailsWidget.disable_input_fields()

    def confirm_reset(self):
        """Presents a confirmation dialog to ask the user if they are sure they wish to remove the talk database.
        If Yes call the reset() function"""
        confirm = QMessageBox.question(self, self.confirmDBClearTitleString,
                                       self.confirmDBClearQuestionString,
                                       QMessageBox.Yes | QMessageBox.No,
                                       QMessageBox.No)

        if confirm == QMessageBox.Yes:
            self.reset()

    def add_talks_from_rss(self):
        rss_url = unicode(self.importTalksWidget.rssLineEdit.text())
        if rss_url:
            self.db.add_talks_from_rss(rss_url)
            self.presentationModel.select()
            self.hide_import_talks_widget()
        else:
            error = QMessageBox()
            error.setText("Please enter a RSS URL")
            error.exec_()

    def closeEvent(self, event):
        if self.unsaved_details_exist():
            log.info("Unsaved changes exist in row %d",
                     self.currentTalkIndex.row())
            confirm = self.show_save_prompt()
            if confirm == self.saveButton:
                log.info("Saving changes in row %d...",
                         self.currentTalkIndex.row())
                self.update_talk()
                log.info('Exiting talk database editor...')
                self.geometry = self.saveGeometry()
                event.accept()
            elif confirm == self.discardButton:
                log.info("Discarding changes in row %d...",
                         self.currentTalkIndex.row())
                # Ensure that changes are discarded
                self.talk_selected(self.currentTalkIndex)
                log.info('Exiting talk database editor...')
                self.geometry = self.saveGeometry()
                event.accept()
            else:
                log.info("Continue editing row %d",
                         self.currentTalkIndex.row())
                event.ignore()
        else:
            log.info('Exiting talk database editor...')
            self.geometry = self.saveGeometry()
            event.accept()

    def csv_file_select(self):
        fname = QFileDialog.getOpenFileName(self, 'Select file', "", "*.csv")
        if fname:
            self.importTalksWidget.csvLineEdit.setText(fname)

    def add_talks_from_csv(self):
        fname = self.importTalksWidget.csvLineEdit.text()

        if fname:
            self.db.add_talks_from_csv(fname)
            self.presentationModel.select()
            self.hide_import_talks_widget()
        else:
            error = QMessageBox()
            error.setText("Please select a file")
            error.exec_()

    def import_talks(self):
        if self.importTalksWidget.csvRadioButton.isChecked():
            self.add_talks_from_csv()
        else:
            self.add_talks_from_rss()

        self.update_autocomplete_fields()

    def export_talks_to_csv(self):
        fname = QFileDialog.getSaveFileName(self, 'Select file', "", "*.csv")
        if fname:
            self.db.export_talks_to_csv(fname)

    def update_autocomplete_fields(self):
        self.titleList = QStringList(self.db.get_string_list("Title"))
        self.speakerList = QStringList(self.db.get_string_list("Speaker"))
        self.categoryList = QStringList(self.db.get_string_list("Category"))
        self.eventList = QStringList(self.db.get_string_list("Event"))
        self.roomList = QStringList(self.db.get_string_list("Room"))

        self.titleCompleter = QCompleter(self.titleList)
        self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.speakerCompleter = QCompleter(self.speakerList)
        self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.categoryCompleter = QCompleter(self.categoryList)
        self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.eventCompleter = QCompleter(self.eventList)
        self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.roomCompleter = QCompleter(self.roomList)
        self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive)

        self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter)
        self.talkDetailsWidget.presenterLineEdit.setCompleter(
            self.speakerCompleter)
        self.talkDetailsWidget.categoryLineEdit.setCompleter(
            self.categoryCompleter)
        self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter)
        self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter)

    def are_fields_enabled(self):
        return (self.talkDetailsWidget.titleLineEdit.isEnabled()
                and self.talkDetailsWidget.presenterLineEdit.isEnabled()
                and self.talkDetailsWidget.categoryLineEdit.isEnabled()
                and self.talkDetailsWidget.eventLineEdit.isEnabled()
                and self.talkDetailsWidget.roomLineEdit.isEnabled()
                and self.talkDetailsWidget.dateEdit.isEnabled()
                and self.talkDetailsWidget.startTimeEdit.isEnabled()
                and self.talkDetailsWidget.endTimeEdit.isEnabled())

    def unsaved_details_exist(self):
        """Checks if changes have been made to new/existing talk details

        Looks for text in the input fields and check the enabled state of the Save Talk button
        If the Save Talk button is enabled, the input fields contain modified values
        """
        return (self.talkDetailsWidget.saveButton.isEnabled() and
                (self.talkDetailsWidget.titleLineEdit.text()
                 or self.talkDetailsWidget.presenterLineEdit.text()
                 or self.talkDetailsWidget.categoryLineEdit.text()
                 or self.talkDetailsWidget.descriptionTextEdit.toPlainText()))

    def enable_save(self):
        self.talkDetailsWidget.saveButton.setEnabled(True)

    def clear_new_talk_fields(self):
        """Removes existing data from all NewTalkWidget fields except event, room, date and time"""
        self.newTalkWidget.talkDetailsWidget.titleLineEdit.clear()
        self.newTalkWidget.talkDetailsWidget.presenterLineEdit.clear()
        self.newTalkWidget.talkDetailsWidget.descriptionTextEdit.clear()
        self.newTalkWidget.talkDetailsWidget.categoryLineEdit.clear()

    def remove_new_talk_placeholder_text(self):
        """Removes placeholder text in NewTalkWidget originally set by TalkDetailsWidget"""
        self.newTalkWidget.talkDetailsWidget.titleLineEdit.setPlaceholderText(
            "")
        self.newTalkWidget.talkDetailsWidget.presenterLineEdit.setPlaceholderText(
            "")
        self.newTalkWidget.talkDetailsWidget.categoryLineEdit.setPlaceholderText(
            "")
        self.newTalkWidget.talkDetailsWidget.eventLineEdit.setPlaceholderText(
            "")
        self.newTalkWidget.talkDetailsWidget.roomLineEdit.setPlaceholderText(
            "")
예제 #58
0
class ManualInstallWidget(QWidget):
    """Manually Installed plugins widget"""
    def __init__(self, parent):
        super(ManualInstallWidget, self).__init__()
        self._parent = parent
        vbox = QVBoxLayout(self)
        form = QFormLayout()
        self._txtName = QLineEdit()
        self._txtName.setPlaceholderText('my_plugin')
        self._txtVersion = QLineEdit()
        self._txtVersion.setPlaceholderText('0.1')
        form.addRow(translations.TR_PROJECT_NAME, self._txtName)
        form.addRow(translations.TR_VERSION, self._txtVersion)
        vbox.addLayout(form)
        hPath = QHBoxLayout()
        self._txtFilePath = QLineEdit()
        self._txtFilePath.setPlaceholderText(
            os.path.join(os.path.expanduser('~'), 'full', 'path', 'to',
                         'plugin.zip'))
        self._btnFilePath = QPushButton(QIcon(":img/open"), '')
        self.completer, self.dirs = QCompleter(self), QDirModel(self)
        self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
        self.completer.setModel(self.dirs)
        self._txtFilePath.setCompleter(self.completer)
        hPath.addWidget(QLabel(translations.TR_FILENAME))
        hPath.addWidget(self._txtFilePath)
        hPath.addWidget(self._btnFilePath)
        vbox.addLayout(hPath)
        vbox.addSpacerItem(
            QSpacerItem(0, 1, QSizePolicy.Expanding, QSizePolicy.Expanding))

        hbox = QHBoxLayout()
        hbox.addSpacerItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
        self._btnInstall = QPushButton(translations.TR_INSTALL)
        hbox.addWidget(self._btnInstall)
        vbox.addLayout(hbox)

        # Signals
        self.connect(self._btnFilePath, SIGNAL("clicked()"),
                     self._load_plugin_path)
        self.connect(self._btnInstall, SIGNAL("clicked()"),
                     self.install_plugin)

    def _load_plugin_path(self):
        """Ask the user a plugin filename"""
        path = QFileDialog.getOpenFileName(self,
                                           translations.TR_SELECT_PLUGIN_PATH)
        if path:
            self._txtFilePath.setText(path)

    def install_plugin(self):
        """Install a plugin manually"""
        if self._txtFilePath.text() and self._txtName.text():
            plug = []
            plug.append(self._txtName.text())
            plug.append(self._txtVersion.text())
            plug.append('')
            plug.append('')
            plug.append('')
            plug.append(self._txtFilePath.text())
            self._parent.install_plugins_manually([plug])
예제 #59
0
class MainWidget(QWidget, PM, Ui_MainWidget):
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)

        self.setupUi(self)
        self.parent = parent

        self._selectedGroups = []
        self._preexceptions = []
        self._postexceptions = []

        self.state = StateManager(self)
        self.currentState = None
        self.completer = None
        self._updatesCheckedOnce = False

        # Search Thread
        self._searchThread = PThread(self, self.startSearch,
                                     self.searchFinished)

        self.statusUpdater = StatusUpdater()
        self.basket = BasketDialog(self.state, self.parent)
        self._postexceptions.append(lambda: self.basket.setActionEnabled(True))
        self.searchButton.setIcon(KIcon(("edit-find", "find")))
        self.initializeUpdateTypeList()

        model = PackageModel(self)
        proxy = PackageProxy(self)
        proxy.setSourceModel(model)
        self.packageList.setModel(proxy)
        self.packageList.setItemDelegate(PackageDelegate(self, self.parent))
        self.packageList.setColumnWidth(0, 32)

        self.connect(self.packageList.model(),
                     SIGNAL("dataChanged(QModelIndex,QModelIndex)"),
                     self.statusChanged)
        self.connect(self.packageList, SIGNAL("updateRequested()"),
                     self.initialize)

        self.updateSettings()
        self.setActionButton()

        self.operation = OperationManager(self.state)

        self.progressDialog = ProgressDialog(self.state, self.parent)
        self._preexceptions.append(self.progressDialog._hide)
        self.progressDialog.registerFunction(
            FINISHED, lambda: self.parent.statusBar().setVisible(
                not self.progressDialog.isVisible()))
        self.progressDialog.registerFunction(
            OUT, lambda: self.parent.statusBar().show())
        self.summaryDialog = SummaryDialog()

        self.connectOperationSignals()
        self.pdsMessageBox = PMessageBox(self.content)

    def connectMainSignals(self):
        self.connect(self.actionButton, SIGNAL("clicked()"), self.showBasket)
        self.connect(self.checkUpdatesButton, SIGNAL("clicked()"),
                     self.state.updateRepoAction)
        self.connect(self.searchButton, SIGNAL("clicked()"),
                     self.searchActivated)
        self.connect(self.searchLine, SIGNAL("textEdited(const QString&)"),
                     self.searchLineChanged)
        self.connect(self.searchLine, SIGNAL("returnPressed()"),
                     self.searchActivated)
        self.connect(self.searchLine, SIGNAL("clearButtonClicked()"),
                     self.groupFilter)
        self.connect(self.typeCombo, SIGNAL("activated(int)"), self.typeFilter)
        self.connect(self.stateTab, SIGNAL("currentChanged(int)"),
                     self.switchState)
        self.connect(self.groupList, SIGNAL("groupChanged()"),
                     self.groupFilter)
        self.connect(self.groupList, SIGNAL("groupChanged()"),
                     lambda: self.searchButton.setEnabled(False))
        self.connect(self.packageList.select_all, SIGNAL("clicked(bool)"),
                     self.toggleSelectAll)
        self.connect(self.statusUpdater,
                     SIGNAL("selectedInfoChanged(int, QString, int, QString)"),
                     self.emitStatusBarInfo)
        self.connect(
            self.statusUpdater, SIGNAL("selectedInfoChanged(QString)"),
            lambda message: self.emit(
                SIGNAL("selectionStatusChanged(QString)"), message))
        self.connect(self.statusUpdater, SIGNAL("finished()"),
                     self.statusUpdated)

    def initialize(self):
        waitCursor()
        self.searchLine.clear()
        self._started = False
        self._last_packages = None
        self.state.reset()
        self.initializePackageList()
        self.initializeGroupList()
        self.initializeStatusUpdater()
        self.statusChanged()
        self._selectedGroups = []
        self.packageList.select_all.setChecked(False)
        self.initializeBasket()
        self.searchLine.setFocus(True)
        if self.currentState == self.state.UPGRADE:
            if self.groupList.count() == 0:
                QTimer.singleShot(0, \
                lambda: self.pdsMessageBox.showMessage(i18n("All packages are up to date"), icon = "info"))
        if self.groupList.count() > 0:
            if self.state.inUpgrade():
                self.pdsMessageBox.hideMessage(force=True)
        restoreCursor()

    def initializeStatusUpdater(self):
        self.statusUpdater.calculate_deps = not self.state.state == self.state.ALL
        self.statusUpdater.setModel(self.packageList.model().sourceModel())

    def initializeBasket(self):
        waitCursor()
        self.basket.setModel(self.packageList.model().sourceModel())
        restoreCursor()

    def initializePackageList(self):
        self.packageList.model().reset()
        self.packageList.setPackages(self.state.packages())

        if self.completer:
            self.completer.deleteLater()
            del self.completer

        self.completer = QCompleter(self.state.packages(), self)
        self.completer.setCaseSensitivity(Qt.CaseInsensitive)
        self.searchLine.setCompleter(self.completer)

    def selectComponent(self, component):
        if not self.state.iface.operationInProgress():
            if self.basket.isVisible():
                self.basket._hide()

            self.stateTab.setCurrentIndex(1)
            self.switchState(self.state.INSTALL)

            if component in self.groupList._list:
                self.groupList.setCurrentItem(self.groupList._list[component])
                self.groupFilter()

    def updateSettings(self):
        self.packageList.showComponents = PMConfig().showComponents()
        self.packageList.showIsA = PMConfig().showIsA()
        self.packageList.setFocus()

    def searchLineChanged(self, text):
        self.searchButton.setEnabled(bool(text))
        if text == '':
            self.searchActivated()

    def statusUpdated(self):
        if self.statusUpdater.needsUpdate:
            self.statusUpdater.needsUpdate = False
            self.statusChanged()

    def statusChanged(self):
        self.setActionEnabled()
        if self.statusUpdater.isRunning():
            self.statusUpdater.needsUpdate = True
        else:
            self.emit(SIGNAL("updatingStatus()"))
            self.statusUpdater.start()

    def initializeGroupList(self):
        self.groupList.clear()
        self.groupList._list = {}
        self.groupList.setAlternatingRowColors(True)
        self.groupList.setIconSize(QSize(32, 32))
        self.groupList.setState(self.state)
        self.groupList.addGroups(self.state.groups())
        if self.state.state == self.state.UPGRADE:
            self.typeCombo.show()
        else:
            self.typeCombo.hide()
            self.state._typeFilter = 'normal'
        self.groupFilter()

    def packageFilter(self, text):
        self.packageList.model().setFilterRole(Qt.DisplayRole)
        self.packageList.model().setFilterRegExp(
            QRegExp(unicode(text), Qt.CaseInsensitive, QRegExp.FixedString))

    def typeFilter(self, index):
        if self.state.state == self.state.UPGRADE:
            filter = self.typeCombo.itemData(index).toString()
            if not self.state._typeFilter == filter:
                self.state._typeFilter = filter
                self.initializeGroupList()

    def groupFilter(self):
        waitCursor()
        self.packageList.resetMoreInfoRow()
        packages = self.state.groupPackages(self.groupList.currentGroup())
        self.packageList.model().setFilterRole(GroupRole)
        self.packageList.model().setFilterPackages(packages)
        self.packageList.scrollToTop()
        self.packageList.select_all.setChecked(
            self.groupList.currentGroup() in self._selectedGroups)
        restoreCursor()

    def searchActivated(self):
        if self.currentState == self.state.UPGRADE:
            if self.groupList.count() == 0 and not self.searchUsed:
                return

        if not self.searchLine.text() == '':
            self.pdsMessageBox.showMessage(i18n("Searching..."), busy=True)
            self.groupList.lastSelected = None
            self._searchThread.start()
            self.searchUsed = True
        else:
            self.state.cached_packages = None
            self.state.packages()
            self.searchUsed = False
            self.searchFinished()

    def searchFinished(self):
        if self.state.cached_packages == []:
            self.pdsMessageBox.showMessage(i18n("No results found."),
                                           "dialog-information")
        else:
            self.pdsMessageBox.hideMessage()
        self.initializeGroupList()

    def startSearch(self):
        searchText = str(self.searchLine.text()).split()
        sourceModel = self.packageList.model().sourceModel()
        self.state.cached_packages = sourceModel.search(searchText)

    def setActionButton(self):
        self.actionButton.setEnabled(False)
        if self.state.state == self.state.ALL:
            menu = QMenu(self.actionButton)
            self.__install_action = menu.addAction(
                self.state.getActionIcon(self.state.INSTALL),
                self.state.getActionName(self.state.INSTALL), self.showBasket)
            self.__remove_action = menu.addAction(
                self.state.getActionIcon(self.state.REMOVE),
                self.state.getActionName(self.state.REMOVE), self.showBasket)
            self.actionButton.setMenu(menu)
        else:
            self.actionButton.setMenu(None)
        self.actionButton.setIcon(self.state.getActionIcon())
        self.actionButton.setText(self.state.getActionName())

    def actionStarted(self, operation):
        self.pdsMessageBox.hideMessage()
        self.progressDialog.reset()
        if not operation in [
                "System.Manager.updateRepository",
                "System.Manager.updateAllRepositories"
        ]:
            totalPackages = self.packageList.packageCount()
            self.operation.setTotalPackages(totalPackages)
            self.progressDialog.updateStatus(0, totalPackages,
                                             self.state.toBe())
        if self.isVisible():
            if operation in [
                    "System.Manager.updateRepository",
                    "System.Manager.updateAllRepositories"
            ]:
                self.progressDialog.repoOperationView()
            if self.basket.isVisible():
                self.basket._hide()
                QTimer.singleShot(0, self.progressDialog._show)
            else:
                self.progressDialog._show()

        if not self._started:
            self.progressDialog.disableCancel()
        else:
            self.progressDialog.enableCancel()

    def actionFinished(self, operation):
        if operation in ("System.Manager.installPackage",
                         "System.Manager.removePackage",
                         "System.Manager.updatePackage"):
            self.notifyFinished()

        if operation == "System.Manager.installPackage" and self._started:
            KIconLoader.updateAvailableIcons()
            self.summaryDialog.setDesktopFiles(self.operation.desktopFiles)
            self.summaryDialog.showSummary()

        if operation in ("System.Manager.updateRepository",
                         "System.Manager.updateAllRepositories"):
            self.emit(SIGNAL("repositoriesUpdated()"))
        self.searchLine.clear()
        self.state.reset()
        self.progressDialog._hide()
        if not self.currentState == self.state.UPGRADE:
            self.switchState(self.currentState)
        self.initialize()

    def actionCancelled(self):
        self.progressDialog._hide()
        self.progressDialog.reset()
        self.switchState(self.currentState)
        self.groupFilter()

    def setActionEnabled(self):
        enabled = self.packageList.isSelected()
        self.actionButton.setEnabled(enabled)
        self.basket.setActionEnabled(enabled)

    def switchState(self, state):
        self.pdsMessageBox.hideMessage()
        self._states[state][1].setChecked(True)
        self.state.setState(state)
        self.currentState = state
        self._selectedGroups = []
        if not state == self.state.HISTORY:
            self.setActionButton()
            self.state.cached_packages = None
            if state == self.state.UPGRADE or (state == self.state.INSTALL and
                                               self.groupList.count() == 1):
                if not self._updatesCheckedOnce:
                    self._updatesCheckedOnce = self.state.updateRepoAction(
                        silence=True)
            self.checkUpdatesButton.setHidden(not state == self.state.UPGRADE)
            self.initialize()

    def emitStatusBarInfo(self, packages, packagesSize, extraPackages,
                          extraPackagesSize):
        self.emit(
            SIGNAL("selectionStatusChanged(QString)"),
            self.state.statusText(packages, packagesSize, extraPackages,
                                  extraPackagesSize))

    def setSelectAll(self, packages=None):
        if packages:
            self.packageList.reverseSelection(packages)

    def setReverseAll(self, packages=None):
        if packages:
            self.packageList.selectAll(packages)

    def toggleSelectAll(self, toggled):
        self._last_packages = self.packageList.model().getFilteredPackages()

        if toggled:
            if self.groupList.currentGroup() not in self._selectedGroups:
                self._selectedGroups.append(self.groupList.currentGroup())
            self.setReverseAll(self._last_packages)
        else:
            if self.groupList.currentGroup() in self._selectedGroups:
                self._selectedGroups.remove(self.groupList.currentGroup())
            self.setSelectAll(self._last_packages)

        self.packageList.setFocus()
        self.statusChanged()

    def showBasket(self):

        if self.basket.isVisible():
            return

        waitCursor()
        self.statusUpdater.wait()

        if self.currentState == self.state.ALL:
            action = {
                self.__remove_action: self.state.REMOVE,
                self.__install_action: self.state.INSTALL
            }.get(self.sender(), self.state.INSTALL)
            if action:
                if action == self.state.REMOVE:
                    installed_packages = self.state.iface.getInstalledPackages(
                    )
                    filtered_packages = filter(
                        lambda x: x not in installed_packages,
                        self.basket.model.selectedPackages())
                    if filtered_packages == self.basket.model.selectedPackages(
                    ):
                        restoreCursor()
                        QMessageBox(
                            i18n("Select packages"),
                            i18n(
                                "You must select at least one installed package"
                            ), QMessageBox.Information, QMessageBox.Ok, 0,
                            0).exec_()
                        return
                    self.packageList.model().sourceModel().selectPackages(
                        filtered_packages, state=False)

                self.state.state = action

        self.basket._show()
        restoreCursor()

    def initializeUpdateTypeList(self):
        self.typeCombo.clear()
        UPDATE_TYPES = [[
            'normal',
            i18n('All Updates'), ('system-software-update', 'ledgreen')
        ],
                        [
                            'security',
                            i18n('Security Updates'),
                            ('security-medium', 'ledyellow')
                        ],
                        [
                            'critical',
                            i18n('Critical Updates'),
                            ('security-low', 'ledred')
                        ]]

        for type in UPDATE_TYPES:
            self.typeCombo.addItem(KIcon(type[2]), type[1], QVariant(type[0]))
예제 #60
0
class AddNewLot(ParentManage):
    def __init__(self, iface, settings, controller, plugin_dir):
        """ Class to control 'Add basic visit' of toolbar 'edit' """
        ParentManage.__init__(self, iface, settings, controller, plugin_dir)
        self.ids = []

    def manage_lot(self, lot_id=None, is_new=True, visitclass_id=None):
        # turnoff autocommit of this and base class. Commit will be done at dialog button box level management
        self.autocommit = True
        self.remove_ids = False
        self.is_new_lot = is_new
        self.chk_position = 5  # Variable used to set the position of the QCheckBox in the relations table

        # Get layers of every geom_type
        self.reset_lists()
        self.reset_layers()
        self.layers['arc'] = [
            self.controller.get_layer_by_tablename('v_edit_arc')
        ]
        self.layers['node'] = [
            self.controller.get_layer_by_tablename('v_edit_node')
        ]
        self.layers['connec'] = [
            self.controller.get_layer_by_tablename('v_edit_connec')
        ]

        # Remove 'gully' for 'WS'
        if self.controller.get_project_type() != 'ws':
            self.layers['gully'] = self.controller.get_group_layers('gully')

        self.dlg_lot = AddLot()
        self.load_settings(self.dlg_lot)
        self.dropdown = self.dlg_lot.findChild(QToolButton, 'action_selector')
        self.dropdown.setPopupMode(QToolButton.MenuButtonPopup)

        # Create action and put into QToolButton
        action_by_expression = self.create_action('action_by_expression',
                                                  self.dlg_lot.action_selector,
                                                  '204',
                                                  'Select by expression')
        action_by_polygon = self.create_action('action_by_polygon',
                                               self.dlg_lot.action_selector,
                                               '205', 'Select by polygon')
        self.dropdown.addAction(action_by_expression)
        self.dropdown.addAction(action_by_polygon)
        self.dropdown.setDefaultAction(action_by_expression)

        self.dlg_lot.open()

        # Set icons
        self.set_icon(self.dlg_lot.btn_feature_insert, "111")
        self.set_icon(self.dlg_lot.btn_feature_delete, "112")
        self.set_icon(self.dlg_lot.btn_feature_snapping, "137")

        self.lot_id = self.dlg_lot.findChild(QLineEdit, "lot_id")
        self.id_val = self.dlg_lot.findChild(QLineEdit, "txt_idval")
        self.user_name = self.dlg_lot.findChild(QLineEdit, "user_name")
        self.visit_class = self.dlg_lot.findChild(QComboBox, "cmb_visit_class")

        # Tab 'Relations'
        self.feature_type = self.dlg_lot.findChild(QComboBox, "feature_type")
        self.tbl_relation = self.dlg_lot.findChild(QTableView, "tbl_relation")
        utils_giswater.set_qtv_config(self.tbl_relation)
        utils_giswater.set_qtv_config(self.dlg_lot.tbl_visit)
        self.feature_type.setEnabled(False)

        # Fill QWidgets of the form
        self.fill_fields()

        new_lot_id = lot_id
        if lot_id is None:
            new_lot_id = self.get_next_id('om_visit_lot', 'id')
        utils_giswater.setWidgetText(self.dlg_lot, self.lot_id, new_lot_id)

        self.geom_type = utils_giswater.get_item_data(self.dlg_lot,
                                                      self.visit_class,
                                                      2).lower()
        viewname = "v_edit_" + self.geom_type
        self.set_completer_feature_id(self.dlg_lot.feature_id, self.geom_type,
                                      viewname)
        self.clear_selection()

        # Set actions signals
        action_by_expression.triggered.connect(
            partial(self.activate_selection, self.dlg_lot,
                    action_by_expression, 'mActionSelectByExpression'))
        action_by_polygon.triggered.connect(
            partial(self.activate_selection, self.dlg_lot, action_by_polygon,
                    'mActionSelectPolygon'))

        # Set widgets signals
        self.dlg_lot.btn_feature_insert.clicked.connect(
            partial(self.insert_row))
        self.dlg_lot.btn_feature_delete.clicked.connect(
            partial(self.remove_selection, self.dlg_lot, self.tbl_relation))
        self.dlg_lot.btn_feature_snapping.clicked.connect(
            partial(self.set_active_layer))
        self.dlg_lot.btn_feature_snapping.clicked.connect(
            partial(self.selection_init, self.dlg_lot))
        self.dlg_lot.cmb_visit_class.currentIndexChanged.connect(
            self.set_feature_type_cmb)
        self.dlg_lot.cmb_visit_class.currentIndexChanged.connect(
            self.set_active_layer)
        self.dlg_lot.cmb_visit_class.currentIndexChanged.connect(
            partial(self.event_feature_type_selected, self.dlg_lot))
        self.dlg_lot.cmb_visit_class.currentIndexChanged.connect(
            partial(self.reload_table_visit))
        self.dlg_lot.txt_filter.textChanged.connect(
            partial(self.reload_table_visit))
        self.dlg_lot.date_event_from.dateChanged.connect(
            partial(self.reload_table_visit))
        self.dlg_lot.date_event_to.dateChanged.connect(
            partial(self.reload_table_visit))

        self.dlg_lot.tbl_relation.doubleClicked.connect(
            partial(self.zoom_to_feature))
        self.dlg_lot.btn_cancel.clicked.connect(partial(self.manage_rejected))
        self.dlg_lot.rejected.connect(partial(self.manage_rejected))
        self.dlg_lot.btn_accept.clicked.connect(partial(self.save_lot))

        self.set_headers(self.tbl_relation)

        if lot_id is not None:
            utils_giswater.set_combo_itemData(self.visit_class,
                                              str(visitclass_id), 0)
            self.geom_type = utils_giswater.get_item_data(
                self.dlg_lot, self.visit_class, 2).lower()
            self.set_values(lot_id)
            self.populate_table_relations(lot_id)
            self.update_id_list()
            sql = ("SELECT * FROM " + self.schema_name + ".om_visit_lot_x_" +
                   str(self.geom_type) + ""
                   " WHERE lot_id ='" + str(lot_id) + "'")
            rows = self.controller.get_rows(sql, log_sql=True)
            self.put_checkbox(self.tbl_relation, rows, 'status', 3)
            self.set_dates()
            self.reload_table_visit()

        self.enable_feature_type(self.dlg_lot)

        self.set_feature_type_cmb()
        # Set autocompleters of the form
        self.set_completers()

        # Set model signals
        self.tbl_relation.model().rowsInserted.connect(self.set_dates)
        self.tbl_relation.model().rowsInserted.connect(self.reload_table_visit)
        self.tbl_relation.model().rowsRemoved.connect(self.set_dates)
        self.tbl_relation.model().rowsRemoved.connect(self.reload_table_visit)

        # Open the dialog
        self.open_dialog(self.dlg_lot, dlg_name="add_lot")

    def test(self):
        self.controller.log_info(str("HOLAs"))

    def read_standaritemmodel(self, qtable):
        headers = self.get_headers(qtable)
        rows = []
        model = qtable.model()
        for x in range(0, model.rowCount()):
            row = {}
            for c in range(0, model.columnCount() - 1):
                index = model.index(x, c)
                item = model.data(index)
                row[headers[c]] = item

            widget_cell = qtable.model().index(x, self.chk_position)
            widget = qtable.indexWidget(widget_cell)
            chk_list = widget.findChildren(QCheckBox)
            if chk_list[0].isChecked():
                row['status'] = '3'
            rows.append(row)
        return rows

    def fill_fields(self):
        """ Fill combo boxes of the form """
        # Visit tab
        # Set current date and time
        current_date = QDate.currentDate()
        self.dlg_lot.startdate.setDate(current_date)
        self.dlg_lot.enddate.setDate(current_date)

        # Set current user
        sql = "SELECT current_user"
        row = self.controller.get_row(sql, commit=self.autocommit)
        utils_giswater.setWidgetText(self.dlg_lot, self.user_name, row[0])

        # Fill ComboBox cmb_visit_class
        sql = ("SELECT id, idval, feature_type"
               " FROM " + self.schema_name + ".om_visit_class "
               " WHERE ismultifeature is False"
               " ORDER BY idval")
        visitclass_ids = self.controller.get_rows(sql, commit=self.autocommit)
        if visitclass_ids:
            utils_giswater.set_item_data(self.dlg_lot.cmb_visit_class,
                                         visitclass_ids, 1)

        # Fill ComboBox cmb_assigned_to
        sql = ("SELECT id, idval"
               " FROM " + self.schema_name + ".cat_team "
               " WHERE active is True "
               " ORDER BY idval")
        users = self.controller.get_rows(sql, commit=self.autocommit)
        if users:
            utils_giswater.set_item_data(self.dlg_lot.cmb_assigned_to, users,
                                         1)

        # TODO fill combo with correct table
        # Fill ComboBox cmb_status
        sql = ("SELECT id, idval"
               " FROM " + self.schema_name + ".om_visit_class "
               " ORDER BY idval")
        status = self.controller.get_rows(sql, commit=self.autocommit)
        status = [(0, 'PLANIFICAT'), (1, 'EXITOS'), (2, 'FAIL'),
                  (3, 'VALIDAT')]
        if status:
            utils_giswater.set_item_data(self.dlg_lot.cmb_status,
                                         status,
                                         1,
                                         sort_combo=False)

        # Relations tab
        # fill feature_type
        sql = ("SELECT id, id"
               " FROM " + self.schema_name + ".sys_feature_type"
               " WHERE net_category = 1"
               " ORDER BY id")
        feature_type = self.controller.get_rows(sql,
                                                log_sql=False,
                                                commit=self.autocommit)
        if feature_type:
            utils_giswater.set_item_data(self.dlg_lot.feature_type,
                                         feature_type, 1)

    def get_next_id(self, table_name, pk):
        sql = ("SELECT max(" + pk + "::integer) FROM " + self.schema_name +
               "." + table_name + ";")
        row = self.controller.get_row(sql, log_sql=False)
        if not row or not row[0]:
            return 0
        else:
            return row[0] + 1

    def event_feature_type_selected(self, dialog):
        """Manage selection change in feature_type combo box.
        THis means that have to set completer for feature_id QTextLine and
        setup model for features to select table."""

        # 1) set the model linked to selecte features
        # 2) check if there are features related to the current visit
        # 3) if so, select them => would appear in the table associated to the model
        self.geom_type = self.feature_type.currentText().lower()

        viewname = "v_edit_" + self.geom_type
        self.set_completer_feature_id(dialog.feature_id, self.geom_type,
                                      viewname)

        # set table model and completer
        # set a fake where expression to avoid to set model to None
        # fake_filter = '{}_id IN ("-1")'.format(self.geom_type)
        # self.set_table_model(dialog, self.tbl_relation, self.geom_type, fake_filter)

        self.set_headers(self.tbl_relation)

    def clear_selection(self, remove_groups=True):
        """ Remove all previous selections """
        layer = self.controller.get_layer_by_tablename("v_edit_arc")
        if layer:
            layer.removeSelection()
        layer = self.controller.get_layer_by_tablename("v_edit_node")
        if layer:
            layer.removeSelection()
        layer = self.controller.get_layer_by_tablename("v_edit_connec")
        if layer:
            layer.removeSelection()
        layer = self.controller.get_layer_by_tablename("v_edit_element")
        if layer:
            layer.removeSelection()

        if self.project_type == 'ud':
            layer = self.controller.get_layer_by_tablename("v_edit_gully")
            if layer:
                layer.removeSelection()

        try:
            if remove_groups:
                for layer in self.layers['arc']:
                    layer.removeSelection()
                for layer in self.layers['node']:
                    layer.removeSelection()
                for layer in self.layers['connec']:
                    layer.removeSelection()
                for layer in self.layers['gully']:
                    layer.removeSelection()
                for layer in self.layers['element']:
                    layer.removeSelection()
        except:
            pass

        self.canvas.refresh()

    def set_values(self, lot_id):
        sql = ("SELECT * FROM " + self.schema_name + ".om_visit_lot "
               " WHERE id ='" + str(lot_id) + "'")
        lot = self.controller.get_row(sql, log_sql=False)
        if lot is not None:
            utils_giswater.setWidgetText(self.dlg_lot, 'txt_idval',
                                         lot['idval'])
            utils_giswater.setCalendarDate(self.dlg_lot, 'startdate',
                                           lot['startdate'])
            utils_giswater.setCalendarDate(self.dlg_lot, 'enddate',
                                           lot['enddate'])
            utils_giswater.set_combo_itemData(self.dlg_lot.cmb_visit_class,
                                              lot['visitclass_id'], 0)
            utils_giswater.set_combo_itemData(self.dlg_lot.cmb_assigned_to,
                                              lot['team_id'], 0)
            utils_giswater.setWidgetText(self.dlg_lot, 'descript',
                                         lot['descript'])
            utils_giswater.set_combo_itemData(self.dlg_lot.cmb_status,
                                              lot['status'], 0)
            self.controller.log_info(str(lot['status']))
            if lot['status'] not in (0, None):
                self.dlg_lot.cmb_status.setEnabled(False)
            utils_giswater.set_combo_itemData(self.dlg_lot.feature_type,
                                              lot['feature_type'], 0)
        feature_type = utils_giswater.get_item_data(self.dlg_lot,
                                                    self.dlg_lot.feature_type,
                                                    1).lower()
        table_name = "v_edit_" + str(feature_type)

        self.set_headers(self.tbl_relation)
        self.set_table_columns(self.dlg_lot, self.dlg_lot.tbl_relation,
                               table_name)

    def set_headers(self, qtable):
        feature_type = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2).lower()
        columns_name = self.controller.get_columns_list('om_visit_lot_x_' +
                                                        str(feature_type))
        columns_name.append(['validate'])
        standard_model = QStandardItemModel()
        qtable.setModel(standard_model)
        qtable.horizontalHeader().setStretchLastSection(True)

        # # Get headers
        headers = []
        for x in columns_name:
            headers.append(x[0])
        # Set headers
        standard_model.setHorizontalHeaderLabels(headers)

    def populate_table_relations(self, lot_id):
        standard_model = self.tbl_relation.model()
        feature_type = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2).lower()
        sql = ("SELECT * FROM " + self.schema_name + ".om_visit_lot_x_" +
               str(feature_type) + ""
               " WHERE lot_id ='" + str(lot_id) + "'")
        rows = self.controller.get_rows(sql, log_sql=True)
        for row in rows:
            item = []
            for value in row:
                if value is not None:
                    item.append(QStandardItem(str(value)))
                else:
                    item.append(QStandardItem(None))
            if len(row) > 0:
                standard_model.appendRow(item)

    def populate_visits(self, widget, table_name, expr_filter=None):
        """ Set a model with selected filter. Attach that model to selected table """
        if self.schema_name not in table_name:
            table_name = self.schema_name + "." + table_name
        # Set model

        #model = CustomSqlModel()
        model = QSqlTableModel()
        model.setTable(table_name)
        model.setEditStrategy(QSqlTableModel.OnManualSubmit)
        model.sort(0, 1)
        if expr_filter:
            model.setFilter(expr_filter)
        model.select()

        # Check for errors
        if model.lastError().isValid():
            self.controller.show_warning(model.lastError().text())

        # Attach model to table view
        widget.setModel(model)

    def update_id_list(self):
        feature_type = utils_giswater.get_item_data(self.dlg_lot,
                                                    self.dlg_lot.feature_type,
                                                    1).lower()
        list_ids = self.get_table_values(self.tbl_relation, feature_type)
        for id_ in list_ids:
            if id_ not in self.ids:
                self.ids.append(id_)

    def get_table_values(self, qtable, geom_type):
        column_index = utils_giswater.get_col_index_by_col_name(
            qtable, geom_type + '_id')
        model = qtable.model()
        id_list = []
        for i in range(0, model.rowCount()):
            i = model.index(i, column_index)
            id_list.append(i.data())
        return id_list

    def activate_selection(self, dialog, action, action_name):
        self.set_active_layer()
        self.dropdown.setDefaultAction(action)
        self.disconnect_signal_selection_changed()
        self.iface.mainWindow().findChild(
            QAction, action_name).triggered.connect(
                partial(self.selection_changed_by_expr, dialog, self.layer_lot,
                        self.geom_type))
        self.iface.mainWindow().findChild(QAction, action_name).trigger()

    def selection_changed_by_expr(self, dialog, layer, geom_type):
        # "arc_id" = '2020'
        self.canvas.selectionChanged.connect(
            partial(self.manage_selection, dialog, layer, geom_type))

    def manage_selection(self, dialog, layer, geom_type):
        """ Slot function for signal 'canvas.selectionChanged' """
        field_id = geom_type + "_id"
        # Iterate over layer
        if layer.selectedFeatureCount() > 0:
            # Get selected features of the layer
            features = layer.selectedFeatures()
            for feature in features:
                # Append 'feature_id' into the list
                selected_id = feature.attribute(field_id)
                if selected_id not in self.ids:
                    self.ids.append(selected_id)
        self.reload_table_relations()
        self.enable_combos(dialog)

    def enable_combos(self, dialog):
        assigned_to = dialog.findChild(QComboBox, 'cmb_assigned_to')
        visit_class = dialog.findChild(QComboBox, 'cmb_visit_class')
        if len(self.ids) > 0:
            assigned_to.setEnabled(False)
            visit_class.setEnabled(False)
        else:
            assigned_to.setEnabled(True)
            visit_class.setEnabled(True)

    def reload_table_relations(self):
        """ Reload @widget with contents of @tablename applying selected @expr_filter """
        standard_model = self.tbl_relation.model()
        feature_type = utils_giswater.get_item_data(self.dlg_lot,
                                                    self.dlg_lot.feature_type,
                                                    1).lower()
        lot_id = utils_giswater.getWidgetText(self.dlg_lot, self.lot_id)
        id_list = self.get_table_values(self.tbl_relation, feature_type)

        layer_name = 'v_edit_' + utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.feature_type, 0).lower()
        field_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.feature_type, 0).lower() + str('_id')
        layer = self.controller.get_layer_by_tablename(layer_name)

        for feature_id in self.ids:
            feature = self.get_feature_by_id(layer, feature_id, field_id)
            item = []
            if feature_id not in id_list:
                row = []
                item.append(lot_id)
                item.append(feature_id)
                item.append(feature.attribute('code'))
                item.append(0)
                for value in item:
                    row.append(QStandardItem(str(value)))
                if len(row) > 0:
                    standard_model.appendRow(row)
                    self.insert_single_checkbox(self.tbl_relation)

    def insert_row(self):
        """ Inser single row into QStandardItemModel """
        standard_model = self.tbl_relation.model()
        feature_id = utils_giswater.getWidgetText(self.dlg_lot,
                                                  self.dlg_lot.feature_id)
        lot_id = utils_giswater.getWidgetText(self.dlg_lot, self.lot_id)

        layer_name = 'v_edit_' + utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.feature_type, 0).lower()
        field_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.feature_type, 0).lower() + str('_id')
        layer = self.controller.get_layer_by_tablename(layer_name)
        feature = self.get_feature_by_id(layer, feature_id, field_id)
        if feature is False:
            return

        if feature_id not in self.ids:
            item = [lot_id, feature_id, feature.attribute('code'), 0]
            row = []
            for value in item:
                if value not in ('', None) and type(value) != QPyNullVariant:
                    row.append(QStandardItem(str(value)))
                else:
                    row.append(QStandardItem(None))
            if len(row) > 0:
                standard_model.appendRow(row)
                self.ids.append(feature_id)
                self.insert_single_checkbox(self.tbl_relation)

    def get_feature_by_id(self, layer, id, field_id):
        iter = layer.getFeatures()
        for feature in iter:
            if feature[field_id] == id:
                return feature
        return False

    def insert_single_checkbox(self, qtable):
        """ Create one QCheckBox and put into QTableView at position @self.chk_position """
        cell_widget = QWidget()
        chk = QCheckBox()
        lay_out = QHBoxLayout(cell_widget)
        lay_out.addWidget(chk)
        lay_out.setAlignment(Qt.AlignCenter)
        lay_out.setContentsMargins(0, 0, 0, 0)
        cell_widget.setLayout(lay_out)
        i = qtable.model().index(qtable.model().rowCount() - 1,
                                 self.chk_position)
        qtable.setIndexWidget(i, cell_widget)

    def remove_selection(self, dialog, qtable):
        self.disconnect_signal_selection_changed()
        feature_type = utils_giswater.get_item_data(self.dlg_lot,
                                                    self.dlg_lot.feature_type,
                                                    0).lower()
        # Get selected rows
        index_list = qtable.selectionModel().selectedRows()

        if len(index_list) == 0:
            message = "Any record selected"
            self.controller.show_info_box(message)
            return
        index = index_list[0]
        model = qtable.model()

        for i in range(len(index_list) - 1, -1, -1):
            row = index_list[i].row()
            column_index = utils_giswater.get_col_index_by_col_name(
                qtable, feature_type + '_id')
            feature_id = index.sibling(row, column_index).data()
            self.ids.remove(feature_id)
            model.takeRow(row)

        self.enable_combos(dialog)

    def set_active_layer(self):
        self.current_layer = self.iface.activeLayer()
        # Set active layer
        layer_name = 'v_edit_' + utils_giswater.get_item_data(
            self.dlg_lot, self.visit_class, 2).lower()

        self.layer_lot = self.controller.get_layer_by_tablename(layer_name)
        self.iface.setActiveLayer(self.layer_lot)
        self.iface.legendInterface().setLayerVisible(self.layer_lot, True)

    def selection_init(self, dialog):
        """ Set canvas map tool to an instance of class 'MultipleSelection' """
        self.disconnect_signal_selection_changed()
        self.iface.actionSelect().trigger()
        self.connect_signal_selection_changed(dialog)

    def connect_signal_selection_changed(self, dialog):
        """ Connect signal selectionChanged """
        try:
            self.canvas.selectionChanged.connect(
                partial(self.manage_selection, dialog, self.layer_lot,
                        self.geom_type))
        except Exception:
            pass

    def set_feature_type_cmb(self):
        feature_type = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2)
        utils_giswater.set_combo_itemData(self.feature_type, feature_type, 1)
        self.feature_type.setEnabled(False)

    def set_dates(self):
        visit_class_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
        sql = ("SELECT visitclass_id, formname, tablename FROM " +
               self.schema_name + ".config_api_visit "
               " WHERE visitclass_id ='" + str(visit_class_id) + "'")
        row = self.controller.get_row(sql, log_sql=True)
        sql = ("SELECT MIN(startdate), MAX(enddate)"
               " FROM {}.{}".format(self.schema_name, row['tablename']))
        row = self.controller.get_row(sql)
        if row:
            if row[0]:
                self.dlg_lot.date_event_from.setDate(row[0])
            else:
                current_date = QDate.currentDate()
                self.dlg_lot.date_event_from.setDate(current_date)
            if row[1]:
                self.dlg_lot.date_event_to.setDate(row[1])
            else:
                current_date = QDate.currentDate()
                self.dlg_lot.date_event_to.setDate(current_date)

    def reload_table_visit(self):
        feature_type = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2)
        object_id = utils_giswater.getWidgetText(self.dlg_lot,
                                                 self.dlg_lot.txt_filter)
        visit_start = self.dlg_lot.date_event_from.date()
        visit_end = self.dlg_lot.date_event_to.date()
        # Get selected dates
        date_from = visit_start.toString('yyyyMMdd 00:00:00')
        date_to = visit_end.toString('yyyyMMdd 23:59:59')
        if date_from > date_to:
            message = "Selected date interval is not valid"
            self.controller.show_warning(message)
            return
        visit_class_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
        sql = ("SELECT visitclass_id, formname, tablename FROM " +
               self.schema_name + ".config_api_visit "
               " WHERE visitclass_id ='" + str(visit_class_id) + "'")
        row = self.controller.get_row(sql, log_sql=False)

        table_name = row['tablename']
        if self.schema_name not in table_name:
            table_name = self.schema_name + "." + table_name

        # Create interval dates
        format_low = 'yyyy-MM-dd 00:00:00.000'
        format_high = 'yyyy-MM-dd 23:59:59.999'
        interval = "'{}'::timestamp AND '{}'::timestamp".format(
            visit_start.toString(format_low), visit_end.toString(format_high))

        expr_filter = ("(startdate BETWEEN {0}) AND (enddate BETWEEN {0})".
                       format(interval))
        if object_id != 'null':
            expr_filter += " AND " + str(
                feature_type) + "_id::TEXT ILIKE '%" + str(object_id) + "%'"

        expr_filter += " AND " + str(feature_type) + "_id IN ('0', "
        for i in range(len(self.ids)):
            expr_filter += "'" + str(self.ids[i]) + "', "
        expr_filter = expr_filter[:-2] + ")"

        model = QSqlTableModel()
        model.setTable(table_name)
        model.setEditStrategy(QSqlTableModel.OnManualSubmit)
        model.setFilter(expr_filter)
        model.sort(0, 1)
        model.select()

        # Check for errors
        if model.lastError().isValid():
            self.controller.show_warning(model.lastError().text())

        # Attach model to table view
        self.dlg_lot.tbl_visit.setModel(model)

    def get_dialog(self):
        visit_class_id = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
        sql = ("SELECT visitclass_id, formname, tablename FROM " +
               self.schema_name + ".config_api_visit "
               " WHERE visitclass_id ='" + str(visit_class_id) + "'")
        row = self.controller.get_row(sql, log_sql=True)

        self.controller.log_info(str("TODO: ABRIR FORMULARIOS"))
        self.controller.log_info(str(row))

    def save_lot(self):
        lot = {}
        lot['idval'] = utils_giswater.getWidgetText(self.dlg_lot, 'txt_idval',
                                                    False, False)
        lot['startdate'] = utils_giswater.getCalendarDate(
            self.dlg_lot, 'startdate')
        lot['enddate'] = utils_giswater.getCalendarDate(
            self.dlg_lot, 'enddate')
        lot['visitclass_id'] = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 0)
        lot['descript'] = utils_giswater.getWidgetText(self.dlg_lot,
                                                       'descript', False,
                                                       False)
        lot['status'] = utils_giswater.get_item_data(self.dlg_lot,
                                                     self.dlg_lot.cmb_status,
                                                     0)
        lot['feature_type'] = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_visit_class, 2).lower()
        lot['team_id'] = utils_giswater.get_item_data(
            self.dlg_lot, self.dlg_lot.cmb_assigned_to, 0)
        keys = ""
        values = ""
        update = ""
        for key, value in lot.items():
            if value != '':
                keys += "" + key + ", "
                if type(value) in (int, bool):
                    values += "$$" + str(value) + "$$, "
                    update += str(key) + "=$$" + str(value) + "$$, "
                else:
                    values += "$$" + value + "$$, "
                    update += str(key) + "=$$" + value + "$$, "

        keys = keys[:-2]
        values = values[:-2]
        update = update[:-2]

        if self.is_new_lot is True:
            sql = ("INSERT INTO " + self.schema_name + ".om_visit_lot(" +
                   keys + ") "
                   " VALUES (" + values + ") RETURNING id")
            row = self.controller.execute_returning(sql, log_sql=False)
            lot_id = row[0]
        else:
            lot_id = utils_giswater.getWidgetText(self.dlg_lot, 'lot_id',
                                                  False, False)
            sql = ("UPDATE " + self.schema_name + ".om_visit_lot "
                   " SET " + str(update) + ""
                   " WHERE id = '" + str(lot_id) + "'; \n")
            self.controller.execute_sql(sql, log_sql=False)
        sql = ("DELETE FROM " + self.schema_name + ".om_visit_lot_x_" +
               lot['feature_type'] + " "
               " WHERE lot_id = '" + str(lot_id) + "'; \n")

        model_rows = self.read_standaritemmodel(self.tbl_relation)

        for item in model_rows:
            keys = "lot_id, "
            values = "$$" + str(lot_id) + "$$, "
            for key, value in item.items():
                if key != 'lot_id':
                    if value not in ('',
                                     None) and type(value) != QPyNullVariant:
                        keys += "" + key + ", "
                        if type(value) in (int, bool):
                            values += "$$" + str(value) + "$$, "
                        else:
                            values += "$$" + value + "$$, "
            keys = keys[:-2]
            values = values[:-2]
            sql += ("INSERT INTO " + self.schema_name + ".om_visit_lot_x_" +
                    lot['feature_type'] + "(" + keys + ") "
                    " VALUES (" + values + "); \n")
        status = self.controller.execute_sql(sql, log_sql=False)
        if status:
            self.manage_rejected()

    def set_completers(self):
        """ Set autocompleters of the form """

        # Adding auto-completion to a QLineEdit - lot_id
        self.completer = QCompleter()
        self.dlg_lot.lot_id.setCompleter(self.completer)
        model = QStringListModel()

        sql = "SELECT DISTINCT(id) FROM " + self.schema_name + ".om_visit"
        rows = self.controller.get_rows(sql, commit=self.autocommit)
        values = []
        if rows:
            for row in rows:
                values.append(str(row[0]))

        model.setStringList(values)
        self.completer.setModel(model)

    def zoom_to_feature(self):
        feature_type = utils_giswater.get_item_data(self.dlg_lot,
                                                    self.visit_class,
                                                    2).lower()
        selected_list = self.tbl_relation.selectionModel().selectedRows()
        if len(selected_list) == 0:
            message = "Any record selected"
            self.controller.show_warning(message)
            return

        index = selected_list[0]
        row = index.row()
        column_index = utils_giswater.get_col_index_by_col_name(
            self.tbl_relation, feature_type + '_id')
        feature_id = index.sibling(row, column_index).data()
        expr_filter = '"{}_id" IN ({})'.format(self.geom_type,
                                               "'" + feature_id + "'")

        # Check expression
        (is_valid, expr) = self.check_expression(expr_filter)
        self.select_features_by_ids(feature_type, expr)
        self.iface.actionZoomToSelected().trigger()

    def manage_rejected(self):
        self.disconnect_signal_selection_changed()
        self.close_dialog(self.dlg_lot)

    def put_checkbox(self, qtable, rows, checker, value):
        """ Set one column of a QtableView as QCheckBox with values from database. """

        for x in range(0, len(rows)):
            row = rows[x]
            cell_widget = QWidget()
            chk = QCheckBox()
            if row[checker] == value:
                chk.setCheckState(Qt.Checked)
            lay_out = QHBoxLayout(cell_widget)
            lay_out.addWidget(chk)
            lay_out.setAlignment(Qt.AlignCenter)
            lay_out.setContentsMargins(0, 0, 0, 0)
            cell_widget.setLayout(lay_out)
            i = qtable.model().index(x, self.chk_position)
            qtable.setIndexWidget(i, cell_widget)

    def get_headers(self, qtable):
        headers = []
        for x in range(0, qtable.model().columnCount()):
            headers.append(qtable.model().headerData(x, Qt.Horizontal))
        return headers

    # def edit_visit(self):
    #     """ Button 65: Edit visit """
    #
    #     # Create the dialog
    #     self.dlg_man = VisitManagement()
    #     self.load_settings(self.dlg_man)
    #     # save previous dialog and set new one.
    #     # previous dialog will be set exiting the current one
    #     # self.previous_dialog = utils_giswater.dialog()
    #     self.dlg_man.tbl_visit.setSelectionBehavior(QAbstractItemView.SelectRows)
    #
    #      # Set a model with selected filter. Attach that model to selected table
    #     table_object = "v_ui_om_visitman_x_" + str(geom_type)
    #     expr_filter = geom_type + "_id = '" + feature_id + "'"
    #     # Refresh model with selected filter
    #     self.fill_table_object(self.dlg_man.tbl_visit, self.schema_name + "." + table_object, expr_filter)
    #     self.set_table_columns(self.dlg_man, self.dlg_man.tbl_visit, table_object)
    #
    #     # manage save and rollback when closing the dialog
    #     self.dlg_man.rejected.connect(partial(self.close_dialog, self.dlg_man))
    #     self.dlg_man.accepted.connect(
    #         partial(self.open_selected_object, self.dlg_man, self.dlg_man.tbl_visit, table_object))
    #
    #     # Set dignals
    #     self.dlg_man.tbl_visit.doubleClicked.connect(
    #         partial(self.open_selected_object, self.dlg_man, self.dlg_man.tbl_visit, table_object))
    #     self.dlg_man.btn_open.clicked.connect(
    #         partial(self.open_selected_object, self.dlg_man, self.dlg_man.tbl_visit, table_object))
    #     self.dlg_man.btn_delete.clicked.connect(
    #         partial(self.delete_selected_object, self.dlg_man.tbl_visit, table_object))
    #     self.dlg_man.txt_filter.textChanged.connect(
    #         partial(self.filter_visit, self.dlg_man, self.dlg_man.tbl_visit, self.dlg_man.txt_filter, table_object,
    #                 expr_filter))
    #
    #     # set timeStart and timeEnd as the min/max dave values get from model
    #     current_date = QDate.currentDate()
    #     sql = ("SELECT MIN(startdate), MAX(enddate)"
    #            " FROM {}.{}".format(self.schema_name, 'om_visit'))
    #     row = self.controller.get_row(sql, log_info=False, commit=self.autocommit)
    #     if row:
    #         if row[0]:
    #             self.dlg_man.date_event_from.setDate(row[0])
    #         if row[1]:
    #             self.dlg_man.date_event_to.setDate(row[1])
    #         else:
    #             self.dlg_man.date_event_to.setDate(current_date)
    #
    #     # set date events
    #     self.dlg_man.date_event_from.dateChanged.connect(
    #         partial(self.filter_visit, self.dlg_man, self.dlg_man.tbl_visit, self.dlg_man.txt_filter, table_object,
    #                 expr_filter))
    #     self.dlg_man.date_event_to.dateChanged.connect(
    #         partial(self.filter_visit, self.dlg_man, self.dlg_man.tbl_visit, self.dlg_man.txt_filter, table_object,
    #                 expr_filter))
    #
    #     # Open form
    #     self.open_dialog(self.dlg_man, dlg_name="visit_management")

    # Attach model to table view

    # def fill_custom_model(self, widget, table_name, expr_filter=None):
    #     """ Set a model with selected filter. Attach that model to selected table """
    #     if self.schema_name not in table_name:
    #         table_name = self.schema_name + "." + table_name
    #     # Set model
    #
    #     model = CustomSqlModel()
    #     model.setTable(table_name)
    #     model.setEditStrategy(QSqlTableModel.OnManualSubmit)
    #     model.sort(0, 1)
    #     if expr_filter:
    #         model.setFilter(expr_filter)
    #     model.select()
    #
    #     # Check for errors
    #     if model.lastError().isValid():
    #         self.controller.show_warning(model.lastError().text())
    #
    #     # Attach model to table view
    #     widget.setModel(model)

    def lot_manager(self):
        """ Button 75: Lot manager """

        # Create the dialog
        self.dlg_lot_man = VisitManagement()
        self.load_settings(self.dlg_lot_man)
        self.dlg_lot_man.setWindowTitle("Lot management")
        self.dlg_lot_man.lbl_filter.setText('Filter by idval: ')
        self.dlg_lot_man.btn_open.setText('Open lot')
        self.dlg_lot_man.btn_delete.setText('Delete lot')
        # save previous dialog and set new one.
        # previous dialog will be set exiting the current one
        # self.previous_dialog = utils_giswater.dialog()
        self.dlg_lot_man.tbl_visit.setSelectionBehavior(
            QAbstractItemView.SelectRows)

        # Set a model with selected filter. Attach that model to selected table
        table_object = "om_visit_lot"
        self.fill_table_object(self.dlg_lot_man.tbl_visit,
                               self.schema_name + "." + table_object)
        self.set_table_columns(self.dlg_lot_man, self.dlg_lot_man.tbl_visit,
                               table_object)

        # manage save and rollback when closing the dialog
        self.dlg_lot_man.rejected.connect(
            partial(self.close_dialog, self.dlg_lot_man))
        self.dlg_lot_man.accepted.connect(
            partial(self.open_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit, table_object))

        # Set signals
        self.dlg_lot_man.tbl_visit.doubleClicked.connect(
            partial(self.open_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit))
        self.dlg_lot_man.btn_open.clicked.connect(
            partial(self.open_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit))
        self.dlg_lot_man.btn_delete.clicked.connect(
            partial(self.delete_lot, self.dlg_lot_man.tbl_visit))
        self.dlg_lot_man.txt_filter.textChanged.connect(
            partial(self.filter_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit, self.dlg_lot_man.txt_filter))

        # set timeStart and timeEnd as the min/max dave values get from model
        current_date = QDate.currentDate()
        sql = ("SELECT MIN(startdate), MAX(enddate)"
               " FROM {}.{}".format(self.schema_name, table_object))
        row = self.controller.get_row(sql,
                                      log_info=True,
                                      commit=self.autocommit)

        if row:
            if row[0]:
                self.dlg_lot_man.date_event_from.setDate(row[0])
            if row[1]:
                self.dlg_lot_man.date_event_to.setDate(row[1])
            else:
                self.dlg_lot_man.date_event_to.setDate(current_date)

        # set date events
        self.dlg_lot_man.date_event_from.dateChanged.connect(
            partial(self.filter_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit, self.dlg_lot_man.txt_filter))
        self.dlg_lot_man.date_event_to.dateChanged.connect(
            partial(self.filter_lot, self.dlg_lot_man,
                    self.dlg_lot_man.tbl_visit, self.dlg_lot_man.txt_filter))

        # Open form
        self.open_dialog(self.dlg_lot_man, dlg_name="visit_management")

    def delete_lot(self, qtable):
        selected_list = qtable.selectionModel().selectedRows()
        if len(selected_list) == 0:
            message = "Any record selected"
            self.controller.show_warning(message)
            return
        for x in range(0, len(selected_list)):
            row = selected_list[x].row()
            _id = qtable.model().record(row).value('id')
            feature_type = qtable.model().record(row).value('feature_type')
            sql = ("DELETE FROM " + self.schema_name + ".om_visit_lot_x_" +
                   str(feature_type) + " "
                   " WHERE lot_id = '" + str(_id) + "'; \n "
                   "DELETE FROM " + self.schema_name + ".om_visit_lot "
                   " WHERE id ='" + str(_id) + "'")
            self.controller.execute_sql(sql, log_sql=False)
        self.filter_lot(self.dlg_lot_man, self.dlg_lot_man.tbl_visit,
                        self.dlg_lot_man.txt_filter)

    def open_lot(self, dialog, widget):
        """ Open object form with selected record of the table """

        selected_list = widget.selectionModel().selectedRows()
        if len(selected_list) == 0:
            message = "Any record selected"
            self.controller.show_warning(message)
            return

        row = selected_list[0].row()

        # Get object_id from selected row
        selected_object_id = widget.model().record(row).value('id')
        visitclass_id = widget.model().record(row).value('visitclass_id')

        # Close this dialog and open selected object
        dialog.close()

        # set previous dialog
        # if hasattr(self, 'previous_dialog'):
        self.manage_lot(selected_object_id,
                        is_new=False,
                        visitclass_id=visitclass_id)

    def filter_lot(self, dialog, widget_table, widget_txt):
        """ Filter om_visit in self.dlg_lot_man.tbl_visit based on (id AND text AND between dates)"""
        object_id = utils_giswater.getWidgetText(dialog, widget_txt)
        visit_start = dialog.date_event_from.date()
        visit_end = dialog.date_event_to.date()

        if visit_start > visit_end:
            message = "Selected date interval is not valid"
            self.controller.show_warning(message)
            return

        # Create interval dates
        format_low = 'yyyy-MM-dd 00:00:00.000'
        format_high = 'yyyy-MM-dd 23:59:59.999'
        interval = "'{}'::timestamp AND '{}'::timestamp".format(
            visit_start.toString(format_low), visit_end.toString(format_high))

        expr_filter = (
            "(startdate BETWEEN {0}) AND (enddate BETWEEN {0} or enddate is null)"
            .format(interval))
        if object_id != 'null':
            expr_filter += " AND idval::TEXT ILIKE '%" + str(object_id) + "%'"

        # Refresh model with selected filter
        widget_table.model().setFilter(expr_filter)
        widget_table.model().select()