def backup(self): model = self.state.model if not model: return widget = QApplication.focusWidget() filename = Lib.incrementedFilename(model.filename) with Lib.Qt.DisableUI(*self.window.widgets(), forModalDialog=True): filename, _ = QFileDialog.getSaveFileName( self.window, "Backup Index — {}".format(QApplication.applicationName()), filename, "{} index (*{})".format(QApplication.applicationName(), EXTENSION)) if filename: with Lib.Qt.DisableUI(*self.window.widgets(), forModalDialog=True): self.state.saving = True try: self.state.maybeSave() if not filename.endswith(EXTENSION): filename += EXTENSION say("Backing up to “{}”...".format( QDir.toNativeSeparators(filename))) model.optimize() model.backup(filename, "Backing up", self.window.reportProgress) say("Backed up to “{}”".format( QDir.toNativeSeparators(filename))) finally: self.state.saving = False Lib.restoreFocus(widget)
def getProjectFile(filename=None): d = QDir() d.cd(app.manifest.get('gendir',"bin")) # cd into the directory we generate to if filename is None: # we want just the generation directory return d.absolutePath() # so return the absolute path else: # the only other option is a file in the gendir return d.absoluteFilePath(filename) # so give the absolute path to that file
def render(self, fileName, width, height): self.setViewportSize(QSize(width, height)) fileInfo = QFileInfo(fileName) dir = QDir() dir.mkpath(fileInfo.absolutePath()) viewportSize = self.viewportSize() pageSize = self.mainFrame().contentsSize() if pageSize.isEmpty(): return False buffer = QImage(pageSize, QImage.Format_ARGB32) buffer.fill(qRgba(255, 255, 255, 0)) p = QPainter(buffer) p.setRenderHint( QPainter.Antialiasing, True) p.setRenderHint( QPainter.TextAntialiasing, True) p.setRenderHint( QPainter.SmoothPixmapTransform, True) self.setViewportSize(pageSize) self.mainFrame().render(p) p.end() self.setViewportSize(viewportSize) return buffer.save(fileName)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.setupUi(self) self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, COMPANY, APPNAME) self.restoreGeometry(self.settings.value(self.__class__.__name__)) self.images = [] if len(sys.argv) > 1: d = QDir(path=sys.argv[1]) else: d = QDir(path=QFileDialog.getExistingDirectory()) d.setNameFilters(['*.png']) d.setFilter(QDir.Files or QDir.NoDotAndDotDot) d = QDirIterator(d) images = [] while d.hasNext(): images.append(d.next()) for i in images: print i self.images = [QImage(i) for i in images] self.images += [crop_image_from_file(i, 50)[0] for i in images]
def __init__(self, parent=None, common_name=None, image=None): QtGui.QDialog.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) types = controller.get_types() self.directory = QDir.root() self.display = QGraphicsView() self.ui.scrollArea.setWidget(self.display) for tipo in types: self.ui.typeBox.addItem(tipo["nombre"], tipo["id_tipo"]) if common_name is None: self.ui.btn_done.clicked.connect(self.add) if image is None: self.ui.image.setPlainText(image) else: self.setWindowTitle(u"Editar animal") self.common = common_name animal_data = controller.get_animal(common_name) self.ui.common_name.setPlainText(animal_data["nombre_comun"]) self.ui.cientific_name.setText(animal_data["nombre_cientifico"]) self.ui.data.setText(animal_data["datos"]) tipo = self.ui.typeBox.currentText() id_type = controller_form.get_id_type(tipo) id_animal = controller_form.get_id_animal(common_name) self.image = controller_form.get_image(id_animal) if self.image: self.path = QDir.currentPath() + "/images/" + self.image[0] + self.image[1] self.ui.image.setPlainText(self.path) Ifile = QFileInfo(self.path) pixImage = controller_form.get_root_image(self.path) item = QGraphicsPixmapItem(pixImage.scaled(100,100)) scene = QGraphicsScene() scene.addItem(item) self.display.setScene(scene) self.ui.image.setPlainText(self.path) else: noimage = controller_form.no_image() item = QGraphicsPixmapItem(noimage.scaled(100,100)) scene = QGraphicsScene() scene.addItem(item) self.display.setScene(scene) scene = QGraphicsScene() scene.addItem(item) self.display.setScene(scene) self.path = "" self.ui.image.setPlainText(self.path) self.ui.btn_done.clicked.connect(self.edit) self.ui.btn_delete.clicked.connect(self.delete) self.ui.btn_open.clicked.connect(self.open) self.ui.btn_cancel.clicked.connect(self.cancel)
def parse_interface(interfacename): tree = xmlparse("views" + QDir.separator() + interfacename + ".xml").getroot() # get the tree Compiler.current_interfacename = interfacename # set the current interfacename imported = [] # this is the list of interfaces to parse after this one Compiler.code += "from PySide.QtGui import *\nfrom PySide.QtCore import *\n" # import PySide Compiler.code += "from oxide.widgets.all import *\n" # import Oxide if interfacename == Compiler.start: # if this is the start interface, create a QApplication Compiler.code += "import sys\n" # using sys.argv, Compiler.code += "app = OxideApplication(sys.argv)\n" # create a QApplication add_util_funcs() # add the utility functions add_model(interfacename,"__main__") # now add the model code to the output file for element in tree: # iterate through the elements in the tree if element.tag.lower() == "animations": # here we handle the special 'animations' tag Compiler.to_be_own_class = False # there is no way that we're in the resources tag here for animation in element: # go through each animation parse_animation(animation) # and parse it elif element.tag.lower() == "window": # here we handle the window Compiler.to_be_own_class = False # there is no way that we're in the resources tag here parse_toplevel(element) # using parse_window elif element.tag.lower() == "resources": Compiler.to_be_own_class = True for child in element: Compiler.direct_resources_child = True parse_abstract_element(child) Compiler.direct_resources_child = False Compiler.direct_resources_child = False elif element.tag.lower() == "import": Compiler.code += "import " + element.get('interface') + "\n" imported.append(element.get('interface')) if interfacename == Compiler.start: # to finish up, if this is the start file Compiler.code += "sys.exit(app.exec_())\n" # run the application # now it has come time to put the code on the filesystem if not QDir("bin").exists(): # if the 'bin' folder doesn't exist QDir().mkdir("bin") # create it interfacefile = open(Compiler.gendir + QDir.separator() + interfacename + ".py", 'w') interfacefile.write(Compiler.code) # write Compiler.code to the file Compiler.code = "" # reset Compiler.code for interface in imported: parse_interface(interface)
def onBrowseClicked(self): """Slot. Called when the user clicks on the `browseButton` button""" # Presents the user with a native directory selector window localdir = QFileDialog.getExistingDirectory() localdir = QDir.fromNativeSeparators(localdir) if len(localdir) > 0: # If `localdir`'s value is good, store it using a `QSettings` object # and triggers a sync request. # Careful with '\' separators on Windows. localdir = QDir.toNativeSeparators(localdir) get_settings().setValue(SettingsKeys['localdir'], localdir) self.localdirEdit.setText(localdir)
def on_change_root_path(self, current_path): if current_path == SOURCEIMAGES_TAG: current_path = os.path.join( cmds.workspace(query=True, rootDirectory=True), cmds.workspace(fileRuleEntry='sourceImages')) self.files_model.setRootPath(current_path) self.files_list.setRootIndex(self.files_model.index(current_path)) if self.path_edit: self.path_edit.setText(current_path) if self.parent_folder_btn: current_dir = QDir(current_path) self.parent_folder_btn.setEnabled(current_dir.cdUp())
def processModels(): for filename in QDir("models").entryList(QDir.Files): out = "" for line in open("models" + QDir.separator() + filename).readlines(): try: if not line.strip()[0] == "#": if line[:8] == "from " + app.manifest.get('gendir',"bin"): out += "# " + line; else: out += line else: out += line except IndexError: # it must have just been a newline (lstrip makes it ""), so there is no index 0 out += "\n" f = open("models" + QDir.separator() + filename, 'w') f.write(out) f.close()
def on_change_root_path(self, current_path): if current_path == SOURCEIMAGES_TAG: current_path = os.path.join( cmds.workspace(query=True, rootDirectory=True), cmds.workspace(fileRuleEntry='sourceImages') ) self.files_model.setRootPath(current_path) self.files_list.setRootIndex(self.files_model.index(current_path)) if self.path_edit: self.path_edit.setText(current_path) if self.parent_folder_btn: current_dir = QDir(current_path) self.parent_folder_btn.setEnabled(current_dir.cdUp())
def create_folder(self): """ Crea carpeta de imagenes si no existe """ self.directory = QDir.root() if not os.path.exists(self.directory.currentPath()+"/images"): os.makedirs(self.directory.currentPath()+"/images")
def no_image(): """ Si no existe imagen carga una por defecto """ path = QDir.currentPath() + "/images/noimage.jpg" pixMap = QPixmap(path) return pixMap
def getConfigStyleDict(): styledict = {} #initialize the new styledict # get the tree from the style.xml file tree = xmlparse("config" + QDir.separator() + "style.xml").getroot() for styletype in tree: # iterate over the types of widget styletype_key = styletype.tag.lower() if styletype.tag.lower().startswith("default-") else styletype.tag styledict[styletype_key] = {} # create a new dictionary for the style-type for state in States: styledict[styletype_key][state] = {} styledict[styletype_key]['normal'] = {} styledict[styletype_key]['durations'] = {} for styledef_or_statedef in styletype: if styledef_or_statedef.tag.lower() in States: for styledef in styledef_or_statedef: styledict[styletype_key][styledef_or_statedef.tag.lower()][styledef.tag.lower()] = getValue(styledef) elif styledef_or_statedef.tag.lower() in StateTransitions: if styledef_or_statedef.get('time') is None: raise StyleError(styletype.tag + " => " + styledef_or_statedef.tag + " must have 'time' attribute") styledict[styletype_key]['durations'][styledef_or_statedef.tag.lower()] = int(styledef_or_statedef.get('time')) else: for state in States: styledict[styletype_key][state][styledef_or_statedef.tag.lower()] = getValue(styledef_or_statedef) styledict[styletype_key]['normal'][styledef_or_statedef.tag.lower()] = getValue(styledef_or_statedef) return styledict
def root_abspath(): global ROOT_ABSPATH if not ROOT_ABSPATH: from PySide.QtCore import QDir ROOT_ABSPATH = QDir.fromNativeSeparators( os.path.abspath(ROOT_LOCATION)) return ROOT_ABSPATH
def fileOpen(self, lineEdit, filters): openFile = QFileDialog.getOpenFileName(self, "Find Files", QDir.currentPath(), filters="*." + filters) uiDebug(openFile) if openFile != None : lineEdit.setText(openFile[0]) self.setUserConfig() self.showConfig()
def localFromServer(self, serverpath): # Removing leading '/' so `os.path.join` doesn't treat # `localpath` as an absolute path localpath = serverpath[1:] if serverpath.startswith('/') else serverpath localpath = QDir.toNativeSeparators(localpath) localpath = os.path.join(self.localdir, localpath) return localpath
def saveAs(self): # No need to restore focus widget filename = self._getSaveAsFilename() if filename: # Do a backup to the new filename, then open it say("Saving to “{}”...".format(QDir.toNativeSeparators(filename))) self.state.model.backup(filename, "Saving", self.window.reportProgress) self.window.openXix(filename)
def _fetchChildren(self): '''Fetch and return new child items.''' children = [] for entry in QDir.drives(): path = os.path.normpath(entry.canonicalFilePath()) children.append(Mount(path)) return children
def localFromServer(self, serverpath): # Removing leading '/' so `os.path.join` doesn't treat # `localpath` as an absolute path localpath = serverpath[1:] if serverpath.startswith( '/') else serverpath localpath = QDir.toNativeSeparators(localpath) localpath = os.path.join(self.localdir, localpath) return localpath
def loadConfig(self): '''加载配置文件''' configfile = QFileDialog.getOpenFileName(self, "Load Config File", QDir.currentPath(), filter="*.cfg") uiDebug(configfile) if configfile != None : self.readConfig(configfile) self.stopServer() self.startServer() self.showConfig() uiDebug("loadConfig")
def addImages(self, directory, images): self.directory = directory json_file_name = self.directory.path() + QDir.separator() + 'box2d.json' if os.path.exists(json_file_name): try: with open(json_file_name) as f: self.images = [Image(self.directory, json_dict=js_image) for js_image in json.load(f)] except ValueError, e: self.images = [Image(self.directory, file_name=image) for image in images]
def config_posix(self): """""" # Path for all pinguinowriteable files PATH = QDir.home().path() + "/.local/share/pinguino_ide" writeable_path = PATH pinguino_user_libs = PATH + "/pinguino-libraries" pinguino_resources = "qtgui/resources" pinguino_examples = PATH + "/examples/examples" pinguino_examples_graphical = PATH + "/examples/examples_graphical" # create (if not exist) a work dir space if not os.path.isdir(writeable_path): os.makedirs(writeable_path, 0777) self.first_config.add_section("Paths") self.first_config.set("Paths", "pinguino_writeable_path", writeable_path) self.first_config.set("Paths", "pinguino_user_libs", pinguino_user_libs) self.first_config.set("Paths", "pinguino_resources", pinguino_resources) self.first_config.set("Paths", "pinguino_examples_graphical", pinguino_examples_graphical) self.first_config.set("Paths", "pinguino_examples", pinguino_examples) # set default paths self.first_config.set("Paths", "sdcc_bin", "/usr/bin/sdcc") #self.first_config.set("Paths", "sdcc_libs", "/usr/share/sdcc") self.first_config.set("Paths", "gcc_bin", "") #self.first_config.set("Paths", "gcc_libs", "") self.first_config.set("Paths", "pinguino_8_libs", "pinguino/p8") self.first_config.set("Paths", "pinguino_32_libs", "pinguino/p32") self.first_config.set("Paths", "source", PATH + "/source") config_location = os.path.join(writeable_path, CONFIG_FILENAME) self.first_config.write(file(config_location, "w")) local_config = file("config", "w") local_config.write(config_location) # Remove examples if os.path.exists(pinguino_examples): shutil.rmtree(pinguino_examples) if os.path.exists(pinguino_examples_graphical): shutil.rmtree(pinguino_examples_graphical) # Copy examples to writeable path shutil.copytree("pinguino/examples", pinguino_examples) shutil.copytree("qtgui/gide/examples", pinguino_examples_graphical) # Copy other configs shutil.copy("qtgui/config/reserved.pickle", PATH + "/reserved.pickle") shutil.copy("qtgui/config/wikidocs.pickle", PATH + "/wikidocs.pickle") # Copy pinguino source dir if os.path.exists(PATH + "/source"): shutil.rmtree(PATH + "/source") shutil.copytree("pinguino/source", PATH + "/source")
def pack(directory, quiet, algorithm, size): cprint('working directory {}'.format(directory), color='green') cprint('quiet {}'.format(quiet), color='green') cprint('algorithm {}'.format(algorithm), color='green') cprint('size {}'.format(size)) folder = QDir(path=directory) folder.setNameFilters(['*.png']) folder.setFilter(QDir.Files or QDir.NoDotAndDotDot) dit = QDirIterator(folder, flags=QDirIterator.Subdirectories, filters=QDir.Files) filenames = [] while dit.hasNext(): im = folder.relativeFilePath(dit.next()) if not re.search('atlas', im): filenames.append(im) images = [Image(directory, filename) for filename in filenames] BinPacking.bin_packing_progress = MyBinPackingProgress() bin_packer = FirstFitShelfBinPacking(Size(2048, 2048), images, bin_parameters={}) bin_packer.saveAtlases(directory) print ''
def __init__(self, directory, filename): self.directory = directory self.filename = filename image = QImage(self.directory + QDir.separator() + self.filename) Rect.__init__(self, Point(), Size(image.width(), image.height())) cropped_image, x, y, width, height = self.__getCrop(image, False) self.crop = Rect(Point(x, y), Size(width, height)) self.rotated = False
def old_add_model(interfacename,scope): try: f = open("models" + QDir.separator() + interfacename + Compiler.model_extension) # try to open the model file except IOError: # there must not be a model for this interface name print "Warning: interface '" + interfacename + "' is missing a model" return for line in f.readlines(): # the if statement prevents generated files from importing each other when we don't want them to if not line.startswith("from " + Compiler.gendir + "."): Compiler.code += line # add the code, under the above condition Compiler.code += "\n" #in case there's not newline at the end of the file
def rewrite_model(interfacename): try: in_file = open("models" + QDir.separator() + interfacename + Compiler.model_extension) # try to open the model file except IOError: # there must not be a model for this interface name print "Warning: interface '" + interfacename + "' is missing a model" return outcode = "from PySide.QtGui import *\nfrom PySide.QtCore import *\nfrom oxide.widgets.all import *\nfrom oxide.widgets import util_funcs\nimport sys\n" # now we won't get errors on import of the rewritten model for line in in_file.readlines(): # the if statement prevents generated files from importing each other when we don't want them to if not line.startswith("from " + Compiler.gendir + "."): # if the line does not import from the gendir match_object = re.match("class (\w+)" + Compiler.modelclass_extension + "\(\w+\):", line) if match_object: line = "class " + match_object.group(1) + Compiler.modelclass_extension + "():\n" outcode += line # add the code, under the above condition sep = QDir.separator() try: out_file = open(Compiler.gendir + sep + "tmp" + sep + "models" + sep + interfacename + Compiler.model_extension,'w') # create the new file except IOError: # could not create the new file print "Could not create file in gendir" sys.exit() out_file.write(outcode)
def parsePluginSpecs(self, parentItem, plugins): ret = 0 loadCount = 0 for i in range(len(plugins)): spec = plugins[i] if spec.hasError(): ret |= ParsedState.ParsedWithErrors pluginItem = QTreeWidgetItem([spec.name(), "", "{0} ({1})".format(spec.version(), spec.compatVersion()), spec.vendor()]) pluginItem.setToolTip(0, QDir.toNativeSeparators(spec.filePath())) ok = not spec.hasError() icon = self.okIcon if ok else self.errorIcon if ok and spec.state() is not PluginState.Running: icon = self.notLoadedIcon pluginItem.setIcon(0, icon) pluginItem.setData(0, Qt.UserRole, spec) state = Qt.Unchecked if spec.isEnabled(): state = Qt.Checked loadCount += 1 if spec.name() not in self.whitelist: pluginItem.setData(C_LOAD, Qt.CheckStateRole, state) else: pluginItem.setData(C_LOAD, Qt.CheckStateRole, Qt.Checked) pluginItem.setFlags(Qt.ItemIsSelectable) pluginItem.setToolTip(C_LOAD, "Load on Startup") self.specToItem[spec] = pluginItem if parentItem: parentItem.addChild(pluginItem) else: self.items.append(pluginItem) if loadCount == len(plugins): groupState = Qt.Checked ret |= ParsedState.ParsedAll elif loadCount == 0: groupState = Qt.Unchecked ret |= ParsedState.ParsedNone else: groupState = Qt.PartiallyChecked ret |= ParsedState.ParsedPartial return ret, groupState
def get_image_pix(id_animal): """ Carga la imagen ya almacenada en la base de datos """ con = controller.connect() c = con.cursor() query = """SELECT ubicacion, formato FROM imagen WHERE fk_id_animal=?""" c.execute(query,[id_animal]) result = c.fetchone() if result: path = result[0] format = result[1] image = QDir.currentPath()+"/images/"+path+format pixMap = QPixmap(image) return pixMap
def __readPluginPaths(self): self.pluginCategories.clear() self.pluginSpecs[:] = [] specFiles = [] searchPaths = self.pluginPaths print("Append plugin spec files:") while searchPaths: searchDir = QDir(searchPaths.pop(0)) pattern = "*." + self.extension fileInfoList = searchDir.entryInfoList([pattern], QDir.Files) for fileInfo in fileInfoList: print(BColors.DARKCYAN + fileInfo.absoluteFilePath() + BColors.ENDC) specFiles.append(fileInfo.absoluteFilePath()) dirInfoList = searchDir.entryInfoList(QDir.Dirs | QDir.NoDotAndDotDot) for dirInfo in dirInfoList: searchPaths.append(dirInfo.absoluteFilePath()) self.defaultCollection = PluginCollection("") self.pluginCategories[""] = self.defaultCollection for specFile in specFiles: spec = PluginSpec(self) spec.private.read(specFile) if spec.category() in self.pluginCategories: collection = self.pluginCategories[spec.category()] else: collection = PluginCollection(spec.category()) self.pluginCategories[spec.category()] = collection if spec.isExperimental() and (spec.name() in self.forceEnabledPlugins): spec.setEnabled(True) if not spec.isExperimental() and (spec.name() in self.disabledPlugins): spec.setEnabled(False) collection.addPlugin(spec) self.pluginSpecs.append(spec) self.resolveDependencies() self.pluginManager.pluginsChanged.emit()
def ReadTagsFromConfiguration(): try: map = {} dom_file = os.path.join(QDir.currentPath(),"Data","swn_tag_data.xml") print "fetching data from ", dom_file dom = parse(dom_file) map["Tags"] = __parseTags(dom) map["Atmosphere"] = __parseTable(dom.getElementsByTagName("Atmosphere")[0]) map["Biosphere"] = __parseTable(dom.getElementsByTagName("Biosphere")[0]) map["Tech"] = __parseTable(dom.getElementsByTagName("Tech")[0]) map["Temperature"] = __parseTable(dom.getElementsByTagName("Temperature")[0]) map["Population"] = __parseTable1(dom.getElementsByTagName("Population")[0]) return map except Exception as inst: print "Some error occurred: %s", inst return None
def _create_control ( self, parent ): # If the caller provided a default path instead of a default directory # and filename, split the path into it directory and filename # components. if ((len( self.default_path ) != 0) and (len( self.default_directory ) == 0) and (len( self.default_filename ) == 0)): default_directory, default_filename = \ os.path.split( self.default_path ) else: default_directory = self.default_directory default_filename = self.default_filename # Convert the filter: keep = True filters = [] for f in self.wildcard.split( '|' ): if keep and f: filters.append( f ) keep = not keep # Set the default directory: if not default_directory: default_directory = QDir.currentPath() dlg = QFileDialog( parent, self.title, default_directory ) dlg.setViewMode( QFileDialog.Detail ) dlg.selectFile( default_filename ) dlg.setFilters( filters ) if self.wildcard_index < filters.count(): dlg.selectFilter( filters[ self.wildcard_index ] ) if self.action == 'open': dlg.setAcceptMode( QFileDialog.AcceptOpen ) dlg.setFileMode( QFileDialog.ExistingFile ) elif self.action == 'open files': dlg.setAcceptMode( QFileDialog.AcceptOpen ) dlg.setFileMode( QFileDialog.ExistingFiles ) else: dlg.setAcceptMode( QFileDialog.AcceptSave ) dlg.setFileMode( QFileDialog.AnyFile ) return dlg
def addImages(self, directory, images): self.directory = directory json_file_name = self.directory.path() + QDir.separator( ) + 'box2d.json' if os.path.exists(json_file_name): try: with open(json_file_name) as f: self.images = [ Image(self.directory, json_dict=js_image) for js_image in json.load(f) ] except ValueError, e: self.images = [ Image(self.directory, file_name=image) for image in images ]
def harvestDirectory(self, directory): folder = QDir(path=directory) folder.setNameFilters(["*.png"]) folder.setFilter(QDir.Files or QDir.NoDotAndDotDot) dit = QDirIterator(folder, flags=QDirIterator.Subdirectories, filters=QDir.Files) while dit.hasNext(): im = folder.relativeFilePath(dit.next()) if not re.search("atlas", im): self.images.append(im) self.bin_packing_thread.setDirectory(self.directory) self.bin_packing_thread.setImages(self.images) self.updateImages(self.images)
def run(self): if not self.directory or not len(self.images): return self.prepare_progress_signal.emit(0) self.packing_progress_signal.emit(0) self.verify_progress_signal.emit(0) self.saving_progress_signal.emit(0) images = [] for i, image in enumerate(self.images): self.prepare_progress_signal.emit(int(100 * (i + 1) / float(len(self.images)))) images.append(Image(self.directory, image)) bin_packing = self.method["type"](self.bin_size, images, bin_parameters=self.bin_parameter[self.method["name"]]) bin_packing.saveAtlases(self.directory + QDir.separator()) self.update_bins.emit(bin_packing.bins) self.on_end.emit(True)
def print_error(type,error,tb): # @ReservedAssignment # re-implementation of sys.excepthook tb = traceback.extract_tb(tb) if os.path.exists("models" + QDir.separator() + os.path.basename(tb[-1][0])): sys.stderr.write("Error in model " + ".".join(os.path.basename(tb[-1][0]).split(".")[:-1]) + ", line " + str(tb[-1][1]) + " in " + str(tb[-1][2]) + ":\n" + " " + tb[-1][3] + "\n") elif issubclass(error.__class__,InterfaceError): sys.stderr.write("Error in view " + error.interface + ".xml:\n") sys.stderr.write(str(type)[:-2].split(".")[-1] + ": ") if not isinstance(error, IOError) and not isinstance(error, OSError): for arg in error.args: sys.stderr.write(arg) else: sys.stderr.write(error.strerror) sys.exit()
def loadLibrary(self): if self.hasError: return False if self.state is not PluginState.Resolved: if self.state is PluginState.Loaded: return True self.errorString = QCoreApplication.translate(None, "Loading the library failed because state != Resolved") self.hasError = True return False pluginPath = QDir.toNativeSeparators(self.location) pluginClass = pluginloader.loadIPlugin(pluginPath, self.name + "." + self.mainClass) if not pluginClass: self.hasError = True self.errorString = QCoreApplication.translate(None, "Plugin is not valid (does not derive from IPlugin") return False self.state = PluginState.Loaded self.plugin = pluginClass(self.manager) self.plugin.private.pluginSpec = self.pluginSpec return True
def updateRecentFilesMenu(self): recentAction = self.fileActions.openRecentAction if self.recent_files: self.recent_files = [ filename for filename in self.recent_files if filename and os.path.exists(filename) ] if not self.recent_files: recentAction.setEnabled(False) else: recentAction.setEnabled(True) menu = QMenu(self) for i, filename in enumerate(self.recent_files, 1): action = QAction( QIcon(":/document-open.svg"), "&{} {}".format(i, QDir.toNativeSeparators(filename)), menu) action.triggered.connect( lambda filename=filename: self.openXix(filename)) menu.addAction(action) recentAction.setMenu(menu)
def _create_lockfile(self): """ Attempt to create a lockfile in the user's temporary directory. This is one of the few things that doesn't obey the path functions of profile. """ lockfile = os.path.abspath(os.path.join(QDir.tempPath(), u'%s.lock' % self._app_id)) try: fd = os.open(lockfile, os.O_TRUNC | os.O_CREAT | os.O_RDWR) fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) os.write(fd, "%d\n" % os.getpid()) except (OSError, IOError) as e: if e.errno in (errno.EACCES, errno.EAGAIN): return False raise # We've got it. self._lockfd = fd self._lockfile = lockfile return True
def _outputIndex(self, filename, widget): monitor = Lib.MonitorFile(filename) self.state.outputPath = os.path.dirname(filename) nativeFilename = QDir.toNativeSeparators(filename) try: say("Outputting to “{}”…".format(nativeFilename)) with Lib.DisableUI(*self.state.window.widgets()): config = self.state.model.configs().copy() config.Filename = filename Output.outputEntries(self.state.model, config, "Outputting", self.window.reportProgress) self._reportOnOutput( monitor, "Output to “{}”".format(nativeFilename), "Output Failed", "Failed to output to “{}”".format(nativeFilename)) except Output.Error as err: self._reportOnOutput( monitor, "Output to “{}”".format(nativeFilename), "Output Failed", "Failed to output to “{}”: {}".format(nativeFilename, err)) Lib.restoreFocus(widget)
def open_folder(self): self.imagesList.clear() if not self.current_directory: self.current_directory = QFileDialog.getExistingDirectory( parent=self, caption=u'Add images from directory') folder = QDir(self.current_directory) folder.setNameFilters(['*.png']) folder.setFilter(QDir.Files or QDir.NoDotAndDotDot) dir_iterator = QDirIterator(folder, flags=QDirIterator.Subdirectories, filters=QDir.Files) images = [] while dir_iterator.hasNext(): images.append(folder.relativeFilePath(dir_iterator.next())) self.white_albatross.addImages(folder, images) self.imagesList.addItems(images)
def generate_data_dir(): lmms_rc_file = os.path.join(QDir.home().absolutePath(), '.lmmsrc.xml') xml = BeautifulSoup(open(lmms_rc_file).read()) return os.path.normpath( os.path.split(os.path.split(xml.paths['artwork'].rstrip('/\\'))[0])[0])
def loadImage(self): self.image = QImage(self.directory.path() + QDir.separator() + self.file_name)
def setUp(self): self.original = QDir("./")
def root_abspath(): from PySide.QtCore import QDir return QDir.fromNativeSeparators(os.path.abspath(ROOT_LOCATION))
def initIcons(): # use "icons" as prefix which we used in the .py file (pixmap: icons:file.svg) QDir.addSearchPath("icons", os.path.dirname(__file__) + ICONS_PATH)
def serverFromLocal(self, localpath): serverpath = localpath.replace(self.localdir, '') serverpath = QDir.fromNativeSeparators(serverpath) return serverpath
def on_go_up_parent(self): current_path = QDir(self.files_model.rootPath()) current_path.cdUp() self.on_change_root_path(current_path.absolutePath())
import os from PySide.QtCore import QDir, QFileInfo from Qt5.QtWidgets import QDesktopServices from skunicode import u from skdebug import dwarn def abspath(path): """As a replacement of os.path.abspath, which has encoding issue for unicode path @param path unicode or str @return unicode """ return QFileInfo(path).absoluteFilePath() if path else u"" HOME = QDir.homePath() # unicode #HOME = os.path.expanduser('~') # This will be str instead of unicode DESKTOP = (QDesktopServices.storageLocation(QDesktopServices.DesktopLocation) or os.path.join(HOME, 'Desktop')) SYSTEMDRIVE = u(os.environ.get('windir')) or r"C:" WINDIR = u(os.environ.get('WinDir')) or os.path.join(SYSTEMDRIVE, r"Windows") PROGRAMFILES = u(os.environ.get('ProgramFiles')) or os.path.join( SYSTEMDRIVE, r"Program Files") PROGRAMFILESx86 = u( os.environ.get('ProgramFiles(x86)')) or PROGRAMFILES # try x86 first COMMONPROGRAMFILES = u(os.environ.get('CommonProgramFiles')) or os.path.join( PROGRAMFILES, r"Common Files") COMMONPROGRAMFILESx86 = u( os.environ.get('CommonProgramFiles(x86)')) or os.path.join(
import os from PySide.QtCore import QDir QDir.setSearchPaths( "resources", [os.path.join(os.getenv("GLADE_ROOT", ""), "resources")] )
def _open_image(self): filename, _ = QFileDialog.getOpenFileName( self, 'Open image ...', QDir.homePath(), "Images (*.tiff *.png *.xpm *.jpg)") if filename: self.image_viewer.image = QImage(filename)
import sys #import os from PySide import QtGui #from PySide import QtCore from PySide.QtCore import QDir if __name__ == "__main__": app = QtGui.QApplication(sys.argv) model = QtGui.QFileSystemModel() sRootPath = u"C:/users/sebcourtois" model.setRootPath(sRootPath) model.setFilter(QDir.Filters(QDir.NoDotAndDotDot | QDir.Dirs | QDir.Files)) model.setNameFilters(["*_pkg"]) tree = QtGui.QTreeView() tree.setModel(model) tree.setRootIndex(model.index(sRootPath)) tree.setSortingEnabled(True) tree.show() sys.exit(app.exec_())
def select_save_path(self): fname, _ = QFileDialog.getSaveFileName(self, 'Save file', QDir.homePath(), "*.pdf") self.dest_path_edit.setText(fname)
def clicked_add(self): fname, _ = QFileDialog.getOpenFileNames( self, 'Select two or more PDFs to merge', QDir.homePath(), "*.pdf") self.files_list.addItems(fname)
def testBeginEntryList(self): obj = TestFSHandler() qdir = QDir('/bup') for n1, n2 in zip(qdir.entryList(), ['.', '..', 'A', 'B', 'C']): self.assertEqual(n1, n2) self.assertEqual(len(qdir.entryList()), 5)
def checkout(self): """ Recursively checks out all files on the server. Returns a dictionary of files on the server with their last modified date. :param download: Indicates whether or not the files should be downloaded """ # Check `self.deleteQueue`, `self.uploadQueue` and `self.downloadQueue` queues. # These tasks are done in queues to make sure all FTP commands # are done sequentially, in the same thread. self.deleteAll() self.uploadAll() self.downloadAll() # Handy list to keep track of the checkout process. # This list contain absolute paths only. checked_dirs = list() # Sets '/' as initial directory and initializes `downloading_dir` self.ftp.cwd('/') downloading_dir = self.currentdir check_date = dt.utcnow() sidirlist = list() root_cached = False fileC = 0 while True: # Gets the list of sub directories and files inside the # current directory `downloading_dir`. self.textStatus.emit('Remote scan- Downloading folder list of ' + downloading_dir + '...') if root_cached and downloading_dir == '/': dir_subdirs = saved_root_dirs dirfiles = saved_root_files else: dir_subdirs = self.getDirs(downloading_dir) if downloading_dir == '/': saved_root_dirs = dir_subdirs # sidirlist.extend(dir_subdirs) self.textStatus.emit( 'Remote scan- Downloading files list of ' + downloading_dir + '...') dirfiles = self.getFiles(downloading_dir) if downloading_dir == '/': saved_root_files = dirfiles root_cached = True # Leading '/' in `downloading_dir` breaks the `os.path.join` call localdir = os.path.join(self.localdir, downloading_dir[1:]) if not os.path.exists(localdir): # Creates the directory if it doesn't already exists. os.makedirs(localdir) for file_ in dirfiles: # `serverpath` is the absolute path of the file on the server, # download it only if it hasn't been already downloaded serverpath = os.path.join(downloading_dir, file_) serverpath = QDir.fromNativeSeparators(serverpath) server_file = File.fromPath(serverpath) self.textStatus.emit('Scanning remote file... ' + serverpath + '...') # How do we know if we should check this server file? # We see if the date last checked is the check start time. if server_file.last_checked_server != check_date: # Do this process only once per file # Added by Simon # Give feedback on scanning of files. fileC += 1 if fileC % 1 == 2: self.textStatus.emit( 'Scanning remote files for changes, ' + str(fileC) + ' files scanned.') # STEP: IS THIS THE FIRST TIME WE SAW THE FILE, OR WAS IT ALREADY IN OUR DB? just_added = not server_file.inserver # STEP: IF ITS A NEW FILE, ENSURE WE DONT WANT TO SKIP IT # Example: If it's a temporary file, or a Unix file with a name we don't support. if just_added: filename = os.path.basename(serverpath) if platform.system() == 'Windows': badName = False for chr in [ '\\', '/', ':', '?', '"', '<', '>', '|' ]: if chr in filename: badName = True break if badName: if filename not in self.warnedNames: self.warnedNames.append(filename) self.badFilenameFound.emit(filename) continue # STEP: ASSUMING THE FILE DID EXIST IN OUR DB, LETS SAVE THE LAST MODIFICATION DATE lastmdate = server_file.servermdate # STEP: SAVE THE MOD DATE TO A VARIABLE # Now we get the last mod time. # We expect this to work fine since this file # was found on the server servermdate = self.lastModified(serverpath) # STEP: SET BOOL SHOWING THAT IT WAS ON THE SERVER, SINCE WE KNOW IT IS. server_file.inserver = True # STEP: SET THE TIME THE FILE WAS LAST CHECKED TO THE SCAN START TIME server_file.last_checked_server = check_date # STEP: SET THE MOD DATE IN THE DATABASE TO THE ONE WE JUST GOT server_file.servermdate = servermdate # STEP: SAVE THIS CHANGE TO THE DATABASE server_file.session.commit() delta = 0 if server_file.inlocal: delta = server_file.timeDiff() # Emit the signals after the attributes has been set and committed if just_added is True: self.fileAdded.emit(ServerWatcher.LOCATION, serverpath) elif server_file.servermdate > lastmdate or delta < -Watcher.TOLERANCE: self.fileChanged.emit(ServerWatcher.LOCATION, serverpath, False) #END FOR self.textStatus.emit('Remote scan- Finding next folder...') dir_ready = True for dir_ in dir_subdirs: # `dirpath` is the absolute path of the subdirectory on the server, dirpath = QDir.fromNativeSeparators( os.path.join(downloading_dir, dir_)) # `downloading_dir` is ready only when all its subdirectory are on the # `checked_dirs` list. if dirpath not in checked_dirs: # Found one subdirectory that is not on `checked_dirs`, # will process it in the next iteration. downloading_dir = dirpath dir_ready = False break if dir_ready is True: # All subdirectories of `downloading_dir` are already in `checked_dirs` if downloading_dir == '/': # All directories ready and at '/', means checkout is complete # So, exit the main While loop!! break else: # Not at '/'. Current directory is ready so is appended to `checked_dirs` # Back one directory to find directories that are not in `checked_dirs` checked_dirs.append(downloading_dir) downloading_dir = os.path.dirname(downloading_dir) self.textStatus.emit('Remote scan- Found Folder...') ##### END OF WHILE ################ ################################################################### # Deleted files are the ones whose `last_checked_server` attribute # didn't get updated in the recursive run. session = Session() deleted = session.query(File).filter( File.last_checked_server < check_date).filter( File.inserver == True) for file_ in deleted: self.fileDeleted.emit(ServerWatcher.LOCATION, file_.path) # Wraps up the checkout process, commits to the database. session.commit()
def save(self): with open(self.directory.path() + QDir.separator() + 'box2d.json', 'w') as js: figures_ = [image.getDict() for image in self.images] json.dump(obj=figures_, fp=js, separators=(',', ':'), indent=4)
def initialize(self): locale = QLocale() model = self.state.model if not bool(model): self.browser.setHtml("<font color=red>Information can only " "be shown if an index is open</font>") return top, total, _ = self.state.indicatorCounts() fullname = QDir.toNativeSeparators(os.path.abspath(model.filename)) creator = model.config(Gconf.Key.Creator) created = model.config("Created") created = locale.toString( QDateTime.fromString(created, "yyyy-MM-dd HH:mm:ss")) updated = locale.toString(QFileInfo(model.filename).lastModified()) size = os.path.getsize(model.filename) KB = 1024 MB = KB * KB if size < MB: size = "~{:,} KB ({:,} bytes)".format(round(size / KB), size) else: size = "~{:,} MB ({:,} bytes)".format(round(size / MB), size) filename = re.sub(r"\.xix$", "", os.path.basename(fullname), re.IGNORECASE) version = str(model.version()) secs = self.state.workTime + int(time.monotonic() - self.state.startTime) hours, secs = divmod(secs, 3600) if hours: worktime = "{:,}h{}'".format(hours, secs // 60) else: worktime = "{}'".format(secs // 60) uuid = model.config(UUID) LEFT_STYLE = """ style=" margin-right: 0; padding-right: 0; spacing-right: 0; border-right: 0; " """ RIGHT_STYLE = """ style=" margin-left: 0; padding-left: 0; spacing-left: 0; border-left: 0; " """ color1 = "#DDDDFF" color2 = "#EEEEFF" STYLE = ' style="background-color: {};"' texts = [ """<html><table border=0 style=" background-color: {}; ">""".format(color1) ] for i, (name, value, right, debug) in enumerate(( ("Index", filename, False, False), ("Creator", creator, False, False), ("Filename", fullname, False, False), ("Size", size, False, False), ("Created", created, False, False), ("Updated", updated, False, False), ("Total Entries", "{:,}".format(total), True, False), ("Main Entries", "{:,}".format(top), True, False), ("Subentries", "{:,}".format(total - top), True, False), ("Worktime", worktime, True, False), (None, None, False, False), ("Index Format", version, True, False), ("Index UUID", uuid, True, True), )): if debug and not self.state.window.debug: continue if name is None: color1 = "#EEEEEE" color2 = "#DDDDDD" continue style = STYLE.format(color1 if i % 2 == 0 else color2) align = " align=right" if right else "" texts.append("""<tr{}><td{}>{} </td> <td{}{}>{}</td></tr>""".format(style, LEFT_STYLE, html.escape(name), align, RIGHT_STYLE, html.escape(value))) texts.append("</table></html>") self.browser.setHtml("".join(texts))