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)
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)
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')
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)
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)
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()
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)
def complete( self, rect ):
" Brings the completer up "
rect.setWidth( self.__width )
self.__rect = rect
QCompleter.complete( self, rect )
self.__selectFirst()
return
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)
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)
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)
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)
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)
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])
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)
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)
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)
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)
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
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)
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
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 )
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 )
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()
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
)
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()
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)
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)
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)
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)
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 __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 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)
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()
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)
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()
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)
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)
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)
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)
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)
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()
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
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()
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)
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
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)
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
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)
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)
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)
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
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)
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)
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(
"")
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])
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]))
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()
