LocationWindowMapObjectsExample.swift

Go to the documentation of this file.

import Foundation
import NavigineSDK
 
/**
 * LocationWindowMapObjects usage example for Swift
 * Demonstrates specific methods: addCircleMapObject, removeCircleMapObject, addIconMapObject,
 * removeIconMapObject, addPolygonMapObject, addPolylineMapObject, removePolylineMapObject,
 * addDottedPolylineMapObject, removeDottedPolylineMapObject, removeAllMapObjects
 */
class LocationWindowMapObjectsExample {
    private var locationWindow: NCLocationWindow?
    private var circleMapObject: NCCircleMapObject?
    private var iconMapObject: NCIconMapObject?
    private var polygonMapObject: NCPolygonMapObject?
    private var polylineMapObject: NCPolylineMapObject?
    private var dottedPolylineMapObject: NCDottedPolylineMapObject?
 
    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()
        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 = [
            NCPoint(x: 1.0, y: 2.0),
            NCPoint(x: 3.0, y: 4.0),
            NCPoint(x: 5.0, y: 2.0),
        ]
        let metricPolygon = NCPolygon(points: ring)
        let locationPolygon = NCLocationPolygon(polygon: metricPolygon, locationId: 42, sublocationId: 7)
        let polygonBack = locationPolygon.polygon
        print("LocationPolygon location \‍(locationPolygon.locationId) sublocation \‍(locationPolygon.sublocationId) vertices \‍(polygonBack.points.count)")
        // [swift_LocationPolygon_record]
 
