class TileStampManager(QObject):
setStamp = pyqtSignal(TileStamp)
def __init__(self, toolManager, parent=None):
super().__init__(parent)
self.mStampsByName = QMap()
self.mQuickStamps = QVector()
for i in range(TileStampManager.quickStampKeys().__len__()):
self.mQuickStamps.append(0)
self.mTileStampModel = TileStampModel(self)
self.mToolManager = toolManager
prefs = preferences.Preferences.instance()
prefs.stampsDirectoryChanged.connect(self.stampsDirectoryChanged)
self.mTileStampModel.stampAdded.connect(self.stampAdded)
self.mTileStampModel.stampRenamed.connect(self.stampRenamed)
self.mTileStampModel.stampChanged.connect(self.saveStamp)
self.mTileStampModel.stampRemoved.connect(self.deleteStamp)
self.loadStamps()
def __del__(self):
# needs to be over here where the TileStamp type is complete
pass
##
# Returns the keys used for quickly accessible tile stamps.
# Note: To store a tile layer <Ctrl> is added. The given keys will work
# for recalling the stored values.
##
def quickStampKeys():
keys = [
Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5, Qt.Key_6,
Qt.Key_7, Qt.Key_8, Qt.Key_9
]
return keys
def tileStampModel(self):
return self.mTileStampModel
def createStamp(self):
stamp = self.tampFromContext(self.mToolManager.selectedTool())
if (not stamp.isEmpty()):
self.mTileStampModel.addStamp(stamp)
return stamp
def addVariation(self, targetStamp):
stamp = stampFromContext(self.mToolManager.selectedTool())
if (stamp.isEmpty()):
return
if (stamp == targetStamp): # avoid easy mistake of adding duplicates
return
for variation in stamp.variations():
self.mTileStampModel.addVariation(targetStamp, variation)
def selectQuickStamp(self, index):
stamp = self.mQuickStamps.at(index)
if (not stamp.isEmpty()):
self.setStamp.emit(stamp)
def createQuickStamp(self, index):
stamp = stampFromContext(self.mToolManager.selectedTool())
if (stamp.isEmpty()):
return
self.setQuickStamp(index, stamp)
def extendQuickStamp(self, index):
quickStamp = self.mQuickStamps[index]
if (quickStamp.isEmpty()):
self.createQuickStamp(index)
else:
self.addVariation(quickStamp)
def stampsDirectoryChanged(self):
# erase current stamps
self.mQuickStamps.fill(TileStamp())
self.mStampsByName.clear()
self.mTileStampModel.clear()
self.loadStamps()
def eraseQuickStamp(self, index):
stamp = self.mQuickStamps.at(index)
if (not stamp.isEmpty()):
self.mQuickStamps[index] = TileStamp()
if (not self.mQuickStamps.contains(stamp)):
self.mTileStampModel.removeStamp(stamp)
def setQuickStamp(self, index, stamp):
stamp.setQuickStampIndex(index)
# make sure existing quickstamp is removed from stamp model
self.eraseQuickStamp(index)
self.mTileStampModel.addStamp(stamp)
self.mQuickStamps[index] = stamp
def loadStamps(self):
prefs = preferences.Preferences.instance()
stampsDirectory = prefs.stampsDirectory()
stampsDir = QDir(stampsDirectory)
iterator = QDirIterator(stampsDirectory, ["*.stamp"],
QDir.Files | QDir.Readable)
while (iterator.hasNext()):
stampFileName = iterator.next()
stampFile = QFile(stampFileName)
if (not stampFile.open(QIODevice.ReadOnly)):
continue
data = stampFile.readAll()
document = QJsonDocument.fromBinaryData(data)
if (document.isNull()):
# document not valid binary data, maybe it's an JSON text file
error = QJsonParseError()
document = QJsonDocument.fromJson(data, error)
if (error.error != QJsonParseError.NoError):
qDebug("Failed to parse stamp file:" + error.errorString())
continue
stamp = TileStamp.fromJson(document.object(), stampsDir)
if (stamp.isEmpty()):
continue
stamp.setFileName(iterator.fileInfo().fileName())
self.mTileStampModel.addStamp(stamp)
index = stamp.quickStampIndex()
if (index >= 0 and index < self.mQuickStamps.size()):
self.mQuickStamps[index] = stamp
def stampAdded(self, stamp):
if (stamp.name().isEmpty()
or self.mStampsByName.contains(stamp.name())):
# pick the first available stamp name
name = QString()
index = self.mTileStampModel.stamps().size()
while (self.mStampsByName.contains(name)):
name = str(index)
index += 1
stamp.setName(name)
self.mStampsByName.insert(stamp.name(), stamp)
if (stamp.fileName().isEmpty()):
stamp.setFileName(findStampFileName(stamp.name()))
self.saveStamp(stamp)
def stampRenamed(self, stamp):
existingName = self.mStampsByName.key(stamp)
self.mStampsByName.remove(existingName)
self.mStampsByName.insert(stamp.name(), stamp)
existingFileName = stamp.fileName()
newFileName = findStampFileName(stamp.name(), existingFileName)
if (existingFileName != newFileName):
if (QFile.rename(stampFilePath(existingFileName),
stampFilePath(newFileName))):
stamp.setFileName(newFileName)
def saveStamp(self, stamp):
# make sure we have a stamps directory
prefs = preferences.Preferences.instance()
stampsDirectory = prefs.stampsDirectory()
stampsDir = QDir(stampsDirectory)
if (not stampsDir.exists() and not stampsDir.mkpath(".")):
qDebug("Failed to create stamps directory" + stampsDirectory)
return
filePath = stampsDir.filePath(stamp.fileName())
file = QSaveFile(filePath)
if (not file.open(QIODevice.WriteOnly)):
qDebug("Failed to open stamp file for writing" + filePath)
return
stampJson = stamp.toJson(QFileInfo(filePath).dir())
file.write(QJsonDocument(stampJson).toJson(QJsonDocument.Compact))
if (not file.commit()):
qDebug() << "Failed to write stamp" << filePath
def deleteStamp(self, stamp):
self.mStampsByName.remove(stamp.name())
QFile.remove(stampFilePath(stamp.fileName()))
class ObjectTypesModel(QAbstractTableModel):
ColorRole = Qt.UserRole
def __init__(self, parent):
super().__init__(parent)
self.mObjectTypes = QVector()
def setObjectTypes(self, objectTypes):
self.beginResetModel()
self.mObjectTypes = objectTypes
self.endResetModel()
def objectTypes(self):
return self.mObjectTypes
def rowCount(self, parent):
if parent.isValid():
_x = 0
else:
_x = self.mObjectTypes.size()
return _x
def columnCount(self, parent):
if parent.isValid():
_x = 0
else:
_x = 2
return _x
def headerData(self, section, orientation, role):
if (orientation == Qt.Horizontal):
if (role == Qt.DisplayRole):
x = section
if x==0:
return self.tr("Type")
elif x==1:
return self.tr("Color")
elif (role == Qt.TextAlignmentRole):
return Qt.AlignLeft
return QVariant()
def data(self, index, role):
# QComboBox requests data for an invalid index when the model is empty
if (not index.isValid()):
return QVariant()
objectType = self.mObjectTypes.at(index.row())
if (role == Qt.DisplayRole or role == Qt.EditRole):
if (index.column() == 0):
return objectType.name
if (role == ObjectTypesModel.ColorRole and index.column() == 1):
return objectType.color
return QVariant()
def setData(self, index, value, role):
if (role == Qt.EditRole and index.column() == 0):
self.mObjectTypes[index.row()].name = value.strip()
self.dataChanged.emit(index, index)
return True
return False
def flags(self, index):
f = super().flags(index)
if (index.column() == 0):
f |= Qt.ItemIsEditable
return f
def setObjectTypeColor(self, objectIndex, color):
self.mObjectTypes[objectIndex].color = color
mi = self.index(objectIndex, 1)
self.dataChanged.emit(mi, mi)
def removeObjectTypes(self, indexes):
rows = QVector()
for index in indexes:
rows.append(index.row())
rows = sorted(rows)
for i in range(len(rows) - 1, -1, -1):
row = rows[i]
self.beginRemoveRows(QModelIndex(), row, row)
self.mObjectTypes.remove(row)
self.endRemoveRows()
def appendNewObjectType(self):
self.beginInsertRows(QModelIndex(), self.mObjectTypes.size(), self.mObjectTypes.size())
self.mObjectTypes.append(ObjectType())
self.endInsertRows()
class AutoMapperWrapper(QUndoCommand):
def __init__(self, mapDocument, autoMapper, where):
super().__init__()
self.mLayersAfter = QVector()
self.mLayersBefore = QVector()
self.mMapDocument = mapDocument
map = self.mMapDocument.Map()
touchedLayers = QSet()
index = 0
while (index < autoMapper.size()):
a = autoMapper.at(index)
if (a.prepareAutoMap()):
touchedLayers|= a.getTouchedTileLayers()
index += 1
else:
autoMapper.remove(index)
for layerName in touchedLayers:
layerindex = map.indexOfLayer(layerName)
self.mLayersBefore (map.layerAt(layerindex).clone())
for a in autoMapper:
a.autoMap(where)
for layerName in touchedLayers:
layerindex = map.indexOfLayer(layerName)
# layerindex exists, because AutoMapper is still alive, dont check
self.mLayersAfter (map.layerAt(layerindex).clone())
# reduce memory usage by saving only diffs
for i in range(self.mLayersAfter.size()):
before = self.mLayersBefore.at(i)
after = self.mLayersAfter.at(i)
diffRegion = before.computeDiffRegion(after).boundingRect()
before1 = before.copy(diffRegion)
after1 = after.copy(diffRegion)
before1.setPosition(diffRegion.topLeft())
after1.setPosition(diffRegion.topLeft())
before1.setName(before.name())
after1.setName(after.name())
self.mLayersBefore.replace(i, before1)
self.mLayersAfter.replace(i, after1)
del before
del after
for a in autoMapper:
a.cleanAll()
def __del__(self):
for i in self.mLayersAfter:
del i
for i in self.mLayersBefore:
del i
def undo(self):
map = self.mMapDocument.Map()
for layer in self.mLayersBefore:
layerindex = map.indexOfLayer(layer.name())
if (layerindex != -1):
self.patchLayer(layerindex, layer)
def redo(self):
map = self.mMapDocument.Map()
for layer in self.mLayersAfter:
layerindex = (map.indexOfLayer(layer.name()))
if (layerindex != -1):
self.patchLayer(layerindex, layer)
def patchLayer(self, layerIndex, layer):
map = self.mMapDocument.Map()
b = layer.bounds()
t = map.layerAt(layerIndex)
t.setCells(b.left() - t.x(), b.top() - t.y(), layer,
b.translated(-t.position()))
self.mMapDocument.emitRegionChanged(b, t)
class AutoMapperWrapper(QUndoCommand):
def __init__(self, mapDocument, autoMapper, where):
super().__init__()
self.mLayersAfter = QVector()
self.mLayersBefore = QVector()
self.mMapDocument = mapDocument
map = self.mMapDocument.Map()
touchedLayers = QSet()
index = 0
while (index < autoMapper.size()):
a = autoMapper.at(index)
if (a.prepareAutoMap()):
touchedLayers |= a.getTouchedTileLayers()
index += 1
else:
autoMapper.remove(index)
for layerName in touchedLayers:
layerindex = map.indexOfLayer(layerName)
self.mLayersBefore(map.layerAt(layerindex).clone())
for a in autoMapper:
a.autoMap(where)
for layerName in touchedLayers:
layerindex = map.indexOfLayer(layerName)
# layerindex exists, because AutoMapper is still alive, dont check
self.mLayersAfter(map.layerAt(layerindex).clone())
# reduce memory usage by saving only diffs
for i in range(self.mLayersAfter.size()):
before = self.mLayersBefore.at(i)
after = self.mLayersAfter.at(i)
diffRegion = before.computeDiffRegion(after).boundingRect()
before1 = before.copy(diffRegion)
after1 = after.copy(diffRegion)
before1.setPosition(diffRegion.topLeft())
after1.setPosition(diffRegion.topLeft())
before1.setName(before.name())
after1.setName(after.name())
self.mLayersBefore.replace(i, before1)
self.mLayersAfter.replace(i, after1)
del before
del after
for a in autoMapper:
a.cleanAll()
def __del__(self):
for i in self.mLayersAfter:
del i
for i in self.mLayersBefore:
del i
def undo(self):
map = self.mMapDocument.Map()
for layer in self.mLayersBefore:
layerindex = map.indexOfLayer(layer.name())
if (layerindex != -1):
self.patchLayer(layerindex, layer)
def redo(self):
map = self.mMapDocument.Map()
for layer in self.mLayersAfter:
layerindex = (map.indexOfLayer(layer.name()))
if (layerindex != -1):
self.patchLayer(layerindex, layer)
def patchLayer(self, layerIndex, layer):
map = self.mMapDocument.Map()
b = layer.bounds()
t = map.layerAt(layerIndex)
t.setCells(b.left() - t.x(),
b.top() - t.y(), layer, b.translated(-t.position()))
self.mMapDocument.emitRegionChanged(b, t)
class TilesetDock(QDockWidget):
##
# Emitted when the current tile changed.
##
currentTileChanged = pyqtSignal(list)
##
# Emitted when the currently selected tiles changed.
##
stampCaptured = pyqtSignal(TileStamp)
##
# Emitted when files are dropped at the tileset dock.
##
tilesetsDropped = pyqtSignal(QStringList)
newTileset = pyqtSignal()
##
# Constructor.
##
def __init__(self, parent=None):
super().__init__(parent)
# Shared tileset references because the dock wants to add new tiles
self.mTilesets = QVector()
self.mCurrentTilesets = QMap()
self.mMapDocument = None
self.mTabBar = QTabBar()
self.mViewStack = QStackedWidget()
self.mToolBar = QToolBar()
self.mCurrentTile = None
self.mCurrentTiles = None
self.mNewTileset = QAction(self)
self.mImportTileset = QAction(self)
self.mExportTileset = QAction(self)
self.mPropertiesTileset = QAction(self)
self.mDeleteTileset = QAction(self)
self.mEditTerrain = QAction(self)
self.mAddTiles = QAction(self)
self.mRemoveTiles = QAction(self)
self.mTilesetMenuButton = TilesetMenuButton(self)
self.mTilesetMenu = QMenu(self) # opens on click of mTilesetMenu
self.mTilesetActionGroup = QActionGroup(self)
self.mTilesetMenuMapper = None # needed due to dynamic content
self.mEmittingStampCaptured = False
self.mSynchronizingSelection = False
self.setObjectName("TilesetDock")
self.mTabBar.setMovable(True)
self.mTabBar.setUsesScrollButtons(True)
self.mTabBar.currentChanged.connect(self.updateActions)
self.mTabBar.tabMoved.connect(self.moveTileset)
w = QWidget(self)
horizontal = QHBoxLayout()
horizontal.setSpacing(0)
horizontal.addWidget(self.mTabBar)
horizontal.addWidget(self.mTilesetMenuButton)
vertical = QVBoxLayout(w)
vertical.setSpacing(0)
vertical.setContentsMargins(5, 5, 5, 5)
vertical.addLayout(horizontal)
vertical.addWidget(self.mViewStack)
horizontal = QHBoxLayout()
horizontal.setSpacing(0)
horizontal.addWidget(self.mToolBar, 1)
vertical.addLayout(horizontal)
self.mNewTileset.setIcon(QIcon(":images/16x16/document-new.png"))
self.mImportTileset.setIcon(QIcon(":images/16x16/document-import.png"))
self.mExportTileset.setIcon(QIcon(":images/16x16/document-export.png"))
self.mPropertiesTileset.setIcon(
QIcon(":images/16x16/document-properties.png"))
self.mDeleteTileset.setIcon(QIcon(":images/16x16/edit-delete.png"))
self.mEditTerrain.setIcon(QIcon(":images/16x16/terrain.png"))
self.mAddTiles.setIcon(QIcon(":images/16x16/add.png"))
self.mRemoveTiles.setIcon(QIcon(":images/16x16/remove.png"))
Utils.setThemeIcon(self.mNewTileset, "document-new")
Utils.setThemeIcon(self.mImportTileset, "document-import")
Utils.setThemeIcon(self.mExportTileset, "document-export")
Utils.setThemeIcon(self.mPropertiesTileset, "document-properties")
Utils.setThemeIcon(self.mDeleteTileset, "edit-delete")
Utils.setThemeIcon(self.mAddTiles, "add")
Utils.setThemeIcon(self.mRemoveTiles, "remove")
self.mNewTileset.triggered.connect(self.newTileset)
self.mImportTileset.triggered.connect(self.importTileset)
self.mExportTileset.triggered.connect(self.exportTileset)
self.mPropertiesTileset.triggered.connect(self.editTilesetProperties)
self.mDeleteTileset.triggered.connect(self.removeTileset)
self.mEditTerrain.triggered.connect(self.editTerrain)
self.mAddTiles.triggered.connect(self.addTiles)
self.mRemoveTiles.triggered.connect(self.removeTiles)
self.mToolBar.addAction(self.mNewTileset)
self.mToolBar.setIconSize(QSize(16, 16))
self.mToolBar.addAction(self.mImportTileset)
self.mToolBar.addAction(self.mExportTileset)
self.mToolBar.addAction(self.mPropertiesTileset)
self.mToolBar.addAction(self.mDeleteTileset)
self.mToolBar.addAction(self.mEditTerrain)
self.mToolBar.addAction(self.mAddTiles)
self.mToolBar.addAction(self.mRemoveTiles)
self.mZoomable = Zoomable(self)
self.mZoomComboBox = QComboBox()
self.mZoomable.connectToComboBox(self.mZoomComboBox)
horizontal.addWidget(self.mZoomComboBox)
self.mViewStack.currentChanged.connect(self.updateCurrentTiles)
TilesetManager.instance().tilesetChanged.connect(self.tilesetChanged)
DocumentManager.instance().documentAboutToClose.connect(
self.documentAboutToClose)
self.mTilesetMenuButton.setMenu(self.mTilesetMenu)
self.mTilesetMenu.aboutToShow.connect(self.refreshTilesetMenu)
self.setWidget(w)
self.retranslateUi()
self.setAcceptDrops(True)
self.updateActions()
def __del__(self):
del self.mCurrentTiles
##
# Sets the map for which the tilesets should be displayed.
##
def setMapDocument(self, mapDocument):
if (self.mMapDocument == mapDocument):
return
# Hide while we update the tab bar, to avoid repeated layouting
if sys.platform != 'darwin':
self.widget().hide()
self.setCurrentTiles(None)
self.setCurrentTile(None)
if (self.mMapDocument):
# Remember the last visible tileset for this map
tilesetName = self.mTabBar.tabText(self.mTabBar.currentIndex())
self.mCurrentTilesets.insert(self.mMapDocument, tilesetName)
# Clear previous content
while (self.mTabBar.count()):
self.mTabBar.removeTab(0)
while (self.mViewStack.count()):
self.mViewStack.removeWidget(self.mViewStack.widget(0))
#self.mTilesets.clear()
# Clear all connections to the previous document
if (self.mMapDocument):
self.mMapDocument.disconnect()
self.mMapDocument = mapDocument
if (self.mMapDocument):
self.mTilesets = self.mMapDocument.map().tilesets()
for tileset in self.mTilesets:
view = TilesetView()
view.setMapDocument(self.mMapDocument)
view.setZoomable(self.mZoomable)
self.mTabBar.addTab(tileset.name())
self.mViewStack.addWidget(view)
self.mMapDocument.tilesetAdded.connect(self.tilesetAdded)
self.mMapDocument.tilesetRemoved.connect(self.tilesetRemoved)
self.mMapDocument.tilesetMoved.connect(self.tilesetMoved)
self.mMapDocument.tilesetNameChanged.connect(
self.tilesetNameChanged)
self.mMapDocument.tilesetFileNameChanged.connect(
self.updateActions)
self.mMapDocument.tilesetChanged.connect(self.tilesetChanged)
self.mMapDocument.tileAnimationChanged.connect(
self.tileAnimationChanged)
cacheName = self.mCurrentTilesets.take(self.mMapDocument)
for i in range(self.mTabBar.count()):
if (self.mTabBar.tabText(i) == cacheName):
self.mTabBar.setCurrentIndex(i)
break
object = self.mMapDocument.currentObject()
if object:
if object.typeId() == Object.TileType:
self.setCurrentTile(object)
self.updateActions()
if sys.platform != 'darwin':
self.widget().show()
##
# Synchronizes the selection with the given stamp. Ignored when the stamp is
# changing because of a selection change in the TilesetDock.
##
def selectTilesInStamp(self, stamp):
if self.mEmittingStampCaptured:
return
processed = QSet()
selections = QMap()
for variation in stamp.variations():
tileLayer = variation.tileLayer()
for cell in tileLayer:
tile = cell.tile
if tile:
if (processed.contains(tile)):
continue
processed.insert(tile) # avoid spending time on duplicates
tileset = tile.tileset()
tilesetIndex = self.mTilesets.indexOf(
tileset.sharedPointer())
if (tilesetIndex != -1):
view = self.tilesetViewAt(tilesetIndex)
if (not view.model()): # Lazily set up the model
self.setupTilesetModel(view, tileset)
model = view.tilesetModel()
modelIndex = model.tileIndex(tile)
selectionModel = view.selectionModel()
_x = QItemSelection()
_x.select(modelIndex, modelIndex)
selections[selectionModel] = _x
if (not selections.isEmpty()):
self.mSynchronizingSelection = True
# Mark captured tiles as selected
for i in selections:
selectionModel = i[0]
selection = i[1]
selectionModel.select(selection,
QItemSelectionModel.SelectCurrent)
# Show/edit properties of all captured tiles
self.mMapDocument.setSelectedTiles(processed.toList())
# Update the current tile (useful for animation and collision editors)
first = selections.first()
selectionModel = first[0]
selection = first[1]
currentIndex = QModelIndex(selection.first().topLeft())
if (selectionModel.currentIndex() != currentIndex):
selectionModel.setCurrentIndex(currentIndex,
QItemSelectionModel.NoUpdate)
else:
self.currentChanged(currentIndex)
self.mSynchronizingSelection = False
def currentTilesetChanged(self):
view = self.currentTilesetView()
if view:
s = view.selectionModel()
if s:
self.setCurrentTile(view.tilesetModel().tileAt(
s.currentIndex()))
##
# Returns the currently selected tile.
##
def currentTile(self):
return self.mCurrentTile
def changeEvent(self, e):
super().changeEvent(e)
x = e.type()
if x == QEvent.LanguageChange:
self.retranslateUi()
else:
pass
def dragEnterEvent(self, e):
urls = e.mimeData().urls()
if (not urls.isEmpty() and not urls.at(0).toLocalFile().isEmpty()):
e.accept()
def dropEvent(self, e):
paths = QStringList()
for url in e.mimeData().urls():
localFile = url.toLocalFile()
if (not localFile.isEmpty()):
paths.append(localFile)
if (not paths.isEmpty()):
self.tilesetsDropped.emit(paths)
e.accept()
def selectionChanged(self):
self.updateActions()
if not self.mSynchronizingSelection:
self.updateCurrentTiles()
def currentChanged(self, index):
if (not index.isValid()):
return
model = index.model()
self.setCurrentTile(model.tileAt(index))
def updateActions(self):
external = False
hasImageSource = False
hasSelection = False
view = None
index = self.mTabBar.currentIndex()
if (index > -1):
view = self.tilesetViewAt(index)
if (view):
tileset = self.mTilesets.at(index)
if (not view.model()): # Lazily set up the model
self.setupTilesetModel(view, tileset)
self.mViewStack.setCurrentIndex(index)
external = tileset.isExternal()
hasImageSource = tileset.imageSource() != ''
hasSelection = view.selectionModel().hasSelection()
tilesetIsDisplayed = view != None
mapIsDisplayed = self.mMapDocument != None
self.mNewTileset.setEnabled(mapIsDisplayed)
self.mImportTileset.setEnabled(tilesetIsDisplayed and external)
self.mExportTileset.setEnabled(tilesetIsDisplayed and not external)
self.mPropertiesTileset.setEnabled(tilesetIsDisplayed and not external)
self.mDeleteTileset.setEnabled(tilesetIsDisplayed)
self.mEditTerrain.setEnabled(tilesetIsDisplayed and not external)
self.mAddTiles.setEnabled(tilesetIsDisplayed and not hasImageSource
and not external)
self.mRemoveTiles.setEnabled(tilesetIsDisplayed and not hasImageSource
and hasSelection and not external)
def updateCurrentTiles(self):
view = self.currentTilesetView()
if (not view):
return
s = view.selectionModel()
if (not s):
return
indexes = s.selection().indexes()
if len(indexes) == 0:
return
first = indexes[0]
minX = first.column()
maxX = first.column()
minY = first.row()
maxY = first.row()
for index in indexes:
if minX > index.column():
minX = index.column()
if maxX < index.column():
maxX = index.column()
if minY > index.row():
minY = index.row()
if maxY < index.row():
maxY = index.row()
# Create a tile layer from the current selection
tileLayer = TileLayer(QString(), 0, 0, maxX - minX + 1,
maxY - minY + 1)
model = view.tilesetModel()
for index in indexes:
tileLayer.setCell(index.column() - minX,
index.row() - minY, Cell(model.tileAt(index)))
self.setCurrentTiles(tileLayer)
def indexPressed(self, index):
view = self.currentTilesetView()
tile = view.tilesetModel().tileAt(index)
if tile:
self.mMapDocument.setCurrentObject(tile)
def tilesetAdded(self, index, tileset):
view = TilesetView()
view.setMapDocument(self.mMapDocument)
view.setZoomable(self.mZoomable)
self.mTilesets.insert(index, tileset.sharedPointer())
self.mTabBar.insertTab(index, tileset.name())
self.mViewStack.insertWidget(index, view)
self.updateActions()
def tilesetChanged(self, tileset):
# Update the affected tileset model, if it exists
index = indexOf(self.mTilesets, tileset)
if (index < 0):
return
model = self.tilesetViewAt(index).tilesetModel()
if model:
model.tilesetChanged()
def tilesetRemoved(self, tileset):
# Delete the related tileset view
index = indexOf(self.mTilesets, tileset)
self.mTilesets.removeAt(index)
self.mTabBar.removeTab(index)
self.tilesetViewAt(index).close()
# Make sure we don't reference this tileset anymore
if (self.mCurrentTiles):
# TODO: Don't clean unnecessarily (but first the concept of
# "current brush" would need to be introduced)
cleaned = self.mCurrentTiles.clone()
cleaned.removeReferencesToTileset(tileset)
self.setCurrentTiles(cleaned)
if (self.mCurrentTile and self.mCurrentTile.tileset() == tileset):
self.setCurrentTile(None)
self.updateActions()
def tilesetMoved(self, _from, to):
self.mTilesets.insert(to, self.mTilesets.takeAt(_from))
# Move the related tileset views
widget = self.mViewStack.widget(_from)
self.mViewStack.removeWidget(widget)
self.mViewStack.insertWidget(to, widget)
self.mViewStack.setCurrentIndex(self.mTabBar.currentIndex())
# Update the titles of the affected tabs
start = min(_from, to)
end = max(_from, to)
for i in range(start, end + 1):
tileset = self.mTilesets.at(i)
if (self.mTabBar.tabText(i) != tileset.name()):
self.mTabBar.setTabText(i, tileset.name())
def tilesetNameChanged(self, tileset):
index = indexOf(self.mTilesets, tileset)
self.mTabBar.setTabText(index, tileset.name())
def tileAnimationChanged(self, tile):
view = self.currentTilesetView()
if view:
model = view.tilesetModel()
if model:
model.tileChanged(tile)
##
# Removes the currently selected tileset.
##
def removeTileset(self, *args):
l = len(args)
if l == 0:
currentIndex = self.mViewStack.currentIndex()
if (currentIndex != -1):
self.removeTileset(self.mViewStack.currentIndex())
elif l == 1:
##
# Removes the tileset at the given index. Prompting the user when the tileset
# is in use by the map.
##
index = args[0]
tileset = self.mTilesets.at(index).data()
inUse = self.mMapDocument.map().isTilesetUsed(tileset)
# If the tileset is in use, warn the user and confirm removal
if (inUse):
warning = QMessageBox(
QMessageBox.Warning, self.tr("Remove Tileset"),
self.tr("The tileset \"%s\" is still in use by the map!" %
tileset.name()), QMessageBox.Yes | QMessageBox.No,
self)
warning.setDefaultButton(QMessageBox.Yes)
warning.setInformativeText(
self.tr("Remove this tileset and all references "
"to the tiles in this tileset?"))
if (warning.exec() != QMessageBox.Yes):
return
remove = RemoveTileset(self.mMapDocument, index, tileset)
undoStack = self.mMapDocument.undoStack()
if (inUse):
# Remove references to tiles in this tileset from the current map
def referencesTileset(cell):
tile = cell.tile
if tile:
return tile.tileset() == tileset
return False
undoStack.beginMacro(remove.text())
removeTileReferences(self.mMapDocument, referencesTileset)
undoStack.push(remove)
if (inUse):
undoStack.endMacro()
def moveTileset(self, _from, to):
command = MoveTileset(self.mMapDocument, _from, to)
self.mMapDocument.undoStack().push(command)
def editTilesetProperties(self):
tileset = self.currentTileset()
if (not tileset):
return
self.mMapDocument.setCurrentObject(tileset)
self.mMapDocument.emitEditCurrentObject()
def importTileset(self):
tileset = self.currentTileset()
if (not tileset):
return
command = SetTilesetFileName(self.mMapDocument, tileset, QString())
self.mMapDocument.undoStack().push(command)
def exportTileset(self):
tileset = self.currentTileset()
if (not tileset):
return
tsxFilter = self.tr("Tiled tileset files (*.tsx)")
helper = FormatHelper(FileFormat.ReadWrite, tsxFilter)
prefs = preferences.Preferences.instance()
suggestedFileName = prefs.lastPath(
preferences.Preferences.ExternalTileset)
suggestedFileName += '/'
suggestedFileName += tileset.name()
extension = ".tsx"
if (not suggestedFileName.endswith(extension)):
suggestedFileName += extension
selectedFilter = tsxFilter
fileName, _ = QFileDialog.getSaveFileName(self,
self.tr("Export Tileset"),
suggestedFileName,
helper.filter(),
selectedFilter)
if fileName == '':
return
prefs.setLastPath(preferences.Preferences.ExternalTileset,
QFileInfo(fileName).path())
tsxFormat = TsxTilesetFormat()
format = helper.formatByNameFilter(selectedFilter)
if not format:
format = tsxFormat
if format.write(tileset, fileName):
command = SetTilesetFileName(self.mMapDocument, tileset, fileName)
self.mMapDocument.undoStack().push(command)
else:
error = format.errorString()
QMessageBox.critical(self.window(), self.tr("Export Tileset"),
self.tr("Error saving tileset: %s" % error))
def editTerrain(self):
tileset = self.currentTileset()
if (not tileset):
return
editTerrainDialog = EditTerrainDialog(self.mMapDocument, tileset, self)
editTerrainDialog.exec()
def addTiles(self):
tileset = self.currentTileset()
if (not tileset):
return
prefs = preferences.Preferences.instance()
startLocation = QFileInfo(
prefs.lastPath(preferences.Preferences.ImageFile)).absolutePath()
filter = Utils.readableImageFormatsFilter()
files = QFileDialog.getOpenFileNames(self.window(),
self.tr("Add Tiles"),
startLocation, filter)
tiles = QList()
id = tileset.tileCount()
for file in files:
image = QPixmap(file)
if (not image.isNull()):
tiles.append(Tile(image, file, id, tileset))
id += 1
else:
warning = QMessageBox(QMessageBox.Warning,
self.tr("Add Tiles"),
self.tr("Could not load \"%s\"!" % file),
QMessageBox.Ignore | QMessageBox.Cancel,
self.window())
warning.setDefaultButton(QMessageBox.Ignore)
if (warning.exec() != QMessageBox.Ignore):
tiles.clear()
return
if (tiles.isEmpty()):
return
prefs.setLastPath(preferences.Preferences.ImageFile, files.last())
self.mMapDocument.undoStack().push(
AddTiles(self.mMapDocument, tileset, tiles))
def removeTiles(self):
view = self.currentTilesetView()
if (not view):
return
if (not view.selectionModel().hasSelection()):
return
indexes = view.selectionModel().selectedIndexes()
model = view.tilesetModel()
tileIds = RangeSet()
tiles = QList()
for index in indexes:
tile = model.tileAt(index)
if tile:
tileIds.insert(tile.id())
tiles.append(tile)
def matchesAnyTile(cell):
tile = cell.tile
if tile:
return tiles.contains(tile)
return False
inUse = self.hasTileReferences(self.mMapDocument, matchesAnyTile)
# If the tileset is in use, warn the user and confirm removal
if (inUse):
warning = QMessageBox(
QMessageBox.Warning, self.tr("Remove Tiles"),
self.tr("One or more of the tiles to be removed are "
"still in use by the map!"),
QMessageBox.Yes | QMessageBox.No, self)
warning.setDefaultButton(QMessageBox.Yes)
warning.setInformativeText(
self.tr("Remove all references to these tiles?"))
if (warning.exec() != QMessageBox.Yes):
return
undoStack = self.mMapDocument.undoStack()
undoStack.beginMacro(self.tr("Remove Tiles"))
removeTileReferences(self.mMapDocument, matchesAnyTile)
# Iterate backwards over the ranges in order to keep the indexes valid
firstRange = tileIds.begin()
it = tileIds.end()
if (it == firstRange): # no range
return
tileset = view.tilesetModel().tileset()
while (it != firstRange):
it -= 1
item = tileIds.item(it)
length = item[1] - item[0] + 1
undoStack.push(
RemoveTiles(self.mMapDocument, tileset, item[0], length))
undoStack.endMacro()
# Clear the current tiles, will be referencing the removed tiles
self.setCurrentTiles(None)
self.setCurrentTile(None)
def documentAboutToClose(self, mapDocument):
self.mCurrentTilesets.remove(mapDocument)
def refreshTilesetMenu(self):
self.mTilesetMenu.clear()
if (self.mTilesetMenuMapper):
self.mTabBar.disconnect(self.mTilesetMenuMapper)
del self.mTilesetMenuMapper
self.mTilesetMenuMapper = QSignalMapper(self)
self.mTilesetMenuMapper.mapped.connect(self.mTabBar.setCurrentIndex)
currentIndex = self.mTabBar.currentIndex()
for i in range(self.mTabBar.count()):
action = QAction(self.mTabBar.tabText(i), self)
action.setCheckable(True)
self.mTilesetActionGroup.addAction(action)
if (i == currentIndex):
action.setChecked(True)
self.mTilesetMenu.addAction(action)
action.triggered.connect(self.mTilesetMenuMapper.map)
self.mTilesetMenuMapper.setMapping(action, i)
def setCurrentTile(self, tile):
if (self.mCurrentTile == tile):
return
self.mCurrentTile = tile
self.currentTileChanged.emit([tile])
if (tile):
self.mMapDocument.setCurrentObject(tile)
def setCurrentTiles(self, tiles):
if (self.mCurrentTiles == tiles):
return
del self.mCurrentTiles
self.mCurrentTiles = tiles
# Set the selected tiles on the map document
if (tiles):
selectedTiles = QList()
for y in range(tiles.height()):
for x in range(tiles.width()):
cell = tiles.cellAt(x, y)
if (not cell.isEmpty()):
selectedTiles.append(cell.tile)
self.mMapDocument.setSelectedTiles(selectedTiles)
# Create a tile stamp with these tiles
map = self.mMapDocument.map()
stamp = Map(map.orientation(), tiles.width(), tiles.height(),
map.tileWidth(), map.tileHeight())
stamp.addLayer(tiles.clone())
stamp.addTilesets(tiles.usedTilesets())
self.mEmittingStampCaptured = True
self.stampCaptured.emit(TileStamp(stamp))
self.mEmittingStampCaptured = False
def retranslateUi(self):
self.setWindowTitle(self.tr("Tilesets"))
self.mNewTileset.setText(self.tr("New Tileset"))
self.mImportTileset.setText(self.tr("Import Tileset"))
self.mExportTileset.setText(self.tr("Export Tileset As..."))
self.mPropertiesTileset.setText(self.tr("Tileset Properties"))
self.mDeleteTileset.setText(self.tr("Remove Tileset"))
self.mEditTerrain.setText(self.tr("Edit Terrain Information"))
self.mAddTiles.setText(self.tr("Add Tiles"))
self.mRemoveTiles.setText(self.tr("Remove Tiles"))
def currentTileset(self):
index = self.mTabBar.currentIndex()
if (index == -1):
return None
return self.mTilesets.at(index)
def currentTilesetView(self):
return self.mViewStack.currentWidget()
def tilesetViewAt(self, index):
return self.mViewStack.widget(index)
def setupTilesetModel(self, view, tileset):
view.setModel(TilesetModel(tileset, view))
s = view.selectionModel()
s.selectionChanged.connect(self.selectionChanged)
s.currentChanged.connect(self.currentChanged)
view.pressed.connect(self.indexPressed)
class TileLayer(Layer):
##
# Constructor.
##
def __init__(self, name, x, y, width, height):
super().__init__(Layer.TileLayerType, name, x, y, width, height)
self.mMaxTileSize = QSize(0, 0)
self.mGrid = QVector()
for i in range(width * height):
self.mGrid.append(Cell())
self.mOffsetMargins = QMargins()
def __iter__(self):
return self.mGrid.__iter__()
##
# Returns the maximum tile size of this layer.
##
def maxTileSize(self):
return self.mMaxTileSize
##
# Returns the margins that have to be taken into account while drawing
# this tile layer. The margins depend on the maximum tile size and the
# offset applied to the tiles.
##
def drawMargins(self):
return QMargins(self.mOffsetMargins.left(),
self.mOffsetMargins.top() + self.mMaxTileSize.height(),
self.mOffsetMargins.right() + self.mMaxTileSize.width(),
self.mOffsetMargins.bottom())
##
# Recomputes the draw margins. Needed after the tile offset of a tileset
# has changed for example.
#
# Generally you want to call Map.recomputeDrawMargins instead.
##
def recomputeDrawMargins(self):
maxTileSize = QSize(0, 0)
offsetMargins = QMargins()
i = 0
while(i<self.mGrid.size()):
cell = self.mGrid.at(i)
tile = cell.tile
if tile:
size = tile.size()
if (cell.flippedAntiDiagonally):
size.transpose()
offset = tile.offset()
maxTileSize = maxSize(size, maxTileSize)
offsetMargins = maxMargins(QMargins(-offset.x(),
-offset.y(),
offset.x(),
offset.y()),
offsetMargins)
i += 1
self.mMaxTileSize = maxTileSize
self.mOffsetMargins = offsetMargins
if (self.mMap):
self.mMap.adjustDrawMargins(self.drawMargins())
##
# Returns whether (x, y) is inside this map layer.
##
def contains(self, *args):
l = len(args)
if l==2:
x, y = args
return x >= 0 and y >= 0 and x < self.mWidth and y < self.mHeight
elif l==1:
point = args[0]
return self.contains(point.x(), point.y())
##
# Calculates the region of cells in this tile layer for which the given
# \a condition returns True.
##
def region(self, *args):
l = len(args)
if l==1:
condition = args[0]
region = QRegion()
for y in range(self.mHeight):
for x in range(self.mWidth):
if (condition(self.cellAt(x, y))):
rangeStart = x
x += 1
while(x<=self.mWidth):
if (x == self.mWidth or not condition(self.cellAt(x, y))):
rangeEnd = x
region += QRect(rangeStart + self.mX, y + self.mY,
rangeEnd - rangeStart, 1)
break
x += 1
return region
elif l==0:
##
# Calculates the region occupied by the tiles of this layer. Similar to
# Layer.bounds(), but leaves out the regions without tiles.
##
return self.region(lambda cell:not cell.isEmpty())
##
# Returns a read-only reference to the cell at the given coordinates. The
# coordinates have to be within this layer.
##
def cellAt(self, *args):
l = len(args)
if l==2:
x, y = args
return self.mGrid.at(x + y * self.mWidth)
elif l==1:
point = args[0]
return self.cellAt(point.x(), point.y())
##
# Sets the cell at the given coordinates.
##
def setCell(self, x, y, cell):
if (cell.tile):
size = cell.tile.size()
if (cell.flippedAntiDiagonally):
size.transpose()
offset = cell.tile.offset()
self.mMaxTileSize = maxSize(size, self.mMaxTileSize)
self.mOffsetMargins = maxMargins(QMargins(-offset.x(),
-offset.y(),
offset.x(),
offset.y()),
self.mOffsetMargins)
if (self.mMap):
self.mMap.adjustDrawMargins(self.drawMargins())
self.mGrid[x + y * self.mWidth] = cell
##
# Returns a copy of the area specified by the given \a region. The
# caller is responsible for the returned tile layer.
##
def copy(self, *args):
l = len(args)
if l==1:
region = args[0]
if type(region) != QRegion:
region = QRegion(region)
area = region.intersected(QRect(0, 0, self.width(), self.height()))
bounds = region.boundingRect()
areaBounds = area.boundingRect()
offsetX = max(0, areaBounds.x() - bounds.x())
offsetY = max(0, areaBounds.y() - bounds.y())
copied = TileLayer(QString(), 0, 0, bounds.width(), bounds.height())
for rect in area.rects():
for x in range(rect.left(), rect.right()+1):
for y in range(rect.top(), rect.bottom()+1):
copied.setCell(x - areaBounds.x() + offsetX,
y - areaBounds.y() + offsetY,
self.cellAt(x, y))
return copied
elif l==4:
x, y, width, height = args
return self.copy(QRegion(x, y, width, height))
##
# Merges the given \a layer onto this layer at position \a pos. Parts that
# fall outside of this layer will be lost and empty tiles in the given
# layer will have no effect.
##
def merge(self, pos, layer):
# Determine the overlapping area
area = QRect(pos, QSize(layer.width(), layer.height()))
area &= QRect(0, 0, self.width(), self.height())
for y in range(area.top(), area.bottom()+1):
for x in range(area.left(), area.right()+1):
cell = layer.cellAt(x - pos.x(), y - pos.y())
if (not cell.isEmpty()):
self.setCell(x, y, cell)
##
# Removes all cells in the specified region.
##
def erase(self, area):
emptyCell = Cell()
for rect in area.rects():
for x in range(rect.left(), rect.right()+1):
for y in range(rect.top(), rect.bottom()+1):
self.setCell(x, y, emptyCell)
##
# Sets the cells starting at the given position to the cells in the given
# \a tileLayer. Parts that fall outside of this layer will be ignored.
#
# When a \a mask is given, only cells that fall within this mask are set.
# The mask is applied in local coordinates.
##
def setCells(self, x, y, layer, mask = QRegion()):
# Determine the overlapping area
area = QRegion(QRect(x, y, layer.width(), layer.height()))
area &= QRect(0, 0, self.width(), self.height())
if (not mask.isEmpty()):
area &= mask
for rect in area.rects():
for _x in range(rect.left(), rect.right()+1):
for _y in range(rect.top(), rect.bottom()+1):
self.setCell(_x, _y, layer.cellAt(_x - x, _y - y))
##
# Flip this tile layer in the given \a direction. Direction must be
# horizontal or vertical. This doesn't change the dimensions of the
# tile layer.
##
def flip(self, direction):
newGrid = QVector()
for i in range(self.mWidth * self.mHeight):
newGrid.append(Cell())
for y in range(self.mHeight):
for x in range(self.mWidth):
dest = newGrid[x + y * self.mWidth]
if (direction == FlipDirection.FlipHorizontally):
source = self.cellAt(self.mWidth - x - 1, y)
dest = source
dest.flippedHorizontally = not source.flippedHorizontally
elif (direction == FlipDirection.FlipVertically):
source = self.cellAt(x, self.mHeight - y - 1)
dest = source
dest.flippedVertically = not source.flippedVertically
self.mGrid = newGrid
##
# Rotate this tile layer by 90 degrees left or right. The tile positions
# are rotated within the layer, and the tiles themselves are rotated. The
# dimensions of the tile layer are swapped.
##
def rotate(self, direction):
rotateRightMask = [5, 4, 1, 0, 7, 6, 3, 2]
rotateLeftMask = [3, 2, 7, 6, 1, 0, 5, 4]
if direction == RotateDirection.RotateRight:
rotateMask = rotateRightMask
else:
rotateMask = rotateLeftMask
newWidth = self.mHeight
newHeight = self.mWidth
newGrid = QVector(newWidth * newHeight)
for y in range(self.mHeight):
for x in range(self.mWidth):
source = self.cellAt(x, y)
dest = source
mask = (dest.flippedHorizontally << 2) | (dest.flippedVertically << 1) | (dest.flippedAntiDiagonally << 0)
mask = rotateMask[mask]
dest.flippedHorizontally = (mask & 4) != 0
dest.flippedVertically = (mask & 2) != 0
dest.flippedAntiDiagonally = (mask & 1) != 0
if (direction == RotateDirection.RotateRight):
newGrid[x * newWidth + (self.mHeight - y - 1)] = dest
else:
newGrid[(self.mWidth - x - 1) * newWidth + y] = dest
t = self.mMaxTileSize.width()
self.mMaxTileSize.setWidth(self.mMaxTileSize.height())
self.mMaxTileSize.setHeight(t)
self.mWidth = newWidth
self.mHeight = newHeight
self.mGrid = newGrid
##
# Computes and returns the set of tilesets used by this tile layer.
##
def usedTilesets(self):
tilesets = QSet()
i = 0
while(i<self.mGrid.size()):
tile = self.mGrid.at(i).tile
if tile:
tilesets.insert(tile.tileset())
i += 1
return tilesets
##
# Returns whether this tile layer has any cell for which the given
# \a condition returns True.
##
def hasCell(self, condition):
i = 0
for cell in self.mGrid:
if (condition(cell)):
return True
i += 1
return False
##
# Returns whether this tile layer is referencing the given tileset.
##
def referencesTileset(self, tileset):
i = 0
while(i<self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == tileset):
return True
i += 1
return False
##
# Removes all references to the given tileset. This sets all tiles on this
# layer that are from the given tileset to null.
##
def removeReferencesToTileset(self, tileset):
i = 0
while(i<self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == tileset):
self.mGrid.replace(i, Cell())
i += 1
##
# Replaces all tiles from \a oldTileset with tiles from \a newTileset.
##
def replaceReferencesToTileset(self, oldTileset, newTileset):
i = 0
while(i<self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == oldTileset):
self.mGrid[i].tile = newTileset.tileAt(tile.id())
i += 1
##
# Resizes this tile layer to \a size, while shifting all tiles by
# \a offset.
##
def resize(self, size, offset):
if (self.size() == size and offset.isNull()):
return
newGrid = QVector()
for i in range(size.width() * size.height()):
newGrid.append(Cell())
# Copy over the preserved part
startX = max(0, -offset.x())
startY = max(0, -offset.y())
endX = min(self.mWidth, size.width() - offset.x())
endY = min(self.mHeight, size.height() - offset.y())
for y in range(startY, endY):
for x in range(startX, endX):
index = x + offset.x() + (y + offset.y()) * size.width()
newGrid[index] = self.cellAt(x, y)
self.mGrid = newGrid
self.setSize(size)
##
# Offsets the tiles in this layer within \a bounds by \a offset,
# and optionally wraps them.
#
# \sa ObjectGroup.offset()
##
def offsetTiles(self, offset, bounds, wrapX, wrapY):
newGrid = QVector()
for i in range(self.mWidth * self.mHeight):
newGrid.append(Cell())
for y in range(self.mHeight):
for x in range(self.mWidth):
# Skip out of bounds tiles
if (not bounds.contains(x, y)):
newGrid[x + y * self.mWidth] = self.cellAt(x, y)
continue
# Get position to pull tile value from
oldX = x - offset.x()
oldY = y - offset.y()
# Wrap x value that will be pulled from
if (wrapX and bounds.width() > 0):
while oldX < bounds.left():
oldX += bounds.width()
while oldX > bounds.right():
oldX -= bounds.width()
# Wrap y value that will be pulled from
if (wrapY and bounds.height() > 0):
while oldY < bounds.top():
oldY += bounds.height()
while oldY > bounds.bottom():
oldY -= bounds.height()
# Set the new tile
if (self.contains(oldX, oldY) and bounds.contains(oldX, oldY)):
newGrid[x + y * self.mWidth] = self.cellAt(oldX, oldY)
else:
newGrid[x + y * self.mWidth] = Cell()
self.mGrid = newGrid
def canMergeWith(self, other):
return other.isTileLayer()
def mergedWith(self, other):
o = other
unitedBounds = self.bounds().united(o.bounds())
offset = self.position() - unitedBounds.topLeft()
merged = self.clone()
merged.resize(unitedBounds.size(), offset)
merged.merge(o.position() - unitedBounds.topLeft(), o)
return merged
##
# Returns the region where this tile layer and the given tile layer
# are different. The relative positions of the layers are taken into
# account. The returned region is relative to this tile layer.
##
def computeDiffRegion(self, other):
ret = QRegion()
dx = other.x() - self.mX
dy = other.y() - self.mY
r = QRect(0, 0, self.width(), self.height())
r &= QRect(dx, dy, other.width(), other.height())
for y in range(r.top(), r.bottom()+1):
for x in range(r.left(), r.right()+1):
if (self.cellAt(x, y) != other.cellAt(x - dx, y - dy)):
rangeStart = x
while (x <= r.right() and self.cellAt(x, y) != other.cellAt(x - dx, y - dy)):
x += 1
rangeEnd = x
ret += QRect(rangeStart, y, rangeEnd - rangeStart, 1)
return ret
##
# Returns True if all tiles in the layer are empty.
##
def isEmpty(self):
i = 0
while(i<self.mGrid.size()):
if (not self.mGrid.at(i).isEmpty()):
return False
i += 1
return True
##
# Returns a duplicate of this TileLayer.
#
# \sa Layer.clone()
##
def clone(self):
return self.initializeClone(TileLayer(self.mName, self.mX, self.mY, self.mWidth, self.mHeight))
def begin(self):
return self.mGrid.begin()
def end(self):
return self.mGrid.end()
def initializeClone(self, clone):
super().initializeClone(clone)
clone.mGrid = self.mGrid
clone.mMaxTileSize = self.mMaxTileSize
clone.mOffsetMargins = self.mOffsetMargins
return clone
class Tile(Object):
def __init__(self, *args):
super().__init__(Object.TileType)
l = len(args)
if l==3:
image, id, tileset = args
self.mImageSource = QString()
elif l==4:
image, imageSource, id, tileset = args
self.mImageSource = imageSource
self.mId = id
self.mTileset = tileset
self.mImage = image
self.mTerrain = 0xffffffff
self.mProbability = 1.0
self.mObjectGroup = None
self.mFrames = QVector()
self.mCurrentFrameIndex = 0
self.mUnusedTime = 0
def __del__(self):
del self.mObjectGroup
##
# Returns the tileset that this tile is part of as a shared pointer.
##
def sharedTileset(self):
return self.mTileset.sharedPointer()
##
# Returns ID of this tile within its tileset.
##
def id(self):
return self.mId
##
# Returns the tileset that this tile is part of.
##
def tileset(self):
return self.mTileset
##
# Returns the image of this tile.
##
def image(self):
return QPixmap(self.mImage)
##
# Returns the image for rendering this tile, taking into account tile
# animations.
##
def currentFrameImage(self):
if (self.isAnimated()):
frame = self.mFrames.at(self.mCurrentFrameIndex)
return self.mTileset.tileAt(frame.tileId).image()
else:
return QPixmap(self.mImage)
##
# Returns the drawing offset of the tile (in pixels).
##
def offset(self):
return self.mTileset.tileOffset()
##
# Sets the image of this tile.
##
def setImage(self, image):
self.mImage = image
##
# Returns the file name of the external image that represents this tile.
# When this tile doesn't refer to an external image, an empty string is
# returned.
##
def imageSource(self):
return self.mImageSource
##
# Returns the file name of the external image that represents this tile.
# When this tile doesn't refer to an external image, an empty string is
# returned.
##
def setImageSource(self, imageSource):
self.mImageSource = imageSource
##
# Returns the width of this tile.
##
def width(self):
return self.mImage.width()
##
# Returns the height of this tile.
##
def height(self):
return self.mImage.height()
##
# Returns the size of this tile.
##
def size(self):
return self.mImage.size()
##
# Returns the Terrain of a given corner.
##
def terrainAtCorner(self, corner):
return self.mTileset.terrain(self.cornerTerrainId(corner))
##
# Returns the terrain id at a given corner.
##
def cornerTerrainId(self, corner):
t = (self.terrain() >> (3 - corner)*8) & 0xFF
if t == 0xFF:
return -1
return t
##
# Set the terrain type of a given corner.
##
def setCornerTerrainId(self, corner, terrainId):
self.setTerrain(setTerrainCorner(self.mTerrain, corner, terrainId))
##
# Returns the terrain for each corner of this tile.
##
def terrain(self):
return self.mTerrain
##
# Set the terrain for each corner of the tile.
##
def setTerrain(self, terrain):
if (self.mTerrain == terrain):
return
self.mTerrain = terrain
self.mTileset.markTerrainDistancesDirty()
##
# Returns the probability of this terrain type appearing while painting (0-100%).
##
def probability(self):
return self.mProbability
##
# Set the relative probability of this tile appearing while painting.
##
def setProbability(self, probability):
self.mProbability = probability
##
# @return The group of objects associated with this tile. This is generally
# expected to be used for editing collision shapes.
##
def objectGroup(self):
return self.mObjectGroup
##
# Sets \a objectGroup to be the group of objects associated with this tile.
# The Tile takes ownership over the ObjectGroup and it can't also be part of
# a map.
##
def setObjectGroup(self, objectGroup):
if (self.mObjectGroup == objectGroup):
return
del self.mObjectGroup
self.mObjectGroup = objectGroup
##
# Swaps the object group of this tile with \a objectGroup. The tile releases
# ownership over its existing object group and takes ownership over the new
# one.
#
# @return The previous object group referenced by this tile.
##
def swapObjectGroup(self, objectGroup):
previousObjectGroup = self.mObjectGroup
self.mObjectGroup = objectGroup
return previousObjectGroup
def frames(self):
return self.mFrames
##
# Sets the animation frames to be used by this tile. Resets any currently
# running animation.
##
def setFrames(self, frames):
self.mFrames = frames
self.mCurrentFrameIndex = 0
self.mUnusedTime = 0
def isAnimated(self):
return not self.mFrames.isEmpty()
def currentFrameIndex(self):
return self.mCurrentFrameIndex
##
# Advances this tile animation by the given amount of milliseconds. Returns
# whether this caused the current tileId to change.
##
def advanceAnimation(self, ms):
if (not self.isAnimated()):
return False
self.mUnusedTime += ms
frame = self.mFrames.at(self.mCurrentFrameIndex)
previousTileId = frame.tileId
while (frame.duration > 0 and self.mUnusedTime > frame.duration):
self.mUnusedTime -= frame.duration
self.mCurrentFrameIndex = (self.mCurrentFrameIndex + 1) % self.mFrames.size()
frame = self.mFrames.at(self.mCurrentFrameIndex)
return previousTileId != frame.tileId
class MapScene(QGraphicsScene):
selectedObjectItemsChanged = pyqtSignal()
##
# Constructor.
##
def __init__(self, parent):
super().__init__(parent)
self.mMapDocument = None
self.mSelectedTool = None
self.mActiveTool = None
self.mObjectSelectionItem = None
self.mUnderMouse = False
self.mCurrentModifiers = Qt.NoModifier,
self.mDarkRectangle = QGraphicsRectItem()
self.mDefaultBackgroundColor = Qt.darkGray
self.mLayerItems = QVector()
self.mObjectItems = QMap()
self.mObjectLineWidth = 0.0
self.mSelectedObjectItems = QSet()
self.mLastMousePos = QPointF()
self.mShowTileObjectOutlines = False
self.mHighlightCurrentLayer = False
self.mGridVisible = False
self.setBackgroundBrush(self.mDefaultBackgroundColor)
tilesetManager = TilesetManager.instance()
tilesetManager.tilesetChanged.connect(self.tilesetChanged)
tilesetManager.repaintTileset.connect(self.tilesetChanged)
prefs = preferences.Preferences.instance()
prefs.showGridChanged.connect(self.setGridVisible)
prefs.showTileObjectOutlinesChanged.connect(self.setShowTileObjectOutlines)
prefs.objectTypesChanged.connect(self.syncAllObjectItems)
prefs.highlightCurrentLayerChanged.connect(self.setHighlightCurrentLayer)
prefs.gridColorChanged.connect(self.update)
prefs.objectLineWidthChanged.connect(self.setObjectLineWidth)
self.mDarkRectangle.setPen(QPen(Qt.NoPen))
self.mDarkRectangle.setBrush(Qt.black)
self.mDarkRectangle.setOpacity(darkeningFactor)
self.addItem(self.mDarkRectangle)
self.mGridVisible = prefs.showGrid()
self.mObjectLineWidth = prefs.objectLineWidth()
self.mShowTileObjectOutlines = prefs.showTileObjectOutlines()
self.mHighlightCurrentLayer = prefs.highlightCurrentLayer()
# Install an event filter so that we can get key events on behalf of the
# active tool without having to have the current focus.
QCoreApplication.instance().installEventFilter(self)
##
# Destructor.
##
def __del__(self):
if QCoreApplication.instance():
QCoreApplication.instance().removeEventFilter(self)
##
# Returns the map document this scene is displaying.
##
def mapDocument(self):
return self.mMapDocument
##
# Sets the map this scene displays.
##
def setMapDocument(self, mapDocument):
if (self.mMapDocument):
self.mMapDocument.disconnect()
if (not self.mSelectedObjectItems.isEmpty()):
self.mSelectedObjectItems.clear()
self.selectedObjectItemsChanged.emit()
self.mMapDocument = mapDocument
if (self.mMapDocument):
renderer = self.mMapDocument.renderer()
renderer.setObjectLineWidth(self.mObjectLineWidth)
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, self.mShowTileObjectOutlines)
self.mMapDocument.mapChanged.connect(self.mapChanged)
self.mMapDocument.regionChanged.connect(self.repaintRegion)
self.mMapDocument.tileLayerDrawMarginsChanged.connect(self.tileLayerDrawMarginsChanged)
self.mMapDocument.layerAdded.connect(self.layerAdded)
self.mMapDocument.layerRemoved.connect(self.layerRemoved)
self.mMapDocument.layerChanged.connect(self.layerChanged)
self.mMapDocument.objectGroupChanged.connect(self.objectGroupChanged)
self.mMapDocument.imageLayerChanged.connect(self.imageLayerChanged)
self.mMapDocument.currentLayerIndexChanged.connect(self.currentLayerIndexChanged)
self.mMapDocument.tilesetTileOffsetChanged.connect(self.tilesetTileOffsetChanged)
self.mMapDocument.objectsInserted.connect(self.objectsInserted)
self.mMapDocument.objectsRemoved.connect(self.objectsRemoved)
self.mMapDocument.objectsChanged.connect(self.objectsChanged)
self.mMapDocument.objectsIndexChanged.connect(self.objectsIndexChanged)
self.mMapDocument.selectedObjectsChanged.connect(self.updateSelectedObjectItems)
self.refreshScene()
##
# Returns whether the tile grid is visible.
##
def isGridVisible(self):
return self.mGridVisible
##
# Returns the set of selected map object items.
##
def selectedObjectItems(self):
return QSet(self.mSelectedObjectItems)
##
# Sets the set of selected map object items. This translates to a call to
# MapDocument.setSelectedObjects.
##
def setSelectedObjectItems(self, items):
# Inform the map document about the newly selected objects
selectedObjects = QList()
#selectedObjects.reserve(items.size())
for item in items:
selectedObjects.append(item.mapObject())
self.mMapDocument.setSelectedObjects(selectedObjects)
##
# Returns the MapObjectItem associated with the given \a mapObject.
##
def itemForObject(self, object):
return self.mObjectItems[object]
##
# Enables the selected tool at this map scene.
# Therefore it tells that tool, that this is the active map scene.
##
def enableSelectedTool(self):
if (not self.mSelectedTool or not self.mMapDocument):
return
self.mActiveTool = self.mSelectedTool
self.mActiveTool.activate(self)
self.mCurrentModifiers = QApplication.keyboardModifiers()
if (self.mCurrentModifiers != Qt.NoModifier):
self.mActiveTool.modifiersChanged(self.mCurrentModifiers)
if (self.mUnderMouse):
self.mActiveTool.mouseEntered()
self.mActiveTool.mouseMoved(self.mLastMousePos, Qt.KeyboardModifiers())
def disableSelectedTool(self):
if (not self.mActiveTool):
return
if (self.mUnderMouse):
self.mActiveTool.mouseLeft()
self.mActiveTool.deactivate(self)
self.mActiveTool = None
##
# Sets the currently selected tool.
##
def setSelectedTool(self, tool):
self.mSelectedTool = tool
##
# QGraphicsScene.drawForeground override that draws the tile grid.
##
def drawForeground(self, painter, rect):
if (not self.mMapDocument or not self.mGridVisible):
return
offset = QPointF()
# Take into account the offset of the current layer
layer = self.mMapDocument.currentLayer()
if layer:
offset = layer.offset()
painter.translate(offset)
prefs = preferences.Preferences.instance()
self.mMapDocument.renderer().drawGrid(painter, rect.translated(-offset), prefs.gridColor())
##
# Override for handling enter and leave events.
##
def event(self, event):
x = event.type()
if x==QEvent.Enter:
self.mUnderMouse = True
if (self.mActiveTool):
self.mActiveTool.mouseEntered()
elif x==QEvent.Leave:
self.mUnderMouse = False
if (self.mActiveTool):
self.mActiveTool.mouseLeft()
else:
pass
return super().event(event)
def keyPressEvent(self, event):
if (self.mActiveTool):
self.mActiveTool.keyPressed(event)
if (not (self.mActiveTool and event.isAccepted())):
super().keyPressEvent(event)
def mouseMoveEvent(self, mouseEvent):
self.mLastMousePos = mouseEvent.scenePos()
if (not self.mMapDocument):
return
super().mouseMoveEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
self.mActiveTool.mouseMoved(mouseEvent.scenePos(), mouseEvent.modifiers())
mouseEvent.accept()
def mousePressEvent(self, mouseEvent):
super().mousePressEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
mouseEvent.accept()
self.mActiveTool.mousePressed(mouseEvent)
def mouseReleaseEvent(self, mouseEvent):
super().mouseReleaseEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
mouseEvent.accept()
self.mActiveTool.mouseReleased(mouseEvent)
##
# Override to ignore drag enter events.
##
def dragEnterEvent(self, event):
event.ignore()
##
# Sets whether the tile grid is visible.
##
def setGridVisible(self, visible):
if (self.mGridVisible == visible):
return
self.mGridVisible = visible
self.update()
def setObjectLineWidth(self, lineWidth):
if (self.mObjectLineWidth == lineWidth):
return
self.mObjectLineWidth = lineWidth
if (self.mMapDocument):
self.mMapDocument.renderer().setObjectLineWidth(lineWidth)
# Changing the line width can change the size of the object items
if (not self.mObjectItems.isEmpty()):
for item in self.mObjectItems:
item[1].syncWithMapObject()
self.update()
def setShowTileObjectOutlines(self, enabled):
if (self.mShowTileObjectOutlines == enabled):
return
self.mShowTileObjectOutlines = enabled
if (self.mMapDocument):
self.mMapDocument.renderer().setFlag(RenderFlag.ShowTileObjectOutlines, enabled)
if (not self.mObjectItems.isEmpty()):
self.update()
##
# Sets whether the current layer should be highlighted.
##
def setHighlightCurrentLayer(self, highlightCurrentLayer):
if (self.mHighlightCurrentLayer == highlightCurrentLayer):
return
self.mHighlightCurrentLayer = highlightCurrentLayer
self.updateCurrentLayerHighlight()
##
# Refreshes the map scene.
##
def refreshScene(self):
self.mLayerItems.clear()
self.mObjectItems.clear()
self.removeItem(self.mDarkRectangle)
self.clear()
self.addItem(self.mDarkRectangle)
if (not self.mMapDocument):
self.setSceneRect(QRectF())
return
self.updateSceneRect()
map = self.mMapDocument.map()
self.mLayerItems.resize(map.layerCount())
if (map.backgroundColor().isValid()):
self.setBackgroundBrush(map.backgroundColor())
else:
self.setBackgroundBrush(self.mDefaultBackgroundColor)
layerIndex = 0
for layer in map.layers():
layerItem = self.createLayerItem(layer)
layerItem.setZValue(layerIndex)
self.addItem(layerItem)
self.mLayerItems[layerIndex] = layerItem
layerIndex += 1
tileSelectionItem = TileSelectionItem(self.mMapDocument)
tileSelectionItem.setZValue(10000 - 2)
self.addItem(tileSelectionItem)
self.mObjectSelectionItem = ObjectSelectionItem(self.mMapDocument)
self.mObjectSelectionItem.setZValue(10000 - 1)
self.addItem(self.mObjectSelectionItem)
self.updateCurrentLayerHighlight()
##
# Repaints the specified region. The region is in tile coordinates.
##
def repaintRegion(self, region, layer):
renderer = self.mMapDocument.renderer()
margins = self.mMapDocument.map().drawMargins()
for r in region.rects():
boundingRect = QRectF(renderer.boundingRect(r))
self.update(QRectF(renderer.boundingRect(r).adjusted(-margins.left(),
-margins.top(),
margins.right(),
margins.bottom())))
boundingRect.translate(layer.offset())
self.update(boundingRect)
def currentLayerIndexChanged(self):
self.updateCurrentLayerHighlight()
# New layer may have a different offset, affecting the grid
if self.mGridVisible:
self.update()
##
# Adapts the scene, layers and objects to new map size, orientation or
# background color.
##
def mapChanged(self):
self.updateSceneRect()
for item in self.mLayerItems:
tli = item
if type(tli) == TileLayerItem:
tli.syncWithTileLayer()
for item in self.mObjectItems.values():
item.syncWithMapObject()
map = self.mMapDocument.map()
if (map.backgroundColor().isValid()):
self.setBackgroundBrush(map.backgroundColor())
else:
self.setBackgroundBrush(self.mDefaultBackgroundColor)
def tilesetChanged(self, tileset):
if (not self.mMapDocument):
return
if (contains(self.mMapDocument.map().tilesets(), tileset)):
self.update()
def tileLayerDrawMarginsChanged(self, tileLayer):
index = self.mMapDocument.map().layers().indexOf(tileLayer)
item = self.mLayerItems.at(index)
item.syncWithTileLayer()
def layerAdded(self, index):
layer = self.mMapDocument.map().layerAt(index)
layerItem = self.createLayerItem(layer)
self.addItem(layerItem)
self.mLayerItems.insert(index, layerItem)
z = 0
for item in self.mLayerItems:
item.setZValue(z)
z += 1
def layerRemoved(self, index):
self.mLayerItems.remove(index)
##
# A layer has changed. This can mean that the layer visibility, opacity or
# offset changed.
##
def layerChanged(self, index):
layer = self.mMapDocument.map().layerAt(index)
layerItem = self.mLayerItems.at(index)
layerItem.setVisible(layer.isVisible())
multiplier = 1
if (self.mHighlightCurrentLayer and self.mMapDocument.currentLayerIndex() < index):
multiplier = opacityFactor
layerItem.setOpacity(layer.opacity() * multiplier)
layerItem.setPos(layer.offset())
# Layer offset may have changed, affecting the scene rect and grid
self.updateSceneRect()
if self.mGridVisible:
self.update()
##
# When an object group has changed it may mean its color or drawing order
# changed, which affects all its objects.
##
def objectGroupChanged(self, objectGroup):
self.objectsChanged(objectGroup.objects())
self.objectsIndexChanged(objectGroup, 0, objectGroup.objectCount() - 1)
##
# When an image layer has changed, it may change size and it may look
# differently.
##
def imageLayerChanged(self, imageLayer):
index = self.mMapDocument.map().layers().indexOf(imageLayer)
item = self.mLayerItems.at(index)
item.syncWithImageLayer()
item.update()
##
# When the tile offset of a tileset has changed, it can affect the bounding
# rect of all tile layers and tile objects. It also requires a full repaint.
##
def tilesetTileOffsetChanged(self, tileset):
self.update()
for item in self.mLayerItems:
tli = item
if type(tli) == TileLayerItem:
tli.syncWithTileLayer()
for item in self.mObjectItems:
cell = item.mapObject().cell()
if (not cell.isEmpty() and cell.tile.tileset() == tileset):
item.syncWithMapObject()
##
# Inserts map object items for the given objects.
##
def objectsInserted(self, objectGroup, first, last):
ogItem = None
# Find the object group item for the object group
for item in self.mLayerItems:
ogi = item
if type(ogi)==ObjectGroupItem:
if (ogi.objectGroup() == objectGroup):
ogItem = ogi
break
drawOrder = objectGroup.drawOrder()
for i in range(first, last+1):
object = objectGroup.objectAt(i)
item = MapObjectItem(object, self.mMapDocument, ogItem)
if (drawOrder == ObjectGroup.DrawOrder.TopDownOrder):
item.setZValue(item.y())
else:
item.setZValue(i)
self.mObjectItems.insert(object, item)
##
# Removes the map object items related to the given objects.
##
def objectsRemoved(self, objects):
for o in objects:
i = self.mObjectItems.find(o)
self.mSelectedObjectItems.remove(i)
# python would not force delete QGraphicsItem
self.removeItem(i)
self.mObjectItems.erase(o)
##
# Updates the map object items related to the given objects.
##
def objectsChanged(self, objects):
for object in objects:
item = self.itemForObject(object)
item.syncWithMapObject()
##
# Updates the Z value of the objects when appropriate.
##
def objectsIndexChanged(self, objectGroup, first, last):
if (objectGroup.drawOrder() != ObjectGroup.DrawOrder.IndexOrder):
return
for i in range(first, last+1):
item = self.itemForObject(objectGroup.objectAt(i))
item.setZValue(i)
def updateSelectedObjectItems(self):
objects = self.mMapDocument.selectedObjects()
items = QSet()
for object in objects:
item = self.itemForObject(object)
if item:
items.insert(item)
self.mSelectedObjectItems = items
self.selectedObjectItemsChanged.emit()
def syncAllObjectItems(self):
for item in self.mObjectItems:
item.syncWithMapObject()
def createLayerItem(self, layer):
layerItem = None
tl = layer.asTileLayer()
if tl:
layerItem = TileLayerItem(tl, self.mMapDocument)
else:
og = layer.asObjectGroup()
if og:
drawOrder = og.drawOrder()
ogItem = ObjectGroupItem(og)
objectIndex = 0
for object in og.objects():
item = MapObjectItem(object, self.mMapDocument, ogItem)
if (drawOrder == ObjectGroup.DrawOrder.TopDownOrder):
item.setZValue(item.y())
else:
item.setZValue(objectIndex)
self.mObjectItems.insert(object, item)
objectIndex += 1
layerItem = ogItem
else:
il = layer.asImageLayer()
if il:
layerItem = ImageLayerItem(il, self.mMapDocument)
layerItem.setVisible(layer.isVisible())
return layerItem
def updateSceneRect(self):
mapSize = self.mMapDocument.renderer().mapSize()
sceneRect = QRectF(0, 0, mapSize.width(), mapSize.height())
margins = self.mMapDocument.map().computeLayerOffsetMargins()
sceneRect.adjust(-margins.left(),
-margins.top(),
margins.right(),
margins.bottom())
self.setSceneRect(sceneRect)
self.mDarkRectangle.setRect(sceneRect)
def updateCurrentLayerHighlight(self):
if (not self.mMapDocument):
return
currentLayerIndex = self.mMapDocument.currentLayerIndex()
if (not self.mHighlightCurrentLayer or currentLayerIndex == -1):
self.mDarkRectangle.setVisible(False)
# Restore opacity for all layers
for i in range(self.mLayerItems.size()):
layer = self.mMapDocument.map().layerAt(i)
self.mLayerItems.at(i).setOpacity(layer.opacity())
return
# Darken layers below the current layer
self.mDarkRectangle.setZValue(currentLayerIndex - 0.5)
self.mDarkRectangle.setVisible(True)
# Set layers above the current layer to half opacity
for i in range(1, self.mLayerItems.size()):
layer = self.mMapDocument.map().layerAt(i)
if currentLayerIndex < i:
_x = opacityFactor
else:
_x = 1
multiplier = _x
self.mLayerItems.at(i).setOpacity(layer.opacity() * multiplier)
def eventFilter(self, object, event):
x = event.type()
if x==QEvent.KeyPress or x==QEvent.KeyRelease:
keyEvent = event
newModifiers = keyEvent.modifiers()
if (self.mActiveTool and newModifiers != self.mCurrentModifiers):
self.mActiveTool.modifiersChanged(newModifiers)
self.mCurrentModifiers = newModifiers
else:
pass
return False
class TileStampManager(QObject):
setStamp = pyqtSignal(TileStamp)
def __init__(self, toolManager, parent = None):
super().__init__(parent)
self.mStampsByName = QMap()
self.mQuickStamps = QVector()
for i in range(TileStampManager.quickStampKeys().__len__()):
self.mQuickStamps.append(0)
self.mTileStampModel = TileStampModel(self)
self.mToolManager = toolManager
prefs = preferences.Preferences.instance()
prefs.stampsDirectoryChanged.connect(self.stampsDirectoryChanged)
self.mTileStampModel.stampAdded.connect(self.stampAdded)
self.mTileStampModel.stampRenamed.connect(self.stampRenamed)
self.mTileStampModel.stampChanged.connect(self.saveStamp)
self.mTileStampModel.stampRemoved.connect(self.deleteStamp)
self.loadStamps()
def __del__(self):
# needs to be over here where the TileStamp type is complete
pass
##
# Returns the keys used for quickly accessible tile stamps.
# Note: To store a tile layer <Ctrl> is added. The given keys will work
# for recalling the stored values.
##
def quickStampKeys():
keys=[Qt.Key_1, Qt.Key_2, Qt.Key_3, Qt.Key_4, Qt.Key_5, Qt.Key_6, Qt.Key_7, Qt.Key_8, Qt.Key_9]
return keys
def tileStampModel(self):
return self.mTileStampModel
def createStamp(self):
stamp = self.tampFromContext(self.mToolManager.selectedTool())
if (not stamp.isEmpty()):
self.mTileStampModel.addStamp(stamp)
return stamp
def addVariation(self, targetStamp):
stamp = stampFromContext(self.mToolManager.selectedTool())
if (stamp.isEmpty()):
return
if (stamp == targetStamp): # avoid easy mistake of adding duplicates
return
for variation in stamp.variations():
self.mTileStampModel.addVariation(targetStamp, variation)
def selectQuickStamp(self, index):
stamp = self.mQuickStamps.at(index)
if (not stamp.isEmpty()):
self.setStamp.emit(stamp)
def createQuickStamp(self, index):
stamp = stampFromContext(self.mToolManager.selectedTool())
if (stamp.isEmpty()):
return
self.setQuickStamp(index, stamp)
def extendQuickStamp(self, index):
quickStamp = self.mQuickStamps[index]
if (quickStamp.isEmpty()):
self.createQuickStamp(index)
else:
self.addVariation(quickStamp)
def stampsDirectoryChanged(self):
# erase current stamps
self.mQuickStamps.fill(TileStamp())
self.mStampsByName.clear()
self.mTileStampModel.clear()
self.loadStamps()
def eraseQuickStamp(self, index):
stamp = self.mQuickStamps.at(index)
if (not stamp.isEmpty()):
self.mQuickStamps[index] = TileStamp()
if (not self.mQuickStamps.contains(stamp)):
self.mTileStampModel.removeStamp(stamp)
def setQuickStamp(self, index, stamp):
stamp.setQuickStampIndex(index)
# make sure existing quickstamp is removed from stamp model
self.eraseQuickStamp(index)
self.mTileStampModel.addStamp(stamp)
self.mQuickStamps[index] = stamp
def loadStamps(self):
prefs = preferences.Preferences.instance()
stampsDirectory = prefs.stampsDirectory()
stampsDir = QDir(stampsDirectory)
iterator = QDirIterator(stampsDirectory,
["*.stamp"],
QDir.Files | QDir.Readable)
while (iterator.hasNext()):
stampFileName = iterator.next()
stampFile = QFile(stampFileName)
if (not stampFile.open(QIODevice.ReadOnly)):
continue
data = stampFile.readAll()
document = QJsonDocument.fromBinaryData(data)
if (document.isNull()):
# document not valid binary data, maybe it's an JSON text file
error = QJsonParseError()
document = QJsonDocument.fromJson(data, error)
if (error.error != QJsonParseError.NoError):
qDebug("Failed to parse stamp file:" + error.errorString())
continue
stamp = TileStamp.fromJson(document.object(), stampsDir)
if (stamp.isEmpty()):
continue
stamp.setFileName(iterator.fileInfo().fileName())
self.mTileStampModel.addStamp(stamp)
index = stamp.quickStampIndex()
if (index >= 0 and index < self.mQuickStamps.size()):
self.mQuickStamps[index] = stamp
def stampAdded(self, stamp):
if (stamp.name().isEmpty() or self.mStampsByName.contains(stamp.name())):
# pick the first available stamp name
name = QString()
index = self.mTileStampModel.stamps().size()
while(self.mStampsByName.contains(name)):
name = str(index)
index += 1
stamp.setName(name)
self.mStampsByName.insert(stamp.name(), stamp)
if (stamp.fileName().isEmpty()):
stamp.setFileName(findStampFileName(stamp.name()))
self.saveStamp(stamp)
def stampRenamed(self, stamp):
existingName = self.mStampsByName.key(stamp)
self.mStampsByName.remove(existingName)
self.mStampsByName.insert(stamp.name(), stamp)
existingFileName = stamp.fileName()
newFileName = findStampFileName(stamp.name(), existingFileName)
if (existingFileName != newFileName):
if (QFile.rename(stampFilePath(existingFileName),
stampFilePath(newFileName))):
stamp.setFileName(newFileName)
def saveStamp(self, stamp):
# make sure we have a stamps directory
prefs = preferences.Preferences.instance()
stampsDirectory = prefs.stampsDirectory()
stampsDir = QDir(stampsDirectory)
if (not stampsDir.exists() and not stampsDir.mkpath(".")):
qDebug("Failed to create stamps directory" + stampsDirectory)
return
filePath = stampsDir.filePath(stamp.fileName())
file = QSaveFile(filePath)
if (not file.open(QIODevice.WriteOnly)):
qDebug("Failed to open stamp file for writing" + filePath)
return
stampJson = stamp.toJson(QFileInfo(filePath).dir())
file.write(QJsonDocument(stampJson).toJson(QJsonDocument.Compact))
if (not file.commit()):
qDebug() << "Failed to write stamp" << filePath
def deleteStamp(self, stamp):
self.mStampsByName.remove(stamp.name())
QFile.remove(stampFilePath(stamp.fileName()))
class TileLayer(Layer):
##
# Constructor.
##
def __init__(self, name, x, y, width, height):
super().__init__(Layer.TileLayerType, name, x, y, width, height)
self.mMaxTileSize = QSize(0, 0)
self.mGrid = QVector()
for i in range(width * height):
self.mGrid.append(Cell())
self.mOffsetMargins = QMargins()
def __iter__(self):
return self.mGrid.__iter__()
##
# Returns the maximum tile size of this layer.
##
def maxTileSize(self):
return self.mMaxTileSize
##
# Returns the margins that have to be taken into account while drawing
# this tile layer. The margins depend on the maximum tile size and the
# offset applied to the tiles.
##
def drawMargins(self):
return QMargins(
self.mOffsetMargins.left(),
self.mOffsetMargins.top() + self.mMaxTileSize.height(),
self.mOffsetMargins.right() + self.mMaxTileSize.width(),
self.mOffsetMargins.bottom())
##
# Recomputes the draw margins. Needed after the tile offset of a tileset
# has changed for example.
#
# Generally you want to call Map.recomputeDrawMargins instead.
##
def recomputeDrawMargins(self):
maxTileSize = QSize(0, 0)
offsetMargins = QMargins()
i = 0
while (i < self.mGrid.size()):
cell = self.mGrid.at(i)
tile = cell.tile
if tile:
size = tile.size()
if (cell.flippedAntiDiagonally):
size.transpose()
offset = tile.offset()
maxTileSize = maxSize(size, maxTileSize)
offsetMargins = maxMargins(
QMargins(-offset.x(), -offset.y(), offset.x(), offset.y()),
offsetMargins)
i += 1
self.mMaxTileSize = maxTileSize
self.mOffsetMargins = offsetMargins
if (self.mMap):
self.mMap.adjustDrawMargins(self.drawMargins())
##
# Returns whether (x, y) is inside this map layer.
##
def contains(self, *args):
l = len(args)
if l == 2:
x, y = args
return x >= 0 and y >= 0 and x < self.mWidth and y < self.mHeight
elif l == 1:
point = args[0]
return self.contains(point.x(), point.y())
##
# Calculates the region of cells in this tile layer for which the given
# \a condition returns True.
##
def region(self, *args):
l = len(args)
if l == 1:
condition = args[0]
region = QRegion()
for y in range(self.mHeight):
for x in range(self.mWidth):
if (condition(self.cellAt(x, y))):
rangeStart = x
x += 1
while (x <= self.mWidth):
if (x == self.mWidth
or not condition(self.cellAt(x, y))):
rangeEnd = x
region += QRect(rangeStart + self.mX,
y + self.mY,
rangeEnd - rangeStart, 1)
break
x += 1
return region
elif l == 0:
##
# Calculates the region occupied by the tiles of this layer. Similar to
# Layer.bounds(), but leaves out the regions without tiles.
##
return self.region(lambda cell: not cell.isEmpty())
##
# Returns a read-only reference to the cell at the given coordinates. The
# coordinates have to be within this layer.
##
def cellAt(self, *args):
l = len(args)
if l == 2:
x, y = args
return self.mGrid.at(x + y * self.mWidth)
elif l == 1:
point = args[0]
return self.cellAt(point.x(), point.y())
##
# Sets the cell at the given coordinates.
##
def setCell(self, x, y, cell):
if (cell.tile):
size = cell.tile.size()
if (cell.flippedAntiDiagonally):
size.transpose()
offset = cell.tile.offset()
self.mMaxTileSize = maxSize(size, self.mMaxTileSize)
self.mOffsetMargins = maxMargins(
QMargins(-offset.x(), -offset.y(), offset.x(), offset.y()),
self.mOffsetMargins)
if (self.mMap):
self.mMap.adjustDrawMargins(self.drawMargins())
self.mGrid[x + y * self.mWidth] = cell
##
# Returns a copy of the area specified by the given \a region. The
# caller is responsible for the returned tile layer.
##
def copy(self, *args):
l = len(args)
if l == 1:
region = args[0]
if type(region) != QRegion:
region = QRegion(region)
area = region.intersected(QRect(0, 0, self.width(), self.height()))
bounds = region.boundingRect()
areaBounds = area.boundingRect()
offsetX = max(0, areaBounds.x() - bounds.x())
offsetY = max(0, areaBounds.y() - bounds.y())
copied = TileLayer(QString(), 0, 0, bounds.width(),
bounds.height())
for rect in area.rects():
for x in range(rect.left(), rect.right() + 1):
for y in range(rect.top(), rect.bottom() + 1):
copied.setCell(x - areaBounds.x() + offsetX,
y - areaBounds.y() + offsetY,
self.cellAt(x, y))
return copied
elif l == 4:
x, y, width, height = args
return self.copy(QRegion(x, y, width, height))
##
# Merges the given \a layer onto this layer at position \a pos. Parts that
# fall outside of this layer will be lost and empty tiles in the given
# layer will have no effect.
##
def merge(self, pos, layer):
# Determine the overlapping area
area = QRect(pos, QSize(layer.width(), layer.height()))
area &= QRect(0, 0, self.width(), self.height())
for y in range(area.top(), area.bottom() + 1):
for x in range(area.left(), area.right() + 1):
cell = layer.cellAt(x - pos.x(), y - pos.y())
if (not cell.isEmpty()):
self.setCell(x, y, cell)
##
# Removes all cells in the specified region.
##
def erase(self, area):
emptyCell = Cell()
for rect in area.rects():
for x in range(rect.left(), rect.right() + 1):
for y in range(rect.top(), rect.bottom() + 1):
self.setCell(x, y, emptyCell)
##
# Sets the cells starting at the given position to the cells in the given
# \a tileLayer. Parts that fall outside of this layer will be ignored.
#
# When a \a mask is given, only cells that fall within this mask are set.
# The mask is applied in local coordinates.
##
def setCells(self, x, y, layer, mask=QRegion()):
# Determine the overlapping area
area = QRegion(QRect(x, y, layer.width(), layer.height()))
area &= QRect(0, 0, self.width(), self.height())
if (not mask.isEmpty()):
area &= mask
for rect in area.rects():
for _x in range(rect.left(), rect.right() + 1):
for _y in range(rect.top(), rect.bottom() + 1):
self.setCell(_x, _y, layer.cellAt(_x - x, _y - y))
##
# Flip this tile layer in the given \a direction. Direction must be
# horizontal or vertical. This doesn't change the dimensions of the
# tile layer.
##
def flip(self, direction):
newGrid = QVector()
for i in range(self.mWidth * self.mHeight):
newGrid.append(Cell())
for y in range(self.mHeight):
for x in range(self.mWidth):
dest = newGrid[x + y * self.mWidth]
if (direction == FlipDirection.FlipHorizontally):
source = self.cellAt(self.mWidth - x - 1, y)
dest = source
dest.flippedHorizontally = not source.flippedHorizontally
elif (direction == FlipDirection.FlipVertically):
source = self.cellAt(x, self.mHeight - y - 1)
dest = source
dest.flippedVertically = not source.flippedVertically
self.mGrid = newGrid
##
# Rotate this tile layer by 90 degrees left or right. The tile positions
# are rotated within the layer, and the tiles themselves are rotated. The
# dimensions of the tile layer are swapped.
##
def rotate(self, direction):
rotateRightMask = [5, 4, 1, 0, 7, 6, 3, 2]
rotateLeftMask = [3, 2, 7, 6, 1, 0, 5, 4]
if direction == RotateDirection.RotateRight:
rotateMask = rotateRightMask
else:
rotateMask = rotateLeftMask
newWidth = self.mHeight
newHeight = self.mWidth
newGrid = QVector(newWidth * newHeight)
for y in range(self.mHeight):
for x in range(self.mWidth):
source = self.cellAt(x, y)
dest = source
mask = (dest.flippedHorizontally << 2) | (
dest.flippedVertically << 1) | (
dest.flippedAntiDiagonally << 0)
mask = rotateMask[mask]
dest.flippedHorizontally = (mask & 4) != 0
dest.flippedVertically = (mask & 2) != 0
dest.flippedAntiDiagonally = (mask & 1) != 0
if (direction == RotateDirection.RotateRight):
newGrid[x * newWidth + (self.mHeight - y - 1)] = dest
else:
newGrid[(self.mWidth - x - 1) * newWidth + y] = dest
t = self.mMaxTileSize.width()
self.mMaxTileSize.setWidth(self.mMaxTileSize.height())
self.mMaxTileSize.setHeight(t)
self.mWidth = newWidth
self.mHeight = newHeight
self.mGrid = newGrid
##
# Computes and returns the set of tilesets used by this tile layer.
##
def usedTilesets(self):
tilesets = QSet()
i = 0
while (i < self.mGrid.size()):
tile = self.mGrid.at(i).tile
if tile:
tilesets.insert(tile.tileset())
i += 1
return tilesets
##
# Returns whether this tile layer has any cell for which the given
# \a condition returns True.
##
def hasCell(self, condition):
i = 0
for cell in self.mGrid:
if (condition(cell)):
return True
i += 1
return False
##
# Returns whether this tile layer is referencing the given tileset.
##
def referencesTileset(self, tileset):
i = 0
while (i < self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == tileset):
return True
i += 1
return False
##
# Removes all references to the given tileset. This sets all tiles on this
# layer that are from the given tileset to null.
##
def removeReferencesToTileset(self, tileset):
i = 0
while (i < self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == tileset):
self.mGrid.replace(i, Cell())
i += 1
##
# Replaces all tiles from \a oldTileset with tiles from \a newTileset.
##
def replaceReferencesToTileset(self, oldTileset, newTileset):
i = 0
while (i < self.mGrid.size()):
tile = self.mGrid.at(i).tile
if (tile and tile.tileset() == oldTileset):
self.mGrid[i].tile = newTileset.tileAt(tile.id())
i += 1
##
# Resizes this tile layer to \a size, while shifting all tiles by
# \a offset.
##
def resize(self, size, offset):
if (self.size() == size and offset.isNull()):
return
newGrid = QVector()
for i in range(size.width() * size.height()):
newGrid.append(Cell())
# Copy over the preserved part
startX = max(0, -offset.x())
startY = max(0, -offset.y())
endX = min(self.mWidth, size.width() - offset.x())
endY = min(self.mHeight, size.height() - offset.y())
for y in range(startY, endY):
for x in range(startX, endX):
index = x + offset.x() + (y + offset.y()) * size.width()
newGrid[index] = self.cellAt(x, y)
self.mGrid = newGrid
self.setSize(size)
##
# Offsets the tiles in this layer within \a bounds by \a offset,
# and optionally wraps them.
#
# \sa ObjectGroup.offset()
##
def offsetTiles(self, offset, bounds, wrapX, wrapY):
newGrid = QVector()
for i in range(self.mWidth * self.mHeight):
newGrid.append(Cell())
for y in range(self.mHeight):
for x in range(self.mWidth):
# Skip out of bounds tiles
if (not bounds.contains(x, y)):
newGrid[x + y * self.mWidth] = self.cellAt(x, y)
continue
# Get position to pull tile value from
oldX = x - offset.x()
oldY = y - offset.y()
# Wrap x value that will be pulled from
if (wrapX and bounds.width() > 0):
while oldX < bounds.left():
oldX += bounds.width()
while oldX > bounds.right():
oldX -= bounds.width()
# Wrap y value that will be pulled from
if (wrapY and bounds.height() > 0):
while oldY < bounds.top():
oldY += bounds.height()
while oldY > bounds.bottom():
oldY -= bounds.height()
# Set the new tile
if (self.contains(oldX, oldY) and bounds.contains(oldX, oldY)):
newGrid[x + y * self.mWidth] = self.cellAt(oldX, oldY)
else:
newGrid[x + y * self.mWidth] = Cell()
self.mGrid = newGrid
def canMergeWith(self, other):
return other.isTileLayer()
def mergedWith(self, other):
o = other
unitedBounds = self.bounds().united(o.bounds())
offset = self.position() - unitedBounds.topLeft()
merged = self.clone()
merged.resize(unitedBounds.size(), offset)
merged.merge(o.position() - unitedBounds.topLeft(), o)
return merged
##
# Returns the region where this tile layer and the given tile layer
# are different. The relative positions of the layers are taken into
# account. The returned region is relative to this tile layer.
##
def computeDiffRegion(self, other):
ret = QRegion()
dx = other.x() - self.mX
dy = other.y() - self.mY
r = QRect(0, 0, self.width(), self.height())
r &= QRect(dx, dy, other.width(), other.height())
for y in range(r.top(), r.bottom() + 1):
for x in range(r.left(), r.right() + 1):
if (self.cellAt(x, y) != other.cellAt(x - dx, y - dy)):
rangeStart = x
while (x <= r.right() and
self.cellAt(x, y) != other.cellAt(x - dx, y - dy)):
x += 1
rangeEnd = x
ret += QRect(rangeStart, y, rangeEnd - rangeStart, 1)
return ret
##
# Returns True if all tiles in the layer are empty.
##
def isEmpty(self):
i = 0
while (i < self.mGrid.size()):
if (not self.mGrid.at(i).isEmpty()):
return False
i += 1
return True
##
# Returns a duplicate of this TileLayer.
#
# \sa Layer.clone()
##
def clone(self):
return self.initializeClone(
TileLayer(self.mName, self.mX, self.mY, self.mWidth, self.mHeight))
def begin(self):
return self.mGrid.begin()
def end(self):
return self.mGrid.end()
def initializeClone(self, clone):
super().initializeClone(clone)
clone.mGrid = self.mGrid
clone.mMaxTileSize = self.mMaxTileSize
clone.mOffsetMargins = self.mOffsetMargins
return clone
class MapScene(QGraphicsScene):
selectedObjectItemsChanged = pyqtSignal()
##
# Constructor.
##
def __init__(self, parent):
super().__init__(parent)
self.mMapDocument = None
self.mSelectedTool = None
self.mActiveTool = None
self.mObjectSelectionItem = None
self.mUnderMouse = False
self.mCurrentModifiers = Qt.NoModifier,
self.mDarkRectangle = QGraphicsRectItem()
self.mDefaultBackgroundColor = Qt.darkGray
self.mLayerItems = QVector()
self.mObjectItems = QMap()
self.mObjectLineWidth = 0.0
self.mSelectedObjectItems = QSet()
self.mLastMousePos = QPointF()
self.mShowTileObjectOutlines = False
self.mHighlightCurrentLayer = False
self.mGridVisible = False
self.setBackgroundBrush(self.mDefaultBackgroundColor)
tilesetManager = TilesetManager.instance()
tilesetManager.tilesetChanged.connect(self.tilesetChanged)
tilesetManager.repaintTileset.connect(self.tilesetChanged)
prefs = preferences.Preferences.instance()
prefs.showGridChanged.connect(self.setGridVisible)
prefs.showTileObjectOutlinesChanged.connect(
self.setShowTileObjectOutlines)
prefs.objectTypesChanged.connect(self.syncAllObjectItems)
prefs.highlightCurrentLayerChanged.connect(
self.setHighlightCurrentLayer)
prefs.gridColorChanged.connect(self.update)
prefs.objectLineWidthChanged.connect(self.setObjectLineWidth)
self.mDarkRectangle.setPen(QPen(Qt.NoPen))
self.mDarkRectangle.setBrush(Qt.black)
self.mDarkRectangle.setOpacity(darkeningFactor)
self.addItem(self.mDarkRectangle)
self.mGridVisible = prefs.showGrid()
self.mObjectLineWidth = prefs.objectLineWidth()
self.mShowTileObjectOutlines = prefs.showTileObjectOutlines()
self.mHighlightCurrentLayer = prefs.highlightCurrentLayer()
# Install an event filter so that we can get key events on behalf of the
# active tool without having to have the current focus.
QCoreApplication.instance().installEventFilter(self)
##
# Destructor.
##
def __del__(self):
if QCoreApplication.instance():
QCoreApplication.instance().removeEventFilter(self)
##
# Returns the map document this scene is displaying.
##
def mapDocument(self):
return self.mMapDocument
##
# Sets the map this scene displays.
##
def setMapDocument(self, mapDocument):
if (self.mMapDocument):
self.mMapDocument.disconnect()
if (not self.mSelectedObjectItems.isEmpty()):
self.mSelectedObjectItems.clear()
self.selectedObjectItemsChanged.emit()
self.mMapDocument = mapDocument
if (self.mMapDocument):
renderer = self.mMapDocument.renderer()
renderer.setObjectLineWidth(self.mObjectLineWidth)
renderer.setFlag(RenderFlag.ShowTileObjectOutlines,
self.mShowTileObjectOutlines)
self.mMapDocument.mapChanged.connect(self.mapChanged)
self.mMapDocument.regionChanged.connect(self.repaintRegion)
self.mMapDocument.tileLayerDrawMarginsChanged.connect(
self.tileLayerDrawMarginsChanged)
self.mMapDocument.layerAdded.connect(self.layerAdded)
self.mMapDocument.layerRemoved.connect(self.layerRemoved)
self.mMapDocument.layerChanged.connect(self.layerChanged)
self.mMapDocument.objectGroupChanged.connect(
self.objectGroupChanged)
self.mMapDocument.imageLayerChanged.connect(self.imageLayerChanged)
self.mMapDocument.currentLayerIndexChanged.connect(
self.currentLayerIndexChanged)
self.mMapDocument.tilesetTileOffsetChanged.connect(
self.tilesetTileOffsetChanged)
self.mMapDocument.objectsInserted.connect(self.objectsInserted)
self.mMapDocument.objectsRemoved.connect(self.objectsRemoved)
self.mMapDocument.objectsChanged.connect(self.objectsChanged)
self.mMapDocument.objectsIndexChanged.connect(
self.objectsIndexChanged)
self.mMapDocument.selectedObjectsChanged.connect(
self.updateSelectedObjectItems)
self.refreshScene()
##
# Returns whether the tile grid is visible.
##
def isGridVisible(self):
return self.mGridVisible
##
# Returns the set of selected map object items.
##
def selectedObjectItems(self):
return QSet(self.mSelectedObjectItems)
##
# Sets the set of selected map object items. This translates to a call to
# MapDocument.setSelectedObjects.
##
def setSelectedObjectItems(self, items):
# Inform the map document about the newly selected objects
selectedObjects = QList()
#selectedObjects.reserve(items.size())
for item in items:
selectedObjects.append(item.mapObject())
self.mMapDocument.setSelectedObjects(selectedObjects)
##
# Returns the MapObjectItem associated with the given \a mapObject.
##
def itemForObject(self, object):
return self.mObjectItems[object]
##
# Enables the selected tool at this map scene.
# Therefore it tells that tool, that this is the active map scene.
##
def enableSelectedTool(self):
if (not self.mSelectedTool or not self.mMapDocument):
return
self.mActiveTool = self.mSelectedTool
self.mActiveTool.activate(self)
self.mCurrentModifiers = QApplication.keyboardModifiers()
if (self.mCurrentModifiers != Qt.NoModifier):
self.mActiveTool.modifiersChanged(self.mCurrentModifiers)
if (self.mUnderMouse):
self.mActiveTool.mouseEntered()
self.mActiveTool.mouseMoved(self.mLastMousePos,
Qt.KeyboardModifiers())
def disableSelectedTool(self):
if (not self.mActiveTool):
return
if (self.mUnderMouse):
self.mActiveTool.mouseLeft()
self.mActiveTool.deactivate(self)
self.mActiveTool = None
##
# Sets the currently selected tool.
##
def setSelectedTool(self, tool):
self.mSelectedTool = tool
##
# QGraphicsScene.drawForeground override that draws the tile grid.
##
def drawForeground(self, painter, rect):
if (not self.mMapDocument or not self.mGridVisible):
return
offset = QPointF()
# Take into account the offset of the current layer
layer = self.mMapDocument.currentLayer()
if layer:
offset = layer.offset()
painter.translate(offset)
prefs = preferences.Preferences.instance()
self.mMapDocument.renderer().drawGrid(painter,
rect.translated(-offset),
prefs.gridColor())
##
# Override for handling enter and leave events.
##
def event(self, event):
x = event.type()
if x == QEvent.Enter:
self.mUnderMouse = True
if (self.mActiveTool):
self.mActiveTool.mouseEntered()
elif x == QEvent.Leave:
self.mUnderMouse = False
if (self.mActiveTool):
self.mActiveTool.mouseLeft()
else:
pass
return super().event(event)
def keyPressEvent(self, event):
if (self.mActiveTool):
self.mActiveTool.keyPressed(event)
if (not (self.mActiveTool and event.isAccepted())):
super().keyPressEvent(event)
def mouseMoveEvent(self, mouseEvent):
self.mLastMousePos = mouseEvent.scenePos()
if (not self.mMapDocument):
return
super().mouseMoveEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
self.mActiveTool.mouseMoved(mouseEvent.scenePos(),
mouseEvent.modifiers())
mouseEvent.accept()
def mousePressEvent(self, mouseEvent):
super().mousePressEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
mouseEvent.accept()
self.mActiveTool.mousePressed(mouseEvent)
def mouseReleaseEvent(self, mouseEvent):
super().mouseReleaseEvent(mouseEvent)
if (mouseEvent.isAccepted()):
return
if (self.mActiveTool):
mouseEvent.accept()
self.mActiveTool.mouseReleased(mouseEvent)
##
# Override to ignore drag enter events.
##
def dragEnterEvent(self, event):
event.ignore()
##
# Sets whether the tile grid is visible.
##
def setGridVisible(self, visible):
if (self.mGridVisible == visible):
return
self.mGridVisible = visible
self.update()
def setObjectLineWidth(self, lineWidth):
if (self.mObjectLineWidth == lineWidth):
return
self.mObjectLineWidth = lineWidth
if (self.mMapDocument):
self.mMapDocument.renderer().setObjectLineWidth(lineWidth)
# Changing the line width can change the size of the object items
if (not self.mObjectItems.isEmpty()):
for item in self.mObjectItems:
item[1].syncWithMapObject()
self.update()
def setShowTileObjectOutlines(self, enabled):
if (self.mShowTileObjectOutlines == enabled):
return
self.mShowTileObjectOutlines = enabled
if (self.mMapDocument):
self.mMapDocument.renderer().setFlag(
RenderFlag.ShowTileObjectOutlines, enabled)
if (not self.mObjectItems.isEmpty()):
self.update()
##
# Sets whether the current layer should be highlighted.
##
def setHighlightCurrentLayer(self, highlightCurrentLayer):
if (self.mHighlightCurrentLayer == highlightCurrentLayer):
return
self.mHighlightCurrentLayer = highlightCurrentLayer
self.updateCurrentLayerHighlight()
##
# Refreshes the map scene.
##
def refreshScene(self):
self.mLayerItems.clear()
self.mObjectItems.clear()
self.removeItem(self.mDarkRectangle)
self.clear()
self.addItem(self.mDarkRectangle)
if (not self.mMapDocument):
self.setSceneRect(QRectF())
return
self.updateSceneRect()
map = self.mMapDocument.map()
self.mLayerItems.resize(map.layerCount())
if (map.backgroundColor().isValid()):
self.setBackgroundBrush(map.backgroundColor())
else:
self.setBackgroundBrush(self.mDefaultBackgroundColor)
layerIndex = 0
for layer in map.layers():
layerItem = self.createLayerItem(layer)
layerItem.setZValue(layerIndex)
self.addItem(layerItem)
self.mLayerItems[layerIndex] = layerItem
layerIndex += 1
tileSelectionItem = TileSelectionItem(self.mMapDocument)
tileSelectionItem.setZValue(10000 - 2)
self.addItem(tileSelectionItem)
self.mObjectSelectionItem = ObjectSelectionItem(self.mMapDocument)
self.mObjectSelectionItem.setZValue(10000 - 1)
self.addItem(self.mObjectSelectionItem)
self.updateCurrentLayerHighlight()
##
# Repaints the specified region. The region is in tile coordinates.
##
def repaintRegion(self, region, layer):
renderer = self.mMapDocument.renderer()
margins = self.mMapDocument.map().drawMargins()
for r in region.rects():
boundingRect = QRectF(renderer.boundingRect(r))
self.update(
QRectF(
renderer.boundingRect(r).adjusted(-margins.left(),
-margins.top(),
margins.right(),
margins.bottom())))
boundingRect.translate(layer.offset())
self.update(boundingRect)
def currentLayerIndexChanged(self):
self.updateCurrentLayerHighlight()
# New layer may have a different offset, affecting the grid
if self.mGridVisible:
self.update()
##
# Adapts the scene, layers and objects to new map size, orientation or
# background color.
##
def mapChanged(self):
self.updateSceneRect()
for item in self.mLayerItems:
tli = item
if type(tli) == TileLayerItem:
tli.syncWithTileLayer()
for item in self.mObjectItems.values():
item.syncWithMapObject()
map = self.mMapDocument.map()
if (map.backgroundColor().isValid()):
self.setBackgroundBrush(map.backgroundColor())
else:
self.setBackgroundBrush(self.mDefaultBackgroundColor)
def tilesetChanged(self, tileset):
if (not self.mMapDocument):
return
if (contains(self.mMapDocument.map().tilesets(), tileset)):
self.update()
def tileLayerDrawMarginsChanged(self, tileLayer):
index = self.mMapDocument.map().layers().indexOf(tileLayer)
item = self.mLayerItems.at(index)
item.syncWithTileLayer()
def layerAdded(self, index):
layer = self.mMapDocument.map().layerAt(index)
layerItem = self.createLayerItem(layer)
self.addItem(layerItem)
self.mLayerItems.insert(index, layerItem)
z = 0
for item in self.mLayerItems:
item.setZValue(z)
z += 1
def layerRemoved(self, index):
self.mLayerItems.remove(index)
##
# A layer has changed. This can mean that the layer visibility, opacity or
# offset changed.
##
def layerChanged(self, index):
layer = self.mMapDocument.map().layerAt(index)
layerItem = self.mLayerItems.at(index)
layerItem.setVisible(layer.isVisible())
multiplier = 1
if (self.mHighlightCurrentLayer
and self.mMapDocument.currentLayerIndex() < index):
multiplier = opacityFactor
layerItem.setOpacity(layer.opacity() * multiplier)
layerItem.setPos(layer.offset())
# Layer offset may have changed, affecting the scene rect and grid
self.updateSceneRect()
if self.mGridVisible:
self.update()
##
# When an object group has changed it may mean its color or drawing order
# changed, which affects all its objects.
##
def objectGroupChanged(self, objectGroup):
self.objectsChanged(objectGroup.objects())
self.objectsIndexChanged(objectGroup, 0, objectGroup.objectCount() - 1)
##
# When an image layer has changed, it may change size and it may look
# differently.
##
def imageLayerChanged(self, imageLayer):
index = self.mMapDocument.map().layers().indexOf(imageLayer)
item = self.mLayerItems.at(index)
item.syncWithImageLayer()
item.update()
##
# When the tile offset of a tileset has changed, it can affect the bounding
# rect of all tile layers and tile objects. It also requires a full repaint.
##
def tilesetTileOffsetChanged(self, tileset):
self.update()
for item in self.mLayerItems:
tli = item
if type(tli) == TileLayerItem:
tli.syncWithTileLayer()
for item in self.mObjectItems:
cell = item.mapObject().cell()
if (not cell.isEmpty() and cell.tile.tileset() == tileset):
item.syncWithMapObject()
##
# Inserts map object items for the given objects.
##
def objectsInserted(self, objectGroup, first, last):
ogItem = None
# Find the object group item for the object group
for item in self.mLayerItems:
ogi = item
if type(ogi) == ObjectGroupItem:
if (ogi.objectGroup() == objectGroup):
ogItem = ogi
break
drawOrder = objectGroup.drawOrder()
for i in range(first, last + 1):
object = objectGroup.objectAt(i)
item = MapObjectItem(object, self.mMapDocument, ogItem)
if (drawOrder == ObjectGroup.DrawOrder.TopDownOrder):
item.setZValue(item.y())
else:
item.setZValue(i)
self.mObjectItems.insert(object, item)
##
# Removes the map object items related to the given objects.
##
def objectsRemoved(self, objects):
for o in objects:
i = self.mObjectItems.find(o)
self.mSelectedObjectItems.remove(i)
# python would not force delete QGraphicsItem
self.removeItem(i)
self.mObjectItems.erase(o)
##
# Updates the map object items related to the given objects.
##
def objectsChanged(self, objects):
for object in objects:
item = self.itemForObject(object)
item.syncWithMapObject()
##
# Updates the Z value of the objects when appropriate.
##
def objectsIndexChanged(self, objectGroup, first, last):
if (objectGroup.drawOrder() != ObjectGroup.DrawOrder.IndexOrder):
return
for i in range(first, last + 1):
item = self.itemForObject(objectGroup.objectAt(i))
item.setZValue(i)
def updateSelectedObjectItems(self):
objects = self.mMapDocument.selectedObjects()
items = QSet()
for object in objects:
item = self.itemForObject(object)
if item:
items.insert(item)
self.mSelectedObjectItems = items
self.selectedObjectItemsChanged.emit()
def syncAllObjectItems(self):
for item in self.mObjectItems:
item.syncWithMapObject()
def createLayerItem(self, layer):
layerItem = None
tl = layer.asTileLayer()
if tl:
layerItem = TileLayerItem(tl, self.mMapDocument)
else:
og = layer.asObjectGroup()
if og:
drawOrder = og.drawOrder()
ogItem = ObjectGroupItem(og)
objectIndex = 0
for object in og.objects():
item = MapObjectItem(object, self.mMapDocument, ogItem)
if (drawOrder == ObjectGroup.DrawOrder.TopDownOrder):
item.setZValue(item.y())
else:
item.setZValue(objectIndex)
self.mObjectItems.insert(object, item)
objectIndex += 1
layerItem = ogItem
else:
il = layer.asImageLayer()
if il:
layerItem = ImageLayerItem(il, self.mMapDocument)
layerItem.setVisible(layer.isVisible())
return layerItem
def updateSceneRect(self):
mapSize = self.mMapDocument.renderer().mapSize()
sceneRect = QRectF(0, 0, mapSize.width(), mapSize.height())
margins = self.mMapDocument.map().computeLayerOffsetMargins()
sceneRect.adjust(-margins.left(), -margins.top(), margins.right(),
margins.bottom())
self.setSceneRect(sceneRect)
self.mDarkRectangle.setRect(sceneRect)
def updateCurrentLayerHighlight(self):
if (not self.mMapDocument):
return
currentLayerIndex = self.mMapDocument.currentLayerIndex()
if (not self.mHighlightCurrentLayer or currentLayerIndex == -1):
self.mDarkRectangle.setVisible(False)
# Restore opacity for all layers
for i in range(self.mLayerItems.size()):
layer = self.mMapDocument.map().layerAt(i)
self.mLayerItems.at(i).setOpacity(layer.opacity())
return
# Darken layers below the current layer
self.mDarkRectangle.setZValue(currentLayerIndex - 0.5)
self.mDarkRectangle.setVisible(True)
# Set layers above the current layer to half opacity
for i in range(1, self.mLayerItems.size()):
layer = self.mMapDocument.map().layerAt(i)
if currentLayerIndex < i:
_x = opacityFactor
else:
_x = 1
multiplier = _x
self.mLayerItems.at(i).setOpacity(layer.opacity() * multiplier)
def eventFilter(self, object, event):
x = event.type()
if x == QEvent.KeyPress or x == QEvent.KeyRelease:
keyEvent = event
newModifiers = keyEvent.modifiers()
if (self.mActiveTool and newModifiers != self.mCurrentModifiers):
self.mActiveTool.modifiersChanged(newModifiers)
self.mCurrentModifiers = newModifiers
else:
pass
return False
class ObjectTypesModel(QAbstractTableModel):
ColorRole = Qt.UserRole
def __init__(self, parent):
super().__init__(parent)
self.mObjectTypes = QVector()
def setObjectTypes(self, objectTypes):
self.beginResetModel()
self.mObjectTypes = objectTypes
self.endResetModel()
def objectTypes(self):
return self.mObjectTypes
def rowCount(self, parent):
if parent.isValid():
_x = 0
else:
_x = self.mObjectTypes.size()
return _x
def columnCount(self, parent):
if parent.isValid():
_x = 0
else:
_x = 2
return _x
def headerData(self, section, orientation, role):
if (orientation == Qt.Horizontal):
if (role == Qt.DisplayRole):
x = section
if x == 0:
return self.tr("Type")
elif x == 1:
return self.tr("Color")
elif (role == Qt.TextAlignmentRole):
return Qt.AlignLeft
return QVariant()
def data(self, index, role):
# QComboBox requests data for an invalid index when the model is empty
if (not index.isValid()):
return QVariant()
objectType = self.mObjectTypes.at(index.row())
if (role == Qt.DisplayRole or role == Qt.EditRole):
if (index.column() == 0):
return objectType.name
if (role == ObjectTypesModel.ColorRole and index.column() == 1):
return objectType.color
return QVariant()
def setData(self, index, value, role):
if (role == Qt.EditRole and index.column() == 0):
self.mObjectTypes[index.row()].name = value.strip()
self.dataChanged.emit(index, index)
return True
return False
def flags(self, index):
f = super().flags(index)
if (index.column() == 0):
f |= Qt.ItemIsEditable
return f
def setObjectTypeColor(self, objectIndex, color):
self.mObjectTypes[objectIndex].color = color
mi = self.index(objectIndex, 1)
self.dataChanged.emit(mi, mi)
def removeObjectTypes(self, indexes):
rows = QVector()
for index in indexes:
rows.append(index.row())
rows = sorted(rows)
for i in range(len(rows) - 1, -1, -1):
row = rows[i]
self.beginRemoveRows(QModelIndex(), row, row)
self.mObjectTypes.remove(row)
self.endRemoveRows()
def appendNewObjectType(self):
self.beginInsertRows(QModelIndex(), self.mObjectTypes.size(),
self.mObjectTypes.size())
self.mObjectTypes.append(ObjectType())
self.endInsertRows()
class EditPolygonTool(AbstractObjectTool):
NoMode, Selecting, Moving = range(3)
def __init__(self, parent = None):
super().__init__(self.tr("Edit Polygons"),
QIcon(":images/24x24/tool-edit-polygons.png"),
QKeySequence(self.tr("E")),
parent)
self.mSelectedHandles = QSet()
self.mModifiers = Qt.KeyboardModifiers()
self.mScreenStart = QPoint()
self.mOldHandlePositions = QVector()
self.mAlignPosition = QPointF()
## The list of handles associated with each selected map object
self.mHandles = QMapList()
self.mOldPolygons = QMap()
self.mStart = QPointF()
self.mSelectionRectangle = SelectionRectangle()
self.mMousePressed = False
self.mClickedHandle = None
self.mClickedObjectItem = None
self.mMode = EditPolygonTool.NoMode
def __del__(self):
del self.mSelectionRectangle
def tr(self, sourceText, disambiguation = '', n = -1):
return QCoreApplication.translate('EditPolygonTool', sourceText, disambiguation, n)
def activate(self, scene):
super().activate(scene)
self.updateHandles()
# TODO: Could be more optimal by separating the updating of handles from
# the creation and removal of handles depending on changes in the
# selection, and by only updating the handles of the objects that changed.
self.mapDocument().objectsChanged.connect(self.updateHandles)
scene.selectedObjectItemsChanged.connect(self.updateHandles)
self.mapDocument().objectsRemoved.connect(self.objectsRemoved)
def deactivate(self, scene):
try:
self.mapDocument().objectsChanged.disconnect(self.updateHandles)
scene.selectedObjectItemsChanged.disconnect(self.updateHandles)
except:
pass
# Delete all handles
self.mHandles.clear()
self.mSelectedHandles.clear()
self.mClickedHandle = None
super().deactivate(scene)
def mouseEntered(self):
pass
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
if (self.mMode == EditPolygonTool.NoMode and self.mMousePressed):
screenPos = QCursor.pos()
dragDistance = (self.mScreenStart - screenPos).manhattanLength()
if (dragDistance >= QApplication.startDragDistance()):
if (self.mClickedHandle):
self.startMoving()
else:
self.startSelecting()
x = self.mMode
if x==EditPolygonTool.Selecting:
self.mSelectionRectangle.setRectangle(QRectF(self.mStart, pos).normalized())
elif x==EditPolygonTool.Moving:
self.updateMovingItems(pos, modifiers)
elif x==EditPolygonTool.NoMode:
pass
def mousePressed(self, event):
if (self.mMode != EditPolygonTool.NoMode): # Ignore additional presses during select/move
return
x = event.button()
if x==Qt.LeftButton:
self.mMousePressed = True
self.mStart = event.scenePos()
self.mScreenStart = event.screenPos()
items = self.mapScene().items(self.mStart,
Qt.IntersectsItemShape,
Qt.DescendingOrder,
viewTransform(event))
self.mClickedObjectItem = first(items, MapObjectItem)
self.mClickedHandle = first(items, PointHandle)
elif x==Qt.RightButton:
items = self.mapScene().items(event.scenePos(),
Qt.IntersectsItemShape,
Qt.DescendingOrder,
viewTransform(event))
clickedHandle = first(items)
if (clickedHandle or not self.mSelectedHandles.isEmpty()):
self.showHandleContextMenu(clickedHandle,
event.screenPos())
else:
super().mousePressed(event)
else:
super().mousePressed(event)
def mouseReleased(self, event):
if (event.button() != Qt.LeftButton):
return
x = self.mMode
if x==EditPolygonTool.NoMode:
if (self.mClickedHandle):
selection = self.mSelectedHandles
modifiers = event.modifiers()
if (modifiers & (Qt.ShiftModifier | Qt.ControlModifier)):
if (selection.contains(self.mClickedHandle)):
selection.remove(self.mClickedHandle)
else:
selection.insert(self.mClickedHandle)
else:
selection.clear()
selection.insert(self.mClickedHandle)
self.setSelectedHandles(selection)
elif (self.mClickedObjectItem):
selection = self.mapScene().selectedObjectItems()
modifiers = event.modifiers()
if (modifiers & (Qt.ShiftModifier | Qt.ControlModifier)):
if (selection.contains(self.mClickedObjectItem)):
selection.remove(self.mClickedObjectItem)
else:
selection.insert(self.mClickedObjectItem)
else:
selection.clear()
selection.insert(self.mClickedObjectItem)
self.mapScene().setSelectedObjectItems(selection)
self.updateHandles()
elif (not self.mSelectedHandles.isEmpty()):
# First clear the handle selection
self.setSelectedHandles(QSet())
else:
# If there is no handle selection, clear the object selection
self.mapScene().setSelectedObjectItems(QSet())
self.updateHandles()
elif x==EditPolygonTool.Selecting:
self.updateSelection(event)
self.mapScene().removeItem(self.mSelectionRectangle)
self.mMode = EditPolygonTool.NoMode
elif x==EditPolygonTool.Moving:
self.finishMoving(event.scenePos())
self.mMousePressed = False
self.mClickedHandle = None
def modifiersChanged(self, modifiers):
self.mModifiers = modifiers
def languageChanged(self):
self.setName(self.tr("Edit Polygons"))
self.setShortcut(QKeySequence(self.tr("E")))
def updateHandles(self):
selection = self.mapScene().selectedObjectItems()
# First destroy the handles for objects that are no longer selected
for l in range(len(self.mHandles)):
i = self.mHandles.itemByIndex(l)
if (not selection.contains(i[0])):
for handle in i[1]:
if (handle.isSelected()):
self.mSelectedHandles.remove(handle)
del handle
del self.mHandles[l]
renderer = self.mapDocument().renderer()
for item in selection:
object = item.mapObject()
if (not object.cell().isEmpty()):
continue
polygon = object.polygon()
polygon.translate(object.position())
pointHandles = self.mHandles.get(item)
# Create missing handles
while (pointHandles.size() < polygon.size()):
handle = PointHandle(item, pointHandles.size())
pointHandles.append(handle)
self.mapScene().addItem(handle)
# Remove superfluous handles
while (pointHandles.size() > polygon.size()):
handle = pointHandles.takeLast()
if (handle.isSelected()):
self.mSelectedHandles.remove(handle)
del handle
# Update the position of all handles
for i in range(pointHandles.size()):
point = polygon.at(i)
handlePos = renderer.pixelToScreenCoords_(point)
internalHandlePos = handlePos - item.pos()
pointHandles.at(i).setPos(item.mapToScene(internalHandlePos))
self.mHandles.insert(item, pointHandles)
def objectsRemoved(self, objects):
if (self.mMode == EditPolygonTool.Moving):
# Make sure we're not going to try to still change these objects when
# finishing the move operation.
# TODO: In addition to avoiding crashes, it would also be good to
# disallow other actions while moving.
for object in objects:
self.mOldPolygons.remove(object)
def deleteNodes(self):
if (self.mSelectedHandles.isEmpty()):
return
p = groupIndexesByObject(self.mSelectedHandles)
undoStack = self.mapDocument().undoStack()
delText = self.tr("Delete %n Node(s)", "", self.mSelectedHandles.size())
undoStack.beginMacro(delText)
for i in p:
object = i[0]
indexRanges = i[1]
oldPolygon = object.polygon()
newPolygon = oldPolygon
# Remove points, back to front to keep the indexes valid
it = indexRanges.end()
begin = indexRanges.begin()
# assert: end != begin, since there is at least one entry
while(it != begin):
it -= 1
newPolygon.remove(it.first(), it.length())
if (newPolygon.size() < 2):
# We've removed the entire object
undoStack.push(RemoveMapObject(self.mapDocument(), object))
else:
undoStack.push(ChangePolygon(self.mapDocument(), object, newPolygon, oldPolygon))
undoStack.endMacro()
def joinNodes(self):
if (self.mSelectedHandles.size() < 2):
return
p = groupIndexesByObject(self.mSelectedHandles)
undoStack = self.mapDocument().undoStack()
macroStarted = False
for i in p:
object = i[0]
indexRanges = i[1]
closed = object.shape() == MapObject.Polygon
oldPolygon = object.polygon()
newPolygon = joinPolygonNodes(oldPolygon, indexRanges,
closed)
if (newPolygon.size() < oldPolygon.size()):
if (not macroStarted):
undoStack.beginMacro(self.tr("Join Nodes"))
macroStarted = True
undoStack.push(ChangePolygon(self.mapDocument(), object, newPolygon, oldPolygon))
if (macroStarted):
undoStack.endMacro()
def splitSegments(self):
if (self.mSelectedHandles.size() < 2):
return
p = groupIndexesByObject(self.mSelectedHandles)
undoStack = self.mapDocument().undoStack()
macroStarted = False
for i in p:
object = i[0]
indexRanges = i[1]
closed = object.shape() == MapObject.Polygon
oldPolygon = object.polygon()
newPolygon = splitPolygonSegments(oldPolygon, indexRanges,
closed)
if (newPolygon.size() > oldPolygon.size()):
if (not macroStarted):
undoStack.beginMacro(self.tr("Split Segments"))
macroStarted = True
undoStack.push(ChangePolygon(self.mapDocument(), object, newPolygon, oldPolygon))
if (macroStarted):
undoStack.endMacro()
def setSelectedHandles(self, handles):
for handle in self.mSelectedHandles:
if (not handles.contains(handle)):
handle.setSelected(False)
for handle in handles:
if (not self.mSelectedHandles.contains(handle)):
handle.setSelected(True)
self.mSelectedHandles = handles
def setSelectedHandle(self, handle):
self.setSelectedHandles(QSet([handle]))
def updateSelection(self, event):
rect = QRectF(self.mStart, event.scenePos()).normalized()
# Make sure the rect has some contents, otherwise intersects returns False
rect.setWidth(max(1.0, rect.width()))
rect.setHeight(max(1.0, rect.height()))
oldSelection = self.mapScene().selectedObjectItems()
if (oldSelection.isEmpty()):
# Allow selecting some map objects only when there aren't any selected
selectedItems = QSet()
for item in self.mapScene().items(rect, Qt.IntersectsItemShape, Qt.DescendingOrder, viewTransform(event)):
if type(item) == MapObjectItem:
selectedItems.insert(item)
newSelection = QSet()
if (event.modifiers() & (Qt.ControlModifier | Qt.ShiftModifier)):
newSelection = oldSelection | selectedItems
else:
newSelection = selectedItems
self.mapScene().setSelectedObjectItems(newSelection)
self.updateHandles()
else:
# Update the selected handles
selectedHandles = QSet()
for item in self.mapScene().items(rect, Qt.IntersectsItemShape, Qt.DescendingOrder, viewTransform(event)):
if type(item) == PointHandle:
selectedHandles.insert(item)
if (event.modifiers() & (Qt.ControlModifier | Qt.ShiftModifier)):
self.setSelectedHandles(self.mSelectedHandles | selectedHandles)
else:
self.setSelectedHandles(selectedHandles)
def startSelecting(self):
self.mMode = EditPolygonTool.Selecting
self.mapScene().addItem(self.mSelectionRectangle)
def startMoving(self):
# Move only the clicked handle, if it was not part of the selection
if (not self.mSelectedHandles.contains(self.mClickedHandle)):
self.setSelectedHandle(self.mClickedHandle)
self.mMode = EditPolygonTool.Moving
renderer = self.mapDocument().renderer()
# Remember the current object positions
self.mOldHandlePositions.clear()
self.mOldPolygons.clear()
self.mAlignPosition = renderer.screenToPixelCoords_((self.mSelectedHandles.begin()).pos())
for handle in self.mSelectedHandles:
pos = renderer.screenToPixelCoords_(handle.pos())
self.mOldHandlePositions.append(handle.pos())
if (pos.x() < self.mAlignPosition.x()):
self.mAlignPosition.setX(pos.x())
if (pos.y() < self.mAlignPosition.y()):
self.mAlignPosition.setY(pos.y())
mapObject = handle.mapObject()
if (not self.mOldPolygons.contains(mapObject)):
self.mOldPolygons.insert(mapObject, mapObject.polygon())
def updateMovingItems(self, pos, modifiers):
renderer = self.mapDocument().renderer()
diff = pos - self.mStart
snapHelper = SnapHelper(renderer, modifiers)
if (snapHelper.snaps()):
alignScreenPos = renderer.pixelToScreenCoords_(self.mAlignPosition)
newAlignScreenPos = alignScreenPos + diff
newAlignPixelPos = renderer.screenToPixelCoords_(newAlignScreenPos)
snapHelper.snap(newAlignPixelPos)
diff = renderer.pixelToScreenCoords_(newAlignPixelPos) - alignScreenPos
i = 0
for handle in self.mSelectedHandles:
# update handle position
newScreenPos = self.mOldHandlePositions.at(i) + diff
handle.setPos(newScreenPos)
# calculate new pixel position of polygon node
item = handle.mapObjectItem()
newInternalPos = item.mapFromScene(newScreenPos)
newScenePos = item.pos() + newInternalPos
newPixelPos = renderer.screenToPixelCoords_(newScenePos)
# update the polygon
mapObject = item.mapObject()
polygon = mapObject.polygon()
polygon[handle.pointIndex()] = newPixelPos - mapObject.position()
self.mapDocument().mapObjectModel().setObjectPolygon(mapObject, polygon)
i += 1
def finishMoving(self, pos):
self.mMode = EditPolygonTool.NoMode
if (self.mStart == pos or self.mOldPolygons.isEmpty()): # Move is a no-op
return
undoStack = self.mapDocument().undoStack()
undoStack.beginMacro(self.tr("Move %n Point(s)", "", self.mSelectedHandles.size()))
# TODO: This isn't really optimal. Would be better to have a single undo
# command that supports changing multiple map objects.
for i in self.mOldPolygons:
undoStack.push(ChangePolygon(self.mapDocument(), i[0], i[1]))
undoStack.endMacro()
self.mOldHandlePositions.clear()
self.mOldPolygons.clear()
def showHandleContextMenu(self, clickedHandle, screenPos):
if (clickedHandle and not self.mSelectedHandles.contains(clickedHandle)):
self.setSelectedHandle(clickedHandle)
n = self.mSelectedHandles.size()
delIcon = QIcon(":images/16x16/edit-delete.png")
delText = self.tr("Delete %n Node(s)", "", n)
menu = QMenu()
deleteNodesAction = menu.addAction(delIcon, delText)
joinNodesAction = menu.addAction(self.tr("Join Nodes"))
splitSegmentsAction = menu.addAction(self.tr("Split Segments"))
Utils.setThemeIcon(deleteNodesAction, "edit-delete")
joinNodesAction.setEnabled(n > 1)
splitSegmentsAction.setEnabled(n > 1)
deleteNodesAction.triggered.connect(self.deleteNodes)
joinNodesAction.triggered.connect(self.joinNodes)
splitSegmentsAction.triggered.connect(self.splitSegments)
menu.exec(screenPos)
class FrameListModel(QAbstractListModel):
DEFAULT_DURATION = 100
def __init__(self, parent):
super().__init__(parent)
self.mFrames = QVector()
self.mTileset = None
def rowCount(self, parent):
if parent.isValid():
_x = 0
else:
_x = self.mFrames.size()
return _x
def data(self, index, role):
x = role
if x == Qt.EditRole or x == Qt.DisplayRole:
return self.mFrames.at(index.row()).duration
elif x == Qt.DecorationRole:
tileId = self.mFrames.at(index.row()).tileId
tile = self.mTileset.tileAt(tileId)
if tile:
return tile.image()
return QVariant()
def setData(self, index, value, role):
if (role == Qt.EditRole):
duration = value
if (duration >= 0):
self.mFrames[index.row()].duration = duration
self.dataChanged.emit(index, index)
return True
return False
def flags(self, index):
defaultFlags = super().flags(index)
if (index.isValid()):
return Qt.ItemIsDragEnabled | Qt.ItemIsEditable | defaultFlags
else:
return Qt.ItemIsDropEnabled | defaultFlags
def removeRows(self, row, count, parent):
if (not parent.isValid()):
if (count > 0):
self.beginRemoveRows(parent, row, row + count - 1)
self.mFrames.remove(row, count)
self.endRemoveRows()
return True
return False
def mimeTypes(self):
types = QStringList()
types.append(TILES_MIMETYPE)
types.append(FRAMES_MIMETYPE)
return types
def mimeData(self, indexes):
mimeData = QMimeData()
encodedData = QByteArray()
stream = QDataStream(encodedData, QIODevice.WriteOnly)
for index in indexes:
if (index.isValid()):
frame = self.mFrames.at(index.row())
stream.writeInt(frame.tileId)
stream.writeInt(frame.duration)
mimeData.setData(FRAMES_MIMETYPE, encodedData)
return mimeData
def dropMimeData(self, data, action, row, column, parent):
if (action == Qt.IgnoreAction):
return True
if (column > 0):
return False
beginRow = 0
if (row != -1):
beginRow = row
elif parent.isValid():
beginRow = parent.row()
else:
beginRow = self.mFrames.size()
newFrames = QVector()
if (data.hasFormat(FRAMES_MIMETYPE)):
encodedData = data.data(FRAMES_MIMETYPE)
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while (not stream.atEnd()):
frame = Frame()
frame.tileId = stream.readInt()
frame.duration = stream.readInt()
newFrames.append(frame)
elif (data.hasFormat(TILES_MIMETYPE)):
encodedData = data.data(TILES_MIMETYPE)
stream = QDataStream(encodedData, QIODevice.ReadOnly)
while (not stream.atEnd()):
frame = Frame()
frame.tileId = stream.readInt()
frame.duration = FrameListModel.DEFAULT_DURATION
newFrames.append(frame)
if (newFrames.isEmpty()):
return False
self.beginInsertRows(QModelIndex(), beginRow,
beginRow + newFrames.size() - 1)
self.mFrames.insert(beginRow, newFrames.size(), Frame())
for i in range(newFrames.size()):
self.mFrames[i + beginRow] = newFrames[i]
self.endInsertRows()
return True
def supportedDropActions(self):
return Qt.CopyAction | Qt.MoveAction
def setFrames(self, tileset, frames):
self.beginResetModel()
self.mTileset = tileset
self.mFrames = frames
self.endResetModel()
def addTileIdAsFrame(self, id):
frame = Frame()
frame.tileId = id
frame.duration = FrameListModel.DEFAULT_DURATION
self.addFrame(frame)
def frames(self):
return self.mFrames
def addFrame(self, frame):
self.beginInsertRows(QModelIndex(), self.mFrames.size(),
self.mFrames.size())
self.mFrames.append(frame)
self.endInsertRows()