def accept(self):
if self.inputFiles is None:
workDir = QDir(self.leInputDir.text())
workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot)
nameFilter = ["*.shp", "*.SHP"]
workDir.setNameFilters(nameFilter)
self.inputFiles = workDir.entryList()
if len(self.inputFiles) == 0:
QMessageBox.warning(
self, self.tr("No shapefiles found"),
self.tr("There are no shapefiles in this directory. Please select another one."))
self.inputFiles = None
return
if self.outFileName is None:
QMessageBox.warning(
self, self.tr("No output file"),
self.tr("Please specify output file."))
return
if self.chkListMode.isChecked():
files = self.leInputDir.text().split(";")
baseDir = QFileInfo(files[0]).absolutePath()
else:
baseDir = self.leInputDir.text()
# look for shapes with specified geometry type
self.inputFiles = ftools_utils.getShapesByGeometryType(baseDir, self.inputFiles, self.cmbGeometry.currentIndex())
if self.inputFiles is None:
QMessageBox.warning(
self, self.tr("No shapefiles found"),
self.tr("There are no shapefiles with the given geometry type. Please select an available geometry type."))
return
self.progressFiles.setRange(0, len(self.inputFiles))
outFile = QFile(self.outFileName)
if outFile.exists():
if not QgsVectorFileWriter.deleteShapeFile(self.outFileName):
QMessageBox.warning(self, self.tr("Delete error"), self.tr("Can't delete file %s") % (self.outFileName))
return
if self.inEncoding is None:
self.inEncoding = "System"
self.btnOk.setEnabled(False)
self.mergeThread = ShapeMergeThread(baseDir, self.inputFiles, self.inEncoding, self.outFileName, self.encoding)
QObject.connect(self.mergeThread, SIGNAL("rangeChanged( PyQt_PyObject )"), self.setFeatureProgressRange)
QObject.connect(self.mergeThread, SIGNAL("checkStarted()"), self.setFeatureProgressFormat)
QObject.connect(self.mergeThread, SIGNAL("checkFinished()"), self.resetFeatureProgressFormat)
QObject.connect(self.mergeThread, SIGNAL("fileNameChanged( PyQt_PyObject )"), self.setShapeProgressFormat)
QObject.connect(self.mergeThread, SIGNAL("featureProcessed()"), self.featureProcessed)
QObject.connect(self.mergeThread, SIGNAL("shapeProcessed()"), self.shapeProcessed)
QObject.connect(self.mergeThread, SIGNAL("processingFinished()"), self.processingFinished)
QObject.connect(self.mergeThread, SIGNAL("processingInterrupted()"), self.processingInterrupted)
self.btnClose.setText(self.tr("Cancel"))
QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject)
QObject.connect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing)
self.mergeThread.start()
def readAllApps(self):
self.allapps.clear()
directoryLocal = QDir(self.folderlist.DirpathLocal)
directoryLocal.setFilter(QDir.Files | QDir.Hidden);
directoryLocal.setNameFilters(QStringList("*.desktop"))
directoryGlobal = QDir(self.folderlist.DirpathGlobal)
directoryGlobal.setFilter(QDir.Files | QDir.Hidden);
directoryGlobal.setNameFilters(QStringList("*.desktop"))
for file in directoryGlobal.entryList():
if not self.getAppIsNoDisplay(self.folderlist.DirpathGlobal + file):
part = self.folderlist.getNameFromDirFile(self.folderlist.DirpathGlobal + file)
icon = self.folderlist.getIconFromDirFile(self.folderlist.DirpathGlobal + file)
self.allapps[part] = {}
self.allapps[part]["path"] = self.folderlist.DirpathGlobal + file
self.allapps[part]["icon"] = icon
for file in directoryLocal.entryList():
if not self.getAppIsNoDisplay(self.folderlist.DirpathLocal + file):
part = self.folderlist.getNameFromDirFile(self.folderlist.DirpathLocal + file)
icon = self.folderlist.getIconFromDirFile(self.folderlist.DirpathLocal + file)
self.allapps[part] = {}
self.allapps[part]["path"] = self.folderlist.DirpathLocal + file
self.allapps[part]["icon"] = icon
def batchRun(self):
exts = re.sub('\).*$', '', re.sub('^.*\(', '', self.formatCombo.currentText())).split(" ")
if len(exts) > 0 and exts[0] != "*" and exts[0] != "*.*":
outExt = exts[0].replace( "*", "" )
else:
outExt = ".tif"
self.base.enableRun( False )
self.base.setCursor( Qt.WaitCursor )
inDir = self.getInputFileName()
outDir = self.getOutputFileName()
extensions = Utils.getRasterExtensions()
workDir = QDir( inDir )
workDir.setFilter( QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot )
workDir.setNameFilters( extensions )
files = workDir.entryList()
self.inFiles = []
self.outFiles = []
for f in files:
self.inFiles.append( inDir + "/" + f )
if outDir is not None:
outFile = re.sub( "\.[a-zA-Z0-9]{2,4}", outExt, f )
self.outFiles.append( outDir + "/" + outFile )
self.errors = []
self.batchIndex = 0
self.batchTotal = len( self.inFiles )
self.setProgressRange( self.batchTotal )
self.runItem( self.batchIndex, self.batchTotal )
def inputDir(self):
settings = QSettings()
lastDir = settings.value("/fTools/lastShapeDir", ".")
inDir = QFileDialog.getExistingDirectory(
self,
self.tr("Select directory with shapefiles to merge"),
lastDir
)
if not inDir:
return
workDir = QDir(inDir)
workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot)
nameFilter = ["*.shp", "*.SHP"]
workDir.setNameFilters(nameFilter)
self.inputFiles = workDir.entryList()
if len(self.inputFiles) == 0:
QMessageBox.warning(
self, self.tr("No shapefiles found"),
self.tr("There are no shapefiles in this directory. Please select another one."))
self.inputFiles = None
return
settings.setValue("/fTools/lastShapeDir", inDir)
self.progressFiles.setRange(0, len(self.inputFiles))
self.leInputDir.setText(inDir)
def _cert_info_from_dir(self, path):
"""
Create certificate info items from the user selected directory.
:param path: Path of the selected directory.
:type path: str
:return: cert_info_items: List of certificate info items.
:rtype cert_info_items: list
"""
dir_ = QDir(path)
dir_.setNameFilters(['*.pdf'])
file_infos = dir_.entryInfoList(
QDir.NoDot | QDir.NoDotDot | QDir.Files | QDir.Name
)
# Check if list contains file names
cert_info_items = []
if len(file_infos) == 0:
msg = self.tr(
'There are no PDF files in the selected directory.'
)
self.show_error_message(msg)
self._cert_model.clear()
else:
# Loop through file info objects
for f in file_infos:
# Create certificate info object for each file
cert_info = CertificateInfo()
cert_info.filename = f.absoluteFilePath()
base_name = f.completeBaseName()
cert_info.certificate_number = base_name.replace('.', '/')
cert_info_items.append(cert_info)
return cert_info_items
def batchRun(self):
exts = re.sub('\).*$', '', re.sub('^.*\(', '', self.formatCombo.currentText())).split(" ")
if len(exts) > 0 and exts[0] != "*" and exts[0] != "*.*":
outExt = exts[0].replace( "*", "" )
else:
outExt = ".tif"
self.base.enableRun( False )
self.base.setCursor( Qt.WaitCursor )
inDir = self.getInputFileName()
outDir = self.getOutputFileName()
filter = Utils.getRasterExtensions()
workDir = QDir( inDir )
workDir.setFilter( QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot )
workDir.setNameFilters( filter )
files = workDir.entryList()
self.inFiles = []
self.outFiles = []
for f in files:
self.inFiles.append( inDir + "/" + f )
if outDir is not None:
outFile = re.sub( "\.[a-zA-Z0-9]{2,4}", outExt, f )
self.outFiles.append( outDir + "/" + outFile )
self.errors = []
self.batchIndex = 0
self.batchTotal = len( self.inFiles )
self.setProgressRange( self.batchTotal )
self.runItem( self.batchIndex, self.batchTotal )
def documentTemplates():
"""
Return a dictionary of document names and their corresponding absolute file paths.
"""
from stdm.settings.registryconfig import RegistryConfig
docTemplates = OrderedDict()
regConfig = RegistryConfig()
keyName = "ComposerTemplates"
pathConfig = regConfig.read([keyName])
if len(pathConfig) > 0:
templateDir = pathConfig[keyName]
pathDir = QDir(templateDir)
pathDir.setNameFilters(["*.sdt"])
docFileInfos = pathDir.entryInfoList(QDir.Files, QDir.Name)
for df in docFileInfos:
docTemplates[df.completeBaseName()] = df.absoluteFilePath()
return docTemplates
def getRasterFiles(path, recursive=False):
rasters = []
if not QFileInfo(path).exists():
return rasters
# TODO remove *.aux.xml
_filter = getRasterExtensions()
workDir = QDir( path )
workDir.setFilter( QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot )
workDir.setNameFilters( _filter )
files = workDir.entryList()
for f in files:
rasters.append( path + "/" + f )
if recursive:
for myRoot, myDirs, myFiles in os.walk( unicode(path) ):
for dir in myDirs:
workDir = QDir( myRoot + "/" + dir )
workDir.setFilter( QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot )
workDir.setNameFilters( _filter )
workFiles = workDir.entryList()
for f in workFiles:
rasters.append( myRoot + "/" + dir + "/" + f )
return rasters
def getThemeList(self):
dir = QDir("/usr/share/enlightenment/data/themes")
dir.setFilter( QDir.NoSymLinks | QDir.Files )
a = QStringList()
a.append("*.edj")
dir.setNameFilters(a)
return dir.entryList()
def getFilesDirectory(self, globalPath, localPath):
directoryLocal = QDir(localPath)
directoryLocal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryLocal.setNameFilters(QStringList("*.directory"))
directoryGlobal = QDir(globalPath)
directoryGlobal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryGlobal.setNameFilters(QStringList("*.directory"))
return directoryGlobal.entryList() + directoryLocal.entryList()
def documentTemplates():
"""
Return a dictionary of document names and their corresponding absolute file paths.
"""
docTemplates = OrderedDict()
regConfig = RegistryConfig()
keyName = "ComposerTemplates"
pathConfig = regConfig.read([keyName])
if len(pathConfig) > 0:
templateDir = pathConfig[keyName]
pathDir = QDir(templateDir)
pathDir.setNameFilters(["*.sdt"])
docFileInfos = pathDir.entryInfoList(QDir.Files,QDir.Name)
for df in docFileInfos:
docTemplates[df.completeBaseName()] = df.absoluteFilePath()
return docTemplates
def fillInputDir(self):
inputDir = Utils.FileDialog.getExistingDirectory(self, self.tr("Select the input directory with files to Warp"))
if not inputDir:
return
self.inSelector.setFilename(inputDir)
filter = Utils.getRasterExtensions()
workDir = QDir(inputDir)
workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot)
workDir.setNameFilters(filter)
if len(workDir.entryList()) > 0:
fl = inputDir + "/" + workDir.entryList()[0]
self.sourceSRSEdit.setText(Utils.getRasterSRS(self, fl))
def fillInputDir(self):
inputDir = Utils.FileDialog.getExistingDirectory(
self, self.tr("Select the input directory with files to Warp"))
if not inputDir:
return
self.inSelector.setFilename(inputDir)
filter = Utils.getRasterExtensions()
workDir = QDir(inputDir)
workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot)
workDir.setNameFilters(filter)
if len(workDir.entryList()) > 0:
fl = inputDir + "/" + workDir.entryList()[0]
self.sourceSRSEdit.setText(Utils.getRasterSRS(self, fl))
def handleWatchUpdate(self,path):
myDir = QDir(path)
myDir.setNameFilters(self.supportedExtensions)
allFilesNow = myDir.entryList()
allFilesNow = list(allFilesNow)
allFilesNow = [str(item) for item in allFilesNow]
differentFiles = list(set(allFilesNow) ^ set(self.fileNames))
if differentFiles != []:
for aFile in differentFiles:
if self.fileNames.__contains__(aFile):
#TODO: delete the file from the table
self.ui.statusbar.showMessage('Removed' + aFile,2500)
else:
#process the new file
self.processFile(os.path.join(self.workingDirectory,aFile))
def selectIcon(self, parent = None):
dialog = DialogSelectFile(self)
dialog.setWindowTitle("Select Icon")
progress = QtGui.QProgressDialog("Please wait while loading icons", "Hide", 0, 100, parent)
progress.setWindowModality(QtCore.Qt.WindowModal)
progress.setAutoReset(True)
progress.setAutoClose(True)
progress.setMinimum(0)
progress.setMaximum(100)
progress.setWindowTitle("Loading...")
progress.show()
progress.setValue(0)
directoryLocal = QDir(self.IconpathLocal)
directoryLocal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryLocal.setNameFilters(QStringList("*.png"))
directoryGlobal = QDir(self.IconpathGlobal)
directoryGlobal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryGlobal.setNameFilters(QStringList("*.png"))
for file in directoryLocal.entryList():
icon = QIcon(self.IconpathLocal + file)
part = string.split(file, '.png')[0]
listItem = QListWidgetItem(icon, part, dialog.listFile, QListWidgetItem.UserType)
progress.setValue(50)
for file in directoryGlobal.entryList():
icon = QIcon(self.IconpathGlobal + file)
part = string.split(file, '.png')[0]
listItem = QListWidgetItem(icon, part, dialog.listFile, QListWidgetItem.UserType)
dialog.listFile.sortItems()
progress.setValue(100)
# progress.hide()
dialog.show()
dialog.exec_()
selected = self.selFile
self.selFile = ""
return selected
def readFilenames(self):
self.nameref.clear()
directoryLocal = QDir(self.DirpathLocal)
directoryLocal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryLocal.setNameFilters(QStringList("*.directory"))
directoryGlobal = QDir(self.DirpathGlobal)
directoryGlobal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryGlobal.setNameFilters(QStringList("*.directory"))
for file in directoryGlobal.entryList():
part = self.getNameFromDirFile(self.DirpathGlobal + file)
self.nameref[part] = self.DirpathGlobal + file
for file in directoryLocal.entryList():
part = self.getNameFromDirFile(self.DirpathLocal + file)
self.nameref[part] = self.DirpathLocal + file
def scan_for_scripts():
"""
Find python files (*.py) inside the scripts directory.
"""
addons = []
scripts = []
qdir = QDir(scripts_dirpath)
qdir.setFilter(QDir.Files)
qdir.setNameFilters(['*.py'])
for py_filename in qdir.entryList():
py_filepath = path.join(str(scripts_dirpath), str(py_filename)) # or unicode?
what = _is_script(py_filepath)
if what == IS_SCRIPT:
scripts.append(py_filepath)
if what == IS_ADDON:
addons.append(py_filepath)
return scripts, addons
def fillInputDir( self ):
inputDir = Utils.FileDialog.getExistingDirectory( self, self.tr( "Select the input directory with files to Translate" ))
if not inputDir:
return
self.inSelector.setFilename( inputDir )
filter = Utils.getRasterExtensions()
workDir = QDir( inputDir )
workDir.setFilter( QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot )
workDir.setNameFilters( filter )
# search for a valid SRS, then use it as default target SRS
srs = ''
for fname in workDir.entryList():
fl = inputDir + "/" + fname
srs = Utils.getRasterSRS( self, fl )
if srs:
break
self.targetSRSEdit.setText( srs )
def fillInputDir(self):
inputDir = Utils.FileDialog.getExistingDirectory(
self,
self.tr("Select the input directory with files to Translate"))
if not inputDir:
return
self.inSelector.setFilename(inputDir)
filter = Utils.getRasterExtensions()
workDir = QDir(inputDir)
workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot)
workDir.setNameFilters(filter)
# search for a valid SRS, then use it as default target SRS
srs = ''
for fname in workDir.entryList():
fl = inputDir + "/" + fname
srs = Utils.getRasterSRS(self, fl)
if srs:
break
self.targetSRSEdit.setText(srs)
def getWallpaperSettings(self):
dir = QDir("/usr/share/wallpapers/Pardus_Mood/contents")
dir.setFilter( QDir.NoSymLinks | QDir.Files )
a = QStringList()
a.append ("*.jpeg")
a.append("*.jpg")
a.append("*.png")
dir.setNameFilters(a)
lst = dir.entryList()
items = []
for desktopFile in lst:
wallpaper = {}
try:
wallpaper["wallpaperTitle"] = "picture"
except:
wallpaper["wallpaperTitle"] = "picture1"
try:
wallpaper["wallpaperDesc"] = "description"
except:
wallpaper["wallpaperDesc"] = "description1"
# Get all files in the wallpaper's directory
thumbFolder = desktopFile
# """
# Appearantly the thumbnail names doesn't have a standart.
# So we get the file list from the contents folder and
# choose the file which has a name that starts with "scre".
# File names I've seen so far;
# screenshot.jpg, screnshot.jpg, screenshot.png, screnshot.png
# """
wallpaper["wallpaperThumb"] = "/usr/share/wallpapers/Pardus_Mood/contents/%s"%desktopFile
wallpaper["wallpaperFile"] = desktopFile
items.append(wallpaper)
CONFIG_KAPTANRC.setValue("Wallpaper/Source","/usr/share/wallpapers/Pardus_Mood/contents/%s" %desktopFile)
self.getWallpaper(desktopFile)
return items
def tearDown(self):
outputDir = QDir(self.testPath + '/output')
outputDir.setNameFilters(['*.m4a'])
for outputFile in outputDir.entryList():
outputDir.remove(outputFile)
class EkdSaveDialog(QDialog):
'''
EkdSaveDialog : Classe représentant la boite de dialogue utiliser lors de
l'enregistrement des modification sur un fichier donné
attributs : suffix - Suffix utilisé en filtre
filter - Filtre (déduit à partir du suffix)
chemin - Chemin du dernier fichier enregistré
multiple - va-t-on enregistrer plus d'un fichier ?
(ex: extraction d'image d'une vidéo)
méthodes : getFile - Invoque la boite de dialogue et retourne
le fichier saisi
'''
### Pourquoi avoir réimplémenté cette classe au lieu de passer par
### QFileDialog ?
## Correction du bug de consommation mémoire
##
## Explication du problème :
## Par défaut un QFileDialog utilise un QFileSystemModel qui lui
## crée un QWatchFileSystem
## Hors QWatchFileSystem scan régulièrement les changement
## dans le répertoire courant
## Ce phénomène provoque une réaction en chaine :
## 1 - je choisi mon répertoire de destination d'enregistrement
## de mes images
## 2 - ffmpeg se lance
## 3 - ffmpeg crée un fichier dans l'arborescence
## 4 - QWatchFileSystem (est toujours dans le répertoire courant)
## détecte un changement
## et recharge l'ensemble du contenue du répertoire
## 5 - goto 3 jusqu'à plus de mémoire ou fin du process ffmpeg
##
##
def __init__(self, parent, path = None, suffix = '', title = u"Sauver",
multiple = False, mode = None):
if type(suffix) == tuple or type(suffix) == list :
sfilter=""
for s in suffix :
sfilter += "*"+s+" "
self.filter=sfilter[:-1]
# Si on a plusieur suffix, on prend le premier par défaut pour
# la sauvegarde
self.suffix = suffix[0]
else :
self.suffix = suffix
self.filter = "*" + self.suffix
QDialog.__init__(self, parent)
self.setWindowTitle(title)
self.multiple = multiple
self.mode = mode
if not path:
if self.mode == "image" :
path = EkdConfig.get("general", "image_output_path")
elif self.mode == "video" :
path = EkdConfig.get("general", "video_output_path")
elif self.mode == "audio" :
path = EkdConfig.get("general", "sound_output_path")
else :
path = unicode(QDir.homePath())
# Nom du répertoire courant
self.location = QLabel("<b>%s</b>" % path)
# Variable permettant de savoir à tout moment le répertoire courant.
self.currentDir = path
self.mkdirButton = QPushButton(u" Créer un répertoire")
self.mkdirButton.setIcon(QIcon("Icones" + os.sep + "add_sub_task.png"))
if int(EkdConfig.get("general", "show_hidden_files")) :
#print "hidden shown"
EkdPrint(u"hidden shown")
shf = QDir.Hidden
else : shf = QDir.Readable
# Liste des fichiers
self.dirList = QListView()
sorting = QDir.DirsFirst
if int(EkdConfig.get("general", "ignore_case")):
sorting |= QDir.IgnoreCase
self.sorting = sorting
self.flags = QDir.Files | QDir.Readable | shf
self.dirModel = QStandardItemModel()
self.dirList.setModel(self.dirModel)
self.updateDir(path)
self.dirList.setWrapping(True)
#panneau latéral
self.dirTree = QTreeView()
self.dirModelLight = QDirModel(QStringList(""), QDir.AllDirs |
QDir.NoDotAndDotDot | shf, QDir.DirsFirst |
QDir.Name | QDir.IgnoreCase)
self.dirTree.setModel(self.dirModelLight)
self.dirTree.setColumnHidden(1,True)
self.dirTree.setColumnHidden(2,True)
self.dirTree.setColumnHidden(3,True)
self.dirTree.setMaximumWidth(200)
self.dirTree.setMinimumWidth(150)
self.dirTree.setCurrentIndex(self.dirModelLight.index(path))
self.dirTree.resizeColumnToContents(0)
self.connect(self.dirTree, SIGNAL("pressed(QModelIndex)"),
self.updateLatDir)
self.connect(self.dirTree, SIGNAL("expanded(QModelIndex)"),
self.treeMAJ)
self.connect(self.dirTree, SIGNAL("collapsed(QModelIndex)"),
self.treeMAJ)
# Nom du fichier
self.fileField = QLineEdit()
# Nom du filtre
self.filterField = QComboBox()
self.filterField.addItems(QStringList(self.filter))
# Bouton de sauvegarde et d'annulation
self.saveButton = QPushButton(_(u" Enregistrer"))
self.saveButton.setIcon(QIcon("Icones" + os.sep + "action.png"))
self.cancelButton = QPushButton(_(u" Annuler"))
self.cancelButton.setIcon(QIcon("Icones" + os.sep + "annuler.png"))
# Organisation des différents objets de la boite de dialogue
self.layout = QHBoxLayout(self)
self.layout.addWidget(self.dirTree)
self.filelinelayout = QGridLayout()
self.filelinelayout.addWidget(self.location, 0, 0, 1, 0)
self.filelinelayout.addWidget(self.mkdirButton, 0, 2)
self.filelinelayout.addWidget(self.dirList, 1, 0, 1, 0)
self.filelinelayout.addWidget(QLabel(_("Nom de fichier : ")), 2, 0)
self.filelinelayout.addWidget(self.fileField, 2, 1)
self.filelinelayout.addWidget(self.saveButton, 2, 2)
self.filelinelayout.addWidget(QLabel(_("Filtre extension : ")), 3, 0)
self.filelinelayout.addWidget(self.filterField, 3, 1)
self.filelinelayout.addWidget(self.cancelButton, 3, 2)
self.layout.addLayout(self.filelinelayout)
# Connexion des différents objets
self.connect(self.dirList, SIGNAL("clicked(QModelIndex)"),
self.updateFile)
self.connect(self.saveButton, SIGNAL("clicked()"), self.accept)
self.connect(self.cancelButton, SIGNAL("clicked()"), self.reject)
self.connect(self.mkdirButton, SIGNAL("clicked()"), self.mkdir)
self.connect(self.dirList,
SIGNAL("indexesMoved (const QModelIndexList&)"),
self.updateFile)
self.connect(self.fileField, SIGNAL("textChanged (const QString&)"),
self.activate)
self.connect(self.fileField, SIGNAL("returnPressed()"), self.accept)
# Taille minimum
self.setMinimumSize(700, 480)
# Par défaut, on désactive
self.deactivate()
# Completion des fichiers
self.completion = QCompleter(self.dirModel, self.dirList)
def updateLatDir(self, item) :
""" Fonction permettant de naviguer dans la listes des répertoires """
self.updateDir(self.dirModelLight.filePath(item))
def treeMAJ(self, item) :
self.dirTree.resizeColumnToContents(0)
def activate(self, filename=None):
""" Activation des boutton de sauvegarde """
self.dirList.clearSelection()
if filename != "":
self.saveButton.setEnabled(True)
else:
self.saveButton.setEnabled(False)
def deactivate(self):
""" Désactivation des boutton de sauvegarde """
self.saveButton.setEnabled(False)
def updateDir(self, path = None):
""" Fonction permettant de naviguer dans la listes des répertoires """
if path :
self.currentDir = path
self.location.setText("<b>%s</b>" % path)
self.dirModel.clear()
self.tmpdir = QDir()
self.tmpdir.setPath(self.currentDir)
self.tmpdir.setNameFilters(QStringList(self.filter))
# Une icône pour les images, un autre icône pour les vidéos, et
# une pour audio
if self.mode == "image" :
icone = QIcon("Icones" + os.sep + "image_image.png")
elif self.mode == "video" :
icone = QIcon("Icones" + os.sep + "image_video.png")
elif self.mode == "audio" :
icone = QIcon("Icones" + os.sep + "image_audio.png")
else:
icone = QIcon("Icones" + os.sep + "image_default.png")
for wlfile in self.tmpdir.entryList(QDir.Files):
if self.mode == "image" :
icone = QIcon(EkdPreview("Icones" + os.sep + "image_default.png").get_preview())
item = QStandardItem(icone, QString(wlfile))
item.setToolTip(wlfile)
item.setData(QVariant(self.tmpdir.absolutePath() + os.sep + wlfile), Qt.UserRole + 2)
item.setData(QVariant(wlfile), Qt.UserRole + 3)
self.dirModel.appendRow(item)
def updateFile(self, item):
""" Fonction appelée par la listView lors d'un changement de repertoire"""
# On récupère le QModel parent du QModelItem
path = "%s" % item.data(Qt.UserRole + 2).toString()
name = os.path.basename(path)
self.fileField.selectAll()
self.fileField.setFocus()
self.fileField.setText(name)
self.activate(name)
def selectedFile(self):
""" Renvoi le fichier selectionné pour la sauvegarde"""
# Récupération du fichier selectionné
fichier = self.fileField.text()
output = "%s%s%s" % (self.currentDir, os.sep, fichier)
info = QFileInfo(output)
# Si l'utilisateur n'a pas spécifié de suffix, on l'ajoute
if info.suffix() != self.suffix[1:]:
output = "%s%s" % (output, self.suffix)
return output
def mkdir(self):
""" Crée un répertoire dans le répertoire courant """
(dirname, ok) = QInputDialog.getText(self, _(u"Nouveau répertoire"), _(u"Nom du répertoire"), QLineEdit.Normal, _(u"Nouveau répertoire"))
if ok :
try :
os.mkdir("%s%s%s" % (self.currentDir, os.sep,dirname))
#print u"Création de : %s%s%s" % (self.currentDir, os.sep, dirname)
EkdPrint(u"Création de : %s%s%s" % (self.currentDir, os.sep, dirname))
self.updateDir()
self.dirModelLight.refresh()
except Exception, e:
#print _(u"Impossible de crée un nouveau répertoire : %s" % e)
EkdPrint(_(u"Impossible de crée un nouveau répertoire : %s" % e))
class DirDocumentTypeSelector(QDialog):
"""
Dialog for selecting supporting documents from a given directory. Default
filter searches for PDF files only.
"""
def __init__(self, dir, doc_types, parent=None, filters=None):
super(DirDocumentTypeSelector, self).__init__(parent)
self.setWindowTitle(
self.tr('Documents in Folder')
)
self._filters = filters
# Use PDF as default filter
if not self._filters:
self._filters = ['*.pdf']
self._init_ui()
self._dir = QDir(dir)
self._dir.setNameFilters(self._filters)
self._doc_types = doc_types
self._attr_model = QStandardItemModel(self)
self._sel_doc_types = OrderedDict()
# Notification bar
self._notif_bar = NotificationBar(self.vl_notif)
self.resize(320, 350)
# Load documents
self.load_document_types()
@property
def selected_document_types(self):
"""
:return: Returns a dictionary of the document types and the
corresponding file paths as selected by the user.
:rtype: dict
"""
return self._sel_doc_types
def _init_ui(self):
# Draw UI widgets
layout = QVBoxLayout()
# Add layout for notification bar
self.vl_notif = QVBoxLayout()
layout.addLayout(self.vl_notif)
self.lbl_info = QLabel()
self.lbl_info.setObjectName('lbl_info')
self.lbl_info.setText(self.tr(
'The selected document types have been found in the directory, '
'check/uncheck to specify which ones to upload.'
))
self.lbl_info.setWordWrap(True)
layout.addWidget(self.lbl_info)
self.lst_docs = QListView()
layout.addWidget(self.lst_docs)
self.lbl_warning = QLabel()
self.lbl_warning.setTextFormat(Qt.RichText)
self.lbl_warning.setText(self.tr(
'<html><head/><body><p><span style=" font-style:italic;">'
'* Previously uploaded documents will be replaced.</span></p>'
'</body></html>'
))
self.lbl_warning.setWordWrap(True)
layout.addWidget(self.lbl_warning)
self.btn_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel
)
layout.addWidget(self.btn_box)
self.setLayout(layout)
# Connect signals
self.btn_box.accepted.connect(
self.set_selected_document_types
)
self.btn_box.rejected.connect(
self.reject
)
def set_selected_document_types(self):
"""
Sets the collections of accepted document types and their
corresponding file paths and accepts the dialog.
"""
self._sel_doc_types = OrderedDict()
for i in range(self._attr_model.rowCount()):
doc_type_item = self._attr_model.item(i, 0)
if doc_type_item.checkState() == Qt.Checked:
path_item = self._attr_model.item(i, 1)
self._sel_doc_types[doc_type_item.text()] = path_item.text()
if len(self._sel_doc_types) == 0:
self._notif_bar.clear()
msg = self.tr('No matching documents found or selected.')
self._notif_bar.insertWarningNotification(msg)
return
self.accept()
def load_document_types(self):
"""
Load all document types to the list view and enable/check the items
for those types that have been found.
"""
self._attr_model.clear()
self._attr_model.setColumnCount(2)
file_infos = self._dir.entryInfoList(
QDir.Readable | QDir.Files,
QDir.Name
)
# Index file info based on name
idx_file_infos = {fi.completeBaseName().lower(): fi for fi in file_infos}
for d in self._doc_types:
doc_type_item = QStandardItem(d)
doc_type_item.setCheckable(True)
path_item = QStandardItem()
item_enabled = False
check_state = Qt.Unchecked
dl = d.lower()
if dl in idx_file_infos:
item_enabled = True
check_state = Qt.Checked
path = idx_file_infos[dl].filePath()
path_item.setText(path)
doc_type_item.setToolTip(path)
doc_type_item.setEnabled(item_enabled)
doc_type_item.setCheckState(check_state)
self._attr_model.appendRow([doc_type_item, path_item])
self.lst_docs.setModel(self._attr_model)
from PyQt4.QtGui import (QApplication,QFileDialog,QPlainTextEdit,QTextCursor)
app = QApplication(sys.argv) # create an app
import pqIMC
IMC = pqIMC.tricorder() # set up a fake IMC for unit test
IMC.settings = QSettings()
IMC.editWidget = QPlainTextEdit()
import pqPages
pqPages.IMC = IMC
IMC.pageTable=pqPages.pagedb()
widj = pngDisplay()
widj.pngPath = QFileDialog.getExistingDirectory(widj,"Pick a Folder of Pngs",".")
widj.pngPath.append(u'/')
png_dir = QDir(widj.pngPath)
png_dir.setFilter(QDir.Files | QDir.NoSymLinks)
png_dir.setSorting(QDir.Name)
png_dir.setNameFilters(QStringList(QString(u'*.png')))
fnumber = 1
for finf in png_dir.entryInfoList():
# Read all the pngs and for each cobble up a "page" just to get
# some data into the page table
fname = finf.baseName()
IMC.editWidget.textCursor().insertText(fname)
fakemd = "{0} {1} {2} {3} {4} {5}\n".format(
IMC.editWidget.textCursor().position(),
fname, QString(u'\\foo\\foo'),
IMC.FolioRuleAdd1, IMC.FolioFormatArabic, fnumber )
IMC.pageTable.metaStringIn(fakemd)
fnumber +=1
widj.lastIndex = -1
widj.nextIndex = 0
widj.ready = True
def getFilesMenu(self, localPath):
directoryLocal = QDir(localPath)
directoryLocal.setFilter(QDir.Files | QDir.Hidden | QDir.NoSymLinks);
directoryLocal.setNameFilters(QStringList("*.menu"))
return directoryLocal.entryList()
