LocationWindowMapObjectsExample.swift

Go to the documentation of this file.

import Foundation
import UIKit
import NavigineSDK
 
/**
 * LocationWindowMapObjects usage example for Swift
 * Demonstrates specific methods: addCircleMapObject, removeCircleMapObject, addIconMapObject,
 * removeIconMapObject, addPolygonMapObject, addPolylineMapObject, removePolylineMapObject,
 * addDottedPolylineMapObject, removeDottedPolylineMapObject, addModelMapObject, removeModelMapObject, removeAllMapObjects
 */
class LocationWindowMapObjectsExample {
    private var locationWindow: NCLocationWindow?
    private var circleMapObject: NCCircleMapObject?
    private var iconMapObject: NCIconMapObject?
    private var modelMapObject: NCModelMapObject?
    private var polygonMapObject: NCPolygonMapObject?
    private var polylineMapObject: NCPolylineMapObject?
    private var dottedPolylineMapObject: NCDottedPolylineMapObject?
    private var clusterMapObjectController: NCClusterMapObjectController?
    private var clusterMapObjectControllerListener: DemoClusterMapObjectControllerListener?
 
    init() {
        demonstrateLocationWindowMapObjectsMethods()
    }
 
    /**
     * Demonstrate LocationWindowMapObjects methods
     */
    private func demonstrateLocationWindowMapObjectsMethods() {
        print("=== LocationWindowMapObjects Example ===")
 
        // Initialize LocationWindow (in real app, this would be provided by the framework)
        // locationWindow = getLocationWindow()
 
        demonstrateLocationScopedGeometryRecords()
 
        demonstrateCircleMapObjects()
        demonstrateIconMapObjects()
        demonstrateClusterMapObjects()
        demonstrateModelMapObjects()
        demonstratePolygonMapObjects()
        demonstratePolylineMapObjects()
        demonstrateDottedPolylineMapObjects()
        demonstrateRemoveAllMapObjects()
 
        cleanup()
    }
 
    /**
     * Metrics geometry scoped to a location / sublocation (@see NCLocationPolygon, NCLocationPolyline).
     */
    private func demonstrateLocationScopedGeometryRecords() {
        print("--- LocationPolygon / LocationPolyline records ---")
 
        // [swift_LocationPolygon_record]
        let ring = [
            NCGlobalPoint(latitude: 55.751, longitude: 37.617),
            NCGlobalPoint(latitude: 55.752, longitude: 37.618),
            NCGlobalPoint(latitude: 55.751, longitude: 37.619),
        ]
        let holes = [[
            NCGlobalPoint(latitude: 55.7512, longitude: 37.6174),
            NCGlobalPoint(latitude: 55.7514, longitude: 37.6176),
            NCGlobalPoint(latitude: 55.7512, longitude: 37.6178),
        ]]
        let locationPolygon = NCLocationPolygon(points: ring, sublocationId: 7, innerRings: holes)
        print("LocationPolygon: sublocation \‍(locationPolygon.sublocationId ?? -1), vertices \‍(locationPolygon.points.count), holes \‍(locationPolygon.innerRings.count)")
        // [swift_LocationPolygon_record]
 
        // [swift_LocationWindow_addPointBatch]
        let batch = locationWindow?.addPointBatch()
        batch?.setPoints([
            NCPointSprite(position: NCGlobalPoint(latitude: 55.751, longitude: 37.617), heading: 0, color: UIColor.orange, size: 5),
            NCPointSprite(position: NCGlobalPoint(latitude: 55.752, longitude: 37.618), heading: 90, color: UIColor.blue, size: 5),
        ], sublocationId: 7)
        let hit = batch?.hitTest(CGPoint(x: 12, y: 8), radius: 8)
        print("PointBatch hit \‍(hit ?? -1)")
        // [swift_LocationWindow_addPointBatch]
 
        // [swift_LocationWindow_addGeoJson]
        let geoJson = #"{"type":"FeatureCollection","features":[{"type":"Feature","geometry":{"type":"Polygon","coordinates":[[[37.617,55.751],[37.619,55.751],[37.619,55.752],[37.617,55.751]],[[37.6174,55.7512],[37.6176,55.7512],[37.6176,55.7514],[37.6174,55.7512]]]}},{"type":"Feature","geometry":{"type":"LineString","coordinates":[[37.617,55.751],[37.620,55.753]]}}]}"#
        let imported = locationWindow?.addGeoJson(geoJson, sublocationId: 7)
        print("GeoJSON polygons \‍(imported?.polygons.count ?? 0), lines \‍(imported?.polylines.count ?? 0)")
        // [swift_LocationWindow_addGeoJson]
 
        // [swift_LocationPolyline_record]
        let linePts = [
            NCGlobalPoint(latitude: 55.751, longitude: 37.617),
            NCGlobalPoint(latitude: 55.753, longitude: 37.620),
        ]
        let locationPolyline = NCLocationPolyline(points: linePts, sublocationId: 7)
        print("LocationPolyline points \‍(locationPolyline.points.count)")
        // [swift_LocationPolyline_record]
    }
 