        // [swift_LocationPolyline_record]
        let linePts = [NCPoint(x: 0.0, y: 0.0), NCPoint(x: 10.0, y: 10.0)]
        let metricPolyline = NCPolyline(points: linePts)
        let locationPolyline = NCLocationPolyline(polyline: metricPolyline, locationId: 42, sublocationId: 7)
        let polylineBack = locationPolyline.polyline
        print("LocationPolyline points \‍(polylineBack.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 = NCLocationPoint(x: 10.0, y: 20.0)
        circleMapObject = locationWindow.addCircleMapObject()
        print("Created circle map object with center (\‍(center.x), \‍(center.y)) and radius 5.0")
        // [swift_CircleMapObject_constructor]
 
        // [swift_CircleMapObject_getCenter]
        // Access circle center
        let circleCenter = circleMapObject!.getPosition()
        print("Circle center: (\‍(circleCenter.x), \‍(circleCenter.y))")
        // [swift_CircleMapObject_getCenter]
 
        // [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 = NCLocationPoint(x: 100.0, y: 200.0)
            let success = circleMapObject.setPosition(centerPoint)
            print("Set circle position to (\‍(centerPoint.x), \‍(centerPoint.y)): \‍(success)")
            // [swift_CircleMapObject_setPosition]
 
            // [swift_CircleMapObject_setPositionAnimated]
            // Set circle position with animation
            let animatedPoint = NCLocationPoint(x: 150.0, y: 250.0)
            let animatedSuccess = circleMapObject.setPositionAnimated(animatedPoint, duration: 2.0, animationType: .linear)
            print("Set circle position with animation to (\‍(animatedPoint.x), \‍(animatedPoint.y)): \‍(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, y: 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(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(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_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(NCLocationPoint(x: 50.0 * Double(i), y: 100.0 * Double(i)))
                circle.setColor(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 = NCLocationPoint(x: 30.0, y: 40.0)
        iconMapObject = locationWindow.addIconMapObject()
        print("Created icon map object at (\‍(position.x), \‍(position.y))")
        // [swift_IconMapObject_constructor]
 
        // [swift_IconMapObject_getPosition]
        // Access icon position
        let iconPosition = iconMapObject!.getPosition()
        print("Icon position: (\‍(iconPosition.x), \‍(iconPosition.y))")
        // [swift_IconMapObject_getPosition]
 
        // [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 = NCLocationPoint(x: 30.0, y: 40.0)
            let success = iconMapObject.setPosition(position)
            print("Set icon position to (\‍(position.x), \‍(position.y)): \‍(success)")
            // [swift_IconMapObject_setPosition]
 
            // [swift_IconMapObject_setPositionAnimated]
            // Set icon position with animation
            let animatedPosition = NCLocationPoint(x: 35.0, y: 45.0)
            let animatedSuccess = iconMapObject.setPositionAnimated(animatedPosition, duration: 1.5, animationType: .cubic)
            print("Set icon position with animation to (\‍(animatedPosition.x), \‍(animatedPosition.y)): \‍(animatedSuccess)")
            // [swift_IconMapObject_setPositionAnimated]
 
            // [swift_IconMapObject_setIcon]
            // Set icon image
            let iconSuccess = iconMapObject.setIcon("path/to/icon.png")
            print("Set icon image: \‍(iconSuccess)")
            // [swift_IconMapObject_setIcon]
 
            // [swift_IconMapObject_setBitmap]
            // Set icon bitmap
            let bitmapSuccess = iconMapObject.setBitmap("path/to/bitmap.png")
            print("Set icon bitmap: \‍(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
            let angleSuccess = iconMapObject.setAngle(45.0)
            print("Set icon rotation angle to 45 degrees: \‍(angleSuccess)")
            // [swift_IconMapObject_setAngle]
 
            // [swift_IconMapObject_setAngleAnimated]
            // Set icon rotation with animation
            let angleAnimatedSuccess = iconMapObject.setAngleAnimated(90.0, duration: 2.0, animationType: .sine)
            print("Set icon rotation with animation to 90 degrees: \‍(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_setPlacement]
            // Set icon placement
            let placementSuccess = iconMapObject.setPlacement(.center)
            print("Set icon placement to CENTER: \‍(placementSuccess)")
            // [swift_IconMapObject_setPlacement]
 
            // [swift_IconMapObject_setOffset]
            // Set position offset
            let offsetSuccess = iconMapObject.setOffset(x: 0.0, y: -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(NCLocationPoint(x: 60.0 * Double(i), y: 120.0 * Double(i)))
                icon.setIcon("path/to/icon\‍(i).png")
                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)")
        }
    }
 
    /**
     * 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 = [
                NCPoint(x: 50.0, y: 60.0),
                NCPoint(x: 55.0, y: 65.0),
                NCPoint(x: 60.0, y: 60.0),
                NCPoint(x: 55.0, y: 55.0),
            ]
            let metricPolygon = NCPolygon(points: points)
            let polygon = NCLocationPolygon(polygon: metricPolygon, locationId: 1, sublocationId: 0)
            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(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(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 = [
                    NCPoint(x: 300.0 + Double(i) * 50, y: 400.0 + Double(i) * 50),
                    NCPoint(x: 350.0 + Double(i) * 50, y: 450.0 + Double(i) * 50),
                    NCPoint(x: 400.0 + Double(i) * 50, y: 400.0 + Double(i) * 50),
                    NCPoint(x: 350.0 + Double(i) * 50, y: 350.0 + Double(i) * 50),
                ]
                let metricPoly = NCPolygon(points: points)
                let polygonGeometry = NCLocationPolygon(polygon: metricPoly, locationId: 1, sublocationId: 0)
                polygon.setPolygon(polygonGeometry)
                polygon.setColor(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 = [
            NCPoint(x: 100.0, y: 110.0),
            NCPoint(x: 105.0, y: 115.0),
            NCPoint(x: 110.0, y: 120.0),
            NCPoint(x: 115.0, y: 125.0),
        ]
        let metricPolyline = NCPolyline(points: points)
        let polyline = NCLocationPolyline(polyline: metricPolyline, locationId: 1, 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 = [
                NCPoint(x: 100.0, y: 110.0),
                NCPoint(x: 105.0, y: 115.0),
                NCPoint(x: 110.0, y: 120.0),
                NCPoint(x: 115.0, y: 125.0),
            ]
            let metricPl = NCPolyline(points: points)
            let polyline = NCLocationPolyline(polyline: metricPl, locationId: 1, sublocationId: 0)
            let success = polylineMapObject.setPolyLine(polyline)
            print("Set polyline with \‍(points.count) points: \‍(success)")
            // [swift_PolylineMapObject_setPolyLine]
 
            // [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(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_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(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 = [
                    NCPoint(x: 120.0 + Double(i) * 30, y: 130.0 + Double(i) * 30),
                    NCPoint(x: 125.0 + Double(i) * 30, y: 135.0 + Double(i) * 30),
                    NCPoint(x: 130.0 + Double(i) * 30, y: 140.0 + Double(i) * 30),
                ]
                let metricPl = NCPolyline(points: points)
                let polylineGeometry = NCLocationPolyline(polyline: metricPl, locationId: 1, sublocationId: 0)
                polyline.setPolyLine(polylineGeometry)
                polyline.setColor(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 = [
            NCPoint(x: 160.0, y: 170.0),
            NCPoint(x: 165.0, y: 175.0),
            NCPoint(x: 170.0, y: 180.0),
            NCPoint(x: 175.0, y: 185.0),
        ]
        let dottedMetric = NCPolyline(points: points)
        let polyline = NCLocationPolyline(polyline: dottedMetric, locationId: 1, 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 = [
                NCPoint(x: 160.0, y: 170.0),
                NCPoint(x: 165.0, y: 175.0),
                NCPoint(x: 170.0, y: 180.0),
                NCPoint(x: 175.0, y: 185.0),
            ]
            let dottedPl = NCPolyline(points: points)
            let polyline = NCLocationPolyline(polyline: dottedPl, locationId: 1, 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(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 = [
                    NCPoint(x: 180.0 + Double(i) * 30, y: 190.0 + Double(i) * 30),
                    NCPoint(x: 185.0 + Double(i) * 30, y: 195.0 + Double(i) * 30),
                    NCPoint(x: 190.0 + Double(i) * 30, y: 200.0 + Double(i) * 30),
                ]
                let pl = NCPolyline(points: points)
                let polylineGeometry = NCLocationPolyline(polyline: pl, locationId: 1, 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 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
        polygonMapObject = nil
        polylineMapObject = nil
        dottedPolylineMapObject = nil
        print("Cleared map objects references")
    }
}
 
// Main function to run the example
let example = LocationWindowMapObjectsExample()