def refreshtiles_get(self, canvasextent, canvascrs, widthpx, forcedownload=False, cancelledcallback=None):
extll = osm.unproject(canvasextent, canvascrs)
zoom = self.zoom(widthpx, extll)
if zoom is None or self.tiletype is None:
return list(self.loadedlayers.keys()), [], []
tiles = osm.tiles(extll.xMinimum(), extll.xMaximum(),
extll.yMinimum(), extll.yMaximum(), zoom)
if forcedownload:
tilestoclean = list(self.loadedlayers.keys())
tilestoload = tiles
else:
loadedtiles = set(self.loadedlayers.keys())
tilestoclean = loadedtiles.difference(set(tiles))
tilestoload = list(set(tiles).difference(loadedtiles))
#calculate file names and urls
cachedir = qosmsettings.get(qosmsettings.CACHE_DIRECTORY)
tilefiles = [tm.filename(cachedir, self.tiletype, tile, zoom) for tile in tilestoload]
tileurls = [tm.tileurl(self.tiletype, tile, zoom) for tile in tilestoload]
if qosmsettings.get(qosmsettings.AUTODOWNLOAD):
#download (keep on same thread for now)
if not cancelledcallback:
cancelledcallback = lambda: False
dlerrors = []
downloader.download(tileurls, tilefiles, overwrite=forcedownload,
errorhandler=dlerrors.append,
cancelledcallback=cancelledcallback)
if dlerrors:
self.rendererrors += 1
return tilestoclean, tilestoload, tilefiles
def apply(self):
#validate
newcachedir = unicode(self.generalCacheLocation.text())
newcachedir = newcachedir.strip()
if newcachedir.endswith(os.path.sep):
newcachedir = newcachedir[:-1]
if not os.path.isdir(newcachedir):
QMessageBox.information(self, "QOSM Error",
"'%s' is not a directory" % newcachedir)
return False
if (not len(os.listdir(newcachedir)) == 0) and \
((newcachedir != s._defaultsetting(s.CACHE_DIRECTORY)) and
(newcachedir != s.get(s.CACHE_DIRECTORY))):
if QMessageBox.Ok != QMessageBox.question(self, "Question",
"Use non-emtpy directory for cache?",
QMessageBox.Ok | QMessageBox.Cancel):
return False
if newcachedir == s._defaultsetting(s.CACHE_DIRECTORY):
s.reset(s.CACHE_DIRECTORY)
self.generalCacheLocation.setText(s.get(s.CACHE_DIRECTORY))
else:
s.put(s.CACHE_DIRECTORY, newcachedir)
self.generalCacheLocation.setText(newcachedir)
if self.generalMaxTiles.value() == s._defaultsetting(s.MAX_TILES):
s.reset(s.MAX_TILES)
else:
s.put(s.MAX_TILES, self.generalMaxTiles.value())
s.put(s.AUTODOWNLOAD, self.autoDownload.isChecked())
self.apply_customtypes()
self.calculate_cachesize()
return True
def sync_dialog(self):
self.autoDownload.setChecked(s.get(s.AUTODOWNLOAD))
self.generalMaxTiles.setValue(s.get(s.MAX_TILES))
self.generalCacheLocation.setText(s.get(s.CACHE_DIRECTORY))
self.logWhichLog.setCurrentIndex(0)
self.reload_customtypes()
self.calculate_cachesize()
self.on_logWhichLog_currentIndexChanged("Current session")
def add_custom_type(self, urlpattern, label):
customtypes = qosmsettings.get(qosmsettings.CUSTOM_TILE_TYPES)
customtypes[urlpattern] = label
qosmsettings.put(qosmsettings.CUSTOM_TILE_TYPES, customtypes)
self.customUrl.setText("")
self.customUrl.clearFocus()
def on_generalClearCache_released(self):
QMessageBox.information(self, "fish", "fish")
if self.generalCacheLocation.text() == s.get(s.CACHE_DIRECTORY):
if QMessageBox.Ok == QMessageBox.question(self, "Question",
"Clear entire cache directory? This cannot be undone.",
QMessageBox.Ok | QMessageBox.Cancel):
try:
shutil.rmtree(s.get(s.CACHE_DIRECTORY))
os.mkdir(s.get(s.CACHE_DIRECTORY))
self.calculate_cachesize()
except Exception as e:
log("Error clearing cache directory: %s" % e)
QMessageBox.information(self, "Error", "Error cleaning directory: %s" % e)
else:
QMessageBox.information(self, "Error",
"Apply changes to cache directory before clearing.")
def apply_customtypes(self):
customtypes = s.get(s.CUSTOM_TILE_TYPES)
customtypes.clear()
for originalpattern, pattern, label in self.customtypes:
if originalpattern != pattern:
del customtypes[originalpattern]
customtypes[pattern] = label
s.put(s.CUSTOM_TILE_TYPES, customtypes)
def get_label(self, tiletype):
if tiletype in tm.BUILT_IN_LABELS:
return tm.BUILT_IN_LABELS[tiletype]
else:
customtypes = qosmsettings.get(qosmsettings.CUSTOM_TILE_TYPES)
if tiletype in customtypes:
return customtypes[tiletype]
else:
return str(tiletype) # in case None is passed
def calculate_cachesize(self):
if self.cachesizethread is None:
self.generalCacheSize.setText("calculating...")
cachedir = s.get(s.CACHE_DIRECTORY)
self.cachesizethread = DirsizeThread(self, cachedir)
self.cachesizethread.finished.connect(self.cachesize_finished)
self.cachesizethread.start()
else:
log("not starting second cachesize thread")
def get_type(self, urlpattern):
customtypes = qosmsettings.get(qosmsettings.CUSTOM_TILE_TYPES)
if urlpattern in customtypes:
return urlpattern
else:
for tiletype, urllist in tm.BUILT_IN_TILETYPES.items():
for url in urllist:
if urlpattern == url:
return tiletype
return None
def reload_customtypes(self):
customtypes = s.get(s.CUSTOM_TILE_TYPES)
self.tiletypesList.clear()
self.customtypes = []
for pattern, label in customtypes.items():
self.customtypes.append([pattern, pattern, label])
self.tiletypesList.addItem(label)
for i in range(self.tiletypesList.count()):
item = self.tiletypesList.item(i)
item.setFlags(item.flags() | Qt.ItemIsEditable)
self.tiletypesPattern.setText("")
def zoom(self, widthpx, extll):
if self.specifiedzoom is None:
maxzoom = tm.maxzoom(self.tiletype) if self.maxzoom is None else self.maxzoom
autozoom = osm.autozoom(widthpx/(extll.xMaximum()-extll.xMinimum()))
return min(max((tm.minzoom(self.tiletype), autozoom)),
maxzoom)
else:
numtiles = len(osm.tiles(extll.xMinimum(), extll.xMaximum(),
extll.yMinimum(), extll.yMaximum(), self.specifiedzoom))
if numtiles > qosmsettings.get(qosmsettings.MAX_TILES):
log("too many tiles for fixed zoom layer!: %s" % numtiles)
self.rendererrors += 1
return None
else:
return self.specifiedzoom
def refresh_types(self):
self.maptypeSpinner.clear()
i = 0
for tiletype, label in tm.BUILT_IN_LABELS.items():
self.maptypeSpinner.insertItem(i, label)
self.maptypeSpinner.setItemData(i, tiletype)
i += 1
self.maptypeSpinner.insertSeparator(i)
i += 1
customtypes = qosmsettings.get(qosmsettings.CUSTOM_TILE_TYPES)
for tiletype, label in customtypes.items():
self.maptypeSpinner.insertItem(i, label)
self.maptypeSpinner.setItemData(i, tiletype)
i += 1
def run(self):
log("ensuring %s tiles are downloaded" % len(self.tilelist))
cachedir = qosmsettings.get(qosmsettings.CACHE_DIRECTORY)
tilefiles = [tm.filename(cachedir, self.tiletype, tile[0:2], tile[2]) for tile in self.tilelist]
tileurls = [tm.tileurl(self.tiletype, tile[0:2], tile[2]) for tile in self.tilelist]
if not self.overwrite:
#remove existing files
indicies = []
for i in range(len(tilefiles)):
if os.path.exists(tilefiles[i]):
indicies.append(i)
log("removing %s tiles that already exist" % len(indicies))
for i in reversed(indicies):
tilefiles.pop(i)
tileurls.pop(i)
downloader.download(tileurls, tilefiles, self.overwrite, errorhandler=self.emiterror, progresshandler=self.emitprogress,
cancelledcallback=self.isCancelled)
