LocationWindowMapObjectsExample.kt

Go to the documentation of this file.

package com.navigine.examples
 
import com.navigine.image.ImageProvider
import com.navigine.idl.kotlin.ModelMapObject
import com.navigine.model.ModelProvider
 
import com.navigine.idl.kotlin.LocationWindow
import com.navigine.idl.kotlin.CircleMapObject
import com.navigine.idl.kotlin.ClusterMapObject
import com.navigine.idl.kotlin.ClusterMapObjectController
import com.navigine.idl.kotlin.ClusterMapObjectControllerListener
import com.navigine.idl.kotlin.ClusterMapObjectListener
import com.navigine.idl.kotlin.IconMapObject
import com.navigine.idl.kotlin.PolygonMapObject
import com.navigine.idl.kotlin.PolylineMapObject
import com.navigine.idl.kotlin.DottedPolylineMapObject
import com.navigine.idl.kotlin.AnimationType
import com.navigine.idl.kotlin.CapType
import com.navigine.idl.kotlin.JoinType
import com.navigine.idl.kotlin.LocationPolygon
import com.navigine.idl.kotlin.LocationPolyline
import com.navigine.idl.kotlin.MapObjectType
import com.navigine.idl.kotlin.Placement
import com.navigine.idl.kotlin.Color
import com.navigine.idl.kotlin.Size
import com.navigine.idl.kotlin.GlobalPoint
import com.navigine.idl.kotlin.Polygon
import com.navigine.idl.kotlin.Polyline
import com.navigine.idl.kotlin.TitleStyle
 
/**
 * LocationWindowMapObjects usage example for Kotlin
 * Demonstrates specific methods: addCircleMapObject, removeCircleMapObject, addIconMapObject,
 * removeIconMapObject, addPolygonMapObject, addPolylineMapObject, removePolylineMapObject,
 * addDottedPolylineMapObject, removeDottedPolylineMapObject, removeAllMapObjects
 */
class LocationWindowMapObjectsExample {
    private var locationWindow: LocationWindow? = null
    private var circleMapObject: CircleMapObject? = null
    private var iconMapObject: IconMapObject? = null
    private var modelMapObject: ModelMapObject? = null
    private var polygonMapObject: PolygonMapObject? = null
    private var polylineMapObject: PolylineMapObject? = null
    private var dottedPolylineMapObject: DottedPolylineMapObject? = null
    private var clusterMapObjectController: ClusterMapObjectController? = null
    private var clusterMapObjectControllerListener: ClusterMapObjectControllerListener? = null
 
    init {
        demonstrateLocationWindowMapObjectsMethods()
    }
 
