LocationWindowMapObjectsExample.java

Go to the documentation of this file.

package com.navigine.examples;
 
import com.navigine.idl.java.LocationWindow;
import com.navigine.idl.java.CircleMapObject;
import com.navigine.idl.java.ClusterMapObject;
import com.navigine.idl.java.ClusterMapObjectController;
import com.navigine.idl.java.ClusterMapObjectControllerListener;
import com.navigine.idl.java.ClusterMapObjectListener;
import com.navigine.idl.java.IconMapObject;
import com.navigine.idl.java.PolygonMapObject;
import com.navigine.idl.java.PolylineMapObject;
import com.navigine.idl.java.DottedPolylineMapObject;
import com.navigine.idl.java.AnimationType;
import com.navigine.idl.java.CapType;
import com.navigine.idl.java.JoinType;
import com.navigine.idl.java.GeoJsonImport;
import com.navigine.idl.java.LocationPolygon;
import com.navigine.idl.java.PointBatch;
import com.navigine.idl.java.PointSprite;
import com.navigine.idl.java.LocationPolyline;
import com.navigine.idl.java.MapObjectType;
import com.navigine.idl.java.GlobalPoint;
import com.navigine.idl.java.Polygon;
import com.navigine.idl.java.Polyline;
import com.navigine.idl.java.TitleStyle;
import com.navigine.idl.java.TitleAnchor;
import com.navigine.image.ImageProvider;
import com.navigine.idl.java.ModelMapObject;
import com.navigine.model.ModelProvider;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class LocationWindowMapObjectsExample {
    private LocationWindow locationWindow;
    private CircleMapObject circleMapObject;
    private IconMapObject iconMapObject;
    private ModelMapObject modelMapObject;
    private PolygonMapObject polygonMapObject;
    private PolylineMapObject polylineMapObject;
    private DottedPolylineMapObject dottedPolylineMapObject;
    private ClusterMapObjectController clusterMapObjectController;
    private ClusterMapObjectControllerListener clusterMapObjectControllerListener;
 
    public LocationWindowMapObjectsExample() {
        demonstrateLocationWindowMapObjectsMethods();
    }

    private void demonstrateLocationWindowMapObjectsMethods() {
        System.out.println("=== LocationWindowMapObjects Example ===");
 
        demonstrateLocationScopedGeometryRecords();
 
        demonstrateCircleMapObjects();
        demonstrateIconMapObjects();
        demonstrateClusterMapObjects();
        demonstrateModelMapObjects();
        demonstratePolygonMapObjects();
        demonstratePolylineMapObjects();
        demonstrateDottedPolylineMapObjects();
        demonstrateRemoveAllMapObjects();
        cleanup();
    }

    private void demonstrateLocationScopedGeometryRecords() {
        System.out.println("--- LocationPolygon / LocationPolyline records ---");
 
        // [java_LocationPolygon_record]
        List<GlobalPoint> ring = Arrays.asList(
            new GlobalPoint(55.751, 37.617),
            new GlobalPoint(55.752, 37.618),
            new GlobalPoint(55.751, 37.619)
        );
        List<List<GlobalPoint>> holes = Arrays.asList(Arrays.asList(
            new GlobalPoint(55.7512, 37.6174),
            new GlobalPoint(55.7514, 37.6176),
            new GlobalPoint(55.7512, 37.6178)
        ));
        LocationPolygon locationPolygon = new LocationPolygon(ring, 7, holes);
        int polygonSublocationId = locationPolygon.getSublocationId();
        System.out.println("LocationPolygon: sublocation "
            + polygonSublocationId + ", vertices " + locationPolygon.getPoints().size()
            + ", holes " + locationPolygon.getInnerRings().size());
        // [java_LocationPolygon_record]
 
        // [java_LocationWindow_addPointBatch]
        PointBatch batch = locationWindow.addPointBatch();
        java.util.List<PointSprite> sprites = java.util.Arrays.asList(
            new PointSprite(new GlobalPoint(55.751, 37.617), 0.f, 0xCCFF8000, 5.f),
            new PointSprite(new GlobalPoint(55.752, 37.618), 90.f, 0xCC0080FF, 5.f));
        batch.setPoints(sprites, 7);
        Integer hit = batch.hitTest(new android.graphics.PointF(12.f, 8.f), 8.f);
        System.out.println("PointBatch hit " + hit);
        // [java_LocationWindow_addPointBatch]
 
        // [java_LocationWindow_addGeoJson]
        String geoJson = "{\"type\":\"FeatureCollection\",\"features\":["
            + "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Polygon\",\"coordinates\":["
            + "[[37.617,55.751],[37.619,55.751],[37.619,55.752],[37.617,55.751]],"
            + "[[37.6174,55.7512],[37.6176,55.7512],[37.6176,55.7514],[37.6174,55.7512]]]}},"
            + "{\"type\":\"Feature\",\"geometry\":{\"type\":\"LineString\",\"coordinates\":"
            + "[[37.617,55.751],[37.620,55.753]]}}]}";
        GeoJsonImport imported = locationWindow.addGeoJson(geoJson, 7);
        System.out.println("GeoJSON polygons " + imported.getPolygons().size()
            + ", lines " + imported.getPolylines().size());
        // [java_LocationWindow_addGeoJson]
 
        // [java_LocationPolyline_record]
        List<GlobalPoint> linePoints = Arrays.asList(
            new GlobalPoint(55.751, 37.617),
            new GlobalPoint(55.753, 37.620)
        );
        LocationPolyline locationPolyline = new LocationPolyline(linePoints, 7);
        System.out.println("LocationPolyline: points " + locationPolyline.getPoints().size());
        // [java_LocationPolyline_record]
    }

    private void demonstrateCircleMapObjects() {
        System.out.println("--- Circle Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_CircleMapObject_constructor]
        // Create circle map object
        GlobalPoint center = new GlobalPoint(10.0, 20.0);
        circleMapObject = locationWindow.addCircleMapObject();
        System.out.println("Created circle map object with center (" + center.getLatitude() + ", " + center.getLongitude() + ") and radius 5.0");
        // [java_CircleMapObject_constructor]
 
        // [java_CircleMapObject_getRadius]
        // Access circle radius
        double radius = circleMapObject.getRadius();
        System.out.println("Circle radius: " + radius);
        // [java_CircleMapObject_getRadius]
 
        // [java_LocationWindow_addCircleMapObject]
        // Add circle map object
        circleMapObject = locationWindow.addCircleMapObject();
        System.out.println("Added circle map object");
        // [java_LocationWindow_addCircleMapObject]
 
        if (circleMapObject != null) {
            // [java_CircleMapObject_setPosition]
            // Set circle position
            GlobalPoint centerPoint = new GlobalPoint(55.7558, 37.6176);
            boolean success = circleMapObject.setPosition(centerPoint, 7);
            System.out.println("Set circle position to (" + centerPoint.getLatitude() + ", " + centerPoint.getLongitude() + "): " + success);
            // [java_CircleMapObject_setPosition]
 
            // [java_CircleMapObject_setPositionAnimated]
            // Set circle position with animation
            GlobalPoint animatedPoint = new GlobalPoint(55.7560, 37.6180);
            boolean animatedSuccess = circleMapObject.setPositionAnimated(animatedPoint, 7, 2.0f, AnimationType.LINEAR);
            System.out.println("Set circle position with animation to (" + animatedPoint.getLatitude() + ", " + animatedPoint.getLongitude() + "): " + animatedSuccess);
            // [java_CircleMapObject_setPositionAnimated]
 
            // [java_CircleMapObject_setRadius]
            // Set circle radius
            boolean radiusSuccess = circleMapObject.setRadius(10.0);
            System.out.println("Set circle radius to 10.0 meters: " + radiusSuccess);
            // [java_CircleMapObject_setRadius]
 
            // [java_CircleMapObject_setCollisionEnabled]
            // Enable collision detection
            boolean collisionSuccess = circleMapObject.setCollisionEnabled(true);
            System.out.println("Enabled collision detection for circle: " + collisionSuccess);
            // [java_CircleMapObject_setCollisionEnabled]
 
            // [java_CircleMapObject_setBuffer]
            // Set collision buffer
            boolean bufferSuccess = circleMapObject.setBuffer(5.0, 5.0);
            System.out.println("Set collision buffer to 5x5 pixels: " + bufferSuccess);
            // [java_CircleMapObject_setBuffer]
 
            // [java_CircleMapObject_setOffset]
            // Set position offset
            boolean offsetSuccess = circleMapObject.setOffset(2.0, 3.0);
            System.out.println("Set position offset to (2.0, 3.0) pixels: " + offsetSuccess);
            // [java_CircleMapObject_setOffset]
 
            // [java_CircleMapObject_setOutlineColor]
            // Set outline color
            boolean outlineColorSuccess = circleMapObject.setOutlineColor(0xFF0000FF);
            System.out.println("Set circle outline color to blue: " + outlineColorSuccess);
            // [java_CircleMapObject_setOutlineColor]
 
            // [java_CircleMapObject_setOutlineAlpha]
            // Set outline alpha
            boolean outlineAlphaSuccess = circleMapObject.setOutlineAlpha(0.5);
            System.out.println("Set circle outline alpha to 0.5: " + outlineAlphaSuccess);
            // [java_CircleMapObject_setOutlineAlpha]
 
            // [java_CircleMapObject_setOutlineRadius]
            // Set outline radius
            boolean outlineRadiusSuccess = circleMapObject.setOutlineRadius(2.0);
            System.out.println("Set circle outline radius to 2.0: " + outlineRadiusSuccess);
            // [java_CircleMapObject_setOutlineRadius]
 
            // [java_CircleMapObject_setColor]
            // Set circle color
            boolean colorSuccess = circleMapObject.setColor(0xCCFF0000);
            System.out.println("Set circle color to red with 80% opacity: " + colorSuccess);
            // [java_CircleMapObject_setColor]
 
            // [java_CircleMapObject_setPriority]
            // Set rendering priority
            boolean prioritySuccess = circleMapObject.setPriority(1);
            System.out.println("Set rendering priority to 1: " + prioritySuccess);
            // [java_CircleMapObject_setPriority]
 
            // [java_MapObject_setVisible]
            // Set visibility
            boolean visibleSuccess = circleMapObject.setVisible(true);
            System.out.println("Set circle visibility to true: " + visibleSuccess);
            // [java_MapObject_setVisible]
 
            // [java_CircleMapObject_getMapObjectType]
            // Get map object type
            MapObjectType objectType = circleMapObject.getMapObjectType();
            System.out.println("Circle map object type: " + objectType);
            // [java_CircleMapObject_getMapObjectType]
 
            // [java_MapObject_setAlpha]
            // Set alpha transparency
            boolean alphaSuccess = circleMapObject.setAlpha(0.7);
            System.out.println("Set circle alpha to 0.7: " + alphaSuccess);
            // [java_MapObject_setAlpha]
 
            // [java_MapObject_setInteractive]
            // Set interactive mode
            boolean interactiveSuccess = circleMapObject.setInteractive(true);
            System.out.println("Set circle interactive to true: " + interactiveSuccess);
            // [java_MapObject_setInteractive]
 
            // [java_MapObject_setTitle]
            // Set title
            boolean titleSuccess = circleMapObject.setTitle("Circle Object");
            System.out.println("Set circle title to 'Circle Object': " + titleSuccess);
            // [java_MapObject_setTitle]
 
            // [java_TitleStyle_record]
            TitleStyle titleStyle = new TitleStyle();
            titleStyle.fontSize = 14f;
            titleStyle.color = 0xFF3366CC;
            titleStyle.outlineColor = 0xFFFFFFFF;
            titleStyle.anchor = TitleAnchor.TOP;
            titleStyle.visible = true;
            // [java_TitleStyle_record]
 
            // [java_MapObject_setTitleWithStyle]
            // Set title with style
            boolean titleStyleSuccess = circleMapObject.setTitleWithStyle("Styled Circle", titleStyle);
            System.out.println("Set circle title with style: " + titleStyleSuccess);
            // [java_MapObject_setTitleWithStyle]
 
            // [java_MapObject_setData]
            // Set custom data
            Map<String, String> customData = new HashMap<>();
            customData.put("key", "value");
            customData.put("number", "42");
            boolean dataSuccess = circleMapObject.setData(customData);
            System.out.println("Set circle custom data: " + dataSuccess);
            // [java_MapObject_setData]
 
            // [java_MapObject_getId]
            // Get object ID
            int objectId = circleMapObject.getId();
            System.out.println("Circle object ID: " + objectId);
            // [java_MapObject_getId]
 
            // [java_MapObject_getType]
            // Get object type
            String objectTypeString = circleMapObject.getType();
            System.out.println("Circle object type: " + objectTypeString);
            // [java_MapObject_getType]
 
            // [java_MapObject_getData]
            // Get custom data
            Map<String, String> retrievedData = circleMapObject.getData();
            System.out.println("Circle custom data: " + retrievedData);
            // [java_MapObject_getData]
        }
 
        // [java_LocationWindow_removeCircleMapObject]
        // Remove circle map object
        if (circleMapObject != null) {
            boolean removed = locationWindow.removeCircleMapObject(circleMapObject);
            System.out.println("Removed circle map object: " + removed);
            circleMapObject = null;
        }
        // [java_LocationWindow_removeCircleMapObject]
 
        // Test multiple circle objects
        List<CircleMapObject> circles = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            CircleMapObject circle = locationWindow.addCircleMapObject();
            if (circle != null) {
                circle.setPosition(new GlobalPoint(50.0 * i, 100.0 * i));
                circle.setColor(0x9900FF00);
                circle.setRadius(5.0 + i * 2.0);
                circles.add(circle);
                System.out.println("Created circle " + i + " at (" + (50.0 * i) + ", " + (100.0 * i) + ") with radius " + (5.0 + i * 2.0));
            }
        }
 
        for (int i = 0; i < circles.size(); i++) {
            locationWindow.removeCircleMapObject(circles.get(i));
            System.out.println("Removed circle " + i);
        }
    }

    private void demonstrateIconMapObjects() {
        System.out.println("--- Icon Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_IconMapObject_constructor]
        // Create icon map object
        GlobalPoint position = new GlobalPoint(30.0, 40.0);
        iconMapObject = locationWindow.addIconMapObject();
        System.out.println("Created icon map object at (" + position.getLatitude() + ", " + position.getLongitude() + ")");
        // [java_IconMapObject_constructor]
 
        // [java_LocationWindow_addIconMapObject]
        // Add icon map object
        iconMapObject = locationWindow.addIconMapObject();
        System.out.println("Added icon map object");
        // [java_LocationWindow_addIconMapObject]
 
        if (iconMapObject != null) {
            // [java_IconMapObject_setPosition]
            // Set icon position
            GlobalPoint iconPoint = new GlobalPoint(200.0, 300.0);
            boolean success = iconMapObject.setPosition(iconPoint, 7);
            System.out.println("Set icon position to (" + iconPoint.getLatitude() + ", " + iconPoint.getLongitude() + "): " + success);
            // [java_IconMapObject_setPosition]
 
            // [java_IconMapObject_setPositionAnimated]
            // Set icon position with animation
            GlobalPoint animatedIconPoint = new GlobalPoint(250.0, 350.0);
            boolean animatedSuccess = iconMapObject.setPositionAnimated(animatedIconPoint, 7, 1.5, AnimationType.CUBIC);
            System.out.println("Set icon position with animation to (" + animatedIconPoint.getLatitude() + ", " + animatedIconPoint.getLongitude() + "): " + animatedSuccess);
            // [java_IconMapObject_setPositionAnimated]
 
            // [java_IconMapObject_setSize]
            // Set icon size
            boolean sizeSuccess = iconMapObject.setSize(32.0, 32.0);
            System.out.println("Set icon size to 32x32 pixels: " + sizeSuccess);
            // [java_IconMapObject_setSize]
 
            // [java_IconMapObject_setAngle]
            // Set icon rotation angle (radians)
            boolean angleSuccess = iconMapObject.setAngle((float) Math.toRadians(45.0));
            System.out.println("Set icon rotation angle to π/4: " + angleSuccess);
            // [java_IconMapObject_setAngle]
 
            // [java_IconMapObject_setAngleAnimated]
            // Set icon rotation with animation (radians)
            boolean angleAnimatedSuccess = iconMapObject.setAngleAnimated((float) Math.toRadians(90.0), 2.0, AnimationType.SINE);
            System.out.println("Set icon rotation with animation to π/2: " + angleAnimatedSuccess);
            // [java_IconMapObject_setAngleAnimated]
 
            // [java_IconMapObject_setCollisionEnabled]
            // Enable collision detection
            boolean collisionSuccess = iconMapObject.setCollisionEnabled(true);
            System.out.println("Enabled collision detection for icon: " + collisionSuccess);
            // [java_IconMapObject_setCollisionEnabled]
 
            // [java_IconMapObject_setBuffer]
            // Set collision buffer
            boolean bufferSuccess = iconMapObject.setBuffer(10.0, 10.0);
            System.out.println("Set collision buffer to 10x10 pixels: " + bufferSuccess);
            // [java_IconMapObject_setBuffer]
 
            // [java_IconMapObject_setOffset]
            // Set position offset
            boolean offsetSuccess = iconMapObject.setOffset(0.0, -16.0);
            System.out.println("Set position offset to (0.0, -16.0) pixels: " + offsetSuccess);
            // [java_IconMapObject_setOffset]
 
            // [java_IconMapObject_setPriority]
            // Set rendering priority
            boolean prioritySuccess = iconMapObject.setPriority(2);
            System.out.println("Set rendering priority to 2: " + prioritySuccess);
            // [java_IconMapObject_setPriority]
 
            // [java_IconMapObject_setVisible]
            // Set visibility
            boolean visibleSuccess = iconMapObject.setVisible(true);
            System.out.println("Set icon visibility to true: " + visibleSuccess);
            // [java_IconMapObject_setVisible]
 
            // [java_IconMapObject_getMapObjectType]
            // Get map object type
            MapObjectType objectType = iconMapObject.getMapObjectType();
            System.out.println("Icon map object type: " + objectType);
            // [java_IconMapObject_getMapObjectType]
 
            // [java_IconMapObject_setBitmap]
            // Icon pixels come from an ImageProvider (ARGB_8888 Bitmap on Android).
            ImageProvider iconBitmap = ImageProvider.fromFile("/path/to/icon.png", true);
            boolean bitmapSuccess = iconMapObject.setBitmap(iconBitmap);
            System.out.println("Set icon from ImageProvider: " + bitmapSuccess);
            // [java_IconMapObject_setBitmap]
 
            // [java_IconMapObject_setFlat]
            // Set icon flat mode
            boolean flatSuccess = iconMapObject.setFlat(true);
            System.out.println("Set icon flat mode to true: " + flatSuccess);
            // [java_IconMapObject_setFlat]
 
            // [java_MapObject_setAlpha_1]
            // Set alpha transparency
            boolean alphaSuccess = iconMapObject.setAlpha(0.8f);
            System.out.println("Set icon alpha to 0.8: " + alphaSuccess);
            // [java_MapObject_setAlpha_1]
 
            // [java_MapObject_setInteractive_1]
            // Set interactive mode
            boolean interactiveSuccess = iconMapObject.setInteractive(true);
            System.out.println("Set icon interactive to true: " + interactiveSuccess);
            // [java_MapObject_setInteractive_1]
 
            // [java_MapObject_setTitle_1]
            // Set title
            boolean titleSuccess = iconMapObject.setTitle("Icon Object");
            System.out.println("Set icon title to 'Icon Object': " + titleSuccess);
            // [java_MapObject_setTitle_1]
 
            // [java_MapObject_setData_1]
            // Set custom data
            Map<String, Object> customData = new HashMap<>();
            customData.put("key", "value");
            customData.put("number", 42);
            boolean dataSuccess = iconMapObject.setData(customData);
            System.out.println("Set icon custom data: " + dataSuccess);
            // [java_MapObject_setData_1]
 
            // [java_MapObject_getId_1]
            // Get object ID
            int objectId = iconMapObject.getId();
            System.out.println("Icon object ID: " + objectId);
            // [java_MapObject_getId_1]
 
            // [java_MapObject_getType_1]
            // Get object type
            String objectTypeString = iconMapObject.getType();
            System.out.println("Icon object type: " + objectTypeString);
            // [java_MapObject_getType_1]
 
            // [java_MapObject_getData_1]
            // Get custom data
            Map<String, Object> retrievedData = iconMapObject.getData();
            System.out.println("Icon custom data: " + retrievedData);
            // [java_MapObject_getData_1]
        }
 
        // [java_LocationWindow_removeIconMapObject]
        // Remove icon map object
        if (iconMapObject != null) {
            boolean removed = locationWindow.removeIconMapObject(iconMapObject);
            System.out.println("Removed icon map object: " + removed);
            iconMapObject = null;
        }
        // [java_LocationWindow_removeIconMapObject]
 
        // Test multiple icon objects
        List<IconMapObject> icons = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            IconMapObject icon = locationWindow.addIconMapObject();
            if (icon != null) {
                icon.setPosition(new GlobalPoint(100.0 * i, 150.0 * i));
                icon.setSize(24.0, 24.0);
                icon.setAngle((float) (i * Math.toRadians(30.0)));
                icons.add(icon);
                System.out.println("Created icon " + i + " at (" + (100.0 * i) + ", " + (150.0 * i) + ") with angle " + (i * Math.toRadians(30.0)) + " rad");
            }
        }
 
        for (int i = 0; i < icons.size(); i++) {
            locationWindow.removeIconMapObject(icons.get(i));
            System.out.println("Removed icon " + i);
        }
    }

    private void demonstrateModelMapObjects() {
        System.out.println("--- Model Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_addModelMapObject]
        modelMapObject = locationWindow.addModelMapObject();
        System.out.println("Added model map object: " + (modelMapObject != null));
        // [java_LocationWindow_addModelMapObject]
 
        if (modelMapObject == null) {
            return;
        }
 
        // [java_ModelMapObject_setPosition]
        GlobalPoint modelPoint = new GlobalPoint(12.0, 34.0);
        boolean posOk = modelMapObject.setPosition(modelPoint, 7);
        System.out.println("Model setPosition: " + posOk);
        // [java_ModelMapObject_setPosition]
 
        // [java_ModelMapObject_setPositionAnimated]
        boolean posAnimOk = modelMapObject.setPositionAnimated(new GlobalPoint(15.0, 40.0), 7, 0.5f, AnimationType.SINE);
        System.out.println("Model setPositionAnimated: " + posAnimOk);
        // [java_ModelMapObject_setPositionAnimated]
 
        // [java_ModelMapObject_setModel]
        ImageProvider texture = ImageProvider.fromFile("/path/to/model_texture.png", true);
        ModelProvider model = ModelProvider.fromFile("/path/to/model.obj", texture);
        boolean modelOk = modelMapObject.setModel(model);
        System.out.println("Model setModel: " + modelOk);
        // [java_ModelMapObject_setModel]
 
        // [java_ModelMapObject_setSize]
        boolean sizeOk = modelMapObject.setSize(64.0f, 64.0f);
        System.out.println("Model setSize: " + sizeOk);
        // [java_ModelMapObject_setSize]
 
        // [java_ModelMapObject_setCollisionEnabled]
        boolean collOk = modelMapObject.setCollisionEnabled(true);
        System.out.println("Model setCollisionEnabled: " + collOk);
        // [java_ModelMapObject_setCollisionEnabled]
 
        // [java_ModelMapObject_setAngle]
        boolean angleOk = modelMapObject.setAngle((float) Math.toRadians(45.0));
        System.out.println("Model setAngle: " + angleOk);
        // [java_ModelMapObject_setAngle]
 
        // [java_ModelMapObject_setAngleAnimated]
        boolean angleAnimOk = modelMapObject.setAngleAnimated((float) Math.toRadians(90.0), 0.5f, AnimationType.QUINT);
        System.out.println("Model setAngleAnimated: " + angleAnimOk);
        // [java_ModelMapObject_setAngleAnimated]
 
        // [java_ModelMapObject_setBuffer]
        boolean bufOk = modelMapObject.setBuffer(4.0f, 4.0f);
        System.out.println("Model setBuffer: " + bufOk);
        // [java_ModelMapObject_setBuffer]
 
        // [java_ModelMapObject_setPriority]
        boolean priOk = modelMapObject.setPriority(10.0f);
        System.out.println("Model setPriority: " + priOk);
        // [java_ModelMapObject_setPriority]
 
        // [java_LocationWindow_removeModelMapObject]
        boolean removed = locationWindow.removeModelMapObject(modelMapObject);
        System.out.println("Removed model map object: " + removed);
        modelMapObject = null;
        // [java_LocationWindow_removeModelMapObject]
    }

    private void demonstratePolygonMapObjects() {
        System.out.println("--- Polygon Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_LocationWindow_addPolygonMapObject]
        // Add polygon map object
        polygonMapObject = locationWindow.addPolygonMapObject();
        System.out.println("Added polygon map object");
        // [java_LocationWindow_addPolygonMapObject]
 
        if (polygonMapObject != null) {
            // [java_PolygonMapObject_setPolygon]
            // Set polygon geometry
            List<GlobalPoint> points = Arrays.asList(
                new GlobalPoint(100.0, 200.0),
                new GlobalPoint(150.0, 250.0),
                new GlobalPoint(200.0, 200.0),
                new GlobalPoint(150.0, 150.0)
            );
            LocationPolygon polygon = new LocationPolygon(points, 0, java.util.Collections.emptyList());
            boolean success = polygonMapObject.setPolygon(polygon);
            System.out.println("Set polygon with " + points.size() + " points: " + success);
            // [java_PolygonMapObject_setPolygon]
 
            // [java_PolygonMapObject_setColor]
            // Set polygon color
            boolean colorSuccess = polygonMapObject.setColor(0xB300FF00);
            System.out.println("Set polygon color to green with 70% opacity: " + colorSuccess);
            // [java_PolygonMapObject_setColor]
 
            // [java_PolygonMapObject_setVisible]
            // Set visibility
            boolean visibleSuccess = polygonMapObject.setVisible(true);
            System.out.println("Set polygon visibility to true: " + visibleSuccess);
            // [java_PolygonMapObject_setVisible]
 
            // [java_PolygonMapObject_getMapObjectType]
            // Get map object type
            MapObjectType objectType = polygonMapObject.getMapObjectType();
            System.out.println("Polygon map object type: " + objectType);
            // [java_PolygonMapObject_getMapObjectType]
 
            // [java_PolygonMapObject_setOrder]
            // Set polygon rendering order
            boolean orderSuccess = polygonMapObject.setOrder(2);
            System.out.println("Set polygon rendering order to 2: " + orderSuccess);
            // [java_PolygonMapObject_setOrder]
 
            // [java_PolygonMapObject_setOutlineColor]
            // Set polygon outline color
            boolean outlineColorSuccess = polygonMapObject.setOutlineColor(0xFF0000FF);
            System.out.println("Set polygon outline color to blue: " + outlineColorSuccess);
            // [java_PolygonMapObject_setOutlineColor]
 
            // [java_PolygonMapObject_setOutlineWidth]
            // Set polygon outline width
            boolean outlineWidthSuccess = polygonMapObject.setOutlineWidth(2.0);
            System.out.println("Set polygon outline width to 2.0 pixels: " + outlineWidthSuccess);
            // [java_PolygonMapObject_setOutlineWidth]
 
            // [java_PolygonMapObject_setOutlineAlpha]
            // Set polygon outline alpha
            boolean outlineAlphaSuccess = polygonMapObject.setOutlineAlpha(0.8);
            System.out.println("Set polygon outline alpha to 0.8: " + outlineAlphaSuccess);
            // [java_PolygonMapObject_setOutlineAlpha]
 
            // [java_PolygonMapObject_setOutlineOrder]
            // Set polygon outline order
            boolean outlineOrderSuccess = polygonMapObject.setOutlineOrder(1);
            System.out.println("Set polygon outline order to 1: " + outlineOrderSuccess);
            // [java_PolygonMapObject_setOutlineOrder]
 
            // [java_MapObject_setAlpha_2]
            // Set alpha transparency
            boolean alphaSuccess = polygonMapObject.setAlpha(0.7);
            System.out.println("Set polygon alpha to 0.7: " + alphaSuccess);
            // [java_MapObject_setAlpha_2]
 
            // [java_MapObject_setInteractive_2]
            // Set interactive mode
            boolean interactiveSuccess = polygonMapObject.setInteractive(true);
            System.out.println("Set polygon interactive to true: " + interactiveSuccess);
            // [java_MapObject_setInteractive_2]
 
            // [java_MapObject_setTitle_2]
            // Set title
            boolean titleSuccess = polygonMapObject.setTitle("Polygon Object");
            System.out.println("Set polygon title to 'Polygon Object': " + titleSuccess);
            // [java_MapObject_setTitle_2]
 
            // [java_MapObject_setData_2]
            // Set custom data
            Map<String, Object> customData = new HashMap<>();
            customData.put("key", "value");
            customData.put("number", 42);
            boolean dataSuccess = polygonMapObject.setData(customData);
            System.out.println("Set polygon custom data: " + dataSuccess);
            // [java_MapObject_setData_2]
 
            // [java_MapObject_getId_2]
            // Get object ID
            int objectId = polygonMapObject.getId();
            System.out.println("Polygon object ID: " + objectId);
            // [java_MapObject_getId_2]
 
            // [java_MapObject_getType_2]
            // Get object type
            String objectTypeString = polygonMapObject.getType();
            System.out.println("Polygon object type: " + objectTypeString);
            // [java_MapObject_getType_2]
 
            // [java_MapObject_getData_2]
            // Get custom data
            Map<String, Object> retrievedData = polygonMapObject.getData();
            System.out.println("Polygon custom data: " + retrievedData);
            // [java_MapObject_getData_2]
        }
 
        // [java_LocationWindow_removePolygonMapObject]
        // Remove polygon map object
        if (polygonMapObject != null) {
            boolean removed = locationWindow.removePolygonMapObject(polygonMapObject);
            System.out.println("Removed polygon map object: " + removed);
            polygonMapObject = null;
        }
        // [java_LocationWindow_removePolygonMapObject]
 
        // Test multiple polygon objects
        List<PolygonMapObject> polygons = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            PolygonMapObject polygon = locationWindow.addPolygonMapObject();
            if (polygon != null) {
                List<GlobalPoint> points = Arrays.asList(
                    new GlobalPoint(300.0 + i * 50, 400.0 + i * 50),
                    new GlobalPoint(350.0 + i * 50, 450.0 + i * 50),
                    new GlobalPoint(400.0 + i * 50, 400.0 + i * 50),
                    new GlobalPoint(350.0 + i * 50, 350.0 + i * 50)
                );
                                LocationPolygon polygonGeometry = new LocationPolygon(points, 0, java.util.Collections.emptyList());
                polygon.setPolygon(polygonGeometry);
                polygon.setColor(0x800000FF);
                polygons.add(polygon);
                System.out.println("Created polygon " + i + " with " + points.size() + " points");
            }
        }
 
        for (int i = 0; i < polygons.size(); i++) {
            locationWindow.removePolygonMapObject(polygons.get(i));
            System.out.println("Removed polygon " + i);
        }
    }

    private void demonstratePolylineMapObjects() {
        System.out.println("--- Polyline Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_PolylineMapObject_constructor]
        // Create polyline map object
        List<GlobalPoint> points = new ArrayList<>();
        points.add(new GlobalPoint(100.0, 110.0));
        points.add(new GlobalPoint(105.0, 115.0));
        points.add(new GlobalPoint(110.0, 120.0));
        points.add(new GlobalPoint(115.0, 125.0));
                LocationPolyline locationPolyline = new LocationPolyline(points, 0);
        polylineMapObject = locationWindow.addPolylineMapObject();
        System.out.println("Created polyline map object with " + points.size() + " points");
        // [java_PolylineMapObject_constructor]
 
        // [java_PolylineMapObject_getPolyline]
        // Access polyline
        LocationPolyline polylineShape = polylineMapObject.getPolyLine();
        System.out.println("Polyline has " + polylineShape.getPoints().size() + " points");
        // [java_PolylineMapObject_getPolyline]
 
        // [java_LocationWindow_addPolylineMapObject]
        // Add polyline map object
        polylineMapObject = locationWindow.addPolylineMapObject();
        System.out.println("Added polyline map object");
        // [java_LocationWindow_addPolylineMapObject]
 
        if (polylineMapObject != null) {
            // [java_PolylineMapObject_setPolyLine]
            // Set polyline geometry
            List<GlobalPoint> polylinePoints = new ArrayList<>();
            polylinePoints.add(new GlobalPoint(0.0, 0.0));
            polylinePoints.add(new GlobalPoint(50.0, 50.0));
            polylinePoints.add(new GlobalPoint(100.0, 0.0));
            polylinePoints.add(new GlobalPoint(150.0, 50.0));
                        LocationPolyline locationPolyline = new LocationPolyline(polylinePoints, 0);
            boolean success = polylineMapObject.setPolyLine(locationPolyline);
            System.out.println("Set polyline geometry: " + success);
            // [java_PolylineMapObject_setPolyLine]
 
            // [java_PolylineMapObject_setDrawnFraction]
            polylineMapObject.setDrawnFraction(0f);
            // [java_PolylineMapObject_setDrawnFraction]
 
            // [java_PolylineMapObject_setDrawnFractionAnimated]
            boolean grew = polylineMapObject.setDrawnFractionAnimated(1f, 1.0f, AnimationType.LINEAR);
            System.out.println("Polyline grow started: " + grew);
            // [java_PolylineMapObject_setDrawnFractionAnimated]
 
            // [java_PolylineMapObject_drawnFraction]
            System.out.println("Drawn fraction: " + polylineMapObject.drawnFraction());
            // [java_PolylineMapObject_drawnFraction]
 
            // [java_PolylineMapObject_setWidth]
            // Set polyline width
            boolean widthSuccess = polylineMapObject.setWidth(3.0);
            System.out.println("Set polyline width to 3.0 pixels: " + widthSuccess);
            // [java_PolylineMapObject_setWidth]
 
            // [java_PolylineMapObject_setColor]
            // Set polyline color
            boolean colorSuccess = polylineMapObject.setColor(0xE6FF8000);
            System.out.println("Set polyline color to orange with 90% opacity: " + colorSuccess);
            // [java_PolylineMapObject_setColor]
 
            // [java_PolylineMapObject_setDashLength]
            // Set dash segment length
            boolean dashSuccess = polylineMapObject.setDashLength(3.0);
            System.out.println("Set polyline dash length: " + dashSuccess);
            // [java_PolylineMapObject_setDashLength]
 
            // [java_PolylineMapObject_dashLength]
            // Get dash segment length
            double dashLength = polylineMapObject.dashLength();
            System.out.println("Polyline dash length: " + dashLength);
            // [java_PolylineMapObject_dashLength]
 
            // [java_PolylineMapObject_setGapLength]
            // Set gap length between dashes
            boolean gapSuccess = polylineMapObject.setGapLength(1.0);
            System.out.println("Set polyline gap length: " + gapSuccess);
            // [java_PolylineMapObject_setGapLength]
 
            // [java_PolylineMapObject_gapLength]
            // Get gap length between dashes
            double gapLength = polylineMapObject.gapLength();
            System.out.println("Polyline gap length: " + gapLength);
            // [java_PolylineMapObject_gapLength]
 
            // [java_PolylineMapObject_setOrder]
            // Set rendering order
            boolean orderSuccess = polylineMapObject.setOrder(2);
            System.out.println("Set rendering order to 2: " + orderSuccess);
            // [java_PolylineMapObject_setOrder]
 
            // [java_PolylineMapObject_setCapType]
            // Set cap type
            boolean capSuccess = polylineMapObject.setCapType(CapType.ROUND);
            System.out.println("Set cap type to ROUND: " + capSuccess);
            // [java_PolylineMapObject_setCapType]
 
            // [java_PolylineMapObject_setJoinType]
            // Set join type
            boolean joinSuccess = polylineMapObject.setJoinType(JoinType.ROUND);
            System.out.println("Set join type to ROUND: " + joinSuccess);
            // [java_PolylineMapObject_setJoinType]
 
            // [java_PolylineMapObject_setMiterLimit]
            // Set miter limit
            boolean miterSuccess = polylineMapObject.setMiterLimit(5.0);
            System.out.println("Set miter limit to 5.0: " + miterSuccess);
            // [java_PolylineMapObject_setMiterLimit]
 
            // [java_PolylineMapObject_setVisible]
            // Set visibility
            boolean visibleSuccess = polylineMapObject.setVisible(true);
            System.out.println("Set polyline visibility to true: " + visibleSuccess);
            // [java_PolylineMapObject_setVisible]
 
            // [java_PolylineMapObject_getMapObjectType]
            // Get map object type
            MapObjectType objectType = polylineMapObject.getMapObjectType();
            System.out.println("Polyline map object type: " + objectType);
            // [java_PolylineMapObject_getMapObjectType]
 
            // [java_MapObject_setAlpha_3]
            // Set alpha transparency
            boolean alphaSuccess = polylineMapObject.setAlpha(0.7);
            System.out.println("Set polyline alpha to 0.7: " + alphaSuccess);
            // [java_MapObject_setAlpha_3]
 
            // [java_MapObject_setInteractive_3]
            // Set interactive mode
            boolean interactiveSuccess = polylineMapObject.setInteractive(true);
            System.out.println("Set polyline interactive to true: " + interactiveSuccess);
            // [java_MapObject_setInteractive_3]
 
            // [java_MapObject_setTitle_3]
            // Set title
            boolean titleSuccess = polylineMapObject.setTitle("Polyline Object");
            System.out.println("Set polyline title to 'Polyline Object': " + titleSuccess);
            // [java_MapObject_setTitle_3]
 
            // [java_MapObject_setData_3]
            // Set custom data
            Map<String, Object> customData = new HashMap<>();
            customData.put("key", "value");
            customData.put("number", 42);
            boolean dataSuccess = polylineMapObject.setData(customData);
            System.out.println("Set polyline custom data: " + dataSuccess);
            // [java_MapObject_setData_3]
 
            // [java_MapObject_getId_3]
            // Get object ID
            int objectId = polylineMapObject.getId();
            System.out.println("Polyline object ID: " + objectId);
            // [java_MapObject_getId_3]
 
            // [java_MapObject_getType_3]
            // Get object type
            String objectTypeString = polylineMapObject.getType();
            System.out.println("Polyline object type: " + objectTypeString);
            // [java_MapObject_getType_3]
 
            // [java_MapObject_getData_3]
            // Get custom data
            Map<String, Object> retrievedData = polylineMapObject.getData();
            System.out.println("Polyline custom data: " + retrievedData);
            // [java_MapObject_getData_3]
 
            // [java_PolylineMapObject_setOutlineWidth]
            // Set polyline outline width
            boolean outlineWidthSuccess2 = polylineMapObject.setOutlineWidth(1.0);
            System.out.println("Set polyline outline width to 1.0 pixels: " + outlineWidthSuccess2);
            // [java_PolylineMapObject_setOutlineWidth]
 
            // [java_PolylineMapObject_setOutlineColor]
            // Set polyline outline color
            boolean outlineColorSuccess2 = polylineMapObject.setOutlineColor(0xFF000000);
            System.out.println("Set polyline outline color to black: " + outlineColorSuccess2);
            // [java_PolylineMapObject_setOutlineColor]
 
            // [java_PolylineMapObject_setOutlineAlpha]
            // Set polyline outline alpha
            boolean outlineAlphaSuccess2 = polylineMapObject.setOutlineAlpha(0.5);
            System.out.println("Set polyline outline alpha to 0.5: " + outlineAlphaSuccess2);
            // [java_PolylineMapObject_setOutlineAlpha]
 
            // [java_PolylineMapObject_setOutlineOrder]
            // Set polyline outline rendering order
            boolean outlineOrderSuccess2 = polylineMapObject.setOutlineOrder(0);
            System.out.println("Set polyline outline rendering order to 0: " + outlineOrderSuccess2);
            // [java_PolylineMapObject_setOutlineOrder]
 
            // [java_PolylineMapObject_setOutlineCapType]
            // Set polyline outline cap type
            boolean outlineCapTypeSuccess2 = polylineMapObject.setOutlineCapType(CapType.SQUARE);
            System.out.println("Set polyline outline cap type to SQUARE: " + outlineCapTypeSuccess2);
            // [java_PolylineMapObject_setOutlineCapType]
 
            // [java_PolylineMapObject_setOutlineJoinType]
            // Set polyline outline join type
            boolean outlineJoinTypeSuccess2 = polylineMapObject.setOutlineJoinType(JoinType.MITER);
            System.out.println("Set polyline outline join type to MITER: " + outlineJoinTypeSuccess2);
            // [java_PolylineMapObject_setOutlineJoinType]
 
            // [java_PolylineMapObject_setOutlineMiterLimit]
            // Set polyline outline miter limit
            boolean outlineMiterLimitSuccess2 = polylineMapObject.setOutlineMiterLimit(3.0);
            System.out.println("Set polyline outline miter limit to 3.0: " + outlineMiterLimitSuccess2);
            // [java_PolylineMapObject_setOutlineMiterLimit]
        }
 
        // [java_LocationWindow_removePolylineMapObject]
        // Remove polyline map object
        if (polylineMapObject != null) {
            boolean removed = locationWindow.removePolylineMapObject(polylineMapObject);
            System.out.println("Removed polyline map object: " + removed);
            polylineMapObject = null;
        }
        // [java_LocationWindow_removePolylineMapObject]
 
        // Test multiple polyline objects
        List<PolylineMapObject> polylines = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            PolylineMapObject polyline = locationWindow.addPolylineMapObject();
            if (polyline != null) {
                List<GlobalPoint> points = new ArrayList<>();
                points.add(new GlobalPoint(i * 30.0, i * 30.0));
                points.add(new GlobalPoint((i + 1) * 30.0, (i + 1) * 30.0));
                                LocationPolyline locPoly = new LocationPolyline(points, 0);
                polyline.setPolyLine(locPoly);
                polyline.setWidth(2.0 + i);
                polyline.setColor(0xCC00FFFF);
                polylines.add(polyline);
                System.out.println("Created polyline " + i + " with width " + (2.0 + i));
            }
        }
 
        for (int i = 0; i < polylines.size(); i++) {
            locationWindow.removePolylineMapObject(polylines.get(i));
            System.out.println("Removed polyline " + i);
        }
    }

    private void demonstrateDottedPolylineMapObjects() {
        System.out.println("--- Dotted Polyline Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // [java_DottedPolylineMapObject_constructor]
        // Create dotted polyline map object
        List<GlobalPoint> points = new ArrayList<>();
        points.add(new GlobalPoint(160.0, 170.0));
        points.add(new GlobalPoint(165.0, 175.0));
        points.add(new GlobalPoint(170.0, 180.0));
        points.add(new GlobalPoint(175.0, 185.0));
                LocationPolyline locationPolyline = new LocationPolyline(points, 0);
        dottedPolylineMapObject = locationWindow.addDottedPolylineMapObject();
        System.out.println("Created dotted polyline map object with " + points.size() + " points");
        // [java_DottedPolylineMapObject_constructor]
 
        // [java_DottedPolylineMapObject_getPolyline]
        // Access dotted polyline
        LocationPolyline dottedPolylineShape = dottedPolylineMapObject.getPolyLine();
        System.out.println("Dotted polyline has " + dottedPolylineShape.getPoints().size() + " points");
        // [java_DottedPolylineMapObject_getPolyline]
 
        // [java_LocationWindow_addDottedPolylineMapObject]
        // Add dotted polyline map object
        dottedPolylineMapObject = locationWindow.addDottedPolylineMapObject();
        System.out.println("Added dotted polyline map object");
        // [java_LocationWindow_addDottedPolylineMapObject]
 
        if (dottedPolylineMapObject != null) {
            // [java_DottedPolylineMapObject_setPolyline]
            // Set dotted polyline geometry
            List<GlobalPoint> dottedPoints = new ArrayList<>();
            dottedPoints.add(new GlobalPoint(0.0, 100.0));
            dottedPoints.add(new GlobalPoint(50.0, 150.0));
            dottedPoints.add(new GlobalPoint(100.0, 100.0));
            dottedPoints.add(new GlobalPoint(150.0, 150.0));
                        LocationPolyline locationDottedPolyline = new LocationPolyline(dottedPoints, 0);
            boolean success = dottedPolylineMapObject.setPolyLine(locationDottedPolyline);
            System.out.println("Set dotted polyline geometry: " + success);
            // [java_DottedPolylineMapObject_setPolyline]
 
            // [java_DottedPolylineMapObject_setWidth]
            // Set dotted polyline width
            boolean widthSuccess = dottedPolylineMapObject.setWidth(2.0);
            System.out.println("Set dotted polyline width to 2.0 pixels: " + widthSuccess);
            // [java_DottedPolylineMapObject_setWidth]
 
            // [java_DottedPolylineMapObject_setColor]
            // Set dotted polyline color
            boolean colorSuccess = dottedPolylineMapObject.setColor(0xCC8000FF);
            System.out.println("Set dotted polyline color to purple with 80% opacity: " + colorSuccess);
            // [java_DottedPolylineMapObject_setColor]
 
            // [java_DottedPolylineMapObject_setOrder]
            // Set rendering order
            boolean orderSuccess = dottedPolylineMapObject.setOrder(3);
            System.out.println("Set rendering order to 3: " + orderSuccess);
            // [java_DottedPolylineMapObject_setOrder]
 
            // [java_DottedPolylineMapObject_setVisible]
            // Set visibility
            boolean visibleSuccess = dottedPolylineMapObject.setVisible(true);
            System.out.println("Set dotted polyline visibility to true: " + visibleSuccess);
            // [java_DottedPolylineMapObject_setVisible]
 
            // [java_DottedPolylineMapObject_getMapObjectType]
            // Get map object type
            MapObjectType objectType = dottedPolylineMapObject.getMapObjectType();
            System.out.println("Dotted polyline map object type: " + objectType);
            // [java_DottedPolylineMapObject_getMapObjectType]
 
            // [java_MapObject_setAlpha_4]
            // Set alpha transparency
            boolean alphaSuccess = dottedPolylineMapObject.setAlpha(0.8);
            System.out.println("Set dotted polyline alpha to 0.8: " + alphaSuccess);
            // [java_MapObject_setAlpha_4]
 
            // [java_MapObject_setInteractive_4]
            // Set interactive mode
            boolean interactiveSuccess = dottedPolylineMapObject.setInteractive(true);
            System.out.println("Set dotted polyline interactive to true: " + interactiveSuccess);
            // [java_MapObject_setInteractive_4]
 
            // [java_MapObject_setTitle_4]
            // Set title
            boolean titleSuccess = dottedPolylineMapObject.setTitle("Dotted Polyline Object");
            System.out.println("Set dotted polyline title to 'Dotted Polyline Object': " + titleSuccess);
            // [java_MapObject_setTitle_4]
 
            // [java_MapObject_setData_4]
            // Set custom data
            Map<String, Object> customData = new HashMap<>();
            customData.put("key", "value");
            customData.put("number", 42);
            boolean dataSuccess = dottedPolylineMapObject.setData(customData);
            System.out.println("Set dotted polyline custom data: " + dataSuccess);
            // [java_MapObject_setData_4]
 
            // [java_MapObject_getId_4]
            // Get object ID
            int objectId = dottedPolylineMapObject.getId();
            System.out.println("Dotted polyline object ID: " + objectId);
            // [java_MapObject_getId_4]
 
            // [java_MapObject_getType_4]
            // Get object type
            String objectTypeString = dottedPolylineMapObject.getType();
            System.out.println("Dotted polyline object type: " + objectTypeString);
            // [java_MapObject_getType_4]
 
            // [java_MapObject_getData_4]
            // Get custom data
            Map<String, Object> retrievedData = dottedPolylineMapObject.getData();
            System.out.println("Dotted polyline custom data: " + retrievedData);
            // [java_MapObject_getData_4]
 
            // [java_DottedPolylineMapObject_setCollisionEnabled]
            // Enable collision detection
            boolean dottedCollisionSuccess = dottedPolylineMapObject.setCollisionEnabled(true);
            System.out.println("Enabled collision detection for dotted polyline: " + dottedCollisionSuccess);
            // [java_DottedPolylineMapObject_setCollisionEnabled]
 
            // [java_DottedPolylineMapObject_setPlacement]
            // Set placement type
            boolean dottedPlacementSuccess = dottedPolylineMapObject.setPlacement(Placement.CENTER);
            System.out.println("Set dotted polyline placement to CENTER: " + dottedPlacementSuccess);
            // [java_DottedPolylineMapObject_setPlacement]
 
            // [java_DottedPolylineMapObject_setPlacementMinRatio]
            // Set placement min ratio
            boolean dottedMinRatioSuccess = dottedPolylineMapObject.setPlacementMinRatio(0.5);
            System.out.println("Set dotted polyline placement min ratio to 0.5: " + dottedMinRatioSuccess);
            // [java_DottedPolylineMapObject_setPlacementMinRatio]
 
            // [java_DottedPolylineMapObject_setPlacementSpacing]
            // Set placement spacing
            boolean dottedSpacingSuccess = dottedPolylineMapObject.setPlacementSpacing(10.0);
            System.out.println("Set dotted polyline placement spacing to 10.0: " + dottedSpacingSuccess);
            // [java_DottedPolylineMapObject_setPlacementSpacing]
 
            // [java_DottedPolylineMapObject_setPriority]
            // Set rendering priority
            boolean dottedPrioritySuccess = dottedPolylineMapObject.setPriority(1);
            System.out.println("Set dotted polyline rendering priority to 1: " + dottedPrioritySuccess);
            // [java_DottedPolylineMapObject_setPriority]
 
            // [java_DottedPolylineMapObject_setRepeatDistance]
            // Set repeat distance
            boolean dottedRepeatDistanceSuccess = dottedPolylineMapObject.setRepeatDistance(20.0);
            System.out.println("Set dotted polyline repeat distance to 20.0: " + dottedRepeatDistanceSuccess);
            // [java_DottedPolylineMapObject_setRepeatDistance]
 
            // [java_DottedPolylineMapObject_setRepeatGroup]
            // Set repeat group
            boolean dottedRepeatGroupSuccess = dottedPolylineMapObject.setRepeatGroup(1);
            System.out.println("Set dotted polyline repeat group to 1: " + dottedRepeatGroupSuccess);
            // [java_DottedPolylineMapObject_setRepeatGroup]
 
            // [java_DottedPolylineMapObject_setSize]
            // Set size
            Size dottedSize = new Size(16.0, 16.0);
            boolean dottedSizeSuccess = dottedPolylineMapObject.setSize(dottedSize);
            System.out.println("Set dotted polyline size to (" + dottedSize.getWidth() + ", " + dottedSize.getHeight() + "): " + dottedSizeSuccess);
            // [java_DottedPolylineMapObject_setSize]
        }
 
        // [java_LocationWindow_removeDottedPolylineMapObject]
        // Remove dotted polyline map object
        if (dottedPolylineMapObject != null) {
            boolean removed = locationWindow.removeDottedPolylineMapObject(dottedPolylineMapObject);
            System.out.println("Removed dotted polyline map object: " + removed);
            dottedPolylineMapObject = null;
        }
        // [java_LocationWindow_removeDottedPolylineMapObject]
 
        // Test multiple dotted polyline objects
        List<DottedPolylineMapObject> dottedPolylines = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            DottedPolylineMapObject dottedPolyline = locationWindow.addDottedPolylineMapObject();
            if (dottedPolyline != null) {
                List<GlobalPoint> points = new ArrayList<>();
                points.add(new GlobalPoint(i * 40.0, i * 40.0 + 100.0));
                points.add(new GlobalPoint((i + 1) * 40.0, (i + 1) * 40.0 + 100.0));
                                LocationPolyline locPoly = new LocationPolyline(points, 0);
                dottedPolyline.setPolyLine(locPoly);
                dottedPolyline.setWidth(1.5);
                dottedPolyline.setColor(0x99FF00FF);
                dottedPolylines.add(dottedPolyline);
                System.out.println("Created dotted polyline " + i);
            }
        }
 
        for (int i = 0; i < dottedPolylines.size(); i++) {
            locationWindow.removeDottedPolylineMapObject(dottedPolylines.get(i));
            System.out.println("Removed dotted polyline " + i);
        }
    }

    private void demonstrateRemoveAllMapObjects() {
        System.out.println("--- Remove All Map Objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available yet");
            return;
        }
 
        // Create various map objects
        CircleMapObject circle = locationWindow.addCircleMapObject();
        IconMapObject icon = locationWindow.addIconMapObject();
        PolygonMapObject polygon = locationWindow.addPolygonMapObject();
        PolylineMapObject polyline = locationWindow.addPolylineMapObject();
        DottedPolylineMapObject dottedPolyline = locationWindow.addDottedPolylineMapObject();
 
        System.out.println("Created 5 map objects");
 
        // [java_LocationWindow_removeAllMapObjects]
        // Remove all map objects
        locationWindow.removeAllMapObjects();
        System.out.println("Removed all map objects");
        // [java_LocationWindow_removeAllMapObjects]
    }

    private void demonstrateClusterMapObjects() {
        System.out.println("--- Cluster map objects ---");
 
        if (locationWindow == null) {
            System.out.println("LocationWindow not available");
            return;
        }
 
        // [java_LocationWindow_addClusterMapObjectController]
        clusterMapObjectController = locationWindow.addClusterMapObjectController();
        System.out.println("Added cluster map object controller");
        // [java_LocationWindow_addClusterMapObjectController]
 
        if (clusterMapObjectController == null) {
            return;
        }
 
        IconMapObject clusterIcon1 = locationWindow.addIconMapObject();
        IconMapObject clusterIcon2 = locationWindow.addIconMapObject();
        if (clusterIcon1 != null) {
            clusterIcon1.setPosition(new GlobalPoint(100.0, 100.0));
        }
        if (clusterIcon2 != null) {
            clusterIcon2.setPosition(new GlobalPoint(105.0, 102.0));
        }
 
        // [java_ClusterMapObjectController_addIconMapObject]
        boolean added1 = clusterMapObjectController.addIconMapObject(clusterIcon1);
        boolean added2 = clusterMapObjectController.addIconMapObject(clusterIcon2);
        System.out.println("Registered icons for clustering: " + added1 + ", " + added2);
        // [java_ClusterMapObjectController_addIconMapObject]
 
        // [java_ClusterMapObjectController_setEnabled]
        clusterMapObjectController.setEnabled(true);
        System.out.println("Clustering enabled");
        // [java_ClusterMapObjectController_setEnabled]
 
        // [java_ClusterMapObjectController_isEnabled]
        boolean clusteringEnabled = clusterMapObjectController.isEnabled();
        System.out.println("Clustering is enabled: " + clusteringEnabled);
        // [java_ClusterMapObjectController_isEnabled]
 
        // [java_ClusterMapObjectController_setRadius]
        clusterMapObjectController.setRadius(40.0f);
        System.out.println("Set cluster radius to 40 px");
        // [java_ClusterMapObjectController_setRadius]
 
        // [java_ClusterMapObjectController_getRadius]
        float clusterRadius = clusterMapObjectController.getRadius();
        System.out.println("Cluster radius: " + clusterRadius);
        // [java_ClusterMapObjectController_getRadius]
 
        // [java_ClusterMapObjectController_setInteractive]
        boolean interactiveSuccess = clusterMapObjectController.setInteractive(true);
        System.out.println("Set cluster markers interactive: " + interactiveSuccess);
        // [java_ClusterMapObjectController_setInteractive]
 
        // [java_ClusterMapObjectController_setClusterSize]
        boolean sizeSuccess = clusterMapObjectController.setClusterSize(32.0f, 32.0f);
        System.out.println("Set default cluster icon size: " + sizeSuccess);
        // [java_ClusterMapObjectController_setClusterSize]
 
        clusterMapObjectControllerListener = new DemoClusterMapObjectControllerListener();
 
        // [java_ClusterMapObjectController_addListener]
        clusterMapObjectController.addListener(clusterMapObjectControllerListener);
        System.out.println("Added cluster map object controller listener");
        // [java_ClusterMapObjectController_addListener]
 
        // [java_ClusterMapObjectController_getClusters]
        List<ClusterMapObject> clusters = clusterMapObjectController.getClusters();
        System.out.println("Visible clusters: " + clusters.size());
        // [java_ClusterMapObjectController_getClusters]
 
        if (!clusters.isEmpty()) {
            ClusterMapObject cluster = clusters.get(0);
            // [java_ClusterMapObject_setBitmap]
            ImageProvider clusterBitmap = ImageProvider.fromFile("/path/to/cluster.png", true);
            boolean bitmapSuccess = cluster.setBitmap(clusterBitmap);
            System.out.println("Set cluster bitmap from ImageProvider: " + bitmapSuccess);
            // [java_ClusterMapObject_setBitmap]
        }
 
        // [java_ClusterMapObjectController_removeListener]
        clusterMapObjectController.removeListener(clusterMapObjectControllerListener);
        System.out.println("Removed cluster map object controller listener");
        // [java_ClusterMapObjectController_removeListener]
 
        if (clusterIcon1 != null) {
            // [java_ClusterMapObjectController_removeIconMapObject]
            boolean removed = clusterMapObjectController.removeIconMapObject(clusterIcon1);
            System.out.println("Removed icon from cluster controller: " + removed);
            // [java_ClusterMapObjectController_removeIconMapObject]
            locationWindow.removeIconMapObject(clusterIcon1);
        }
        if (clusterIcon2 != null) {
            locationWindow.removeIconMapObject(clusterIcon2);
        }
 
        // [java_ClusterMapObjectController_clear]
        clusterMapObjectController.clear();
        System.out.println("Cleared cluster controller");
        // [java_ClusterMapObjectController_clear]
 
        // [java_LocationWindow_removeClusterMapObjectController]
        boolean controllerRemoved =
            locationWindow.removeClusterMapObjectController(clusterMapObjectController);
        System.out.println("Removed cluster map object controller: " + controllerRemoved);
        // [java_LocationWindow_removeClusterMapObjectController]
 
        clusterMapObjectController = null;
        clusterMapObjectControllerListener = null;
    }

    public void cleanup() {
        if (circleMapObject != null) {
            locationWindow.removeCircleMapObject(circleMapObject);
            circleMapObject = null;
        }
        if (iconMapObject != null) {
            locationWindow.removeIconMapObject(iconMapObject);
            iconMapObject = null;
        }
        if (polygonMapObject != null) {
            // Polygon objects are removed automatically when LocationWindow is destroyed
            polygonMapObject = null;
        }
        if (polylineMapObject != null) {
            locationWindow.removePolylineMapObject(polylineMapObject);
            polylineMapObject = null;
        }
        if (dottedPolylineMapObject != null) {
            locationWindow.removeDottedPolylineMapObject(dottedPolylineMapObject);
            dottedPolylineMapObject = null;
        }
        if (modelMapObject != null) {
            locationWindow.removeModelMapObject(modelMapObject);
            modelMapObject = null;
        }
        System.out.println("LocationWindowMapObjects example cleanup completed");
    }
}
 
