C++ ObjectGroup::addObject方法代码示例

Layer *ObjectGroup::mergedWith(Layer *other) const
{
    Q_ASSERT(canMergeWith(other));

    const ObjectGroup *og = static_cast<ObjectGroup*>(other);

    ObjectGroup *merged = static_cast<ObjectGroup*>(clone());
    for (const MapObject *mapObject : og->objects())
        merged->addObject(mapObject->clone());
    return merged;
}

/**
 * Convenience method to copy the current selection to the clipboard.
 * Deals with either tile selection or object selection.
 */
void ClipboardManager::copySelection(const MapDocument *mapDocument)
{
    const Layer *currentLayer = mapDocument->currentLayer();
    if (!currentLayer)
        return;

    const Map *map = mapDocument->map();
    const QRegion &selectedArea = mapDocument->selectedArea();
    const QList<MapObject*> &selectedObjects = mapDocument->selectedObjects();
    const TileLayer *tileLayer = dynamic_cast<const TileLayer*>(currentLayer);
    Layer *copyLayer = nullptr;

    if (!selectedArea.isEmpty() && tileLayer) {
        const QRegion area = selectedArea.intersected(tileLayer->bounds());

        // Copy the selected part of the layer
        copyLayer = tileLayer->copy(area.translated(-tileLayer->position()));
        copyLayer->setPosition(area.boundingRect().topLeft());

    } else if (!selectedObjects.isEmpty()) {
        // Create a new object group with clones of the selected objects
        ObjectGroup *objectGroup = new ObjectGroup;
        for (const MapObject *mapObject : selectedObjects)
            objectGroup->addObject(mapObject->clone());
        copyLayer = objectGroup;
    } else {
        return;
    }

    // Create a temporary map to write to the clipboard
    Map copyMap(map->orientation(),
                0, 0,
                map->tileWidth(), map->tileHeight());

    copyMap.setRenderOrder(map->renderOrder());

    // Resolve the set of tilesets used by this layer
    foreach (const SharedTileset &tileset, copyLayer->usedTilesets())
        copyMap.addTileset(tileset);

    copyMap.addLayer(copyLayer);

    setMap(copyMap);
}

	void TiledMapLoader::loadObjectGroupObjects(Map &map, ObjectGroup &objectGroup, rapidxml::xml_node<> &objectGroupNode) {
		rapidxml::xml_node<> *objectNode = nullptr;
		rapidxml::xml_node<> *objectNature = nullptr;
		objectNode = objectGroupNode.first_node("object");
		while (objectNode) {
			Object::Ptr object(new Object);
			XMLElement objectGroupElement(*objectNode);
			object->setGid(objectGroupElement.getInt("gid", -1));
			object->setId(objectGroupElement.getInt("id", -1));
			object->setName(objectGroupElement.getString("name"));
			object->setType(objectGroupElement.getString("type"));
			object->setX(objectGroupElement.getFloat("x"));
			object->setY(objectGroupElement.getFloat("y"));
			object->setWidth(objectGroupElement.getFloat("width"));
			object->setHeight(objectGroupElement.getFloat("height"));
			object->setRotation(objectGroupElement.getFloat("rotation"));
			object->setVisible(objectGroupElement.getInt("visible", 1));
			objectNature = objectNode->first_node("ellipse");
			if (objectNature) {
				object->setPolygonType("ellipse");
			}
			objectNature = objectNode->first_node("polygon");
			if (objectNature) {
				XMLElement objectNatureElement(*objectNature);

				object->setPolygonType("polygon");
				object->setVertices(objectNatureElement.getString("points"));
			}
			objectNature = objectNode->first_node("polyline");
			if (objectNature) {
				XMLElement objectNatureElement(*objectNature);

				object->setPolygonType("polyline");
				object->setVertices(objectNatureElement.getString("points"));
			}
			object->parseProperties(*objectNode);
			objectGroup.addObject(std::move(object));
			objectNode = objectNode->next_sibling("object");
		}
	}