    /**
     * Demonstrate LocationWindowMapObjects methods
     */
    private fun demonstrateLocationWindowMapObjectsMethods() {
        println("=== 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 LocationPolygon, LocationPolyline).
     */
    private fun demonstrateLocationScopedGeometryRecords() {
        println("--- LocationPolygon / LocationPolyline records ---")
 
        // [kotlin_LocationPolygon_record]
        val ring = listOf(
            GlobalPoint(55.751, 37.617),
            GlobalPoint(55.752, 37.618),
            GlobalPoint(55.751, 37.619)
        )
        val locationPolygon = LocationPolygon(ring, 7)
        val polygonSublocationId = locationPolygon.sublocationId
        println("LocationPolygon: sublocation $polygonSublocationId, vertices ${locationPolygon.points.size}")
        // [kotlin_LocationPolygon_record]
 
        // [kotlin_LocationPolyline_record]
        val linePoints = listOf(
            GlobalPoint(55.751, 37.617),
            GlobalPoint(55.753, 37.620)
        )
        val locationPolyline = LocationPolyline(linePoints, 7)
        println("LocationPolyline: points ${locationPolyline.points.size}")
        // [kotlin_LocationPolyline_record]
    }
 
    /**
     * Demonstrate circle map objects
     */
    private fun demonstrateCircleMapObjects() {
        println("--- Circle Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_CircleMapObject_constructor]
        // Create circle map object
        val center = GlobalPoint(10.0, 20.0)
        circleMapObject = locationWindow!!.addCircleMapObject()
        println("Created circle map object with center (${center.latitude}, ${center.longitude}) and radius 5.0")
        // [kotlin_CircleMapObject_constructor]
 
        // [kotlin_CircleMapObject_getRadius]
        // Access circle radius
        val radius = circleMapObject!!.getRadius()
        println("Circle radius: $radius")
        // [kotlin_CircleMapObject_getRadius]
 
        // [kotlin_LocationWindow_addCircleMapObject]
        // Add circle map object
        circleMapObject = locationWindow!!.addCircleMapObject()
        println("Added circle map object")
        // [kotlin_LocationWindow_addCircleMapObject]
 
        if (circleMapObject != null) {
            // [kotlin_CircleMapObject_setPosition]
            // Set circle position
            val centerPoint = GlobalPoint(100.0, 200.0)
            val success = circleMapObject!!.setPosition(centerPoint, 7)
            println("Set circle position to (${centerPoint.latitude}, ${centerPoint.longitude}): $success")
            // [kotlin_CircleMapObject_setPosition]
 
            // [kotlin_CircleMapObject_setPositionAnimated]
            // Set circle position with animation
            val animatedPoint = GlobalPoint(150.0, 250.0)
            val animatedSuccess = circleMapObject!!.setPositionAnimated(animatedPoint, 7, 2.0, AnimationType.LINEAR)
            println("Set circle position with animation to (${animatedPoint.latitude}, ${animatedPoint.longitude}): $animatedSuccess")
            // [kotlin_CircleMapObject_setPositionAnimated]
 
            // [kotlin_CircleMapObject_setRadius]
            // Set circle radius
            val radiusSuccess = circleMapObject!!.setRadius(10.0)
            println("Set circle radius to 10.0 meters: $radiusSuccess")
            // [kotlin_CircleMapObject_setRadius]
 
            // [kotlin_CircleMapObject_setCollisionEnabled]
            // Enable collision detection
            val collisionSuccess = circleMapObject!!.setCollisionEnabled(true)
            println("Enabled collision detection for circle: $collisionSuccess")
            // [kotlin_CircleMapObject_setCollisionEnabled]
 
            // [kotlin_CircleMapObject_setBuffer]
            // Set collision buffer
            val bufferSuccess = circleMapObject!!.setBuffer(5.0, 5.0)
            println("Set collision buffer to 5x5 pixels: $bufferSuccess")
            // [kotlin_CircleMapObject_setBuffer]
 
            // [kotlin_CircleMapObject_setOffset]
            // Set position offset
            val offsetSuccess = circleMapObject!!.setOffset(2.0, 3.0)
            println("Set position offset to (2.0, 3.0) pixels: $offsetSuccess")
            // [kotlin_CircleMapObject_setOffset]
 
            // [kotlin_CircleMapObject_setOutlineColor]
            // Set outline color
            val outlineColorSuccess = circleMapObject!!.setOutlineColor(0xFF0000FF.toInt())
            println("Set circle outline color to blue: $outlineColorSuccess")
            // [kotlin_CircleMapObject_setOutlineColor]
 
            // [kotlin_CircleMapObject_setOutlineAlpha]
            // Set outline alpha
            val outlineAlphaSuccess = circleMapObject!!.setOutlineAlpha(0.5)
            println("Set circle outline alpha to 0.5: $outlineAlphaSuccess")
            // [kotlin_CircleMapObject_setOutlineAlpha]
 
            // [kotlin_CircleMapObject_setOutlineRadius]
            // Set outline radius
            val outlineRadiusSuccess = circleMapObject!!.setOutlineRadius(2.0)
            println("Set circle outline radius to 2.0: $outlineRadiusSuccess")
            // [kotlin_CircleMapObject_setOutlineRadius]
 
            // [kotlin_CircleMapObject_setColor]
            // Set circle color
            val colorSuccess = circleMapObject!!.setColor(0xCCFF0000.toInt())
            println("Set circle color to red with 80% opacity: $colorSuccess")
            // [kotlin_CircleMapObject_setColor]
 
            // [kotlin_CircleMapObject_setPriority]
            // Set rendering priority
            val prioritySuccess = circleMapObject!!.setPriority(1)
            println("Set rendering priority to 1: $prioritySuccess")
            // [kotlin_CircleMapObject_setPriority]
 
            // [kotlin_MapObject_setVisible]
            // Set visibility
            val visibleSuccess = circleMapObject!!.setVisible(true)
            println("Set circle visibility to true: $visibleSuccess")
            // [kotlin_MapObject_setVisible]
 
            // [kotlin_CircleMapObject_getMapObjectType]
            // Get map object type
            val objectType = circleMapObject!!.mapObjectType
            println("Circle map object type: $objectType")
            // [kotlin_CircleMapObject_getMapObjectType]
 
            // [kotlin_MapObject_setAlpha]
            // Set alpha transparency
            val alphaSuccess = circleMapObject!!.setAlpha(0.7)
            println("Set circle alpha to 0.7: $alphaSuccess")
            // [kotlin_MapObject_setAlpha]
 
            // [kotlin_MapObject_setInteractive]
            // Set interactive mode
            val interactiveSuccess = circleMapObject!!.setInteractive(true)
            println("Set circle interactive to true: $interactiveSuccess")
            // [kotlin_MapObject_setInteractive]
 
            // [kotlin_MapObject_setTitle]
            // Set title
            val titleSuccess = circleMapObject!!.setTitle("Circle Object")
            println("Set circle title to 'Circle Object': $titleSuccess")
            // [kotlin_MapObject_setTitle]
 
            // [kotlin_TitleStyle_record]
            val titleStyle = TitleStyle()
            titleStyle.fontSize = 14f
            titleStyle.color = "#3366CC"
            titleStyle.outlineColor = "#FFFFFF"
            titleStyle.anchor = TitleAnchor.TOP
            titleStyle.visible = true
            // [kotlin_TitleStyle_record]
 
            // [kotlin_MapObject_setTitleWithStyle]
            // Set title with style
            val titleStyleSuccess = circleMapObject!!.setTitleWithStyle("Styled Circle", titleStyle)
            println("Set circle title with style: $titleStyleSuccess")
            // [kotlin_MapObject_setTitleWithStyle]
 
            // [kotlin_MapObject_setData]
            // Set custom data
            val customData = mapOf("key" to "value", "number" to "42")
            val dataSuccess = circleMapObject!!.setData(customData)
            println("Set circle custom data: $dataSuccess")
            // [kotlin_MapObject_setData]
 
            // [kotlin_MapObject_getId]
            // Get object ID
            val objectId = circleMapObject!!.id
            println("Circle object ID: $objectId")
            // [kotlin_MapObject_getId]
 
            // [kotlin_MapObject_getType]
            // Get object type
            val objectTypeString = circleMapObject!!.type
            println("Circle object type: $objectTypeString")
            // [kotlin_MapObject_getType]
 
            // [kotlin_MapObject_getData]
            // Get custom data
            val retrievedData = circleMapObject!!.data
            println("Circle custom data: $retrievedData")
            // [kotlin_MapObject_getData]
        }
 
        // [kotlin_LocationWindow_removeCircleMapObject]
        // Remove circle map object
        if (circleMapObject != null) {
            val removed = locationWindow!!.removeCircleMapObject(circleMapObject!!)
            println("Removed circle map object: $removed")
            circleMapObject = null
        }
        // [kotlin_LocationWindow_removeCircleMapObject]
 
        // Test multiple circle objects
        val circles = mutableListOf<CircleMapObject>()
        for (i in 0..2) {
            val circle = locationWindow!!.addCircleMapObject()
            if (circle != null) {
                circle.setPosition(GlobalPoint(50.0 * i, 100.0 * i))
                circle.setColor(0x9900FF00.toInt())
                circle.setRadius(5.0 + i * 2.0)
                circles.add(circle)
                println("Created circle $i at (${50.0 * i}, ${100.0 * i}) with radius ${5.0 + i * 2.0}")
            }
        }
 
        for (i in circles.indices) {
            locationWindow!!.removeCircleMapObject(circles[i])
            println("Removed circle $i")
        }
    }
 
    /**
     * Demonstrate icon map objects
     */
    private fun demonstrateIconMapObjects() {
        println("--- Icon Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_IconMapObject_constructor]
        // Create icon map object
        val position = GlobalPoint(30.0, 40.0)
        iconMapObject = locationWindow!!.addIconMapObject()
        println("Created icon map object at (${position.latitude}, ${position.longitude})")
        // [kotlin_IconMapObject_constructor]
 
        // [kotlin_LocationWindow_addIconMapObject]
        // Add icon map object
        iconMapObject = locationWindow!!.addIconMapObject()
        println("Added icon map object")
        // [kotlin_LocationWindow_addIconMapObject]
 
        if (iconMapObject != null) {
            // [kotlin_IconMapObject_setPosition]
            // Set icon position
            val position = GlobalPoint(30.0, 40.0)
            val success = iconMapObject!!.setPosition(position, 7)
            println("Set icon position to (${position.latitude}, ${position.longitude}): $success")
            // [kotlin_IconMapObject_setPosition]
 
            // [kotlin_IconMapObject_setPositionAnimated]
            // Set icon position with animation
            val animatedPosition = GlobalPoint(35.0, 45.0)
            val animatedSuccess = iconMapObject!!.setPositionAnimated(animatedPosition, 7, 1.5, AnimationType.CUBIC)
            println("Set icon position with animation to (${animatedPosition.latitude}, ${animatedPosition.longitude}): $animatedSuccess")
            // [kotlin_IconMapObject_setPositionAnimated]
 
            // [kotlin_IconMapObject_setBitmap]
            val iconBitmap = ImageProvider.fromFile("/path/to/icon.png", true)
            val bitmapSuccess = iconMapObject!!.setBitmap(iconBitmap)
            println("Set icon from ImageProvider: $bitmapSuccess")
            // [kotlin_IconMapObject_setBitmap]
 
            // [kotlin_IconMapObject_setFlat]
            // Set icon flat mode
            val flatSuccess = iconMapObject!!.setFlat(true)
            println("Set icon flat mode to true: $flatSuccess")
            // [kotlin_IconMapObject_setFlat]
 
            // [kotlin_IconMapObject_setSize]
            // Set icon size
            val size = Size(32.0, 32.0)
            val sizeSuccess = iconMapObject!!.setSize(size)
            println("Set icon size to (${size.width}, ${size.height}): $sizeSuccess")
            // [kotlin_IconMapObject_setSize]
 
            // [kotlin_IconMapObject_setAngle]
            // Set icon rotation angle (radians)
            val angleSuccess = iconMapObject!!.setAngle(Math.toRadians(45.0).toFloat())
            println("Set icon rotation angle to π/4: $angleSuccess")
            // [kotlin_IconMapObject_setAngle]
 
            // [kotlin_IconMapObject_setAngleAnimated]
            // Set icon rotation with animation (radians)
            val angleAnimatedSuccess = iconMapObject!!.setAngleAnimated(Math.toRadians(90.0).toFloat(), 2.0, AnimationType.SINE)
            println("Set icon rotation with animation to π/2: $angleAnimatedSuccess")
            // [kotlin_IconMapObject_setAngleAnimated]
 
            // [kotlin_IconMapObject_setCollisionEnabled]
            // Enable collision detection
            val collisionSuccess = iconMapObject!!.setCollisionEnabled(true)
            println("Enabled collision detection for icon: $collisionSuccess")
            // [kotlin_IconMapObject_setCollisionEnabled]
 
            // [kotlin_IconMapObject_setBuffer]
            // Set collision buffer
            val bufferSuccess = iconMapObject!!.setBuffer(10.0, 10.0)
            println("Set collision buffer to 10x10 pixels: $bufferSuccess")
            // [kotlin_IconMapObject_setBuffer]
 
            // [kotlin_IconMapObject_setBuffer]
            // Set position offset
            val offsetSuccess = iconMapObject!!.setOffset(0.0, -16.0)
            println("Set position offset to (0.0, -16.0) pixels: $offsetSuccess")
            // [kotlin_IconMapObject_setOffset]
 
            // [kotlin_IconMapObject_setPriority]
            // Set rendering priority
            val prioritySuccess = iconMapObject!!.setPriority(2)
            println("Set rendering priority to 2: $prioritySuccess")
            // [kotlin_IconMapObject_setPriority]
 
            // [kotlin_IconMapObject_setVisible]
            // Set visibility
            val visibleSuccess = iconMapObject!!.setVisible(true)
            println("Set icon visibility to true: $visibleSuccess")
            // [kotlin_IconMapObject_setVisible]
 
            // [kotlin_IconMapObject_getMapObjectType]
            // Get map object type
            val objectType = iconMapObject!!.mapObjectType
            println("Icon map object type: $objectType")
            // [kotlin_IconMapObject_getMapObjectType]
 
            // [kotlin_MapObject_setAlpha_1]
            // Set alpha transparency
            val alphaSuccess = iconMapObject!!.setAlpha(0.8)
            println("Set icon alpha to 0.8: $alphaSuccess")
            // [kotlin_MapObject_setAlpha_1]
 
            // [kotlin_MapObject_setInteractive_1]
            // Set interactive mode
            val interactiveSuccess = iconMapObject!!.setInteractive(true)
            println("Set icon interactive to true: $interactiveSuccess")
            // [kotlin_MapObject_setInteractive_1]
 
            // [kotlin_MapObject_setTitle_1]
            // Set title
            val titleSuccess = iconMapObject!!.setTitle("Icon Object")
            println("Set icon title to 'Icon Object': $titleSuccess")
            // [kotlin_MapObject_setTitle_1]
 
            // [kotlin_MapObject_setData_1]
            // Set custom data
            val customData = mapOf("key" to "value", "number" to "42")
            val dataSuccess = iconMapObject!!.setData(customData)
            println("Set icon custom data: $dataSuccess")
            // [kotlin_MapObject_setData_1]
 
            // [kotlin_MapObject_getId_1]
            // Get object ID
            val objectId = iconMapObject!!.id
            println("Icon object ID: $objectId")
            // [kotlin_MapObject_getId_1]
 
            // [kotlin_MapObject_getType_1]
            // Get object type
            val objectTypeString = iconMapObject!!.type
            println("Icon object type: $objectTypeString")
            // [kotlin_MapObject_getType_1]
 
            // [kotlin_MapObject_getData_1]
            // Get custom data
            val retrievedData = iconMapObject!!.data
            println("Icon custom data: $retrievedData")
            // [kotlin_MapObject_getData_1]
        }
 
        // [kotlin_LocationWindow_removeIconMapObject]
        // Remove icon map object
        if (iconMapObject != null) {
            val removed = locationWindow!!.removeIconMapObject(iconMapObject!!)
            println("Removed icon map object: $removed")
            iconMapObject = null
        }
        // [kotlin_LocationWindow_removeIconMapObject]
 
        // Test multiple icon objects
        val icons = mutableListOf<IconMapObject>()
        for (i in 0..2) {
            val icon = locationWindow!!.addIconMapObject()
            if (icon != null) {
                icon.setPosition(GlobalPoint(60.0 * i, 120.0 * i))
                icon.setBitmap(ImageProvider.fromFile("/path/to/icon.png", true))
                icon.setSize(Size(24.0, 24.0))
                icons.add(icon)
                println("Created icon $i at (${60.0 * i}, ${120.0 * i})")
            }
        }
 
        for (i in icons.indices) {
            locationWindow!!.removeIconMapObject(icons[i])
            println("Removed icon $i")
        }
    }
 
    private fun demonstrateModelMapObjects() {
        println("--- Model Map Objects ---")
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_addModelMapObject]
        modelMapObject = locationWindow!!.addModelMapObject()
        println("Added model map object: ${modelMapObject != null}")
        // [kotlin_LocationWindow_addModelMapObject]
 
        val m = modelMapObject ?: return
 
        // [kotlin_ModelMapObject_setPosition]
        val posOk = m.setPosition(GlobalPoint(12.0, 34.0))
        println("Model setPosition: $posOk")
        // [kotlin_ModelMapObject_setPosition]
 
        // [kotlin_ModelMapObject_setPositionAnimated]
        val posAnimOk = m.setPositionAnimated(GlobalPoint(15.0, 40.0), 0.5f, AnimationType.SINE)
        println("Model setPositionAnimated: $posAnimOk")
        // [kotlin_ModelMapObject_setPositionAnimated]
 
        // [kotlin_ModelMapObject_setModel]
        val texture = ImageProvider.fromFile("/path/to/model_texture.png", true)
        val model = ModelProvider.fromFile("/path/to/model.obj", texture)
        val modelOk = m.setModel(model)
        println("Model setModel: $modelOk")
        // [kotlin_ModelMapObject_setModel]
 
        // [kotlin_ModelMapObject_setSize]
        val sizeOk = m.setSize(64.0f, 64.0f)
        println("Model setSize: $sizeOk")
        // [kotlin_ModelMapObject_setSize]
 
        // [kotlin_ModelMapObject_setCollisionEnabled]
        println("Model setCollisionEnabled: ${m.setCollisionEnabled(true)}")
        // [kotlin_ModelMapObject_setCollisionEnabled]
 
        // [kotlin_ModelMapObject_setAngle]
        println("Model setAngle: ${m.setAngle(Math.toRadians(45.0).toFloat())}")
        // [kotlin_ModelMapObject_setAngle]
 
        // [kotlin_ModelMapObject_setAngleAnimated]
        println("Model setAngleAnimated: ${m.setAngleAnimated(Math.toRadians(90.0).toFloat(), 0.5f, AnimationType.QUINT)}")
        // [kotlin_ModelMapObject_setAngleAnimated]
 
        // [kotlin_ModelMapObject_setBuffer]
        println("Model setBuffer: ${m.setBuffer(4.0f, 4.0f)}")
        // [kotlin_ModelMapObject_setBuffer]
 
        // [kotlin_ModelMapObject_setPriority]
        println("Model setPriority: ${m.setPriority(10.0f)}")
        // [kotlin_ModelMapObject_setPriority]
 
        // [kotlin_LocationWindow_removeModelMapObject]
        println("Removed model: ${locationWindow!!.removeModelMapObject(m)}")
        modelMapObject = null
        // [kotlin_LocationWindow_removeModelMapObject]
    }
 
    /**
     * Demonstrate polygon map objects
     */
    private fun demonstratePolygonMapObjects() {
        println("--- Polygon Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_LocationWindow_addPolygonMapObject]
        // Add polygon map object
        polygonMapObject = locationWindow!!.addPolygonMapObject()
        println("Added polygon map object")
        // [kotlin_LocationWindow_addPolygonMapObject]
 
        if (polygonMapObject != null) {
            // [kotlin_PolygonMapObject_setPolygon]
            // Set polygon geometry
            val points = listOf(
                Point(50.0, 60.0),
                Point(55.0, 65.0),
                Point(60.0, 60.0),
                Point(55.0, 55.0)
            )
            val polygon = LocationPolygon(points, 0)
            val success = polygonMapObject!!.setPolygon(polygon)
            println("Set polygon with ${points.size} points: $success")
            // [kotlin_PolygonMapObject_setPolygon]
 
            // [kotlin_PolygonMapObject_setColor]
            // Set polygon color
            val colorSuccess = polygonMapObject!!.setColor(0xB300FF00.toInt())
            println("Set polygon color to green with 70% opacity: $colorSuccess")
            // [kotlin_PolygonMapObject_setColor]
 
            // [kotlin_PolygonMapObject_setOrder]
            // Set polygon rendering order
            val orderSuccess = polygonMapObject!!.setOrder(2)
            println("Set polygon rendering order to 2: $orderSuccess")
            // [kotlin_PolygonMapObject_setOrder]
 
            // [kotlin_PolygonMapObject_setOutlineColor]
            // Set polygon outline color
            val outlineColorSuccess = polygonMapObject!!.setOutlineColor(0xFF0000FF.toInt())
            println("Set polygon outline color to blue: $outlineColorSuccess")
            // [kotlin_PolygonMapObject_setOutlineColor]
 
            // [kotlin_PolygonMapObject_setOutlineWidth]
            // Set polygon outline width
            val outlineWidthSuccess = polygonMapObject!!.setOutlineWidth(2.0)
            println("Set polygon outline width to 2.0 pixels: $outlineWidthSuccess")
            // [kotlin_PolygonMapObject_setOutlineWidth]
 
            // [kotlin_PolygonMapObject_setOutlineAlpha]
            // Set polygon outline alpha
            val outlineAlphaSuccess = polygonMapObject!!.setOutlineAlpha(0.8)
            println("Set polygon outline alpha to 0.8: $outlineAlphaSuccess")
            // [kotlin_PolygonMapObject_setOutlineAlpha]
 
            // [kotlin_PolygonMapObject_setOutlineOrder]
            // Set polygon outline order
            val outlineOrderSuccess = polygonMapObject!!.setOutlineOrder(1)
            println("Set polygon outline order to 1: $outlineOrderSuccess")
            // [kotlin_PolygonMapObject_setOutlineOrder]
 
            // [kotlin_PolygonMapObject_setVisible]
            // Set visibility
            val visibleSuccess = polygonMapObject!!.setVisible(true)
            println("Set polygon visibility to true: $visibleSuccess")
            // [kotlin_PolygonMapObject_setVisible]
 
            // [kotlin_PolygonMapObject_getMapObjectType]
            // Get map object type
            val objectType = polygonMapObject!!.mapObjectType
            println("Polygon map object type: $objectType")
            // [kotlin_PolygonMapObject_getMapObjectType]
 
            // [kotlin_MapObject_setAlpha_2]
            // Set alpha transparency
            val alphaSuccess = polygonMapObject!!.setAlpha(0.6)
            println("Set polygon alpha to 0.6: $alphaSuccess")
            // [kotlin_MapObject_setAlpha_2]
 
            // [kotlin_MapObject_setInteractive_2]
            // Set interactive mode
            val interactiveSuccess = polygonMapObject!!.setInteractive(true)
            println("Set polygon interactive to true: $interactiveSuccess")
            // [kotlin_MapObject_setInteractive_2]
 
            // [kotlin_MapObject_setTitle_2]
            // Set title
            val titleSuccess = polygonMapObject!!.setTitle("Polygon Object")
            println("Set polygon title to 'Polygon Object': $titleSuccess")
            // [kotlin_MapObject_setTitle_2]
 
            // [kotlin_MapObject_setData_2]
            // Set custom data
            val customData = mapOf("key" to "value", "number" to "42")
            val dataSuccess = polygonMapObject!!.setData(customData)
            println("Set polygon custom data: $dataSuccess")
            // [kotlin_MapObject_setData_2]
 
            // [kotlin_MapObject_getId_2]
            // Get object ID
            val objectId = polygonMapObject!!.id
            println("Polygon object ID: $objectId")
            // [kotlin_MapObject_getId_2]
 
            // [kotlin_MapObject_getType_2]
            // Get object type
            val objectTypeString = polygonMapObject!!.type
            println("Polygon object type: $objectTypeString")
            // [kotlin_MapObject_getType_2]
 
            // [kotlin_MapObject_getData_2]
            // Get custom data
            val retrievedData = polygonMapObject!!.data
            println("Polygon custom data: $retrievedData")
            // [kotlin_MapObject_getData_2]
        }
 
        // [kotlin_LocationWindow_removePolygonMapObject]
        // Remove polygon map object
        if (polygonMapObject != null) {
            val removed = locationWindow!!.removePolygonMapObject(polygonMapObject!!)
            println("Removed polygon map object: $removed")
            polygonMapObject = null
        }
        // [kotlin_LocationWindow_removePolygonMapObject]
 
        // Test multiple polygon objects
        val polygons = mutableListOf<PolygonMapObject>()
        for (i in 0..2) {
            val polygon = locationWindow!!.addPolygonMapObject()
            if (polygon != null) {
                val points = listOf(
                    Point(300.0 + i * 50, 400.0 + i * 50),
                    Point(350.0 + i * 50, 450.0 + i * 50),
                    Point(400.0 + i * 50, 400.0 + i * 50),
                    Point(350.0 + i * 50, 350.0 + i * 50)
                )
                                val polygonGeometry = LocationPolygon(points, 0)
                polygon.setPolygon(polygonGeometry)
                polygon.setColor(0x800000FF.toInt())
                polygons.add(polygon)
                println("Created polygon $i with ${points.size} points")
            }
        }
 
        for (i in polygons.indices) {
            locationWindow!!.removePolygonMapObject(polygons[i])
            println("Removed polygon $i")
        }
    }
 
    /**
     * Demonstrate polyline map objects
     */
    private fun demonstratePolylineMapObjects() {
        println("--- Polyline Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_PolylineMapObject_constructor]
        // Create polyline map object
        val points = listOf(
            Point(100.0, 110.0),
            Point(105.0, 115.0),
            Point(110.0, 120.0),
            Point(115.0, 125.0)
        )
                val polyline = LocationPolyline(points, 0)
        polylineMapObject = locationWindow!!.addPolylineMapObject()
        println("Created polyline map object with ${points.size} points")
        // [kotlin_PolylineMapObject_constructor]
 
        // [kotlin_PolylineMapObject_getPolyline]
        // Access polyline
        val polylineShape = polylineMapObject!!.getPolyLine()
        println("Polyline has ${polylineShape.points.size} points")
        // [kotlin_PolylineMapObject_getPolyline]
 
        // [kotlin_LocationWindow_addPolylineMapObject]
        // Add polyline map object
        polylineMapObject = locationWindow!!.addPolylineMapObject()
        println("Added polyline map object")
        // [kotlin_LocationWindow_addPolylineMapObject]
 
        if (polylineMapObject != null) {
            // [kotlin_PolylineMapObject_setPolyLine]
            // Set polyline geometry
            val points = listOf(
                Point(100.0, 110.0),
                Point(105.0, 115.0),
                Point(110.0, 120.0),
                Point(115.0, 125.0)
            )
                        val polyline = LocationPolyline(points, 0)
            val success = polylineMapObject!!.setPolyLine(polyline)
            println("Set polyline with ${points.size} points: $success")
            // [kotlin_PolylineMapObject_setPolyLine]
 
            // [kotlin_PolylineMapObject_setWidth]
            // Set polyline width
            val widthSuccess = polylineMapObject!!.setWidth(3.0)
            println("Set polyline width to 3.0 pixels: $widthSuccess")
            // [kotlin_PolylineMapObject_setWidth]
 
            // [kotlin_PolylineMapObject_setColor]
            // Set polyline color
            val colorSuccess = polylineMapObject!!.setColor(0xCC00FF00.toInt())
            println("Set polyline color to green with 80% opacity: $colorSuccess")
            // [kotlin_PolylineMapObject_setColor]
 
            // [kotlin_PolylineMapObject_setOrder]
            // Set polyline rendering order
            val orderSuccess = polylineMapObject!!.setOrder(1)
            println("Set polyline rendering order to 1: $orderSuccess")
            // [kotlin_PolylineMapObject_setOrder]
 
            // [kotlin_PolylineMapObject_setCapType]
            // Set polyline cap type
            val capTypeSuccess = polylineMapObject!!.setCapType(CapType.ROUND)
            println("Set polyline cap type to ROUND: $capTypeSuccess")
            // [kotlin_PolylineMapObject_setCapType]
 
            // [kotlin_PolylineMapObject_setJoinType]
            // Set polyline join type
            val joinTypeSuccess = polylineMapObject!!.setJoinType(JoinType.ROUND)
            println("Set polyline join type to ROUND: $joinTypeSuccess")
            // [kotlin_PolylineMapObject_setJoinType]
 
            // [kotlin_PolylineMapObject_setMiterLimit]
            // Set polyline miter limit
            val miterLimitSuccess = polylineMapObject!!.setMiterLimit(2.0)
            println("Set polyline miter limit to 2.0: $miterLimitSuccess")
            // [kotlin_PolylineMapObject_setMiterLimit]
 
            // [kotlin_PolylineMapObject_setOutlineWidth]
            // Set polyline outline width
            val outlineWidthSuccess = polylineMapObject!!.setOutlineWidth(1.0)
            println("Set polyline outline width to 1.0 pixels: $outlineWidthSuccess")
            // [kotlin_PolylineMapObject_setOutlineWidth]
 
            // [kotlin_PolylineMapObject_setOutlineColor]
            // Set polyline outline color
            val outlineColorSuccess = polylineMapObject!!.setOutlineColor(0xFF000000.toInt())
            println("Set polyline outline color to black: $outlineColorSuccess")
            // [kotlin_PolylineMapObject_setOutlineColor]
 
            // [kotlin_PolylineMapObject_setOutlineAlpha]
            // Set polyline outline alpha
            val outlineAlphaSuccess = polylineMapObject!!.setOutlineAlpha(0.5)
            println("Set polyline outline alpha to 0.5: $outlineAlphaSuccess")
            // [kotlin_PolylineMapObject_setOutlineAlpha]
 
            // [kotlin_PolylineMapObject_setOutlineOrder]
            // Set polyline outline rendering order
            val outlineOrderSuccess = polylineMapObject!!.setOutlineOrder(0)
            println("Set polyline outline rendering order to 0: $outlineOrderSuccess")
            // [kotlin_PolylineMapObject_setOutlineOrder]
 
            // [kotlin_PolylineMapObject_setOutlineCapType]
            // Set polyline outline cap type
            val outlineCapTypeSuccess = polylineMapObject!!.setOutlineCapType(CapType.SQUARE)
            println("Set polyline outline cap type to SQUARE: $outlineCapTypeSuccess")
            // [kotlin_PolylineMapObject_setOutlineCapType]
 
            // [kotlin_PolylineMapObject_setOutlineJoinType]
            // Set polyline outline join type
            val outlineJoinTypeSuccess = polylineMapObject!!.setOutlineJoinType(JoinType.MITER)
            println("Set polyline outline join type to MITER: $outlineJoinTypeSuccess")
            // [kotlin_PolylineMapObject_setOutlineJoinType]
 
            // [kotlin_PolylineMapObject_setOutlineMiterLimit]
            // Set polyline outline miter limit
            val outlineMiterLimitSuccess = polylineMapObject!!.setOutlineMiterLimit(3.0)
            println("Set polyline outline miter limit to 3.0: $outlineMiterLimitSuccess")
            // [kotlin_PolylineMapObject_setOutlineMiterLimit]
 
            // [kotlin_PolylineMapObject_setVisible]
            // Set visibility
            val visibleSuccess = polylineMapObject!!.setVisible(true)
            println("Set polyline visibility to true: $visibleSuccess")
            // [kotlin_PolylineMapObject_setVisible]
 
            // [kotlin_PolylineMapObject_getMapObjectType]
            // Get map object type
            val objectType = polylineMapObject!!.mapObjectType
            println("Polyline map object type: $objectType")
            // [kotlin_PolylineMapObject_getMapObjectType]
 
            // [kotlin_MapObject_setAlpha_3]
            // Set alpha transparency
            val alphaSuccess = polylineMapObject!!.setAlpha(0.7)
            println("Set polyline alpha to 0.7: $alphaSuccess")
            // [kotlin_MapObject_setAlpha_3]
 
            // [kotlin_MapObject_setInteractive_3]
            // Set interactive mode
            val interactiveSuccess = polylineMapObject!!.setInteractive(true)
            println("Set polyline interactive to true: $interactiveSuccess")
            // [kotlin_MapObject_setInteractive_3]
 
            // [kotlin_MapObject_setTitle_3]
            // Set title
            val titleSuccess = polylineMapObject!!.setTitle("Polyline Object")
            println("Set polyline title to 'Polyline Object': $titleSuccess")
            // [kotlin_MapObject_setTitle_3]
 
            // [kotlin_MapObject_setData_3]
            // Set custom data
            val customData = mapOf("key" to "value", "number" to "42")
            val dataSuccess = polylineMapObject!!.setData(customData)
            println("Set polyline custom data: $dataSuccess")
            // [kotlin_MapObject_setData_3]
 
            // [kotlin_MapObject_getId_3]
            // Get object ID
            val objectId = polylineMapObject!!.id
            println("Polyline object ID: $objectId")
            // [kotlin_MapObject_getId_3]
 
            // [kotlin_MapObject_getType_3]
            // Get object type
            val objectTypeString = polylineMapObject!!.type
            println("Polyline object type: $objectTypeString")
            // [kotlin_MapObject_getType_3]
 
            // [kotlin_MapObject_getData_3]
            // Get custom data
            val retrievedData = polylineMapObject!!.data
            println("Polyline custom data: $retrievedData")
            // [kotlin_MapObject_getData_3]
        }
 
        // [kotlin_LocationWindow_removePolylineMapObject]
        // Remove polyline map object
        if (polylineMapObject != null) {
            val removed = locationWindow!!.removePolylineMapObject(polylineMapObject!!)
            println("Removed polyline map object: $removed")
            polylineMapObject = null
        }
        // [kotlin_LocationWindow_removePolylineMapObject]
 
        // Test multiple polyline objects
        val polylines = mutableListOf<PolylineMapObject>()
        for (i in 0..2) {
            val polyline = locationWindow!!.addPolylineMapObject()
            if (polyline != null) {
                val points = listOf(
                    Point(120.0 + i * 30, 130.0 + i * 30),
                    Point(125.0 + i * 30, 135.0 + i * 30),
                    Point(130.0 + i * 30, 140.0 + i * 30)
                )
                                val polylineGeometry = LocationPolyline(points, 0)
                polyline.setPolyLine(polylineGeometry)
                polyline.setColor(0x99FF0000.toInt())
                polyline.setWidth(2.0)
                polylines.add(polyline)
                println("Created polyline $i with ${points.size} points")
            }
        }
 
        for (i in polylines.indices) {
            locationWindow!!.removePolylineMapObject(polylines[i])
            println("Removed polyline $i")
        }
    }
 
    /**
     * Demonstrate dotted polyline map objects
     */
    private fun demonstrateDottedPolylineMapObjects() {
        println("--- Dotted Polyline Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        // [kotlin_DottedPolylineMapObject_constructor]
        // Create dotted polyline map object
        val points = listOf(
            Point(160.0, 170.0),
            Point(165.0, 175.0),
            Point(170.0, 180.0),
            Point(175.0, 185.0)
        )
                val polyline = LocationPolyline(points, 0)
        dottedPolylineMapObject = locationWindow!!.addDottedPolylineMapObject()
        println("Created dotted polyline map object with ${points.size} points")
        // [kotlin_DottedPolylineMapObject_constructor]
 
        // [kotlin_DottedPolylineMapObject_getPolyline]
        // Access dotted polyline
        val dottedPolylineShape = dottedPolylineMapObject!!.getPolyLine()
        println("Dotted polyline has ${dottedPolylineShape.points.size} points")
        // [kotlin_DottedPolylineMapObject_getPolyline]
 
        // [kotlin_LocationWindow_addDottedPolylineMapObject]
        // Add dotted polyline map object
        dottedPolylineMapObject = locationWindow!!.addDottedPolylineMapObject()
        println("Added dotted polyline map object")
        // [kotlin_LocationWindow_addDottedPolylineMapObject]
 
        if (dottedPolylineMapObject != null) {
            // [kotlin_DottedPolylineMapObject_setPolyline]
            // Set dotted polyline geometry
            val points = listOf(
                Point(160.0, 170.0),
                Point(165.0, 175.0),
                Point(170.0, 180.0),
                Point(175.0, 185.0)
            )
                        val polyline = LocationPolyline(points, 0)
            val success = dottedPolylineMapObject!!.setPolyline(polyline)
            println("Set dotted polyline with ${points.size} points: $success")
            // [kotlin_DottedPolylineMapObject_setPolyline]
 
            // [kotlin_DottedPolylineMapObject_setColor]
            // Set dotted polyline color
            val colorSuccess = dottedPolylineMapObject!!.setColor(0xCC8000FF.toInt())
            println("Set dotted polyline color to purple with 80% opacity: $colorSuccess")
            // [kotlin_DottedPolylineMapObject_setColor]
 
            // [kotlin_DottedPolylineMapObject_setWidth]
            // Set dotted polyline width
            val widthSuccess = dottedPolylineMapObject!!.setWidth(3.0)
            println("Set dotted polyline width to 3.0 pixels: $widthSuccess")
            // [kotlin_DottedPolylineMapObject_setWidth]
 
            // [kotlin_DottedPolylineMapObject_setOrder]
            // Set dotted polyline rendering order
            val orderSuccess = dottedPolylineMapObject!!.setOrder(2)
            println("Set dotted polyline rendering order to 2: $orderSuccess")
            // [kotlin_DottedPolylineMapObject_setOrder]
 
            // [kotlin_DottedPolylineMapObject_setCollisionEnabled]
            // Enable collision detection
            val collisionSuccess = dottedPolylineMapObject!!.setCollisionEnabled(true)
            println("Enabled collision detection for dotted polyline: $collisionSuccess")
            // [kotlin_DottedPolylineMapObject_setCollisionEnabled]
 
            // [kotlin_DottedPolylineMapObject_setPlacement]
            // Set placement type
            val placementSuccess = dottedPolylineMapObject!!.setPlacement(Placement.CENTER)
            println("Set dotted polyline placement to CENTER: $placementSuccess")
            // [kotlin_DottedPolylineMapObject_setPlacement]
 
            // [kotlin_DottedPolylineMapObject_setPlacementMinRatio]
            // Set placement min ratio
            val minRatioSuccess = dottedPolylineMapObject!!.setPlacementMinRatio(0.5)
            println("Set dotted polyline placement min ratio to 0.5: $minRatioSuccess")
            // [kotlin_DottedPolylineMapObject_setPlacementMinRatio]
 
            // [kotlin_DottedPolylineMapObject_setPlacementSpacing]
            // Set placement spacing
            val spacingSuccess = dottedPolylineMapObject!!.setPlacementSpacing(10.0)
            println("Set dotted polyline placement spacing to 10.0: $spacingSuccess")
            // [kotlin_DottedPolylineMapObject_setPlacementSpacing]
 
            // [kotlin_DottedPolylineMapObject_setPriority]
            // Set rendering priority
            val prioritySuccess = dottedPolylineMapObject!!.setPriority(1)
            println("Set dotted polyline rendering priority to 1: $prioritySuccess")
            // [kotlin_DottedPolylineMapObject_setPriority]
 
            // [kotlin_DottedPolylineMapObject_setRepeatDistance]
            // Set repeat distance
            val repeatDistanceSuccess = dottedPolylineMapObject!!.setRepeatDistance(20.0)
            println("Set dotted polyline repeat distance to 20.0: $repeatDistanceSuccess")
            // [kotlin_DottedPolylineMapObject_setRepeatDistance]
 
            // [kotlin_DottedPolylineMapObject_setRepeatGroup]
            // Set repeat group
            val repeatGroupSuccess = dottedPolylineMapObject!!.setRepeatGroup(1)
            println("Set dotted polyline repeat group to 1: $repeatGroupSuccess")
            // [kotlin_DottedPolylineMapObject_setRepeatGroup]
 
            // [kotlin_DottedPolylineMapObject_setSize]
            // Set size
            val size = Size(16.0, 16.0)
            val sizeSuccess = dottedPolylineMapObject!!.setSize(size)
            println("Set dotted polyline size to (${size.width}, ${size.height}): $sizeSuccess")
            // [kotlin_DottedPolylineMapObject_setSize]
 
            // [kotlin_DottedPolylineMapObject_setVisible]
            // Set visibility
            val visibleSuccess = dottedPolylineMapObject!!.setVisible(true)
            println("Set dotted polyline visibility to true: $visibleSuccess")
            // [kotlin_DottedPolylineMapObject_setVisible]
 
            // [kotlin_DottedPolylineMapObject_getMapObjectType]
            // Get map object type
            val objectType = dottedPolylineMapObject!!.mapObjectType
            println("Dotted polyline map object type: $objectType")
            // [kotlin_DottedPolylineMapObject_getMapObjectType]
 
            // [kotlin_MapObject_setAlpha_4]
            // Set alpha transparency
            val alphaSuccess = dottedPolylineMapObject!!.setAlpha(0.8)
            println("Set dotted polyline alpha to 0.8: $alphaSuccess")
            // [kotlin_MapObject_setAlpha_4]
 
            // [kotlin_MapObject_setInteractive_4]
            // Set interactive mode
            val interactiveSuccess = dottedPolylineMapObject!!.setInteractive(true)
            println("Set dotted polyline interactive to true: $interactiveSuccess")
            // [kotlin_MapObject_setInteractive_4]
 
            // [kotlin_MapObject_setTitle_4]
            // Set title
            val titleSuccess = dottedPolylineMapObject!!.setTitle("Dotted Polyline Object")
            println("Set dotted polyline title to 'Dotted Polyline Object': $titleSuccess")
            // [kotlin_MapObject_setTitle_4]
 
            // [kotlin_MapObject_setData_4]
            // Set custom data
            val customData = mapOf("key" to "value", "number" to "42")
            val dataSuccess = dottedPolylineMapObject!!.setData(customData)
            println("Set dotted polyline custom data: $dataSuccess")
            // [kotlin_MapObject_setData_4]
 
            // [kotlin_MapObject_getId_4]
            // Get object ID
            val objectId = dottedPolylineMapObject!!.id
            println("Dotted polyline object ID: $objectId")
            // [kotlin_MapObject_getId_4]
 
            // [kotlin_MapObject_getType_4]
            // Get object type
            val objectTypeString = dottedPolylineMapObject!!.type
            println("Dotted polyline object type: $objectTypeString")
            // [kotlin_MapObject_getType_4]
 
            // [kotlin_MapObject_getData_4]
            // Get custom data
            val retrievedData = dottedPolylineMapObject!!.data
            println("Dotted polyline custom data: $retrievedData")
            // [kotlin_MapObject_getData_4]
        }
 
        // [kotlin_LocationWindow_removeDottedPolylineMapObject]
        // Remove dotted polyline map object
        if (dottedPolylineMapObject != null) {
            val removed = locationWindow!!.removeDottedPolylineMapObject(dottedPolylineMapObject!!)
            println("Removed dotted polyline map object: $removed")
            dottedPolylineMapObject = null
        }
        // [kotlin_LocationWindow_removeDottedPolylineMapObject]
 
        // Test multiple dotted polyline objects
        val dottedPolylines = mutableListOf<DottedPolylineMapObject>()
        for (i in 0..2) {
            val dottedPolyline = locationWindow!!.addDottedPolylineMapObject()
            if (dottedPolyline != null) {
                val points = listOf(
                    Point(180.0 + i * 30, 190.0 + i * 30),
                    Point(185.0 + i * 30, 195.0 + i * 30),
                    Point(190.0 + i * 30, 200.0 + i * 30)
                )
                                val polylineGeometry = LocationPolyline(points, 0)
                dottedPolyline.setPolyline(polylineGeometry)
                dottedPolylines.add(dottedPolyline)
                println("Created dotted polyline $i with ${points.size} points")
            }
        }
 
        for (i in dottedPolylines.indices) {
            locationWindow!!.removeDottedPolylineMapObject(dottedPolylines[i])
            println("Removed dotted polyline $i")
        }
    }
 
    /**
     * Demonstrate icon clustering via ClusterMapObjectController.
     */
    private fun demonstrateClusterMapObjects() {
        println("--- Cluster map objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available")
            return
        }
 
        // [kotlin_LocationWindow_addClusterMapObjectController]
        clusterMapObjectController = locationWindow!!.addClusterMapObjectController()
        println("Added cluster map object controller")
        // [kotlin_LocationWindow_addClusterMapObjectController]
 
        val controller = clusterMapObjectController ?: return
 
        val clusterIcon1 = locationWindow!!.addIconMapObject()
        val clusterIcon2 = locationWindow!!.addIconMapObject()
        clusterIcon1?.setPosition(GlobalPoint(100.0, 100.0))
        clusterIcon2?.setPosition(GlobalPoint(105.0, 102.0))
 
        // [kotlin_ClusterMapObjectController_addIconMapObject]
        val added1 = controller.addIconMapObject(clusterIcon1)
        val added2 = controller.addIconMapObject(clusterIcon2)
        println("Registered icons for clustering: $added1, $added2")
        // [kotlin_ClusterMapObjectController_addIconMapObject]
 
        // [kotlin_ClusterMapObjectController_setEnabled]
        controller.setEnabled(true)
        println("Clustering enabled")
        // [kotlin_ClusterMapObjectController_setEnabled]
 
        // [kotlin_ClusterMapObjectController_isEnabled]
        val clusteringEnabled = controller.isEnabled
        println("Clustering is enabled: $clusteringEnabled")
        // [kotlin_ClusterMapObjectController_isEnabled]
 
        // [kotlin_ClusterMapObjectController_setRadius]
        controller.setRadius(40.0f)
        println("Set cluster radius to 40 px")
        // [kotlin_ClusterMapObjectController_setRadius]
 
        // [kotlin_ClusterMapObjectController_getRadius]
        val clusterRadius = controller.getRadius()
        println("Cluster radius: $clusterRadius")
        // [kotlin_ClusterMapObjectController_getRadius]
 
        // [kotlin_ClusterMapObjectController_setInteractive]
        val interactiveSuccess = controller.setInteractive(true)
        println("Set cluster markers interactive: $interactiveSuccess")
        // [kotlin_ClusterMapObjectController_setInteractive]
 
        // [kotlin_ClusterMapObjectController_setClusterSize]
        val sizeSuccess = controller.setClusterSize(32.0f, 32.0f)
        println("Set default cluster icon size: $sizeSuccess")
        // [kotlin_ClusterMapObjectController_setClusterSize]
 
        clusterMapObjectControllerListener = DemoClusterMapObjectControllerListener()
 
        // [kotlin_ClusterMapObjectController_addListener]
        controller.addListener(clusterMapObjectControllerListener!!)
        println("Added cluster map object listener")
        // [kotlin_ClusterMapObjectController_addListener]
 
        // [kotlin_ClusterMapObjectController_getClusters]
        val clusters = controller.getClusters()
        println("Visible clusters: ${clusters.size}")
        // [kotlin_ClusterMapObjectController_getClusters]
 
        if (clusters.isNotEmpty()) {
            val cluster = clusters[0]
            // [kotlin_ClusterMapObject_setBitmap]
            val clusterBitmap = ImageProvider.fromFile("/path/to/cluster.png", true)
            val bitmapSuccess = cluster.setBitmap(clusterBitmap)
            println("Set cluster bitmap from ImageProvider: $bitmapSuccess")
            // [kotlin_ClusterMapObject_setBitmap]
        }
 
        // [kotlin_ClusterMapObjectController_removeListener]
        controller.removeListener(clusterMapObjectControllerListener!!)
        println("Removed cluster map object listener")
        // [kotlin_ClusterMapObjectController_removeListener]
 
        clusterIcon1?.let {
            // [kotlin_ClusterMapObjectController_removeIconMapObject]
            val removed = controller.removeIconMapObject(it)
            println("Removed icon from cluster controller: $removed")
            // [kotlin_ClusterMapObjectController_removeIconMapObject]
            locationWindow!!.removeIconMapObject(it)
        }
        clusterIcon2?.let { locationWindow!!.removeIconMapObject(it) }
 
        // [kotlin_ClusterMapObjectController_clear]
        controller.clear()
        println("Cleared cluster controller")
        // [kotlin_ClusterMapObjectController_clear]
 
        // [kotlin_LocationWindow_removeClusterMapObjectController]
        val controllerRemoved =
            locationWindow!!.removeClusterMapObjectController(controller)
        println("Removed cluster map object controller: $controllerRemoved")
        // [kotlin_LocationWindow_removeClusterMapObjectController]
 
        clusterMapObjectController = null
        clusterMapObjectControllerListener = null
    }
 
    /**
     * Demonstrate remove all map objects
     */
    private fun demonstrateRemoveAllMapObjects() {
        println("--- Remove All Map Objects ---")
 
        if (locationWindow == null) {
            println("LocationWindow not available yet")
            return
        }
 
        println("Current map objects count: ${getMapObjectsCount()}")
 
        // [kotlin_LocationWindow_removeAllMapObjects]
        // Remove all map objects
        locationWindow!!.removeAllMapObjects()
        println("Removed all map objects")
        // [kotlin_LocationWindow_removeAllMapObjects]
 
        println("Map objects count after removal: ${getMapObjectsCount()}")
    }
 
    /**
     * Get current map objects count
     */
    private fun getMapObjectsCount(): Int {
        var count = 0
        if (circleMapObject != null) count++
        if (iconMapObject != null) count++
        if (polygonMapObject != null) count++
        if (polylineMapObject != null) count++
        if (dottedPolylineMapObject != null) count++
        return count
    }
 
    /**
     * Cleanup resources
     */
    private fun cleanup() {
        println("--- Cleanup ---")
 
        if (locationWindow != null) {
            locationWindow!!.removeAllMapObjects()
            println("Cleaned up all map objects")
        }
 
        circleMapObject = null
        iconMapObject = null
        modelMapObject = null
        polygonMapObject = null
        polylineMapObject = null
        dottedPolylineMapObject = null
        println("Cleared map objects references")
    }
}
 
class DemoClusterMapObjectControllerListener : ClusterMapObjectControllerListener {
    private val clusterChangeListener = DemoClusterMapObjectListener()
    private var activeCluster: ClusterMapObject? = null
 
    // [kotlin_ClusterMapObjectControllerListener_onClusterCreated]
    override fun onClusterCreated(controller: ClusterMapObjectController, cluster: ClusterMapObject) {
        // [kotlin_ClusterMapObject_addListener]
        cluster.addListener(clusterChangeListener)
        println("Added cluster change listener, initial count: ${cluster.count}")
        // [kotlin_ClusterMapObject_addListener]
        activeCluster = cluster
    }
    // [kotlin_ClusterMapObjectControllerListener_onClusterCreated]
 
    // [kotlin_ClusterMapObjectControllerListener_onClusterDestroyed]
    override fun onClusterDestroyed(controller: ClusterMapObjectController, clusterId: Int) {
        val cluster = activeCluster
        if (cluster != null && cluster.id == clusterId) {
            // [kotlin_ClusterMapObject_removeListener]
            cluster.removeListener(clusterChangeListener)
            println("Removed cluster change listener")
            // [kotlin_ClusterMapObject_removeListener]
            activeCluster = null
        }
        println("Cluster destroyed, id: $clusterId")
    }
    // [kotlin_ClusterMapObjectControllerListener_onClusterDestroyed]
}
 
class DemoClusterMapObjectListener : ClusterMapObjectListener {
 
    // [kotlin_ClusterMapObjectListener_onClusterChanged]
    override fun onClusterChanged(cluster: ClusterMapObject) {
        val memberCount = cluster.getCount()
        println("Cluster changed, member count: $memberCount")
    }
    // [kotlin_ClusterMapObjectListener_onClusterChanged]
}
 
// Main function to run the example
fun main() {
    LocationWindowMapObjectsExample()
}