def reloadList(self):
try:
saveFileDir = self.savesFolderComboBox.itemData(
self.savesFolderComboBox.currentIndex())
if saveFileDir is None:
log.error("No item selected in savesFolderComboBox!!(?)")
return
if not os.path.isdir(saveFileDir):
raise IOError(
u"Could not find the Minecraft saves directory!\n\n({0} was not found or is not a directory)"
.format(saveFileDir))
log.info("Scanning %s for worlds...", saveFileDir)
potentialWorlds = os.listdir(saveFileDir)
potentialWorlds = [
os.path.join(saveFileDir, p) for p in potentialWorlds
]
worldFiles = [
p for p in potentialWorlds if isLevel(AnvilWorldAdapter, p)
]
self.worldListModel = WorldListModel(worldFiles)
self.worldListView.setModel(self.worldListModel)
except Exception as e:
setWidgetError(
self, e, "An error occurred while scanning the saves folder.")
def reloadList(self):
try:
itemData = self.savesFolderComboBox.itemData(self.savesFolderComboBox.currentIndex())
if itemData is None:
log.error("No item selected in savesFolderComboBox!!(?)")
return
saveFileDir, instanceIndex = itemData
if instanceIndex is not None:
# disable version selector, update resource packs(?)
pass
if not os.path.isdir(saveFileDir):
raise IOError(u"Could not find the Minecraft saves directory!\n\n({0} was not found or is not a directory)".format(saveFileDir))
log.info("Scanning %s for worlds...", saveFileDir)
potentialWorlds = os.listdir(saveFileDir)
potentialWorlds = [os.path.join(saveFileDir, p) for p in potentialWorlds]
worldFiles = [p for p in potentialWorlds if isLevel(AnvilWorldAdapter, p)]
self.worldListModel = WorldListModel(worldFiles)
self.worldListView.setModel(self.worldListModel)
if len(self.worldListModel.worlds):
self.worldListView.setFocus()
self.worldListView.setCurrentIndex(self.worldListModel.createIndex(0, 0))
self.showWorld(self.worldListModel.worlds[0][0])
except EnvironmentError as e:
setWidgetError(self, e)
def reloadList(self):
self.selectedWorldIndex = -1
self.itemWidgets = []
try:
if not os.path.isdir(self.saveFileDir):
raise IOError(
u"Could not find the Minecraft saves directory!\n\n({0} was not found or is not a directory)"
.format(self.saveFileDir))
log.info("Scanning %s for worlds...", self.saveFileDir)
potentialWorlds = os.listdir(self.saveFileDir)
potentialWorlds = [
os.path.join(self.saveFileDir, p) for p in potentialWorlds
]
worldFiles = [
p for p in potentialWorlds if isLevel(AnvilWorldAdapter, p)
]
worldAdapters = []
for f in worldFiles:
try:
adapter = findAdapter(f, readonly=True)
except Exception as e:
log.exception("Could not find adapter for %s: %r", f, e)
continue
else:
worldAdapters.append(adapter)
if len(worldAdapters) == 0:
raise IOError(
"No worlds found! You should probably play Minecraft to create your first world."
)
column = QtGui.QVBoxLayout()
column.setContentsMargins(0, 0, 0, 0)
column.setSpacing(0)
worldGroup = QtGui.QButtonGroup(self)
#worldGroup.setExclusive(True)
for adapter in worldAdapters:
item = WorldListItemWidget(adapter)
self.itemWidgets.append(item)
self.itemWidgets.sort(key=lambda i: i.lastPlayed, reverse=True)
for i, item in enumerate(self.itemWidgets):
worldGroup.addButton(item, i)
column.addWidget(item)
item.doubleClicked.connect(self.worldListItemDoubleClicked)
worldGroup.buttonClicked[int].connect(self.worldListItemClicked)
self.scrollAreaWidgetContents.setLayout(column)
except EnvironmentError as e:
setWidgetError(self, e)
def showWorld(self, filename):
if filename == self._currentFilename:
return
self._currentFilename = filename
self.removeWorldView()
try:
worldEditor = worldeditor.WorldEditor(filename, readonly=True)
except Exception as e:
self.errorWidget = QtGui.QWidget()
setWidgetError(
self.errorWidget, e,
"An error occurred while reading the file %s. This file might not be a Minecraft world. If it is, please file a bug report."
% filename)
self.stackedWidget.addWidget(self.errorWidget)
self.stackedWidget.setCurrentWidget(self.errorWidget)
else:
dim = worldEditor.getDimension()
self.setWorldView(MinimapWorldView(dim))
self.chunkLoader = ChunkLoader(dim)
self.chunkLoader.addClient(self.worldView)
self.chunkLoader.chunkCompleted.connect(self.worldView.update)
try:
try:
player = worldEditor.getPlayer()
log.info("Centering on single-player player.")
except (PlayerNotFound, NBTFormatError):
try:
center = worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = dim.bounds.origin + (dim.bounds.size * 0.5)
else:
if player.dimName == dim.dimName:
center = Vector(*player.Position)
self.worldView.centerOnPoint(center)
else:
center = dim.bounds.origin + (dim.bounds.size * 0.5)
self.worldView.centerOnPoint(center)
except Exception as e:
log.exception("Error while centering view in world list: %s",
e)
log.info("Switched world view")
def __init__(self, worldAdapter, parent=None):
QtGui.QPushButton.__init__(self, parent)
self.filename = worldAdapter.filename
self.setCheckable(True)
self.setFlat(True)
try:
# mapLabel = QtGui.QLabel()
# mapLabel.setFixedSize(72, 72)
displayNameLimit = 50
name = displayName(worldAdapter.filename)
if len(name) > displayNameLimit:
name = name[:displayNameLimit] + "..."
self.displayNameLabel = QtGui.QLabel(name)
self.lastPlayed = lastPlayedTime(worldAdapter)
lastPlayedText = self.lastPlayed.humanize(
) if self.lastPlayed else "Unknown"
self.lastPlayedLabel = QtGui.QLabel(lastPlayedText)
#self.sizeLabel = QtGui.QLabel(self.tr("Calculating area..."))
# areaText = self.tr("%.02f million square meters") % (world.chunkCount * 0.25)
# diskSize = 0
# if hasattr(worldAdapter, 'worldFolder'):
# folder = worldAdapter.worldFolder
# for rf in folder.findRegionFiles():
# diskSize += os.stat(rf).st_size
# else:
# diskSize = os.stat(worldAdapter.filename).st_size
#
# self.diskSizeLabel = QtGui.QLabel(self.tr("%0.2f MB") % (diskSize / 1000000.0))
infoColumn = Column(
self.displayNameLabel,
self.lastPlayedLabel,
#self.diskSizeLabel,
None)
#layout = Row(mapLabel, (infoColumn, 1), None)
layout = infoColumn
#if usefulFilename(world) == world.displayName:
# boxLabelText = world.displayName
#else:
# boxLabelText = self.tr("%s (%s)" % (world.displayName, usefulFilename(world)))
self.setLayout(layout)
self.setMinimumSize(layout.sizeHint())
self.setSizePolicy(QtGui.QSizePolicy.MinimumExpanding,
QtGui.QSizePolicy.MinimumExpanding)
except EnvironmentError as e:
setWidgetError(self, e)
def worldListItemClicked(self, i):
if self.selectedWorldIndex == i:
return
self.selectedWorldIndex = i
import gc
gc.collect()
models = {}
try:
worldEditor = worldeditor.WorldEditor(self.itemWidgets[i].filename,
readonly=True)
except (EnvironmentError, LevelFormatError) as e:
setWidgetError(self.errorWidget, e)
while self.stackedWidget.count():
self.stackedWidget.removeWidget(self.stackedWidget.widget(0))
self.worldViewBox.addWidget(self.errorWidget)
else:
i, v, p = self.getSelectedIVP()
blockModels = models.get(worldEditor.blocktypes)
resLoader = i.getResourceLoader(v, p)
if blockModels is None:
models[worldEditor.blocktypes] = blockModels = BlockModels(
worldEditor.blocktypes, resLoader)
textureAtlas = TextureAtlas(worldEditor, resLoader, blockModels)
dim = worldEditor.getDimension()
self.setWorldView(MinimapWorldView(dim, textureAtlas))
self.chunkLoader = ChunkLoader(dim)
self.chunkLoader.addClient(self.worldView)
self.chunkLoader.chunkCompleted.connect(self.worldView.update)
try:
player = worldEditor.getPlayer()
log.info("Centering on single-player player.")
except PlayerNotFound:
try:
center = worldEditor.worldSpawnPosition()
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = dim.bounds.origin + (dim.bounds.size * 0.5)
else:
if player.dimName == dim.dimName:
center = Vector(*player.Position)
self.worldView.centerOnPoint(center)
else:
center = dim.bounds.origin + (dim.bounds.size * 0.5)
self.worldView.centerOnPoint(center)
log.info("Switched world view")
def showWorld(self, filename):
if filename == self._currentFilename:
return
self._currentFilename = filename
self.removeWorldView()
try:
worldEditor = worldeditor.WorldEditor(filename, readonly=True)
except (EnvironmentError, LevelFormatError, zipfile.BadZipfile) as e:
self.errorWidget = QtGui.QWidget()
setWidgetError(self.errorWidget, e, "An error occurred while reading the world %s." % filename)
self.stackedWidget.addWidget(self.errorWidget)
self.stackedWidget.setCurrentWidget(self.errorWidget)
else:
dim = worldEditor.getDimension()
self.setWorldView(MinimapWorldView(dim))
self.chunkLoader = ChunkLoader(dim)
self.chunkLoader.addClient(self.worldView)
self.chunkLoader.chunkCompleted.connect(self.worldView.update)
try:
try:
player = worldEditor.getPlayer()
log.info("Centering on single-player player.")
except PlayerNotFound:
try:
center = worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = dim.bounds.origin + (dim.bounds.size * 0.5)
else:
if player.dimName == dim.dimName:
center = Vector(*player.Position)
self.worldView.centerOnPoint(center)
else:
center = dim.bounds.origin + (dim.bounds.size * 0.5)
self.worldView.centerOnPoint(center)
except Exception as e:
log.exception("Error while centering view in world list: %s", e)
log.info("Switched world view")
def showWorld(self, filename):
self.removeWorldView()
try:
worldEditor = worldeditor.WorldEditor(filename, readonly=True)
resLoader = QtGui.qApp.getResourceLoaderForFilename(filename)
blockModels = BlockModels(worldEditor.blocktypes, resLoader)
textureAtlas = TextureAtlas(worldEditor, resLoader, blockModels)
except (EnvironmentError, LevelFormatError, zipfile.BadZipfile) as e:
self.errorWidget = QtGui.QWidget()
setWidgetError(self.errorWidget, e)
self.stackedWidget.addWidget(self.errorWidget)
self.stackedWidget.setCurrentWidget(self.errorWidget)
else:
dim = worldEditor.getDimension()
self.setWorldView(MinimapWorldView(dim, textureAtlas))
self.chunkLoader = ChunkLoader(dim)
self.chunkLoader.addClient(self.worldView)
self.chunkLoader.chunkCompleted.connect(self.worldView.update)
try:
try:
player = worldEditor.getPlayer()
log.info("Centering on single-player player.")
except PlayerNotFound:
try:
center = worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = dim.bounds.origin + (dim.bounds.size * 0.5)
else:
if player.dimName == dim.dimName:
center = Vector(*player.Position)
self.worldView.centerOnPoint(center)
else:
center = dim.bounds.origin + (dim.bounds.size * 0.5)
self.worldView.centerOnPoint(center)
except Exception as e:
log.exception("Error while centering view in world list: %s",
e)
log.info("Switched world view")
def loadFile(self, filename, readonly=False):
filename = os.path.normpath(filename)
for s in self.sessions:
if s.filename == filename:
self.tabWidget.setCurrentWidget(s.editorTab)
return
self.hideWorldList()
fileLoadingDialog = MCEProgressDialog(self.tr("Loading world..."),
None, 0, 1, self.mainWindow)
fileLoadingDialog.setAutoReset(False)
fileLoadingDialog.setWindowModality(Qt.WindowModal)
fileLoadingDialog.setMinimumDuration(0)
fileLoadingDialog.setValue(0)
fileLoadingDialog.setWindowTitle(self.tr("Loading world..."))
self.processEvents()
def callback(current, max, status):
fileLoadingDialog.setValue(current)
fileLoadingDialog.setMaximum(max)
fileLoadingDialog.setLabelText(status)
try:
configuredBlocks = self.configureBlocksDialog.getConfiguredBlocks()
session = EditorSession(filename,
configuredBlocks,
readonly=readonly,
progressCallback=callback)
self.undoGroup.addStack(session.undoStack)
self.tabWidget.addTab(session.editorTab, session.tabCaption())
self.tabWidget.setCurrentWidget(session.editorTab)
self.sessions.append(session)
self.addRecentFile(filename)
session.loadDone()
except Exception as e:
log.exception("EditorSession failed to open %s: %r", filename, e)
errorTab = QtGui.QWidget()
setWidgetError(errorTab, e,
"An error occurred while opening %s" % filename)
self.tabWidget.addTab(errorTab, "Failed to open %s" % filename)
fileLoadingDialog.reset()
def showWorld(self, filename):
self.removeWorldView()
try:
worldEditor = worldeditor.WorldEditor(filename, readonly=True)
resLoader = QtGui.qApp.getResourceLoaderForFilename(filename)
blockModels = BlockModels(worldEditor.blocktypes, resLoader)
textureAtlas = TextureAtlas(worldEditor, resLoader, blockModels)
except (EnvironmentError, LevelFormatError, zipfile.BadZipfile) as e:
self.errorWidget = QtGui.QWidget()
setWidgetError(self.errorWidget, e)
self.stackedWidget.addWidget(self.errorWidget)
self.stackedWidget.setCurrentWidget(self.errorWidget)
else:
dim = worldEditor.getDimension()
self.setWorldView(MinimapWorldView(dim, textureAtlas))
self.chunkLoader = ChunkLoader(dim)
self.chunkLoader.addClient(self.worldView)
self.chunkLoader.chunkCompleted.connect(self.worldView.update)
try:
try:
player = worldEditor.getPlayer()
log.info("Centering on single-player player.")
except PlayerNotFound:
try:
center = worldEditor.getWorldMetadata().Spawn
log.info("Centering on spawn position.")
except AttributeError:
log.info("Centering on world center")
center = dim.bounds.origin + (dim.bounds.size * 0.5)
else:
if player.dimName == dim.dimName:
center = Vector(*player.Position)
self.worldView.centerOnPoint(center)
else:
center = dim.bounds.origin + (dim.bounds.size * 0.5)
self.worldView.centerOnPoint(center)
except Exception as e:
log.exception("Error while centering view in world list: %s", e)
log.info("Switched world view")
def loadFile(self, filename, readonly=False):
self.hideWorldList()
try:
session = EditorSession(filename,
self.worldList.getSelectedIVP(),
readonly=readonly)
self.undoGroup.addStack(session.undoStack)
self.tabWidget.addTab(session.editorTab, session.tabCaption())
self.tabWidget.setCurrentWidget(session.editorTab)
self.sessions.append(session)
session.loadDone()
except EnvironmentError as e:
log.exception("EditorSession failed to open %s: %r", filename, e)
errorTab = QtGui.QWidget()
setWidgetError(errorTab, e)
self.tabWidget.addTab(errorTab, "Failed to open %s" % filename)
def reloadList(self):
try:
saveFileDir = self.savesFolderComboBox.itemData(self.savesFolderComboBox.currentIndex())
if saveFileDir is None:
log.error("No item selected in savesFolderComboBox!!(?)")
return
if not os.path.isdir(saveFileDir):
raise IOError(u"Could not find the Minecraft saves directory!\n\n({0} was not found or is not a directory)".format(saveFileDir))
log.info("Scanning %s for worlds...", saveFileDir)
potentialWorlds = os.listdir(saveFileDir)
potentialWorlds = [os.path.join(saveFileDir, p) for p in potentialWorlds]
worldFiles = [p for p in potentialWorlds if isLevel(AnvilWorldAdapter, p)]
self.worldListModel = WorldListModel(worldFiles)
self.worldListView.setModel(self.worldListModel)
except Exception as e:
setWidgetError(self, e, "An error occurred while scanning the saves folder.")
def loadFile(self, filename, readonly=False):
self.hideWorldList()
fileLoadingDialog = QtGui.QProgressDialog(self.tr("Loading world..."),
None,
0,
1,
self.mainWindow)
fileLoadingDialog.setAutoReset(False)
fileLoadingDialog.setWindowModality(Qt.WindowModal)
fileLoadingDialog.setMinimumDuration(0)
fileLoadingDialog.setValue(0)
fileLoadingDialog.setWindowTitle(self.tr("Loading world..."))
self.processEvents()
def callback(current, max, status):
fileLoadingDialog.setValue(current)
fileLoadingDialog.setMaximum(max)
fileLoadingDialog.setLabelText(status)
try:
resourceLoader = self.getResourceLoaderForFilename(filename)
configuredBlocks = self.configureBlocksDialog.getConfiguredBlocks()
session = EditorSession(filename, resourceLoader, configuredBlocks, readonly=readonly, progressCallback=callback)
self.undoGroup.addStack(session.undoStack)
self.tabWidget.addTab(session.editorTab, session.tabCaption())
self.tabWidget.setCurrentWidget(session.editorTab)
self.sessions.append(session)
self.addRecentFile(filename)
session.loadDone()
except EnvironmentError as e:
log.exception("EditorSession failed to open %s: %r", filename, e)
errorTab = QtGui.QWidget()
setWidgetError(errorTab, e)
self.tabWidget.addTab(errorTab, "Failed to open %s" % filename)
fileLoadingDialog.reset()
def loadFile(self, filename, readonly=False):
self.hideWorldList()
fileLoadingDialog = QtGui.QProgressDialog(self.tr("Loading world..."),
None,
0,
1,
self.mainWindow)
fileLoadingDialog.setAutoReset(False)
fileLoadingDialog.setWindowModality(Qt.WindowModal)
fileLoadingDialog.setMinimumDuration(0)
fileLoadingDialog.setValue(0)
fileLoadingDialog.setWindowTitle(self.tr("Loading world..."))
self.processEvents()
def callback(current, max, status):
fileLoadingDialog.setValue(current)
fileLoadingDialog.setMaximum(max)
fileLoadingDialog.setLabelText(status)
try:
session = EditorSession(filename, self.worldList.getSelectedIVP(), readonly=readonly, progressCallback=callback)
self.undoGroup.addStack(session.undoStack)
self.tabWidget.addTab(session.editorTab, session.tabCaption())
self.tabWidget.setCurrentWidget(session.editorTab)
self.sessions.append(session)
self.addRecentFile(filename)
session.loadDone()
except EnvironmentError as e:
log.exception("EditorSession failed to open %s: %r", filename, e)
errorTab = QtGui.QWidget()
setWidgetError(errorTab, e)
self.tabWidget.addTab(errorTab, "Failed to open %s" % filename)
fileLoadingDialog.reset()
def reloadList(self):
try:
itemData = self.savesFolderComboBox.itemData(
self.savesFolderComboBox.currentIndex())
if itemData is None:
log.error("No item selected in savesFolderComboBox!!(?)")
return
saveFileDir, instanceIndex = itemData
if instanceIndex is not None:
# disable version selector, update resource packs(?)
pass
if not os.path.isdir(saveFileDir):
raise IOError(
u"Could not find the Minecraft saves directory!\n\n({0} was not found or is not a directory)"
.format(saveFileDir))
log.info("Scanning %s for worlds...", saveFileDir)
potentialWorlds = os.listdir(saveFileDir)
potentialWorlds = [
os.path.join(saveFileDir, p) for p in potentialWorlds
]
worldFiles = [
p for p in potentialWorlds if isLevel(AnvilWorldAdapter, p)
]
self.worldListModel = WorldListModel(worldFiles)
self.worldListView.setModel(self.worldListModel)
if len(self.worldListModel.worlds):
self.worldListView.setFocus()
self.worldListView.setCurrentIndex(
self.worldListModel.createIndex(0, 0))
self.showWorld(self.worldListModel.worlds[0][0])
except EnvironmentError as e:
setWidgetError(self, e)