    /**
     * Demonstrate circle map objects
     */
    private func demonstrateCircleMapObjects() {
        print("--- Circle Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_CircleMapObject_constructor]
        // Create circle map object
        let center = NCGlobalPoint(latitude: 10.0, longitude: 20.0)
        circleMapObject = locationWindow.addCircleMapObject()
        print("Created circle map object with center (\‍(center.latitude), \‍(center.longitude)) and radius 5.0")
        // [swift_CircleMapObject_constructor]
 
        // [swift_CircleMapObject_getRadius]
        // Access circle radius
        let radius = circleMapObject!.getRadius()
        print("Circle radius: \‍(radius)")
        // [swift_CircleMapObject_getRadius]
 
        // [swift_LocationWindow_addCircleMapObject]
        // Add circle map object
        circleMapObject = locationWindow.addCircleMapObject()
        print("Added circle map object")
        // [swift_LocationWindow_addCircleMapObject]
 
        if let circleMapObject = circleMapObject {
            // [swift_CircleMapObject_setPosition]
            // Set circle position
            let centerPoint = NCGlobalPoint(latitude: 100.0, longitude: 200.0)
            let success = circleMapObject.setPosition(centerPoint, sublocationId: 7)
            print("Set circle position to (\‍(centerPoint.latitude), \‍(centerPoint.longitude)): \‍(success)")
            // [swift_CircleMapObject_setPosition]
 
            // [swift_CircleMapObject_setPositionAnimated]
            // Set circle position with animation
            let animatedPoint = NCGlobalPoint(latitude: 150.0, longitude: 250.0)
            let animatedSuccess = circleMapObject.setPositionAnimated(animatedPoint, duration: 2.0, animationType: .linear)
            print("Set circle position with animation to (\‍(animatedPoint.latitude), \‍(animatedPoint.longitude)): \‍(animatedSuccess)")
            // [swift_CircleMapObject_setPositionAnimated]
 
            // [swift_CircleMapObject_setRadius]
            // Set circle radius
            let radiusSuccess = circleMapObject.setRadius(10.0)
            print("Set circle radius to 10.0 meters: \‍(radiusSuccess)")
            // [swift_CircleMapObject_setRadius]
 
            // [swift_CircleMapObject_setCollisionEnabled]
            // Enable collision detection
            let collisionSuccess = circleMapObject.setCollisionEnabled(true)
            print("Enabled collision detection for circle: \‍(collisionSuccess)")
            // [swift_CircleMapObject_setCollisionEnabled]
 
            // [swift_CircleMapObject_setBuffer]
            // Set collision buffer
            let bufferSuccess = circleMapObject.setBuffer(width: 5.0, height: 5.0)
            print("Set collision buffer to 5x5 pixels: \‍(bufferSuccess)")
            // [swift_CircleMapObject_setBuffer]
 
            // [swift_CircleMapObject_setOffset]
            // Set position offset
            let offsetSuccess = circleMapObject.setOffset(x: 2.0, longitude: 3.0)
            print("Set position offset to (2.0, 3.0) pixels: \‍(offsetSuccess)")
            // [swift_CircleMapObject_setOffset]
 
            // [swift_CircleMapObject_setOutlineColor]
            // Set outline color
            let outlineColorSuccess = circleMapObject.setOutlineColor(UIColor(red: 0.0, green: 0.0, blue: 1.0, alpha: 1.0))
            print("Set circle outline color to blue: \‍(outlineColorSuccess)")
            // [swift_CircleMapObject_setOutlineColor]
 
            // [swift_CircleMapObject_setOutlineAlpha]
            // Set outline alpha
            let outlineAlphaSuccess = circleMapObject.setOutlineAlpha(0.5)
            print("Set circle outline alpha to 0.5: \‍(outlineAlphaSuccess)")
            // [swift_CircleMapObject_setOutlineAlpha]
 
            // [swift_CircleMapObject_setOutlineRadius]
            // Set outline radius
            let outlineRadiusSuccess = circleMapObject.setOutlineRadius(2.0)
            print("Set circle outline radius to 2.0: \‍(outlineRadiusSuccess)")
            // [swift_CircleMapObject_setOutlineRadius]
 
            // [swift_CircleMapObject_setColor]
            // Set circle color
            let colorSuccess = circleMapObject.setColor(UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 0.8))
            print("Set circle color to red with 80% opacity: \‍(colorSuccess)")
            // [swift_CircleMapObject_setColor]
 
            // [swift_CircleMapObject_setPriority]
            // Set rendering priority
            let prioritySuccess = circleMapObject.setPriority(1)
            print("Set rendering priority to 1: \‍(prioritySuccess)")
            // [swift_CircleMapObject_setPriority]
 
            // [swift_MapObject_setVisible]
            // Set visibility
            let visibleSuccess = circleMapObject.setVisible(true)
            print("Set circle visibility to true: \‍(visibleSuccess)")
            // [swift_MapObject_setVisible]
 
            // [swift_CircleMapObject_getMapObjectType]
            // Get map object type
            let objectType = circleMapObject.mapObjectType
            print("Circle map object type: \‍(objectType)")
            // [swift_CircleMapObject_getMapObjectType]
 
            // [swift_MapObject_setAlpha]
            // Set alpha transparency
            let alphaSuccess = circleMapObject.setAlpha(0.7)
            print("Set circle alpha to 0.7: \‍(alphaSuccess)")
            // [swift_MapObject_setAlpha]
 
            // [swift_MapObject_setInteractive]
            // Set interactive mode
            let interactiveSuccess = circleMapObject.setInteractive(true)
            print("Set circle interactive to true: \‍(interactiveSuccess)")
            // [swift_MapObject_setInteractive]
 
            // [swift_MapObject_setTitle]
            // Set title
            let titleSuccess = circleMapObject.setTitle("Circle Object")
            print("Set circle title to 'Circle Object': \‍(titleSuccess)")
            // [swift_MapObject_setTitle]
 
            // [swift_TitleStyle_record]
            let titleStyle = NCTitleStyle()
            titleStyle.fontSize = 14
            titleStyle.color = "#3366CC"
            titleStyle.outlineColor = "#FFFFFF"
            titleStyle.anchor = .top
            titleStyle.visible = true
            // [swift_TitleStyle_record]
 
            // [swift_MapObject_setTitleWithStyle]
            // Set title with style
            let titleStyleSuccess = circleMapObject.setTitleWithStyle("Styled Circle", style: titleStyle)
            print("Set circle title with style: \‍(titleStyleSuccess)")
            // [swift_MapObject_setTitleWithStyle]
 
            // [swift_MapObject_setData]
            // Set custom data
            let customData = ["key": "value", "number": "42"]
            let dataSuccess = circleMapObject.setData(customData)
            print("Set circle custom data: \‍(dataSuccess)")
            // [swift_MapObject_setData]
 
            // [swift_MapObject_getId]
            // Get object ID
            let objectId = circleMapObject.id
            print("Circle object ID: \‍(objectId)")
            // [swift_MapObject_getId]
 
            // [swift_MapObject_getType]
            // Get object type
            let objectTypeString = circleMapObject.type
            print("Circle object type: \‍(objectTypeString)")
            // [swift_MapObject_getType]
 
            // [swift_MapObject_getData]
            // Get custom data
            let retrievedData = circleMapObject.data
            print("Circle custom data: \‍(retrievedData)")
            // [swift_MapObject_getData]
        }
 
        // [swift_LocationWindow_removeCircleMapObject]
        // Remove circle map object
        if let circleMapObject = circleMapObject {
            let removed = locationWindow.removeCircleMapObject(circleMapObject)
            print("Removed circle map object: \‍(removed)")
            self.circleMapObject = nil
        }
        // [swift_LocationWindow_removeCircleMapObject]
 
        // Test multiple circle objects
        var circles: [NCCircleMapObject] = []
        for i in 0..<3 {
            if let circle = locationWindow.addCircleMapObject() {
                circle.setPosition(NCGlobalPoint(latitude: 50.0 * Double(i), longitude: 100.0 * Double(i)), sublocationId: 7)
                circle.setColor(UIColor(red: 0.0, green: 1.0, blue: 0.0, alpha: 0.6))
                circle.setRadius(5.0 + Double(i) * 2.0)
                circles.append(circle)
                print("Created circle \‍(i) at (\‍(50.0 * Double(i)), \‍(100.0 * Double(i))) with radius \‍(5.0 + Double(i) * 2.0)")
            }
        }
 
        for i in circles.indices {
            locationWindow.removeCircleMapObject(circles[i])
            print("Removed circle \‍(i)")
        }
    }
 