class DemoClusterMapObjectControllerListener implements ClusterMapObjectControllerListener {
    private final ClusterMapObjectListener clusterChangeListener = new DemoClusterMapObjectListener();
    private ClusterMapObject activeCluster;
 
    // [java_ClusterMapObjectControllerListener_onClusterCreated]
    @Override
    public void onClusterCreated(ClusterMapObjectController controller, ClusterMapObject cluster) {
        // [java_ClusterMapObject_addListener]
        cluster.addListener(clusterChangeListener);
        System.out.println("Added cluster change listener, initial count: " + cluster.getCount());
        // [java_ClusterMapObject_addListener]
        activeCluster = cluster;
    }
    // [java_ClusterMapObjectControllerListener_onClusterCreated]
 
    // [java_ClusterMapObjectControllerListener_onClusterDestroyed]
    @Override
    public void onClusterDestroyed(ClusterMapObjectController controller, int clusterId) {
        if (activeCluster != null && activeCluster.getId() == clusterId) {
            // [java_ClusterMapObject_removeListener]
            activeCluster.removeListener(clusterChangeListener);
            System.out.println("Removed cluster change listener");
            // [java_ClusterMapObject_removeListener]
            activeCluster = null;
        }
        System.out.println("Cluster destroyed, id: " + clusterId);
    }
    // [java_ClusterMapObjectControllerListener_onClusterDestroyed]
}
 
class DemoClusterMapObjectListener implements ClusterMapObjectListener {
 
    // [java_ClusterMapObjectListener_onClusterChanged]
    @Override
    public void onClusterChanged(ClusterMapObject cluster) {
        int memberCount = cluster.getCount();
        System.out.println("Cluster changed, member count: " + memberCount);
    }
    // [java_ClusterMapObjectListener_onClusterChanged]
}
 
// Main class
class Main {
    public static void main(String[] args) {
        LocationWindowMapObjectsExample example = new LocationWindowMapObjectsExample();
    }
}