def startNewMapObject(self, pos, objectGroup):
super().startNewMapObject(pos, objectGroup)
newMapObject = self.mNewMapObjectItem.mapObject()
polygon = QPolygonF()
polygon.append(QPointF())
newMapObject.setPolygon(polygon)
polygon.append(QPointF()) # The last point is connected to the mouse
self.mOverlayPolygonObject.setPolygon(polygon)
self.mOverlayPolygonObject.setShape(newMapObject.shape())
self.mOverlayPolygonObject.setPosition(pos)
self.mOverlayPolygonItem = MapObjectItem(self.mOverlayPolygonObject, self.mapDocument(), self.mObjectGroupItem)
def startNewMapObject(self, pos, objectGroup):
newMapObject = self.createNewMapObject()
if not newMapObject:
return
newMapObject.setPosition(pos)
objectGroup.addObject(newMapObject)
self.mObjectGroupItem.setObjectGroup(objectGroup)
self.mNewMapObjectItem = MapObjectItem(newMapObject,
self.mapDocument(),
self.mObjectGroupItem)
class CreateMultipointObjectTool(CreateObjectTool):
def __init__(self, parent):
super().__init__(CreationMode.CreateGeometry, parent)
self.mOverlayPolygonObject = MapObject()
self.mOverlayObjectGroup = ObjectGroup()
self.mOverlayObjectGroup.addObject(self.mOverlayPolygonObject)
highlight = QApplication.palette().highlight().color()
self.mOverlayObjectGroup.setColor(highlight)
def startNewMapObject(self, pos, objectGroup):
super().startNewMapObject(pos, objectGroup)
newMapObject = self.mNewMapObjectItem.mapObject()
polygon = QPolygonF()
polygon.append(QPointF())
newMapObject.setPolygon(polygon)
polygon.append(QPointF()) # The last point is connected to the mouse
self.mOverlayPolygonObject.setPolygon(polygon)
self.mOverlayPolygonObject.setShape(newMapObject.shape())
self.mOverlayPolygonObject.setPosition(pos)
self.mOverlayPolygonItem = MapObjectItem(self.mOverlayPolygonObject, self.mapDocument(), self.mObjectGroupItem)
def languageChanged(self):
pass
def mouseMovedWhileCreatingObject(self, pos, modifiers):
renderer = self.mapDocument().renderer()
pixelCoords = renderer.screenToPixelCoords_(pos)
SnapHelper(renderer, modifiers).snap(pixelCoords)
pixelCoords -= self.mNewMapObjectItem.mapObject().position()
polygon = self.mOverlayPolygonObject.polygon()
polygon[-1] = pixelCoords
self.mOverlayPolygonItem.setPolygon(polygon)
def mousePressedWhileCreatingObject(self, event):
if (event.button() == Qt.RightButton):
self.finishNewMapObject()
elif (event.button() == Qt.LeftButton):
current = self.mNewMapObjectItem.mapObject().polygon()
next = self.mOverlayPolygonObject.polygon()
# If the last position is still the same, ignore the click
if (next.last() == current.last()):
return
# Assign current overlay polygon to the new object
self.mNewMapObjectItem.setPolygon(next)
# Add a new editable point to the overlay
next.append(next.last())
self.mOverlayPolygonItem.setPolygon(next)
def render(self, size):
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
if (self.mIncludeBackgroundColor):
if (self.mMap.backgroundColor().isValid()):
image.fill(self.mMap.backgroundColor())
else:
image.fill(Qt.gray)
else :
image.fill(Qt.transparent)
mapSize = self.mRenderer.mapSize()
margins = self.mRenderer.map().drawMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
scale = min(size.width() / mapSize.width(), size.height() / mapSize.height())
scaledSize = mapSize * scale
painter = QPainter(image)
# Center the thumbnail in the requested size
painter.translate((size.width() - scaledSize.width()) / 2,
(size.height() - scaledSize.height()) / 2)
# Scale the map and translate it to adjust for its margins
painter.scale(scale, scale)
painter.translate(margins.left() + (size.width() - scaledSize.width()) / 2,
margins.top() + (size.height() - scaledSize.height()) / 2)
if (smoothTransform(scale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
self.mRenderer.setPainterScale(scale)
for layer in self.mMap.layers():
if (self.mVisibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
tileLayer = dynamic_cast(layer, TileLayer)
objGroup = dynamic_cast(layer, ObjectGroup)
imageLayer = dynamic_cast(layer, ImageLayer)
if (tileLayer):
self.mRenderer.drawTileLayer(painter, tileLayer)
elif (objGroup):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if object.rotation() != 0.0:
origin = self.mRenderer.pixelToScreenCoords(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
self.mRenderer.drawMapObject(painter, object, color)
if (object.rotation() != 0):
painter.restore()
elif (imageLayer):
self.mRenderer.drawImageLayer(painter, imageLayer)
return image
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 startNewMapObject(self, pos, objectGroup):
newMapObject = self.createNewMapObject()
if not newMapObject:
return
newMapObject.setPosition(pos)
objectGroup.addObject(newMapObject)
self.mObjectGroupItem.setObjectGroup(objectGroup)
self.mNewMapObjectItem = MapObjectItem(newMapObject, self.mapDocument(), self.mObjectGroupItem)
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 paint(self, painter, arg2, arg3):
color = MapObjectItem.objectColor(self.mObject)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.drawRoundedRect(self.mBoundingRect.translated(1, 1), 4, 4)
painter.setBrush(color)
painter.drawRoundedRect(self.mBoundingRect, 4, 4)
textPos = QPointF(-(self.mBoundingRect.width() - labelMargin*4) / 2, -labelDistance)
painter.drawRoundedRect(self.mBoundingRect, 4, 4)
painter.setPen(Qt.black)
painter.drawText(textPos + QPointF(1,1), self.mObject.name())
painter.setPen(Qt.white)
painter.drawText(textPos, self.mObject.name())
def paint(self, painter, arg2, arg3):
color = MapObjectItem.objectColor(self.mObject)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.drawRoundedRect(self.mBoundingRect.translated(1, 1), 4, 4)
painter.setBrush(color)
painter.drawRoundedRect(self.mBoundingRect, 4, 4)
textPos = QPointF(-(self.mBoundingRect.width() - labelMargin * 4) / 2,
-labelDistance)
painter.drawRoundedRect(self.mBoundingRect, 4, 4)
painter.setPen(Qt.black)
painter.drawText(textPos + QPointF(1, 1), self.mObject.name())
painter.setPen(Qt.white)
painter.drawText(textPos, self.mObject.name())
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)
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)
def renderMapToImage(self):
if (not self.mMapDocument):
self.mMapImage = QImage()
return
renderer = self.mMapDocument.renderer()
r = self.contentsRect()
mapSize = renderer.mapSize()
if (mapSize.isEmpty()):
self.mMapImage = QImage()
return
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
# Determine the largest possible scale
scale = min(r.width() / mapSize.width(), r.height() / mapSize.height())
# Allocate a new image when the size changed
imageSize = mapSize * scale
if (self.mMapImage.size() != imageSize):
self.mMapImage = QImage(imageSize,
QImage.Format_ARGB32_Premultiplied)
self.updateImageRect()
if (imageSize.isEmpty()):
return
drawObjects = bool(self.mRenderFlags & MiniMapRenderFlag.DrawObjects)
drawTiles = bool(self.mRenderFlags & MiniMapRenderFlag.DrawTiles)
drawImages = bool(self.mRenderFlags & MiniMapRenderFlag.DrawImages)
drawTileGrid = bool(self.mRenderFlags & MiniMapRenderFlag.DrawGrid)
visibleLayersOnly = bool(self.mRenderFlags
& MiniMapRenderFlag.IgnoreInvisibleLayer)
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
self.mMapImage.fill(Qt.transparent)
painter = QPainter(self.mMapImage)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(QTransform.fromScale(scale, scale))
painter.translate(margins.left(), margins.top())
renderer.setPainterScale(scale)
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if (tp == TileLayer and drawTiles):
renderer.drawTileLayer(painter, tileLayer)
elif (tp == ObjectGroup and drawObjects):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder
):
objects = QList(
sorted(objects, key=lambda x: x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(
object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif (tp == ImageLayer and drawImages):
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter, QRectF(QPointF(), renderer.mapSize()),
prefs.gridColor())
painter.end()
renderer.setFlags(renderFlags)
class CreateObjectTool(AbstractObjectTool):
def __init__(self, mode, parent=None):
super().__init__(QString(),
QIcon(":images/24x24/insert-rectangle.png"),
QKeySequence(self.tr("O")), parent)
self.mNewMapObjectGroup = ObjectGroup()
self.mObjectGroupItem = ObjectGroupItem(self.mNewMapObjectGroup)
self.mNewMapObjectItem = None
self.mOverlayPolygonItem = None
self.mTile = None
self.mMode = mode
self.mObjectGroupItem.setZValue(10000) # same as the BrushItem
def __del__(self):
#del self.mOverlayObjectGroup
pass
def tr(self, sourceText, disambiguation='', n=-1):
return QCoreApplication.translate('CreateObjectTool', sourceText,
disambiguation, n)
def activate(self, scene):
super().activate(scene)
scene.addItem(self.mObjectGroupItem)
def deactivate(self, scene):
if (self.mNewMapObjectItem):
self.cancelNewMapObject()
scene.removeItem(self.mObjectGroupItem)
super().deactivate(scene)
def keyPressed(self, event):
x = event.key()
if x == Qt.Key_Enter or x == Qt.Key_Return:
if (self.mNewMapObjectItem):
self.finishNewMapObject()
return
elif x == Qt.Key_Escape:
if (self.mNewMapObjectItem):
self.cancelNewMapObject()
return
super().keyPressed(event)
def mouseEntered(self):
pass
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
if (self.mNewMapObjectItem):
offset = self.mNewMapObjectItem.mapObject().objectGroup().offset()
self.mouseMovedWhileCreatingObject(pos - offset, modifiers)
def mousePressed(self, event):
if (self.mNewMapObjectItem):
self.mousePressedWhileCreatingObject(event)
return
if (event.button() != Qt.LeftButton):
super().mousePressed(event)
return
objectGroup = self.currentObjectGroup()
if (not objectGroup or type(objectGroup) != ObjectGroup
or not objectGroup.isVisible()):
return
renderer = self.mapDocument().renderer()
offsetPos = event.scenePos() - objectGroup.offset()
pixelCoords = QPointF()
##TODO: calculate the tile offset with a polymorphic behaviour object
# that is instantiated by the correspondend ObjectTool
##
if (self.mMode == CreationMode.CreateTile):
if (not self.mTile):
return
diff = QPointF(-self.mTile.width() / 2, self.mTile.height() / 2)
pixelCoords = renderer.screenToPixelCoords_(offsetPos + diff)
else:
pixelCoords = renderer.screenToPixelCoords_(offsetPos)
SnapHelper(renderer, event.modifiers()).snap(pixelCoords)
self.startNewMapObject(pixelCoords, objectGroup)
def mouseReleased(self, event):
if (self.mNewMapObjectItem):
self.mouseReleasedWhileCreatingObject(event)
##
# Sets the tile that will be used when the creation mode is
# CreateTileObjects.
##
def setTile(self, tile):
if type(tile) == list:
tile = tile[0]
self.mTile = tile
def mouseMovedWhileCreatingObject(self, pos, modifiers):
# optional override
pass
def mousePressedWhileCreatingObject(self, event):
# optional override
pass
def mouseReleasedWhileCreatingObject(self, event):
# optional override
pass
def startNewMapObject(self, pos, objectGroup):
newMapObject = self.createNewMapObject()
if not newMapObject:
return
newMapObject.setPosition(pos)
objectGroup.addObject(newMapObject)
self.mObjectGroupItem.setObjectGroup(objectGroup)
self.mNewMapObjectItem = MapObjectItem(newMapObject,
self.mapDocument(),
self.mObjectGroupItem)
def cancelNewMapObject(self):
newMapObject = self.clearNewMapObjectItem()
del newMapObject
def finishNewMapObject(self):
newMapObject = self.mNewMapObjectItem.mapObject()
objectGroup = newMapObject.objectGroup()
self.clearNewMapObjectItem()
self.mapDocument().undoStack().push(
AddMapObject(self.mapDocument(), objectGroup, newMapObject))
self.mapDocument().setSelectedObjects(QList([newMapObject]))
def clearNewMapObjectItem(self):
newMapObject = self.mNewMapObjectItem.mapObject()
objectGroup = newMapObject.objectGroup()
objectGroup.removeObject(newMapObject)
if self.mNewMapObjectItem:
self.mapScene().removeItem(self.mNewMapObjectItem)
self.mNewMapObjectItem = None
if self.mOverlayPolygonItem:
self.mapScene().removeItem(self.mOverlayPolygonItem)
self.mOverlayPolygonItem = None
return newMapObject
def render(self, size):
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
if (self.mIncludeBackgroundColor):
if (self.mMap.backgroundColor().isValid()):
image.fill(self.mMap.backgroundColor())
else:
image.fill(Qt.gray)
else:
image.fill(Qt.transparent)
mapSize = self.mRenderer.mapSize()
margins = self.mRenderer.map().drawMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
scale = min(size.width() / mapSize.width(),
size.height() / mapSize.height())
scaledSize = mapSize * scale
painter = QPainter(image)
# Center the thumbnail in the requested size
painter.translate((size.width() - scaledSize.width()) / 2,
(size.height() - scaledSize.height()) / 2)
# Scale the map and translate it to adjust for its margins
painter.scale(scale, scale)
painter.translate(
margins.left() + (size.width() - scaledSize.width()) / 2,
margins.top() + (size.height() - scaledSize.height()) / 2)
if (smoothTransform(scale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
self.mRenderer.setPainterScale(scale)
for layer in self.mMap.layers():
if (self.mVisibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
tileLayer = dynamic_cast(layer, TileLayer)
objGroup = dynamic_cast(layer, ObjectGroup)
imageLayer = dynamic_cast(layer, ImageLayer)
if (tileLayer):
self.mRenderer.drawTileLayer(painter, tileLayer)
elif (objGroup):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.TopDownOrder):
objects = QList(
sorted(objects, key=lambda x: x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if object.rotation() != 0.0:
origin = self.mRenderer.pixelToScreenCoords(
object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
self.mRenderer.drawMapObject(painter, object, color)
if (object.rotation() != 0):
painter.restore()
elif (imageLayer):
self.mRenderer.drawImageLayer(painter, imageLayer)
return image
class CreateObjectTool(AbstractObjectTool):
def __init__(self, mode, parent = None):
super().__init__(QString(),
QIcon(":images/24x24/insert-rectangle.png"),
QKeySequence(self.tr("O")),
parent)
self.mNewMapObjectGroup = ObjectGroup()
self.mObjectGroupItem = ObjectGroupItem(self.mNewMapObjectGroup)
self.mNewMapObjectItem = None
self.mOverlayPolygonItem = None
self.mTile = None
self.mMode = mode
self.mObjectGroupItem.setZValue(10000) # same as the BrushItem
def __del__(self):
#del self.mOverlayObjectGroup
pass
def tr(self, sourceText, disambiguation = '', n = -1):
return QCoreApplication.translate('CreateObjectTool', sourceText, disambiguation, n)
def activate(self, scene):
super().activate(scene)
scene.addItem(self.mObjectGroupItem)
def deactivate(self, scene):
if (self.mNewMapObjectItem):
self.cancelNewMapObject()
scene.removeItem(self.mObjectGroupItem)
super().deactivate(scene)
def keyPressed(self, event):
x = event.key()
if x==Qt.Key_Enter or x==Qt.Key_Return:
if (self.mNewMapObjectItem):
self.finishNewMapObject()
return
elif x==Qt.Key_Escape:
if (self.mNewMapObjectItem):
self.cancelNewMapObject()
return
super().keyPressed(event)
def mouseEntered(self):
pass
def mouseMoved(self, pos, modifiers):
super().mouseMoved(pos, modifiers)
if (self.mNewMapObjectItem):
offset = self.mNewMapObjectItem.mapObject().objectGroup().offset()
self.mouseMovedWhileCreatingObject(pos-offset, modifiers)
def mousePressed(self, event):
if (self.mNewMapObjectItem):
self.mousePressedWhileCreatingObject(event)
return
if (event.button() != Qt.LeftButton):
super().mousePressed(event)
return
objectGroup = self.currentObjectGroup()
if (not objectGroup or type(objectGroup)!=ObjectGroup or not objectGroup.isVisible()):
return
renderer = self.mapDocument().renderer()
offsetPos = event.scenePos() - objectGroup.offset()
pixelCoords = QPointF()
##TODO: calculate the tile offset with a polymorphic behaviour object
# that is instantiated by the correspondend ObjectTool
##
if (self.mMode == CreationMode.CreateTile):
if (not self.mTile):
return
diff = QPointF(-self.mTile.width() / 2, self.mTile.height() / 2)
pixelCoords = renderer.screenToPixelCoords_(offsetPos + diff)
else:
pixelCoords = renderer.screenToPixelCoords_(offsetPos)
SnapHelper(renderer, event.modifiers()).snap(pixelCoords)
self.startNewMapObject(pixelCoords, objectGroup)
def mouseReleased(self, event):
if (self.mNewMapObjectItem):
self.mouseReleasedWhileCreatingObject(event)
##
# Sets the tile that will be used when the creation mode is
# CreateTileObjects.
##
def setTile(self, tile):
if type(tile)==list:
tile = tile[0]
self.mTile = tile
def mouseMovedWhileCreatingObject(self, pos, modifiers):
# optional override
pass
def mousePressedWhileCreatingObject(self, event):
# optional override
pass
def mouseReleasedWhileCreatingObject(self, event):
# optional override
pass
def startNewMapObject(self, pos, objectGroup):
newMapObject = self.createNewMapObject()
if not newMapObject:
return
newMapObject.setPosition(pos)
objectGroup.addObject(newMapObject)
self.mObjectGroupItem.setObjectGroup(objectGroup)
self.mNewMapObjectItem = MapObjectItem(newMapObject, self.mapDocument(), self.mObjectGroupItem)
def cancelNewMapObject(self):
newMapObject = self.clearNewMapObjectItem()
del newMapObject
def finishNewMapObject(self):
newMapObject = self.mNewMapObjectItem.mapObject()
objectGroup = newMapObject.objectGroup()
self.clearNewMapObjectItem()
self.mapDocument().undoStack().push(AddMapObject(self.mapDocument(), objectGroup, newMapObject))
self.mapDocument().setSelectedObjects(QList([newMapObject]))
def clearNewMapObjectItem(self):
newMapObject = self.mNewMapObjectItem.mapObject()
objectGroup = newMapObject.objectGroup()
objectGroup.removeObject(newMapObject)
if self.mNewMapObjectItem:
self.mapScene().removeItem(self.mNewMapObjectItem)
self.mNewMapObjectItem = None
if self.mOverlayPolygonItem:
self.mapScene().removeItem(self.mOverlayPolygonItem)
self.mOverlayPolygonItem = None
return newMapObject
def renderMapToImage(self):
if (not self.mMapDocument):
self.mMapImage = QImage()
return
renderer = self.mMapDocument.renderer()
r = self.contentsRect()
mapSize = renderer.mapSize()
if (mapSize.isEmpty()):
self.mMapImage = QImage()
return
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
# Determine the largest possible scale
scale = min( r.width() / mapSize.width(), r.height() / mapSize.height())
# Allocate a new image when the size changed
imageSize = mapSize * scale
if (self.mMapImage.size() != imageSize):
self.mMapImage = QImage(imageSize, QImage.Format_ARGB32_Premultiplied)
self.updateImageRect()
if (imageSize.isEmpty()):
return
drawObjects = bool(self.mRenderFlags & MiniMapRenderFlag.DrawObjects)
drawTiles = bool(self.mRenderFlags & MiniMapRenderFlag.DrawTiles)
drawImages = bool(self.mRenderFlags & MiniMapRenderFlag.DrawImages)
drawTileGrid = bool(self.mRenderFlags & MiniMapRenderFlag.DrawGrid)
visibleLayersOnly = bool(self.mRenderFlags & MiniMapRenderFlag.IgnoreInvisibleLayer)
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
self.mMapImage.fill(Qt.transparent)
painter = QPainter(self.mMapImage)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(QTransform.fromScale(scale, scale))
painter.translate(margins.left(), margins.top())
renderer.setPainterScale(scale)
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if (tp==TileLayer and drawTiles):
renderer.drawTileLayer(painter, tileLayer)
elif (tp==ObjectGroup and drawObjects):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif (tp==ImageLayer and drawImages):
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter, QRectF(QPointF(), renderer.mapSize()),
prefs.gridColor())
painter.end()
renderer.setFlags(renderFlags)
def accept(self):
fileName = self.mUi.fileNameEdit.text()
if fileName == '':
return
if (QFile.exists(fileName)):
button = QMessageBox.warning(
self, self.tr("Export as Image"),
self.tr("%s already exists.\nDo you want to replace it?" %
QFileInfo(fileName).fileName()),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if (button != QMessageBox.Yes):
return
visibleLayersOnly = self.mUi.visibleLayersOnly.isChecked()
useCurrentScale = self.mUi.currentZoomLevel.isChecked()
drawTileGrid = self.mUi.drawTileGrid.isChecked()
includeBackgroundColor = self.mUi.includeBackgroundColor.isChecked()
renderer = self.mMapDocument.renderer()
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
mapSize = renderer.mapSize()
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
if (useCurrentScale):
mapSize *= self.mCurrentScale
image = QImage()
try:
image = QImage(mapSize, QImage.Format_ARGB32_Premultiplied)
if (includeBackgroundColor):
if (self.mMapDocument.map().backgroundColor().isValid()):
image.fill(self.mMapDocument.map().backgroundColor())
else:
image.fill(Qt.gray)
else:
image.fill(Qt.transparent)
except:
QMessageBox.critical(
self, self.tr("Out of Memory"),
self.
tr("Could not allocate sufficient memory for the image. "
"Try reducing the zoom level or using a 64-bit version of Tiled."
))
return
if (image.isNull()):
gigabyte = 1073741824
memory = mapSize.width() * mapSize.height() * 4
gigabytes = memory / gigabyte
QMessageBox.critical(
self, self.tr("Image too Big"),
self.
tr("The resulting image would be %d x %d pixels and take %.2f GB of memory. "
"Tiled is unable to create such an image. Try reducing the zoom level."
% (mapSize.width(), mapSize.height(), gigabytes)))
return
painter = QPainter(image)
if (useCurrentScale):
if (smoothTransform(self.mCurrentScale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(
QTransform.fromScale(self.mCurrentScale, self.mCurrentScale))
renderer.setPainterScale(self.mCurrentScale)
else:
renderer.setPainterScale(1)
painter.translate(margins.left(), margins.top())
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if tp == TileLayer:
renderer.drawTileLayer(painter, tileLayer)
elif tp == ObjectGroup:
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder
):
objects = QList(
sorted(objects, key=lambda x: x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(
object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif tp == ImageLayer:
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter,
QRectF(QPointF(), QSizeF(renderer.mapSize())),
prefs.gridColor())
painter.end()
# Restore the previous render flags
renderer.setFlags(renderFlags)
image.save(fileName)
self.mPath = QFileInfo(fileName).path()
# Store settings for next time
s = preferences.Preferences.instance().settings()
s.setValue(VISIBLE_ONLY_KEY, visibleLayersOnly)
s.setValue(CURRENT_SCALE_KEY, useCurrentScale)
s.setValue(DRAW_GRID_KEY, drawTileGrid)
s.setValue(INCLUDE_BACKGROUND_COLOR, includeBackgroundColor)
super().accept()