def __printPreviewImage(self):
"""
Private slot to handle the Print Preview menu action.
"""
from PyQt4.QtGui import QPrintPreviewDialog
if self.mainWidget is None:
KQMessageBox.critical(None,
self.trUtf8("Print Preview"),
self.trUtf8("""There is no UI file loaded."""))
return
settings = Preferences.Prefs.settings
printer = KdeQt.KQPrinter.KQPrinter(mode = QPrinter.HighResolution)
printer.setFullPage(True)
if not KdeQt.isKDE():
printer.setPrinterName(settings.value("UIPreviewer/printername").toString())
printer.setPageSize(
QPrinter.PageSize(settings.value("UIPreviewer/pagesize").toInt()[0]))
printer.setPageOrder(
QPrinter.PageOrder(settings.value("UIPreviewer/pageorder").toInt()[0]))
printer.setOrientation(
QPrinter.Orientation(settings.value("UIPreviewer/orientation").toInt()[0]))
printer.setColorMode(
QPrinter.ColorMode(settings.value("UIPreviewer/colormode").toInt()[0]))
preview = QPrintPreviewDialog(printer, self)
self.connect(preview, SIGNAL("paintRequested(QPrinter*)"), self.__print)
preview.exec_()
def __loadFile(self, fn):
"""
Private slot to load a ui file.
@param fn name of the ui file to be laoded (string or QString)
"""
if self.mainWidget:
self.mainWidget.close()
self.previewSV.takeWidget()
del self.mainWidget
self.mainWidget = None
# load the file
try:
self.mainWidget = uic.loadUi(fn)
except:
pass
if self.mainWidget:
self.currentFile = fn
self.__updateChildren(self.styleCombo.currentText())
if isinstance(self.mainWidget, QDialog) or \
isinstance(self.mainWidget, QMainWindow):
self.mainWidget.show()
self.mainWidget.installEventFilter(self)
else:
self.previewSV.setWidget(self.mainWidget)
self.mainWidget.show()
else:
KQMessageBox.warning(None,
self.trUtf8("Load UI File"),
self.trUtf8("""<p>The file <b>%1</b> could not be loaded.</p>""")\
.arg(fn))
self.__updateActions()
def __loadRules(self):
"""
Private method to load the rules of the subscription.
"""
fileName = self.rulesFileName()
f = QFile(fileName)
if f.exists():
if not f.open(QIODevice.ReadOnly):
KQMessageBox.warning(
None,
self.trUtf8("Load subscription rules"),
self.trUtf8("""Unable to open adblock file '%1' for reading.""").arg(fileName),
)
else:
textStream = QTextStream(f)
header = textStream.readLine(1024)
if not header.startsWith("[Adblock"):
KQMessageBox.warning(
None,
self.trUtf8("Load subscription rules"),
self.trUtf8("""Adblock file '%1' does not start with [Adblock.""").arg(fileName),
)
f.close()
f.remove()
self.__lastUpdate = QDateTime()
else:
self.__rules = []
while not textStream.atEnd():
line = textStream.readLine()
self.__rules.append(AdBlockRule(line))
self.__populateCache()
self.emit(SIGNAL("changed()"))
if not self.__lastUpdate.isValid() or self.__lastUpdate.addDays(7) < QDateTime.currentDateTime():
self.updateNow()
def on_addInstalledApiFileButton_clicked(self):
"""
Private slot to add an API file from the list of installed API files
for the selected lexer language.
"""
installedAPIFiles = self.__currentAPI.installedAPIFiles()
if len(installedAPIFiles) > 0:
installedAPIFilesPath = QFileInfo(installedAPIFiles[0]).path()
installedAPIFilesShort = QStringList()
for installedAPIFile in installedAPIFiles:
installedAPIFilesShort.append(QFileInfo(installedAPIFile).fileName())
file, ok = KQInputDialog.getItem(
self,
self.trUtf8("Add from installed APIs"),
self.trUtf8("Select from the list of installed API files"),
installedAPIFilesShort,
0,
False,
)
if ok:
self.apiList.addItem(
Utilities.toNativeSeparators(QFileInfo(QDir(installedAPIFilesPath), file).absoluteFilePath())
)
else:
KQMessageBox.warning(
self,
self.trUtf8("Add from installed APIs"),
self.trUtf8("""There are no APIs installed yet.""" """ Selection is not available."""),
)
self.addInstalledApiFileButton.setEnabled(False)
def on_renameButton_clicked(self):
"""
Private slot to rename a custom toolbar.
"""
oldName = self.toolbarComboBox.currentText()
newName, ok = KQInputDialog.getText(\
self,
self.trUtf8("Rename Toolbar"),
self.trUtf8("New Toolbar Name:"),
QLineEdit.Normal,
oldName)
if ok and not newName.isEmpty():
if oldName == newName:
return
if self.toolbarComboBox.findText(newName) != -1:
# toolbar with this name already exists
KQMessageBox.critical(self,
self.trUtf8("Rename Toolbar"),
self.trUtf8("""A toolbar with the name <b>%1</b> already exists.""")\
.arg(newName),
QMessageBox.StandardButtons(\
QMessageBox.Abort))
return
index = self.toolbarComboBox.currentIndex()
self.toolbarComboBox.setItemText(index, newName)
tbItem = \
self.__toolbarItems[self.toolbarComboBox.itemData(index).toULongLong()[0]]
tbItem.title = newName
tbItem.isChanged = True
def startSynchronizedProcess(self, proc, program, arguments, workingDir = None):
"""
Public method to start a synchroneous process
This method starts a process and waits
for its end while still serving the Qt event loop.
@param proc process to start (QProcess)
@param program path of the executable to start (string or QString)
@param arguments list of arguments for the process (QStringList)
@param workingDir working directory for the process (string or QString)
@return flag indicating normal exit (boolean)
"""
if proc is None:
return
if workingDir:
proc.setWorkingDirectory(workingDir)
proc.start(program, arguments)
procStarted = proc.waitForStarted()
if not procStarted:
KQMessageBox.critical(None,
self.trUtf8('Process Generation Error'),
self.trUtf8(
'The process %1 could not be started. '
'Ensure, that it is in the search path.'
).arg(program))
return False
else:
while proc.state() == QProcess.Running:
QApplication.processEvents()
QThread.msleep(300)
QApplication.processEvents()
return (proc.exitStatus() == QProcess.NormalExit) and (proc.exitCode() == 0)
def on_newButton_clicked(self):
"""
Private slot to create a new toolbar.
"""
name, ok = KQInputDialog.getText(\
self,
self.trUtf8("New Toolbar"),
self.trUtf8("Toolbar Name:"),
QLineEdit.Normal)
if ok and not name.isEmpty():
if self.toolbarComboBox.findText(name) != -1:
# toolbar with this name already exists
KQMessageBox.critical(self,
self.trUtf8("New Toolbar"),
self.trUtf8("""A toolbar with the name <b>%1</b> already exists.""")\
.arg(name),
QMessageBox.StandardButtons(\
QMessageBox.Abort))
return
tbItem = E4ToolBarItem(None, [], False)
tbItem.title = name
tbItem.isChanged = True
self.__toolbarItems[id(tbItem)] = tbItem
self.__toolBarItemToWidgetActionID[id(tbItem)] = []
self.toolbarComboBox.addItem(name, QVariant(long(id(tbItem))))
self.toolbarComboBox.model().sort(0)
self.toolbarComboBox.setCurrentIndex(self.toolbarComboBox.findText(name))
def __writeXMLMultiProject(self, fn = None):
"""
Private method to write the multi project data to an XML file.
@param fn the filename of the multi project file (string)
"""
try:
if fn.lower().endswith("e4mz"):
try:
import gzip
except ImportError:
KQMessageBox.critical(None,
self.trUtf8("Save multiproject file"),
self.trUtf8("""Compressed multiproject files not supported."""
""" The compression library is missing."""))
return False
f = gzip.open(fn, "wb")
else:
f = open(fn, "wb")
MultiProjectWriter(self, f, os.path.splitext(os.path.basename(fn))[0])\
.writeXML()
f.close()
except IOError:
KQMessageBox.critical(None,
self.trUtf8("Save multiproject file"),
self.trUtf8("<p>The multiproject file <b>%1</b> could not be "
"written.</p>").arg(fn))
return False
return True
def start(self, pfn, fn=None):
"""
Public slot to start the calculation of the profile data.
@param pfn basename of the profiling file (string)
@param fn file to display the profiling data for (string)
"""
self.basename = os.path.splitext(pfn)[0]
fname = "%s.profile" % self.basename
if not os.path.exists(fname):
KQMessageBox.warning(None,
self.trUtf8("Profile Results"),
self.trUtf8("""<p>There is no profiling data"""
""" available for <b>%1</b>.</p>""")
.arg(pfn))
self.close()
return
try:
f = open(fname, 'rb')
self.stats = pickle.load(f)
f.close()
except (EnvironmentError, pickle.PickleError, EOFError):
KQMessageBox.critical(None,
self.trUtf8("Loading Profiling Data"),
self.trUtf8("""<p>The profiling data could not be"""
""" read from file <b>%1</b>.</p>""")
.arg(fname))
self.close()
return
self.file = fn
self.__populateLists()
self.__finish()
def __compileIDLDone(self, exitCode, exitStatus):
"""
Private slot to handle the finished signal of the omniidl process.
@param exitCode exit code of the process (integer)
@param exitStatus exit status of the process (QProcess.ExitStatus)
"""
self.compileRunning = False
if exitStatus == QProcess.NormalExit and exitCode == 0:
path = os.path.dirname(self.idlFile)
poaList = glob.glob(os.path.join(path, "*__POA"))
npoaList = [f.replace("__POA", "") for f in poaList]
fileList = glob.glob(os.path.join(path, "*_idl.py"))
for dir in poaList + npoaList:
fileList += Utilities.direntries(dir, True, "*.py")
for file in fileList:
self.project.appendFile(file)
if not self.noDialog:
KQMessageBox.information(
None,
self.trUtf8("Interface Compilation"),
self.trUtf8("The compilation of the interface file was successful."),
)
else:
if not self.noDialog:
KQMessageBox.information(
None,
self.trUtf8("Interface Compilation"),
self.trUtf8("The compilation of the interface file failed."),
)
self.compileProc = None
def __checkPluginsDownloadDirectory(self):
"""
Private slot to check for the existance of the plugins download directory.
"""
downloadDir = unicode(Preferences.getPluginManager("DownloadPath"))
if not downloadDir:
downloadDir = self.__defaultDownloadDir
if not os.path.exists(downloadDir):
try:
os.mkdir(downloadDir, 0755)
except (OSError, IOError), err:
# try again with (possibly) new default
downloadDir = self.__defaultDownloadDir
if not os.path.exists(downloadDir):
try:
os.mkdir(downloadDir, 0755)
except (OSError, IOError), err:
KQMessageBox.critical(self.__ui,
self.trUtf8("Plugin Manager Error"),
self.trUtf8("""<p>The plugin download directory <b>%1</b> """
"""could not be created. Please configure it """
"""via the configuration dialog.</p>"""
"""<p>Reason: %2</p>""")\
.arg(downloadDir).arg(str(err)))
downloadDir = ""
def on_namedReferenceButton_clicked(self):
"""
Private slot to handle the named reference toolbutton.
"""
# determine cursor position as length into text
length = self.regexpTextEdit.textCursor().position()
# only present group names that occur before the current cursor position
regex = unicode(self.regexpTextEdit.toPlainText().left(length))
names = self.namedGroups(regex)
if not names:
KQMessageBox.information(None,
self.trUtf8("Named reference"),
self.trUtf8("""No named groups have been defined yet."""))
return
qs = QStringList()
for name in names:
qs.append(name)
groupName, ok = KQInputDialog.getItem(\
None,
self.trUtf8("Named reference"),
self.trUtf8("Select group name:"),
qs,
0, True)
if ok and not groupName.isEmpty():
self.__insertString("(?P=%s)" % groupName)
def __findDuplicates(self, cond, special, showMessage = False, index = QModelIndex()):
"""
Private method to check, if an entry already exists.
@param cond condition to check (string or QString)
@param special special condition to check (string or QString)
@param showMessage flag indicating a message should be shown,
if a duplicate entry is found (boolean)
@param index index that should not be considered duplicate (QModelIndex)
@return flag indicating a duplicate entry (boolean)
"""
cond = unicode(cond)
special = unicode(special)
idx = self.__model.getWatchPointIndex(cond, special)
duplicate = idx.isValid() and idx.internalPointer() != index.internalPointer()
if showMessage and duplicate:
if not special:
msg = self.trUtf8("""<p>A watch expression '<b>%1</b>'"""
""" already exists.</p>""")\
.arg(Utilities.html_encode(unicode(cond)))
else:
msg = self.trUtf8("""<p>A watch expression '<b>%1</b>'"""
""" for the variable <b>%2</b> already exists.</p>""")\
.arg(special)\
.arg(Utilities.html_encode(unicode(cond)))
KQMessageBox.warning(None,
self.trUtf8("Watch expression already exists"),
msg)
return duplicate
def __init__(self, parent = None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
QWidget.__init__(self, parent)
self.setupUi(self)
self.table.addAction(self.insertRowAction)
self.table.addAction(self.deleteRowAction)
if QSqlDatabase.drivers().isEmpty():
KQMessageBox.information(None,
self.trUtf8("No database drivers found"),
self.trUtf8("""This tool requires at least one Qt database driver. """
"""Please check the Qt documentation how to build the """
"""Qt SQL plugins."""))
self.connect(self.connections, SIGNAL("tableActivated(QString)"),
self.on_connections_tableActivated)
self.connect(self.connections, SIGNAL("schemaRequested(QString)"),
self.on_connections_schemaRequested)
self.connect(self.connections, SIGNAL("cleared()"),
self.on_connections_cleared)
self.emit(SIGNAL("statusMessage(QString)"), self.trUtf8("Ready"))
def __importStyles(self, lexers):
"""
Private method to import the styles of the given lexers.
@param lexers dictionary of lexer objects for which to import the styles
"""
fn = KQFileDialog.getOpenFileName(\
self,
self.trUtf8("Import Highlighting Styles"),
QString(),
self.trUtf8("eric4 highlighting styles file (*.e4h)"),
None)
if fn.isEmpty():
return
fn = unicode(fn)
try:
f = open(fn, "rb")
try:
line = f.readline()
dtdLine = f.readline()
finally:
f.close()
except IOError, err:
KQMessageBox.critical(self,
self.trUtf8("Import Highlighting Styles"),
self.trUtf8("""<p>The highlighting styles could not be read"""
""" from file <b>%1</b>.</p><p>Reason: %2</p>""")\
.arg(fn)\
.arg(str(err))
)
return
def exportShortcuts(fn):
"""
Module function to export the keyboard shortcuts for the defined QActions.
@param fn filename of the export file (string)
@return flag indicating success
"""
try:
if fn.lower().endswith("e4kz"):
try:
import gzip
except ImportError:
KQMessageBox.critical(None,
QApplication.translate("Shortcuts", "Export Keyboard Shortcuts"),
QApplication.translate("Shortcuts",
"""Compressed keyboard shortcut files"""
""" not supported. The compression library is missing."""))
return 0
f = gzip.open(fn, "wb")
else:
f = open(fn, "wb")
ShortcutsWriter(f).writeXML()
f.close()
return True
except IOError:
return False
def buildWidget(self):
"""
Public slot to load a UI file.
"""
if self.__widget:
self.__widget.close()
self.__layout.removeWidget(self.__widget)
del self.__widget
self.__widget = None
try:
self.__widget = uic.loadUi(self.__uiFileName)
except:
pass
if not self.__widget:
KQMessageBox.warning(None,
self.trUtf8("Load UI File"),
self.trUtf8("""<p>The file <b>%1</b> could not be loaded.</p>""")\
.arg(self.__uiFileName))
self.__valid = False
return
self.__widget.setParent(self)
self.__layout.addWidget(self.__widget)
self.__widget.show()
self.__valid = True
self.adjustSize()
self.__timer.stop()
def __generateTSFileDone(self, exitCode, exitStatus):
"""
Private slot to handle the finished signal of the pylupdate process.
@param exitCode exit code of the process (integer)
@param exitStatus exit status of the process (QProcess.ExitStatus)
"""
if exitStatus == QProcess.NormalExit and exitCode == 0:
KQMessageBox.information(None,
self.trUtf8("Translation file generation"),
self.trUtf8("The generation of the translation files (*.ts)"
" was successful."))
else:
KQMessageBox.critical(None,
self.trUtf8("Translation file generation"),
self.trUtf8("The generation of the translation files (*.ts) has failed."))
proc = self.sender()
for index in range(len(self.__pylupdateProcesses)):
if proc == self.__pylupdateProcesses[index][0]:
try:
os.remove(self.__pylupdateProcesses[index][1])
except EnvironmentError:
pass
del self.__pylupdateProcesses[index]
break
if not self.__pylupdateProcesses:
# all done
self.pylupdateProcRunning = False
def add(self, transFileName, setTranslation = True):
"""
Public method to add a translation to the list.
If the translation file (*.qm) has not been loaded yet, it will
be loaded automatically.
@param transFileName name of the translation file to be added (string or QString)
@param setTranslation flag indicating, if this should be set as the active
translation (boolean)
"""
fileName = QString(transFileName)
if not self.__haveFileName(fileName):
ntr = Translation()
ntr.fileName = fileName
ntr.name = self.__uniqueName(fileName)
if ntr.name.isNull():
KQMessageBox.warning(None,
self.trUtf8("Set Translator"),
self.trUtf8("""<p>The translation filename <b>%1</b>"""
""" is invalid.</p>""").arg(fileName))
return
ntr.translator = self.loadTransFile(fileName)
if ntr.translator is None:
return
self.selector.addItem(ntr.name)
self.translations.append(ntr)
if setTranslation:
tr = self.__findFileName(fileName)
self.set(tr.name)
def set(self, name):
"""
Public slot to set a translator by name.
@param name name (language) of the translator to set (string or QString)
"""
name = QString(name)
nTranslator = None
if name.compare(noTranslationName) != 0:
trans = self.__findName(name)
if trans is None:
KQMessageBox.warning(None,
self.trUtf8("Set Translator"),
self.trUtf8("""<p>The translator <b>%1</b> is not known.</p>""")\
.arg(name))
return
nTranslator = trans.translator
if nTranslator == self.currentTranslator:
return
if self.currentTranslator is not None:
QApplication.removeTranslator(self.currentTranslator)
if nTranslator is not None:
QApplication.installTranslator(nTranslator)
self.currentTranslator = nTranslator
self.selector.blockSignals(True)
self.selector.setCurrentIndex(self.selector.findText(name))
self.selector.blockSignals(False)
self.emit(SIGNAL('translationChanged'))
def findPrev(self):
"""
Public slot to find the next previous of text.
"""
if not self.havefound or self.ui.findtextCombo.currentText().isEmpty():
self.show(self.viewmanager.textForFind())
return
self.__findBackwards = True
txt = self.ui.findtextCombo.currentText()
# This moves any previous occurrence of this statement to the head
# of the list and updates the combobox
self.findHistory.removeAll(txt)
self.findHistory.prepend(txt)
self.ui.findtextCombo.clear()
self.ui.findtextCombo.addItems(self.findHistory)
self.emit(SIGNAL('searchListChanged'))
ok = self.__findNextPrev(txt, True)
if ok:
if self.replace:
self.ui.replaceButton.setEnabled(True)
self.ui.replaceSearchButton.setEnabled(True)
else:
KQMessageBox.information(self, self.windowTitle(),
self.trUtf8("'%1' was not found.").arg(txt))
def on_changeButton_clicked(self):
"""
Private slot to change an entry.
"""
row = self.groupsList.currentRow()
if row < 0:
return
groupName = self.nameEdit.text()
if groupName.isEmpty():
KQMessageBox.critical(self,
self.trUtf8("Add tool group entry"),
self.trUtf8("You have to give a name for the group to add."))
return
if len(self.groupsList.findItems(groupName, Qt.MatchFlags(Qt.MatchExactly))):
KQMessageBox.critical(self,
self.trUtf8("Add tool group entry"),
self.trUtf8("An entry for the group name %1 already exists.")\
.arg(groupName))
return
self.toolGroups[row][0] = unicode(groupName)
self.groupsList.currentItem().setText(groupName)
def on_saveButton_clicked(self):
"""
Private slot to handle the Save button press.
It saves the diff shown in the dialog to a file in the local
filesystem.
"""
if type(self.filename) is types.ListType:
if len(self.filename) > 1:
fname = self.vcs.splitPathList(self.filename)[0]
else:
dname, fname = self.vcs.splitPath(self.filename[0])
if fname != '.':
fname = "%s.diff" % self.filename[0]
else:
fname = dname
else:
fname = self.vcs.splitPath(self.filename)[0]
selectedFilter = QString("")
fname = KQFileDialog.getSaveFileName(\
self,
self.trUtf8("Save Diff"),
fname,
self.trUtf8("Patch Files (*.diff)"),
selectedFilter,
QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
if fname.isEmpty():
return
ext = QFileInfo(fname).suffix()
if ext.isEmpty():
ex = selectedFilter.section('(*',1,1).section(')',0,0)
if not ex.isEmpty():
fname.append(ex)
if QFileInfo(fname).exists():
res = KQMessageBox.warning(self,
self.trUtf8("Save Diff"),
self.trUtf8("<p>The patch file <b>%1</b> already exists.</p>")
.arg(fname),
QMessageBox.StandardButtons(\
QMessageBox.Abort | \
QMessageBox.Save),
QMessageBox.Abort)
if res != QMessageBox.Save:
return
fname = unicode(Utilities.toNativeSeparators(fname))
try:
f = open(fname, "wb")
f.write(unicode(self.contents.toPlainText()))
f.close()
except IOError, why:
KQMessageBox.critical(self, self.trUtf8('Save Diff'),
self.trUtf8('<p>The patch file <b>%1</b> could not be saved.'
'<br>Reason: %2</p>')
.arg(unicode(fname)).arg(str(why)))
def __about(self):
"""
Private slot to show the about information.
"""
KQMessageBox.about(self, self.trUtf8("TR Previewer"), self.trUtf8(
"""<h3> About TR Previewer </h3>"""
"""<p>The TR Previewer loads and displays Qt User-Interface files"""
""" and translation files and shows dialogs for a selected language.</p>"""
))
def startProcess(self, args, workingDir=None, setLanguage=False):
"""
Public slot used to start the process.
@param args list of arguments for the process (QStringList)
@param workingDir working directory for the process (string or QString)
@param setLanguage flag indicating to set the language to "C" (boolean)
@return flag indicating a successful start of the process
"""
self.errorGroup.hide()
self.normal = False
self.intercept = False
self.__hasAddOrDelete = False
self.proc = QProcess()
if setLanguage:
env = QProcessEnvironment.systemEnvironment()
env.insert("LANG", "C")
self.proc.setProcessEnvironment(env)
nargs = QStringList()
lastWasPwd = False
for arg in args:
if lastWasPwd:
lastWasPwd = True
continue
nargs.append(arg)
if arg == QString("--password"):
lastWasPwd = True
nargs.append("*****")
self.resultbox.append(nargs.join(" "))
self.resultbox.append("")
self.connect(self.proc, SIGNAL("finished(int, QProcess::ExitStatus)"), self.__procFinished)
self.connect(self.proc, SIGNAL("readyReadStandardOutput()"), self.__readStdout)
self.connect(self.proc, SIGNAL("readyReadStandardError()"), self.__readStderr)
if workingDir:
self.proc.setWorkingDirectory(workingDir)
self.proc.start("svn", args)
procStarted = self.proc.waitForStarted()
if not procStarted:
self.buttonBox.setFocus()
self.inputGroup.setEnabled(False)
self.inputGroup.hide()
KQMessageBox.critical(
None,
self.trUtf8("Process Generation Error"),
self.trUtf8("The process %1 could not be started. " "Ensure, that it is in the search path.").arg(
"svn"
),
)
else:
self.inputGroup.setEnabled(True)
self.inputGroup.show()
return procStarted
def __about(self):
"""
Private slot to show the about information.
"""
KQMessageBox.about(self, self.trUtf8("UI Previewer"), self.trUtf8(
"""<h3> About UI Previewer </h3>"""
"""<p>The UI Previewer loads and displays Qt User-Interface files"""
""" with various styles, which are selectable via a selection list.</p>"""
))
def _selectEntries(self, local = True, filter = None):
"""
Protected method to select entries based on their VCS status.
@param local flag indicating local (i.e. non VCS controlled) file/directory
entries should be selected (boolean)
@param filter list of classes to check against
"""
if self.project.vcs is None:
return
if local:
compareString = QApplication.translate('ProjectBaseBrowser', "local")
else:
compareString = QString(self.project.vcs.vcsName())
# expand all directories in order to iterate over all entries
self._expandAllDirs()
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
QApplication.processEvents()
self.selectionModel().clear()
QApplication.processEvents()
# now iterate over all entries
startIndex = None
endIndex = None
selectedEntries = 0
index = self.model().index(0, 0)
while index.isValid():
itm = self.model().item(index)
if self.wantedItem(itm, filter) and \
QString.compare(compareString, itm.data(1)) == 0:
if startIndex is not None and \
startIndex.parent() != index.parent():
self._setItemRangeSelected(startIndex, endIndex, True)
startIndex = None
selectedEntries += 1
if startIndex is None:
startIndex = index
endIndex = index
else:
if startIndex is not None:
self._setItemRangeSelected(startIndex, endIndex, True)
startIndex = None
index = self.indexBelow(index)
if startIndex is not None:
self._setItemRangeSelected(startIndex, endIndex, True)
QApplication.restoreOverrideCursor()
QApplication.processEvents()
if selectedEntries == 0:
KQMessageBox.information(None,
QApplication.translate('ProjectBaseBrowser', "Select entries"),
QApplication.translate('ProjectBaseBrowser',
"""There were no matching entries found."""))
def on_deleteButton_clicked(self):
"""
Private slot to delete the selected search engines.
"""
if self.enginesTable.model().rowCount() == 1:
KQMessageBox.critical(self,
self.trUtf8("Delete selected engines"),
self.trUtf8("""You must have at least one search engine."""))
self.enginesTable.removeSelected()
def __about(self):
"""
Private slot to show the about information.
"""
KQMessageBox.about(self, self.trUtf8("SQL Browser"), self.trUtf8(
"""<h3>About SQL Browser</h3>"""
"""<p>The SQL browser window is a little tool to examine """
"""the data and the schema of a database and to execute """
"""queries on a database.</p>"""
))
def __uiStartUp(self):
"""
Private slot to do some actions after the UI has started and the main loop is up.
"""
for warning in self.__warnings:
KQMessageBox.warning(self,
self.trUtf8("SQL Browser startup problem"),
warning)
if QSqlDatabase.connectionNames().isEmpty():
self.__browser.addConnectionByDialog()