    /**
     * Demonstrate icon map objects
     */
    private func demonstrateIconMapObjects() {
        print("--- Icon Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_IconMapObject_constructor]
        // Create icon map object
        let position = NCGlobalPoint(latitude: 30.0, longitude: 40.0)
        iconMapObject = locationWindow.addIconMapObject()
        print("Created icon map object at (\‍(position.latitude), \‍(position.longitude))")
        // [swift_IconMapObject_constructor]
 
        // [swift_LocationWindow_addIconMapObject]
        // Add icon map object
        iconMapObject = locationWindow.addIconMapObject()
        print("Added icon map object")
        // [swift_LocationWindow_addIconMapObject]
 
        if let iconMapObject = iconMapObject {
            // [swift_IconMapObject_setPosition]
            // Set icon position
            let position = NCGlobalPoint(latitude: 30.0, longitude: 40.0)
            let success = iconMapObject.setPosition(position, sublocationId: 7)
            print("Set icon position to (\‍(position.latitude), \‍(position.longitude)): \‍(success)")
            // [swift_IconMapObject_setPosition]
 
            // [swift_IconMapObject_setPositionAnimated]
            // Set icon position with animation
            let animatedPosition = NCGlobalPoint(latitude: 35.0, longitude: 45.0)
            let animatedSuccess = iconMapObject.setPositionAnimated(animatedPosition, duration: 1.5, animationType: .cubic)
            print("Set icon position with animation to (\‍(animatedPosition.latitude), \‍(animatedPosition.longitude)): \‍(animatedSuccess)")
            // [swift_IconMapObject_setPositionAnimated]
 
            // [swift_IconMapObject_setBitmap]
            if let iconImage = UIImage(contentsOfFile: "/path/to/icon.png") {
                let bitmapSuccess = iconMapObject.setBitmap(iconImage)
                print("Set icon bitmap (UIImage): \‍(bitmapSuccess)")
            }
            // [swift_IconMapObject_setBitmap]
 
            // [swift_IconMapObject_setFlat]
            // Set icon flat mode
            let flatSuccess = iconMapObject.setFlat(true)
            print("Set icon flat mode to true: \‍(flatSuccess)")
            // [swift_IconMapObject_setFlat]
 
            // [swift_IconMapObject_setSize]
            // Set icon size
            let size = NCSize(width: 32.0, height: 32.0)
            let sizeSuccess = iconMapObject.setSize(size)
            print("Set icon size to (\‍(size.width), \‍(size.height)): \‍(sizeSuccess)")
            // [swift_IconMapObject_setSize]
 
            // [swift_IconMapObject_setAngle]
            // Set icon rotation angle (radians)
            let angleSuccess = iconMapObject.setAngle(Float.pi / 4)
            print("Set icon rotation angle to π/4: \‍(angleSuccess)")
            // [swift_IconMapObject_setAngle]
 
            // [swift_IconMapObject_setAngleAnimated]
            // Set icon rotation with animation (radians)
            let angleAnimatedSuccess = iconMapObject.setAngleAnimated(Float.pi / 2, duration: 2.0, animationType: .sine)
            print("Set icon rotation with animation to π/2: \‍(angleAnimatedSuccess)")
            // [swift_IconMapObject_setAngleAnimated]
 
            // [swift_IconMapObject_setCollisionEnabled]
            // Enable collision detection
            let collisionSuccess = iconMapObject.setCollisionEnabled(true)
            print("Enabled collision detection for icon: \‍(collisionSuccess)")
            // [swift_IconMapObject_setCollisionEnabled]
 
            // [swift_IconMapObject_setBuffer]
            // Set collision buffer
            let bufferSuccess = iconMapObject.setBuffer(width: 10.0, height: 10.0)
            print("Set collision buffer to 10x10 pixels: \‍(bufferSuccess)")
            // [swift_IconMapObject_setBuffer]
 
            // [swift_IconMapObject_setOffset]
            // Set position offset
            let offsetSuccess = iconMapObject.setOffset(x: 0.0, longitude: -16.0)
            print("Set position offset to (0.0, -16.0) pixels: \‍(offsetSuccess)")
            // [swift_IconMapObject_setOffset]
 
            // [swift_IconMapObject_setPriority]
            // Set rendering priority
            let prioritySuccess = iconMapObject.setPriority(2)
            print("Set rendering priority to 2: \‍(prioritySuccess)")
            // [swift_IconMapObject_setPriority]
 
            // [swift_IconMapObject_setVisible]
            // Set visibility
            let visibleSuccess = iconMapObject.setVisible(true)
            print("Set icon visibility to true: \‍(visibleSuccess)")
            // [swift_IconMapObject_setVisible]
 
            // [swift_IconMapObject_getMapObjectType]
            // Get map object type
            let objectType = iconMapObject.mapObjectType
            print("Icon map object type: \‍(objectType)")
            // [swift_IconMapObject_getMapObjectType]
 
            // [swift_MapObject_setAlpha_1]
            // Set alpha transparency
            let alphaSuccess = iconMapObject.setAlpha(0.8)
            print("Set icon alpha to 0.8: \‍(alphaSuccess)")
            // [swift_MapObject_setAlpha_1]
 
            // [swift_MapObject_setInteractive_1]
            // Set interactive mode
            let interactiveSuccess = iconMapObject.setInteractive(true)
            print("Set icon interactive to true: \‍(interactiveSuccess)")
            // [swift_MapObject_setInteractive_1]
 
            // [swift_MapObject_setTitle_1]
            // Set title
            let titleSuccess = iconMapObject.setTitle("Icon Object")
            print("Set icon title to 'Icon Object': \‍(titleSuccess)")
            // [swift_MapObject_setTitle_1]
 
            // [swift_MapObject_setData_1]
            // Set custom data
            let customData = ["key": "value", "number": "42"]
            let dataSuccess = iconMapObject.setData(customData)
            print("Set icon custom data: \‍(dataSuccess)")
            // [swift_MapObject_setData_1]
 
            // [swift_MapObject_getId_1]
            // Get object ID
            let objectId = iconMapObject.id
            print("Icon object ID: \‍(objectId)")
            // [swift_MapObject_getId_1]
 
            // [swift_MapObject_getType_1]
            // Get object type
            let objectTypeString = iconMapObject.type
            print("Icon object type: \‍(objectTypeString)")
            // [swift_MapObject_getType_1]
 
            // [swift_MapObject_getData_1]
            // Get custom data
            let retrievedData = iconMapObject.data
            print("Icon custom data: \‍(retrievedData)")
            // [swift_MapObject_getData_1]
        }
 
        // [swift_LocationWindow_removeIconMapObject]
        // Remove icon map object
        if let iconMapObject = iconMapObject {
            let removed = locationWindow.removeIconMapObject(iconMapObject)
            print("Removed icon map object: \‍(removed)")
            self.iconMapObject = nil
        }
        // [swift_LocationWindow_removeIconMapObject]
 
        // Test multiple icon objects
        var icons: [NCIconMapObject] = []
        for i in 0..<3 {
            if let icon = locationWindow.addIconMapObject() {
                icon.setPosition(NCGlobalPoint(latitude: 60.0 * Double(i), longitude: 120.0 * Double(i)), sublocationId: 7)
                if let img = UIImage(contentsOfFile: "/path/to/icon.png") {
                    _ = icon.setBitmap(img)
                }
                icon.setSize(NCSize(width: 24.0, height: 24.0))
                icons.append(icon)
                print("Created icon \‍(i) at (\‍(60.0 * Double(i)), \‍(120.0 * Double(i)))")
            }
        }
 
        for i in icons.indices {
            locationWindow.removeIconMapObject(icons[i])
            print("Removed icon \‍(i)")
        }
    }
 
    /**
     * 3D model map objects (OBJ + texture via ModelProvider / NCModelProviderFactory).
     */
    private func demonstrateModelMapObjects() {
        print("--- Model Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_addModelMapObject]
        modelMapObject = locationWindow.addModelMapObject()
        print("Added model map object: \‍(modelMapObject != nil)")
        // [swift_LocationWindow_addModelMapObject]
 
        guard let m = modelMapObject else { return }
 
        // [swift_ModelMapObject_setPosition]
        let posOk = m.setPosition(NCGlobalPoint(latitude: 12.0, longitude: 34.0), sublocationId: 7)
        print("Model setPosition: \‍(posOk)")
        // [swift_ModelMapObject_setPosition]
 
        // [swift_ModelMapObject_setPositionAnimated]
        let posAnimOk = m.setPositionAnimated(
            NCGlobalPoint(latitude: 15.0, longitude: 40.0),
            duration: 0.5,
            animationType: .sine
        )
        print("Model setPositionAnimated: \‍(posAnimOk)")
        // [swift_ModelMapObject_setPositionAnimated]
 
        // [swift_ModelMapObject_setModel]
        if let texture = UIImage(contentsOfFile: "/path/to/model_texture.png") {
            let provider = NCModelProviderFactory.fromFile("/path/to/model.obj", texture: texture)
            let modelOk = m.setModel(provider)
            print("Model setModel: \‍(modelOk)")
        }
        // [swift_ModelMapObject_setModel]
 
        // [swift_ModelMapObject_setSize]
        let sizeOk = m.setSize(width: 64.0, height: 64.0)
        print("Model setSize: \‍(sizeOk)")
        // [swift_ModelMapObject_setSize]
 
        // [swift_ModelMapObject_setCollisionEnabled]
        let collOk = m.setCollisionEnabled(true)
        print("Model setCollisionEnabled: \‍(collOk)")
        // [swift_ModelMapObject_setCollisionEnabled]
 
        // [swift_ModelMapObject_setAngle]
        let angleOk = m.setAngle(Float.pi / 4)
        print("Model setAngle: \‍(angleOk)")
        // [swift_ModelMapObject_setAngle]
 
        // [swift_ModelMapObject_setAngleAnimated]
        let angleAnimOk = m.setAngleAnimated(Float.pi / 2, duration: 0.5, animationType: .quint)
        print("Model setAngleAnimated: \‍(angleAnimOk)")
        // [swift_ModelMapObject_setAngleAnimated]
 
        // [swift_ModelMapObject_setBuffer]
        let bufOk = m.setBuffer(width: 4.0, height: 4.0)
        print("Model setBuffer: \‍(bufOk)")
        // [swift_ModelMapObject_setBuffer]
 
        // [swift_ModelMapObject_setPriority]
        let priOk = m.setPriority(10.0)
        print("Model setPrioritlongitude: \‍(priOk)")
        // [swift_ModelMapObject_setPriority]
 
        // [swift_LocationWindow_removeModelMapObject]
        let removed = locationWindow.removeModelMapObject(m)
        print("Removed model map object: \‍(removed)")
        modelMapObject = nil
        // [swift_LocationWindow_removeModelMapObject]
    }
 
    /**
     * Demonstrate polygon map objects
     */
    private func demonstratePolygonMapObjects() {
        print("--- Polygon Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_LocationWindow_addPolygonMapObject]
        // Add polygon map object
        polygonMapObject = locationWindow.addPolygonMapObject()
        print("Added polygon map object")
        // [swift_LocationWindow_addPolygonMapObject]
 
        if let polygonMapObject = polygonMapObject {
            // [swift_PolygonMapObject_setPolygon]
            // Set polygon geometry
            let points = [
                NCGlobalPoint(latitude: 50.0, longitude: 60.0),
                NCGlobalPoint(latitude: 55.0, longitude: 65.0),
                NCGlobalPoint(latitude: 60.0, longitude: 60.0),
                NCGlobalPoint(latitude: 55.0, longitude: 55.0),
            ]
            let polygon = NCLocationPolygon(points: points, sublocationId: 0, innerRings: [])
            let success = polygonMapObject.setPolygon(polygon)
            print("Set polygon with \‍(points.count) points: \‍(success)")
            // [swift_PolygonMapObject_setPolygon]
 
            // [swift_PolygonMapObject_setColor]
            // Set polygon color
            let colorSuccess = polygonMapObject.setColor(UIColor(red: 0.0, green: 1.0, blue: 0.0, alpha: 0.7))
            print("Set polygon color to green with 70% opacity: \‍(colorSuccess)")
            // [swift_PolygonMapObject_setColor]
 
            // [swift_PolygonMapObject_setOrder]
            // Set polygon rendering order
            let orderSuccess = polygonMapObject.setOrder(2)
            print("Set polygon rendering order to 2: \‍(orderSuccess)")
            // [swift_PolygonMapObject_setOrder]
 
            // [swift_PolygonMapObject_setOutlineColor]
            // Set polygon outline color
            let outlineColorSuccess = polygonMapObject.setOutlineColor(UIColor(red: 0.0, green: 0.0, blue: 1.0, alpha: 1.0))
            print("Set polygon outline color to blue: \‍(outlineColorSuccess)")
            // [swift_PolygonMapObject_setOutlineColor]
 
            // [swift_PolygonMapObject_setOutlineWidth]
            // Set polygon outline width
            let outlineWidthSuccess = polygonMapObject.setOutlineWidth(2.0)
            print("Set polygon outline width to 2.0 pixels: \‍(outlineWidthSuccess)")
            // [swift_PolygonMapObject_setOutlineWidth]
 
            // [swift_PolygonMapObject_setOutlineAlpha]
            // Set polygon outline alpha
            let outlineAlphaSuccess = polygonMapObject.setOutlineAlpha(0.8)
            print("Set polygon outline alpha to 0.8: \‍(outlineAlphaSuccess)")
            // [swift_PolygonMapObject_setOutlineAlpha]
 
            // [swift_PolygonMapObject_setOutlineOrder]
            // Set polygon outline order
            let outlineOrderSuccess = polygonMapObject.setOutlineOrder(1)
            print("Set polygon outline order to 1: \‍(outlineOrderSuccess)")
            // [swift_PolygonMapObject_setOutlineOrder]
 
            // [swift_PolygonMapObject_setVisible]
            // Set visibility
            let visibleSuccess = polygonMapObject.setVisible(true)
            print("Set polygon visibility to true: \‍(visibleSuccess)")
            // [swift_PolygonMapObject_setVisible]
 
            // [swift_PolygonMapObject_getMapObjectType]
            // Get map object type
            let objectType = polygonMapObject.mapObjectType
            print("Polygon map object type: \‍(objectType)")
            // [swift_PolygonMapObject_getMapObjectType]
 
            // [swift_MapObject_setAlpha_2]
            // Set alpha transparency
            let alphaSuccess = polygonMapObject.setAlpha(0.6)
            print("Set polygon alpha to 0.6: \‍(alphaSuccess)")
            // [swift_MapObject_setAlpha_2]
 
            // [swift_MapObject_setInteractive_2]
            // Set interactive mode
            let interactiveSuccess = polygonMapObject.setInteractive(true)
            print("Set polygon interactive to true: \‍(interactiveSuccess)")
            // [swift_MapObject_setInteractive_2]
 
            // [swift_MapObject_setTitle_2]
            // Set title
            let titleSuccess = polygonMapObject.setTitle("Polygon Object")
            print("Set polygon title to 'Polygon Object': \‍(titleSuccess)")
            // [swift_MapObject_setTitle_2]
 
            // [swift_MapObject_setData_2]
            // Set custom data
            let customData = ["key": "value", "number": "42"]
            let dataSuccess = polygonMapObject.setData(customData)
            print("Set polygon custom data: \‍(dataSuccess)")
            // [swift_MapObject_setData_2]
 
            // [swift_MapObject_getId_2]
            // Get object ID
            let objectId = polygonMapObject.id
            print("Polygon object ID: \‍(objectId)")
            // [swift_MapObject_getId_2]
 
            // [swift_MapObject_getType_2]
            // Get object type
            let objectTypeString = polygonMapObject.type
            print("Polygon object type: \‍(objectTypeString)")
            // [swift_MapObject_getType_2]
 
            // [swift_MapObject_getData_2]
            // Get custom data
            let retrievedData = polygonMapObject.data
            print("Polygon custom data: \‍(retrievedData)")
            // [swift_MapObject_getData_2]
        }
 
        // [swift_LocationWindow_removePolygonMapObject]
        // Remove polygon map object
        if let polygonMapObject = polygonMapObject {
            let removed = locationWindow.removePolygonMapObject(polygonMapObject)
            print("Removed polygon map object: \‍(removed)")
            self.polygonMapObject = nil
        }
        // [swift_LocationWindow_removePolygonMapObject]
 
        // Test multiple polygon objects
        var polygons: [NCPolygonMapObject] = []
        for i in 0..<3 {
            if let polygon = locationWindow.addPolygonMapObject() {
                let points = [
                    NCGlobalPoint(latitude: 300.0 + Double(i) * 50, longitude: 400.0 + Double(i) * 50),
                    NCGlobalPoint(latitude: 350.0 + Double(i) * 50, longitude: 450.0 + Double(i) * 50),
                    NCGlobalPoint(latitude: 400.0 + Double(i) * 50, longitude: 400.0 + Double(i) * 50),
                    NCGlobalPoint(latitude: 350.0 + Double(i) * 50, longitude: 350.0 + Double(i) * 50),
                ]
                                let polygonGeometry = NCLocationPolygon(points: points, sublocationId: 0, innerRings: [])
                polygon.setPolygon(polygonGeometry)
                polygon.setColor(UIColor(red: 0.0, green: 0.0, blue: 1.0, alpha: 0.5))
                polygons.append(polygon)
                print("Created polygon \‍(i) with \‍(points.count) points")
            }
        }
 
        for i in polygons.indices {
            locationWindow.removePolygonMapObject(polygons[i])
            print("Removed polygon \‍(i)")
        }
    }
 
    /**
     * Demonstrate polyline map objects
     */
    private func demonstratePolylineMapObjects() {
        print("--- Polyline Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_PolylineMapObject_constructor]
        // Create polyline map object
        let points = [
            NCGlobalPoint(latitude: 100.0, longitude: 110.0),
            NCGlobalPoint(latitude: 105.0, longitude: 115.0),
            NCGlobalPoint(latitude: 110.0, longitude: 120.0),
            NCGlobalPoint(latitude: 115.0, longitude: 125.0),
        ]
                let polyline = NCLocationPolyline(points: points, sublocationId: 0)
        polylineMapObject = locationWindow.addPolylineMapObject()
        print("Created polyline map object with \‍(points.count) points")
        // [swift_PolylineMapObject_constructor]
 
        // [swift_PolylineMapObject_getPolyline]
        // Access polyline
        let polylineShape = polylineMapObject!.getPolyLine()
        print("Polyline has \‍(polylineShape.polyline.points.count) points")
        // [swift_PolylineMapObject_getPolyline]
 
        // [swift_LocationWindow_addPolylineMapObject]
        // Add polyline map object
        polylineMapObject = locationWindow.addPolylineMapObject()
        print("Added polyline map object")
        // [swift_LocationWindow_addPolylineMapObject]
 
        if let polylineMapObject = polylineMapObject {
            // [swift_PolylineMapObject_setPolyLine]
            // Set polyline geometry
            let points = [
                NCGlobalPoint(latitude: 100.0, longitude: 110.0),
                NCGlobalPoint(latitude: 105.0, longitude: 115.0),
                NCGlobalPoint(latitude: 110.0, longitude: 120.0),
                NCGlobalPoint(latitude: 115.0, longitude: 125.0),
            ]
                        let polyline = NCLocationPolyline(points: points, sublocationId: 0)
            let success = polylineMapObject.setPolyLine(polyline)
            print("Set polyline with \‍(points.count) points: \‍(success)")
            // [swift_PolylineMapObject_setPolyLine]
 
            // [swift_PolylineMapObject_setDrawnFraction]
            _ = polylineMapObject.setDrawnFraction(0)
            // [swift_PolylineMapObject_setDrawnFraction]
 
            // [swift_PolylineMapObject_setDrawnFractionAnimated]
            let grew = polylineMapObject.setDrawnFractionAnimated(1, duration: 1.0, animationType: .linear)
            print("Polyline grow started: \‍(grew)")
            // [swift_PolylineMapObject_setDrawnFractionAnimated]
 
            // [swift_PolylineMapObject_drawnFraction]
            print("Drawn fraction: \‍(polylineMapObject.drawnFraction())")
            // [swift_PolylineMapObject_drawnFraction]
 
            // [swift_PolylineMapObject_setWidth]
            // Set polyline width
            let widthSuccess = polylineMapObject.setWidth(3.0)
            print("Set polyline width to 3.0 pixels: \‍(widthSuccess)")
            // [swift_PolylineMapObject_setWidth]
 
            // [swift_PolylineMapObject_setColor]
            // Set polyline color
            let colorSuccess = polylineMapObject.setColor(UIColor(red: 0.0, green: 1.0, blue: 0.0, alpha: 0.8))
            print("Set polyline color to green with 80% opacity: \‍(colorSuccess)")
            // [swift_PolylineMapObject_setColor]
 
            // [swift_PolylineMapObject_setDashLength]
            // Set dash segment length
            let dashSuccess = polylineMapObject.setDashLength(3.0)
            print("Set polyline dash length: \‍(dashSuccess)")
            // [swift_PolylineMapObject_setDashLength]
 
            // [swift_PolylineMapObject_dashLength]
            // Get dash segment length
            let dashLength = polylineMapObject.dashLength()
            print("Polyline dash length: \‍(dashLength)")
            // [swift_PolylineMapObject_dashLength]
 
            // [swift_PolylineMapObject_setGapLength]
            // Set gap length between dashes
            let gapSuccess = polylineMapObject.setGapLength(1.0)
            print("Set polyline gap length: \‍(gapSuccess)")
            // [swift_PolylineMapObject_setGapLength]
 
            // [swift_PolylineMapObject_gapLength]
            // Get gap length between dashes
            let gapLength = polylineMapObject.gapLength()
            print("Polyline gap length: \‍(gapLength)")
            // [swift_PolylineMapObject_gapLength]
 
            // [swift_PolylineMapObject_setOrder]
            // Set polyline rendering order
            let orderSuccess = polylineMapObject.setOrder(1)
            print("Set polyline rendering order to 1: \‍(orderSuccess)")
            // [swift_PolylineMapObject_setOrder]
 
            // [swift_PolylineMapObject_setCapType]
            // Set polyline cap type
            let capTypeSuccess = polylineMapObject.setCapType(.round)
            print("Set polyline cap type to ROUND: \‍(capTypeSuccess)")
            // [swift_PolylineMapObject_setCapType]
 
            // [swift_PolylineMapObject_setJoinType]
            // Set polyline join type
            let joinTypeSuccess = polylineMapObject.setJoinType(.round)
            print("Set polyline join type to ROUND: \‍(joinTypeSuccess)")
            // [swift_PolylineMapObject_setJoinType]
 
            // [swift_PolylineMapObject_setMiterLimit]
            // Set polyline miter limit
            let miterLimitSuccess = polylineMapObject.setMiterLimit(2.0)
            print("Set polyline miter limit to 2.0: \‍(miterLimitSuccess)")
            // [swift_PolylineMapObject_setMiterLimit]
 
            // [swift_PolylineMapObject_setOutlineWidth]
            // Set polyline outline width
            let outlineWidthSuccess = polylineMapObject.setOutlineWidth(1.0)
            print("Set polyline outline width to 1.0 pixels: \‍(outlineWidthSuccess)")
            // [swift_PolylineMapObject_setOutlineWidth]
 
            // [swift_PolylineMapObject_setOutlineColor]
            // Set polyline outline color
            let outlineColorSuccess = polylineMapObject.setOutlineColor(UIColor(red: 0.0, green: 0.0, blue: 0.0, alpha: 1.0))
            print("Set polyline outline color to black: \‍(outlineColorSuccess)")
            // [swift_PolylineMapObject_setOutlineColor]
 
            // [swift_PolylineMapObject_setOutlineAlpha]
            // Set polyline outline alpha
            let outlineAlphaSuccess = polylineMapObject.setOutlineAlpha(0.5)
            print("Set polyline outline alpha to 0.5: \‍(outlineAlphaSuccess)")
            // [swift_PolylineMapObject_setOutlineAlpha]
 
            // [swift_PolylineMapObject_setOutlineOrder]
            // Set polyline outline rendering order
            let outlineOrderSuccess = polylineMapObject.setOutlineOrder(0)
            print("Set polyline outline rendering order to 0: \‍(outlineOrderSuccess)")
            // [swift_PolylineMapObject_setOutlineOrder]
 
            // [swift_PolylineMapObject_setOutlineCapType]
            // Set polyline outline cap type
            let outlineCapTypeSuccess = polylineMapObject.setOutlineCapType(.square)
            print("Set polyline outline cap type to SQUARE: \‍(outlineCapTypeSuccess)")
            // [swift_PolylineMapObject_setOutlineCapType]
 
            // [swift_PolylineMapObject_setOutlineJoinType]
            // Set polyline outline join type
            let outlineJoinTypeSuccess = polylineMapObject.setOutlineJoinType(.miter)
            print("Set polyline outline join type to MITER: \‍(outlineJoinTypeSuccess)")
            // [swift_PolylineMapObject_setOutlineJoinType]
 
            // [swift_PolylineMapObject_setOutlineMiterLimit]
            // Set polyline outline miter limit
            let outlineMiterLimitSuccess = polylineMapObject.setOutlineMiterLimit(3.0)
            print("Set polyline outline miter limit to 3.0: \‍(outlineMiterLimitSuccess)")
            // [swift_PolylineMapObject_setOutlineMiterLimit]
 
            // [swift_PolylineMapObject_setVisible]
            // Set visibility
            let visibleSuccess = polylineMapObject.setVisible(true)
            print("Set polyline visibility to true: \‍(visibleSuccess)")
            // [swift_PolylineMapObject_setVisible]
 
            // [swift_PolylineMapObject_getMapObjectType]
            // Get map object type
            let objectType = polylineMapObject.mapObjectType
            print("Polyline map object type: \‍(objectType)")
            // [swift_PolylineMapObject_getMapObjectType]
 
            // [swift_MapObject_setAlpha_3]
            // Set alpha transparency
            let alphaSuccess = polylineMapObject.setAlpha(0.7)
            print("Set polyline alpha to 0.7: \‍(alphaSuccess)")
            // [swift_MapObject_setAlpha_3]
 
            // [swift_MapObject_setInteractive_3]
            // Set interactive mode
            let interactiveSuccess = polylineMapObject.setInteractive(true)
            print("Set polyline interactive to true: \‍(interactiveSuccess)")
            // [swift_MapObject_setInteractive_3]
 
            // [swift_MapObject_setTitle_3]
            // Set title
            let titleSuccess = polylineMapObject.setTitle("Polyline Object")
            print("Set polyline title to 'Polyline Object': \‍(titleSuccess)")
            // [swift_MapObject_setTitle_3]
 
            // [swift_MapObject_setData_3]
            // Set custom data
            let customData = ["key": "value", "number": "42"]
            let dataSuccess = polylineMapObject.setData(customData)
            print("Set polyline custom data: \‍(dataSuccess)")
            // [swift_MapObject_setData_3]
 
            // [swift_MapObject_getId_3]
            // Get object ID
            let objectId = polylineMapObject.id
            print("Polyline object ID: \‍(objectId)")
            // [swift_MapObject_getId_3]
 
            // [swift_MapObject_getType_3]
            // Get object type
            let objectTypeString = polylineMapObject.type
            print("Polyline object type: \‍(objectTypeString)")
            // [swift_MapObject_getType_3]
 
            // [swift_MapObject_getData_3]
            // Get custom data
            let retrievedData = polylineMapObject.data
            print("Polyline custom data: \‍(retrievedData)")
            // [swift_MapObject_getData_3]
        }
 
        // [swift_LocationWindow_removePolylineMapObject]
        // Remove polyline map object
        if let polylineMapObject = polylineMapObject {
            let removed = locationWindow.removePolylineMapObject(polylineMapObject)
            print("Removed polyline map object: \‍(removed)")
            self.polylineMapObject = nil
        }
        // [swift_LocationWindow_removePolylineMapObject]
 
        // Test multiple polyline objects
        var polylines: [NCPolylineMapObject] = []
        for i in 0..<3 {
            if let polyline = locationWindow.addPolylineMapObject() {
                let points = [
                    NCGlobalPoint(latitude: 120.0 + Double(i) * 30, longitude: 130.0 + Double(i) * 30),
                    NCGlobalPoint(latitude: 125.0 + Double(i) * 30, longitude: 135.0 + Double(i) * 30),
                    NCGlobalPoint(latitude: 130.0 + Double(i) * 30, longitude: 140.0 + Double(i) * 30),
                ]
                                let polylineGeometry = NCLocationPolyline(points: points, sublocationId: 0)
                polyline.setPolyLine(polylineGeometry)
                polyline.setColor(UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 0.6))
                polyline.setWidth(2.0)
                polylines.append(polyline)
                print("Created polyline \‍(i) with \‍(points.count) points")
            }
        }
 
        for i in polylines.indices {
            locationWindow.removePolylineMapObject(polylines[i])
            print("Removed polyline \‍(i)")
        }
    }
 
    /**
     * Demonstrate dotted polyline map objects
     */
    private func demonstrateDottedPolylineMapObjects() {
        print("--- Dotted Polyline Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        // [swift_DottedPolylineMapObject_constructor]
        // Create dotted polyline map object
        let points = [
            NCGlobalPoint(latitude: 160.0, longitude: 170.0),
            NCGlobalPoint(latitude: 165.0, longitude: 175.0),
            NCGlobalPoint(latitude: 170.0, longitude: 180.0),
            NCGlobalPoint(latitude: 175.0, longitude: 185.0),
        ]
                let polyline = NCLocationPolyline(points: points, sublocationId: 0)
        dottedPolylineMapObject = locationWindow.addDottedPolylineMapObject()
        print("Created dotted polyline map object with \‍(points.count) points")
        // [swift_DottedPolylineMapObject_constructor]
 
        // [swift_DottedPolylineMapObject_getPolyline]
        // Access dotted polyline
        let dottedPolylineShape = dottedPolylineMapObject!.getPolyLine()
        print("Dotted polyline has \‍(dottedPolylineShape.polyline.points.count) points")
        // [swift_DottedPolylineMapObject_getPolyline]
 
        // [swift_LocationWindow_addDottedPolylineMapObject]
        // Add dotted polyline map object
        dottedPolylineMapObject = locationWindow.addDottedPolylineMapObject()
        print("Added dotted polyline map object")
        // [swift_LocationWindow_addDottedPolylineMapObject]
 
        if let dottedPolylineMapObject = dottedPolylineMapObject {
            // [swift_DottedPolylineMapObject_setPolyline]
            // Set dotted polyline geometry
            let points = [
                NCGlobalPoint(latitude: 160.0, longitude: 170.0),
                NCGlobalPoint(latitude: 165.0, longitude: 175.0),
                NCGlobalPoint(latitude: 170.0, longitude: 180.0),
                NCGlobalPoint(latitude: 175.0, longitude: 185.0),
            ]
                        let polyline = NCLocationPolyline(points: points, sublocationId: 0)
            let success = dottedPolylineMapObject.setPolyline(polyline)
            print("Set dotted polyline with \‍(points.count) points: \‍(success)")
            // [swift_DottedPolylineMapObject_setPolyline]
 
            // [swift_DottedPolylineMapObject_setColor]
            // Set dotted polyline color
            let colorSuccess = dottedPolylineMapObject.setColor(UIColor(red: 0.5, green: 0.0, blue: 1.0, alpha: 0.8))
            print("Set dotted polyline color to purple with 80% opacity: \‍(colorSuccess)")
            // [swift_DottedPolylineMapObject_setColor]
 
            // [swift_DottedPolylineMapObject_setWidth]
            // Set dotted polyline width
            let widthSuccess = dottedPolylineMapObject.setWidth(3.0)
            print("Set dotted polyline width to 3.0 pixels: \‍(widthSuccess)")
            // [swift_DottedPolylineMapObject_setWidth]
 
            // [swift_DottedPolylineMapObject_setOrder]
            // Set dotted polyline rendering order
            let orderSuccess = dottedPolylineMapObject.setOrder(2)
            print("Set dotted polyline rendering order to 2: \‍(orderSuccess)")
            // [swift_DottedPolylineMapObject_setOrder]
 
            // [swift_DottedPolylineMapObject_setCollisionEnabled]
            // Enable collision detection
            let dottedCollisionSuccess = dottedPolylineMapObject.setCollisionEnabled(true)
            print("Enabled collision detection for dotted polyline: \‍(dottedCollisionSuccess)")
            // [swift_DottedPolylineMapObject_setCollisionEnabled]
 
            // [swift_DottedPolylineMapObject_setPlacement]
            // Set placement type
            let dottedPlacementSuccess = dottedPolylineMapObject.setPlacement(.center)
            print("Set dotted polyline placement to CENTER: \‍(dottedPlacementSuccess)")
            // [swift_DottedPolylineMapObject_setPlacement]
 
            // [swift_DottedPolylineMapObject_setPlacementMinRatio]
            // Set placement min ratio
            let dottedMinRatioSuccess = dottedPolylineMapObject.setPlacementMinRatio(0.5)
            print("Set dotted polyline placement min ratio to 0.5: \‍(dottedMinRatioSuccess)")
            // [swift_DottedPolylineMapObject_setPlacementMinRatio]
 
            // [swift_DottedPolylineMapObject_setPlacementSpacing]
            // Set placement spacing
            let dottedSpacingSuccess = dottedPolylineMapObject.setPlacementSpacing(10.0)
            print("Set dotted polyline placement spacing to 10.0: \‍(dottedSpacingSuccess)")
            // [swift_DottedPolylineMapObject_setPlacementSpacing]
 
            // [swift_DottedPolylineMapObject_setPriority]
            // Set rendering priority
            let dottedPrioritySuccess = dottedPolylineMapObject.setPriority(1)
            print("Set dotted polyline rendering priority to 1: \‍(dottedPrioritySuccess)")
            // [swift_DottedPolylineMapObject_setPriority]
 
            // [swift_DottedPolylineMapObject_setRepeatDistance]
            // Set repeat distance
            let dottedRepeatDistanceSuccess = dottedPolylineMapObject.setRepeatDistance(20.0)
            print("Set dotted polyline repeat distance to 20.0: \‍(dottedRepeatDistanceSuccess)")
            // [swift_DottedPolylineMapObject_setRepeatDistance]
 
            // [swift_DottedPolylineMapObject_setRepeatGroup]
            // Set repeat group
            let dottedRepeatGroupSuccess = dottedPolylineMapObject.setRepeatGroup(1)
            print("Set dotted polyline repeat group to 1: \‍(dottedRepeatGroupSuccess)")
            // [swift_DottedPolylineMapObject_setRepeatGroup]
 
            // [swift_DottedPolylineMapObject_setSize]
            // Set size
            let dottedSize = NCSize(width: 16.0, height: 16.0)
            let dottedSizeSuccess = dottedPolylineMapObject.setSize(dottedSize)
            print("Set dotted polyline size to (\‍(dottedSize.width), \‍(dottedSize.height)): \‍(dottedSizeSuccess)")
            // [swift_DottedPolylineMapObject_setSize]
 
            // [swift_DottedPolylineMapObject_setVisible]
            // Set visibility
            let visibleSuccess = dottedPolylineMapObject.setVisible(true)
            print("Set dotted polyline visibility to true: \‍(visibleSuccess)")
            // [swift_DottedPolylineMapObject_setVisible]
 
            // [swift_DottedPolylineMapObject_getMapObjectType]
            // Get map object type
            let objectType = dottedPolylineMapObject.mapObjectType
            print("Dotted polyline map object type: \‍(objectType)")
            // [swift_DottedPolylineMapObject_getMapObjectType]
 
            // [swift_MapObject_setAlpha_4]
            // Set alpha transparency
            let alphaSuccess = dottedPolylineMapObject.setAlpha(0.8)
            print("Set dotted polyline alpha to 0.8: \‍(alphaSuccess)")
            // [swift_MapObject_setAlpha_4]
 
            // [swift_MapObject_setInteractive_4]
            // Set interactive mode
            let interactiveSuccess = dottedPolylineMapObject.setInteractive(true)
            print("Set dotted polyline interactive to true: \‍(interactiveSuccess)")
            // [swift_MapObject_setInteractive_4]
 
            // [swift_MapObject_setTitle_4]
            // Set title
            let titleSuccess = dottedPolylineMapObject.setTitle("Dotted Polyline Object")
            print("Set dotted polyline title to 'Dotted Polyline Object': \‍(titleSuccess)")
            // [swift_MapObject_setTitle_4]
 
            // [swift_MapObject_setData_4]
            // Set custom data
            let customData = ["key": "value", "number": "42"]
            let dataSuccess = dottedPolylineMapObject.setData(customData)
            print("Set dotted polyline custom data: \‍(dataSuccess)")
            // [swift_MapObject_setData_4]
 
            // [swift_MapObject_getId_4]
            // Get object ID
            let objectId = dottedPolylineMapObject.id
            print("Dotted polyline object ID: \‍(objectId)")
            // [swift_MapObject_getId_4]
 
            // [swift_MapObject_getType_4]
            // Get object type
            let objectTypeString = dottedPolylineMapObject.type
            print("Dotted polyline object type: \‍(objectTypeString)")
            // [swift_MapObject_getType_4]
 
            // [swift_MapObject_getData_4]
            // Get custom data
            let retrievedData = dottedPolylineMapObject.data
            print("Dotted polyline custom data: \‍(retrievedData)")
            // [swift_MapObject_getData_4]
        }
 
        // [swift_LocationWindow_removeDottedPolylineMapObject]
        // Remove dotted polyline map object
        if let dottedPolylineMapObject = dottedPolylineMapObject {
            let removed = locationWindow.removeDottedPolylineMapObject(dottedPolylineMapObject)
            print("Removed dotted polyline map object: \‍(removed)")
            self.dottedPolylineMapObject = nil
        }
        // [swift_LocationWindow_removeDottedPolylineMapObject]
 
        // Test multiple dotted polyline objects
        var dottedPolylines: [NCDottedPolylineMapObject] = []
        for i in 0..<3 {
            if let dottedPolyline = locationWindow.addDottedPolylineMapObject() {
                let points = [
                    NCGlobalPoint(latitude: 180.0 + Double(i) * 30, longitude: 190.0 + Double(i) * 30),
                    NCGlobalPoint(latitude: 185.0 + Double(i) * 30, longitude: 195.0 + Double(i) * 30),
                    NCGlobalPoint(latitude: 190.0 + Double(i) * 30, longitude: 200.0 + Double(i) * 30),
                ]
                                let polylineGeometry = NCLocationPolyline(points: points, sublocationId: 0)
                dottedPolyline.setPolyline(polylineGeometry)
                dottedPolylines.append(dottedPolyline)
                print("Created dotted polyline \‍(i) with \‍(points.count) points")
            }
        }
 
        for i in dottedPolylines.indices {
            locationWindow.removeDottedPolylineMapObject(dottedPolylines[i])
            print("Removed dotted polyline \‍(i)")
        }
    }
 
    /**
     * Demonstrate icon clustering via ClusterMapObjectController.
     */
    private func demonstrateClusterMapObjects() {
        print("--- Cluster map objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available")
            return
        }
 
        // [swift_LocationWindow_addClusterMapObjectController]
        clusterMapObjectController = locationWindow.addClusterMapObjectController()
        print("Added cluster map object controller")
        // [swift_LocationWindow_addClusterMapObjectController]
 
        guard let controller = clusterMapObjectController else { return }
 
        let clusterIcon1 = locationWindow.addIconMapObject()
        let clusterIcon2 = locationWindow.addIconMapObject()
        clusterIcon1?.setPosition(NCGlobalPoint(latitude: 100.0, longitude: 100.0), sublocationId: 7)
        clusterIcon2?.setPosition(NCGlobalPoint(latitude: 105.0, longitude: 102.0), sublocationId: 7)
 
        // [swift_ClusterMapObjectController_addIconMapObject]
        let added1 = controller.add(clusterIcon1)
        let added2 = controller.add(clusterIcon2)
        print("Registered icons for clustering: \‍(added1), \‍(added2)")
        // [swift_ClusterMapObjectController_addIconMapObject]
 
        // [swift_ClusterMapObjectController_setEnabled]
        controller.setEnabled(true)
        print("Clustering enabled")
        // [swift_ClusterMapObjectController_setEnabled]
 
        // [swift_ClusterMapObjectController_isEnabled]
        let clusteringEnabled = controller.isEnabled()
        print("Clustering is enabled: \‍(clusteringEnabled)")
        // [swift_ClusterMapObjectController_isEnabled]
 
        // [swift_ClusterMapObjectController_setRadius]
        controller.setRadius(40.0)
        print("Set cluster radius to 40 px")
        // [swift_ClusterMapObjectController_setRadius]
 
        // [swift_ClusterMapObjectController_getRadius]
        let clusterRadius = controller.getRadius()
        print("Cluster radius: \‍(clusterRadius)")
        // [swift_ClusterMapObjectController_getRadius]
 
        // [swift_ClusterMapObjectController_setInteractive]
        let interactiveSuccess = controller.setInteractive(true)
        print("Set cluster markers interactive: \‍(interactiveSuccess)")
        // [swift_ClusterMapObjectController_setInteractive]
 
        // [swift_ClusterMapObjectController_setClusterSize]
        let sizeSuccess = controller.setClusterSize(32.0, height: 32.0)
        print("Set default cluster icon size: \‍(sizeSuccess)")
        // [swift_ClusterMapObjectController_setClusterSize]
 
        let listener = DemoClusterMapObjectControllerListener()
        clusterMapObjectControllerListener = listener
 
        // [swift_ClusterMapObjectController_addListener]
        controller.add(listener)
        print("Added cluster map object controller listener")
        // [swift_ClusterMapObjectController_addListener]
 
        // [swift_ClusterMapObjectController_getClusters]
        let clusters = controller.getClusters()
        print("Visible clusters: \‍(clusters.count)")
        // [swift_ClusterMapObjectController_getClusters]
 
        if let cluster = clusters.first {
            // [swift_ClusterMapObject_setBitmap]
            if let clusterImage = UIImage(contentsOfFile: "/path/to/cluster.png") {
                let bitmapSuccess = cluster.setBitmap(clusterImage)
                print("Set cluster bitmap (UIImage): \‍(bitmapSuccess)")
            }
            // [swift_ClusterMapObject_setBitmap]
        }
 
        // [swift_ClusterMapObjectController_removeListener]
        controller.remove(listener)
        print("Removed cluster map object controller listener")
        // [swift_ClusterMapObjectController_removeListener]
 
        if let clusterIcon1 = clusterIcon1 {
            // [swift_ClusterMapObjectController_removeIconMapObject]
            let removed = controller.remove(clusterIcon1)
            print("Removed icon from cluster controller: \‍(removed)")
            // [swift_ClusterMapObjectController_removeIconMapObject]
            locationWindow.removeIconMapObject(clusterIcon1)
        }
        if let clusterIcon2 = clusterIcon2 {
            locationWindow.removeIconMapObject(clusterIcon2)
        }
 
        // [swift_ClusterMapObjectController_clear]
        controller.clear()
        print("Cleared cluster controller")
        // [swift_ClusterMapObjectController_clear]
 
        // [swift_LocationWindow_removeClusterMapObjectController]
        let controllerRemoved = locationWindow.removeClusterMapObjectController(controller)
        print("Removed cluster map object controller: \‍(controllerRemoved)")
        // [swift_LocationWindow_removeClusterMapObjectController]
 
        clusterMapObjectController = nil
        clusterMapObjectControllerListener = nil
    }
 
    /**
     * Demonstrate remove all map objects
     */
    private func demonstrateRemoveAllMapObjects() {
        print("--- Remove All Map Objects ---")
 
        guard let locationWindow = locationWindow else {
            print("LocationWindow not available yet")
            return
        }
 
        print("Current map objects count: \‍(getMapObjectsCount())")
 
        // [swift_LocationWindow_removeAllMapObjects]
        // Remove all map objects
        locationWindow.removeAllMapObjects()
        print("Removed all map objects")
        // [swift_LocationWindow_removeAllMapObjects]
 
        print("Map objects count after removal: \‍(getMapObjectsCount())")
    }
 
    /**
     * Get current map objects count
     */
    private func getMapObjectsCount() -> Int {
        var count = 0
        if circleMapObject != nil { count += 1 }
        if iconMapObject != nil { count += 1 }
        if polygonMapObject != nil { count += 1 }
        if polylineMapObject != nil { count += 1 }
        if dottedPolylineMapObject != nil { count += 1 }
        return count
    }
 
    /**
     * Cleanup resources
     */
    private func cleanup() {
        print("--- Cleanup ---")
 
        if let locationWindow = locationWindow {
            locationWindow.removeAllMapObjects()
            print("Cleaned up all map objects")
        }
 
        circleMapObject = nil
        iconMapObject = nil
        modelMapObject = nil
        polygonMapObject = nil
        polylineMapObject = nil
        dottedPolylineMapObject = nil
        print("Cleared map objects references")
    }
}
 
class DemoClusterMapObjectControllerListener: NSObject, NCClusterMapObjectControllerListener {
    private let clusterChangeListener = DemoClusterMapObjectListener()
    private weak var activeCluster: NCClusterMapObject?
 
    // [swift_ClusterMapObjectControllerListener_onClusterCreated]
    func onClusterCreated(_ controller: NCClusterMapObjectController?, cluster: NCClusterMapObject?) {
        guard let cluster else { return }
        // [swift_ClusterMapObject_addListener]
        cluster.add(clusterChangeListener)
        print("Added cluster change listener, initial count: \‍(cluster.count)")
        // [swift_ClusterMapObject_addListener]
        activeCluster = cluster
    }
    // [swift_ClusterMapObjectControllerListener_onClusterCreated]
 
    // [swift_ClusterMapObjectControllerListener_onClusterDestroyed]
    func onClusterDestroyed(_ controller: NCClusterMapObjectController?, clusterId: Int32) {
        if let cluster = activeCluster, cluster.id == clusterId {
            // [swift_ClusterMapObject_removeListener]
            cluster.remove(clusterChangeListener)
            print("Removed cluster change listener")
            // [swift_ClusterMapObject_removeListener]
            activeCluster = nil
        }
        print("Cluster destroyed, id: \‍(clusterId)")
    }
    // [swift_ClusterMapObjectControllerListener_onClusterDestroyed]
}
 
class DemoClusterMapObjectListener: NSObject, NCClusterMapObjectListener {
 
    // [swift_ClusterMapObjectListener_onClusterChanged]
    func onClusterChanged(_ cluster: NCClusterMapObject) {
        let memberCount = cluster.count
        print("Cluster changed, member count: \‍(memberCount)")
    }
    // [swift_ClusterMapObjectListener_onClusterChanged]
}
 
// Main function to run the example
let example = LocationWindowMapObjectsExample()