void ClipboardManager::copySelection(const MapDocument *mapDocument)
{
    const Layer *currentLayer = mapDocument->currentLayer();
    if (!currentLayer)
        return;

    const Map *map = mapDocument->map();
    const QRegion &selectedArea = mapDocument->selectedArea();
    const QList<MapObject*> &selectedObjects = mapDocument->selectedObjects();
    const TileLayer *tileLayer = dynamic_cast<const TileLayer*>(currentLayer);
    Layer *copyLayer = 0;

    if (!selectedArea.isEmpty() && tileLayer) {
        // Copy the selected part of the layer
        copyLayer = tileLayer->copy(selectedArea.translated(-tileLayer->x(),
                                    -tileLayer->y()));
    } else if (!selectedObjects.isEmpty()) {
        // Create a new object group with clones of the selected objects
        ObjectGroup *objectGroup = new ObjectGroup;
        foreach (const MapObject *mapObject, selectedObjects)
            objectGroup->addObject(mapObject->clone());
        copyLayer = objectGroup;
    } else {

void TemplatesDock::setTemplate(ObjectTemplate *objectTemplate)
{
    if (mObjectTemplate == objectTemplate)
        return;

    mObjectTemplate = objectTemplate;

    mMapScene->setSelectedTool(nullptr);
    MapDocumentPtr previousDocument = mDummyMapDocument;

    mMapView->setEnabled(objectTemplate);

    if (objectTemplate && objectTemplate->object()) {
        mDummyMapDocument = ourDummyDocuments.value(objectTemplate);

        if (!mDummyMapDocument) {
            Map::Orientation orientation = Map::Orthogonal;
            std::unique_ptr<Map> map { new Map(orientation, 1, 1, 1, 1) };

            MapObject *dummyObject = objectTemplate->object()->clone();
            dummyObject->markAsTemplateBase();

            if (Tileset *tileset = dummyObject->cell().tileset()) {
                map->addTileset(tileset->sharedPointer());
                dummyObject->setPosition({-dummyObject->width() / 2, dummyObject->height() / 2});
            } else {
                dummyObject->setPosition({-dummyObject->width() / 2, -dummyObject->height()  /2});
            }

            ObjectGroup *objectGroup = new ObjectGroup;
            objectGroup->addObject(dummyObject);

            map->addLayer(objectGroup);

            mDummyMapDocument = MapDocumentPtr::create(std::move(map));
            mDummyMapDocument->setAllowHidingObjects(false);
            mDummyMapDocument->setCurrentLayer(objectGroup);

            ourDummyDocuments.insert(objectTemplate, mDummyMapDocument);
        }

        mDummyMapDocument->setCurrentObject(dummyObject());

        mUndoAction->setEnabled(mDummyMapDocument->undoStack()->canUndo());
        mRedoAction->setEnabled(mDummyMapDocument->undoStack()->canRedo());

        connect(mDummyMapDocument->undoStack(), &QUndoStack::indexChanged,
                this, &TemplatesDock::applyChanges);

        checkTileset();
    } else {
        mDummyMapDocument.reset();
    }

    mMapScene->setMapDocument(mDummyMapDocument.data());
    mToolManager->setMapDocument(mDummyMapDocument.data());
    mPropertiesDock->setDocument(mDummyMapDocument.data());

    mMapScene->setSelectedTool(mToolManager->selectedTool());

    if (previousDocument)
        previousDocument->undoStack()->disconnect(this);
}

ObjectGroup *VariantToMapConverter::toObjectGroup(const QVariantMap &variantMap)
{
    ObjectGroup *objectGroup = new ObjectGroup(variantMap["name"].toString(),
                                               variantMap["x"].toInt(),
                                               variantMap["y"].toInt(),
                                               variantMap["width"].toInt(),
                                               variantMap["height"].toInt());

    const qreal opacity = variantMap["opacity"].toReal();
    const bool visible = variantMap["visible"].toBool();

    objectGroup->setOpacity(opacity);
    objectGroup->setVisible(visible);

    objectGroup->setColor(variantMap.value("color").value<QColor>());

    const PixelToTileCoordinates toTile(mMap);

    foreach (const QVariant &objectVariant, variantMap["objects"].toList()) {
        const QVariantMap objectVariantMap = objectVariant.toMap();

        const QString name = objectVariantMap["name"].toString();
        const QString type = objectVariantMap["type"].toString();
        const int gid = objectVariantMap["gid"].toInt();
        const int x = objectVariantMap["x"].toInt();
        const int y = objectVariantMap["y"].toInt();
        const int width = objectVariantMap["width"].toInt();
        const int height = objectVariantMap["height"].toInt();

        const QPointF pos = toTile(x, y);
        const QPointF size = toTile(width, height);

        MapObject *object = new MapObject(name, type,
                                          pos,
                                          QSizeF(size.x(), size.y()));

        if (gid) {
            bool ok;
            const Cell cell = mGidMapper.gidToCell(gid, ok);
            object->setTile(cell.tile);
        }

        if (objectVariantMap.contains("visible"))
            object->setVisible(objectVariantMap["visible"].toBool());

        object->setProperties(toProperties(objectVariantMap["properties"]));
        objectGroup->addObject(object);

        const QVariant polylineVariant = objectVariantMap["polyline"];
        const QVariant polygonVariant = objectVariantMap["polygon"];

        if (polygonVariant.isValid()) {
            object->setShape(MapObject::Polygon);
            object->setPolygon(toPolygon(polygonVariant));
        }
        if (polylineVariant.isValid()) {
            object->setShape(MapObject::Polyline);
            object->setPolygon(toPolygon(polylineVariant));
        }
        if (objectVariantMap.contains("ellipse"))
            object->setShape(MapObject::Ellipse);
    }

    return objectGroup;
}