LocationWindow.java

Go to the documentation of this file.

package com.navigine.idl.java;
 
import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicBoolean;

public abstract class LocationWindow {
    public abstract void setSublocationId(int id);

    public abstract Point screenPositionToMeters(android.graphics.PointF point);

    public abstract android.graphics.PointF metersToScreenPosition(Point point, boolean clipToViewport);

    public abstract CircleMapObject addCircleMapObject();

    public abstract boolean removeCircleMapObject(CircleMapObject circleMapObject);

    public abstract IconMapObject addIconMapObject();

    public abstract boolean removeIconMapObject(IconMapObject iconMapObject);

    public abstract FlatIconMapObject addFlatIconMapObject();

    public abstract boolean removeFlatIconMapObject(FlatIconMapObject flatIconMapObject);

    public abstract PolygonMapObject addPolygonMapObject();

    public abstract boolean removePolygonMapObject(PolygonMapObject polygonMapObject);

    public abstract PolylineMapObject addPolylineMapObject();

    public abstract boolean removePolylineMapObject(PolylineMapObject polylineMapObject);

    public abstract void removeAllMapObjects();

    public abstract void pickMapObjectAt(android.graphics.PointF point);

    public abstract void pickMapFeatureAt(android.graphics.PointF point);

    public abstract void addPickListener(PickListener listener);

    public abstract void removePickListener(PickListener listener);

    public abstract void addInputListener(InputListener listener);

    public abstract void removeInputListener(InputListener listener);

    public abstract void addCameraListener(CameraListener listener);

    public abstract void removeCameraListener(CameraListener listener);

    public abstract void flyTo(Camera camera, int duration, CameraCallback callback);

    public abstract boolean selectMapFeature(String featureId);

    public abstract boolean deselectMapFeature(String featureId);

    public abstract void deselectAllMapFeatures();

    public abstract void applyFilter(String filter, String layer);

    public abstract void moveTo(Camera camera, int duration, AnimationType animationType, CameraCallback callback);

    public abstract float getZoomFactor();

    public abstract void setZoomFactor(float newZoomFactor);

    public abstract float getMinZoomFactor();

    public abstract void setMinZoomFactor(float newMinZoomFactor);

    public abstract float getMaxZoomFactor();

    public abstract void setMaxZoomFactor(float newMaxZoomFactor);

    public abstract boolean getStickToBorder();

    public abstract void setStickToBorder(boolean newStickToBorder);

    public abstract Camera getCamera();

    public abstract void setCamera(Camera newCamera);

    public abstract boolean getRotateGestureEnabled();

    public abstract void setRotateGestureEnabled(boolean newRotateGestureEnabled);

    public abstract boolean getTiltGesturesEnabled();

    public abstract void setTiltGesturesEnabled(boolean newTiltGesturesEnabled);

    public abstract boolean getScrollGesturesEnabled();

    public abstract void setScrollGesturesEnabled(boolean newScrollGesturesEnabled);

    public abstract boolean getZoomGesturesEnabled();

    public abstract void setZoomGesturesEnabled(boolean newZoomGesturesEnabled);

    public abstract float getPickRadius();

    public abstract void setPickRadius(float newPickRadius);

    public abstract ArrayList<String> getSelectedMapFeatures();
 
    public static void setDebugFlag(DebugFlag flag, boolean on)
    {
        CppProxy.setDebugFlag(flag,
                              on);
    }
 
    public static boolean getDebugFlag(DebugFlag flag)
    {
        return CppProxy.getDebugFlag(flag);
    }
 
    private static final class CppProxy extends LocationWindow
    {
        private final long nativeRef;
        private final AtomicBoolean destroyed = new AtomicBoolean(false);
 
        private CppProxy(long nativeRef)
        {
            if (nativeRef == 0) throw new RuntimeException("nativeRef is zero");
            this.nativeRef = nativeRef;
        }
 
        private native void nativeDestroy(long nativeRef);
        public void _djinni_private_destroy()
        {
            boolean destroyed = this.destroyed.getAndSet(true);
            if (!destroyed) nativeDestroy(this.nativeRef);
        }
        protected void finalize() throws java.lang.Throwable
        {
            _djinni_private_destroy();
            super.finalize();
        }
 
        // LocationWindow methods
 
        @Override
        public void setSublocationId(int id)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setSublocationId(this.nativeRef, id);
        }
        private native void native_setSublocationId(long _nativeRef, int id);
 
        @Override
        public Point screenPositionToMeters(android.graphics.PointF point)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_screenPositionToMeters(this.nativeRef, point);
        }
        private native Point native_screenPositionToMeters(long _nativeRef, android.graphics.PointF point);
 
        @Override
        public android.graphics.PointF metersToScreenPosition(Point point, boolean clipToViewport)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_metersToScreenPosition(this.nativeRef, point, clipToViewport);
        }
        private native android.graphics.PointF native_metersToScreenPosition(long _nativeRef, Point point, boolean clipToViewport);
 
        @Override
        public CircleMapObject addCircleMapObject()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_addCircleMapObject(this.nativeRef);
        }
        private native CircleMapObject native_addCircleMapObject(long _nativeRef);
 
        @Override
        public boolean removeCircleMapObject(CircleMapObject circleMapObject)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_removeCircleMapObject(this.nativeRef, circleMapObject);
        }
        private native boolean native_removeCircleMapObject(long _nativeRef, CircleMapObject circleMapObject);
 
        @Override
        public IconMapObject addIconMapObject()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_addIconMapObject(this.nativeRef);
        }
        private native IconMapObject native_addIconMapObject(long _nativeRef);
 
        @Override
        public boolean removeIconMapObject(IconMapObject iconMapObject)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_removeIconMapObject(this.nativeRef, iconMapObject);
        }
        private native boolean native_removeIconMapObject(long _nativeRef, IconMapObject iconMapObject);
 
        @Override
        public FlatIconMapObject addFlatIconMapObject()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_addFlatIconMapObject(this.nativeRef);
        }
        private native FlatIconMapObject native_addFlatIconMapObject(long _nativeRef);
 
        @Override
        public boolean removeFlatIconMapObject(FlatIconMapObject flatIconMapObject)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_removeFlatIconMapObject(this.nativeRef, flatIconMapObject);
        }
        private native boolean native_removeFlatIconMapObject(long _nativeRef, FlatIconMapObject flatIconMapObject);
 
        @Override
        public PolygonMapObject addPolygonMapObject()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_addPolygonMapObject(this.nativeRef);
        }
        private native PolygonMapObject native_addPolygonMapObject(long _nativeRef);
 
        @Override
        public boolean removePolygonMapObject(PolygonMapObject polygonMapObject)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_removePolygonMapObject(this.nativeRef, polygonMapObject);
        }
        private native boolean native_removePolygonMapObject(long _nativeRef, PolygonMapObject polygonMapObject);
 
        @Override
        public PolylineMapObject addPolylineMapObject()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_addPolylineMapObject(this.nativeRef);
        }
        private native PolylineMapObject native_addPolylineMapObject(long _nativeRef);
 
        @Override
        public boolean removePolylineMapObject(PolylineMapObject polylineMapObject)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_removePolylineMapObject(this.nativeRef, polylineMapObject);
        }
        private native boolean native_removePolylineMapObject(long _nativeRef, PolylineMapObject polylineMapObject);
 
        @Override
        public void removeAllMapObjects()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_removeAllMapObjects(this.nativeRef);
        }
        private native void native_removeAllMapObjects(long _nativeRef);
 
        @Override
        public void pickMapObjectAt(android.graphics.PointF point)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_pickMapObjectAt(this.nativeRef, point);
        }
        private native void native_pickMapObjectAt(long _nativeRef, android.graphics.PointF point);
 
        @Override
        public void pickMapFeatureAt(android.graphics.PointF point)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_pickMapFeatureAt(this.nativeRef, point);
        }
        private native void native_pickMapFeatureAt(long _nativeRef, android.graphics.PointF point);
 
        @Override
        public void addPickListener(PickListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_addPickListener(this.nativeRef, listener);
        }
        private native void native_addPickListener(long _nativeRef, PickListener listener);
 
        @Override
        public void removePickListener(PickListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_removePickListener(this.nativeRef, listener);
        }
        private native void native_removePickListener(long _nativeRef, PickListener listener);
 
        @Override
        public void addInputListener(InputListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_addInputListener(this.nativeRef, listener);
        }
        private native void native_addInputListener(long _nativeRef, InputListener listener);
 
        @Override
        public void removeInputListener(InputListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_removeInputListener(this.nativeRef, listener);
        }
        private native void native_removeInputListener(long _nativeRef, InputListener listener);
 
        @Override
        public void addCameraListener(CameraListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_addCameraListener(this.nativeRef, listener);
        }
        private native void native_addCameraListener(long _nativeRef, CameraListener listener);
 
        @Override
        public void removeCameraListener(CameraListener listener)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_removeCameraListener(this.nativeRef, listener);
        }
        private native void native_removeCameraListener(long _nativeRef, CameraListener listener);
 
        @Override
        public void flyTo(Camera camera, int duration, CameraCallback callback)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_flyTo(this.nativeRef, camera, duration, callback);
        }
        private native void native_flyTo(long _nativeRef, Camera camera, int duration, CameraCallback callback);
 
        @Override
        public boolean selectMapFeature(String featureId)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_selectMapFeature(this.nativeRef, featureId);
        }
        private native boolean native_selectMapFeature(long _nativeRef, String featureId);
 
        @Override
        public boolean deselectMapFeature(String featureId)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_deselectMapFeature(this.nativeRef, featureId);
        }
        private native boolean native_deselectMapFeature(long _nativeRef, String featureId);
 
        @Override
        public void deselectAllMapFeatures()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_deselectAllMapFeatures(this.nativeRef);
        }
        private native void native_deselectAllMapFeatures(long _nativeRef);
 
        @Override
        public void applyFilter(String filter, String layer)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_applyFilter(this.nativeRef, filter, layer);
        }
        private native void native_applyFilter(long _nativeRef, String filter, String layer);
 
        @Override
        public void moveTo(Camera camera, int duration, AnimationType animationType, CameraCallback callback)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_moveTo(this.nativeRef, camera, duration, animationType, callback);
        }
        private native void native_moveTo(long _nativeRef, Camera camera, int duration, AnimationType animationType, CameraCallback callback);
 
        @Override
        public float getZoomFactor()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getZoomFactor(this.nativeRef);
        }
        private native float native_getZoomFactor(long _nativeRef);
 
        @Override
        public void setZoomFactor(float newZoomFactor)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setZoomFactor(this.nativeRef, newZoomFactor);
        }
        private native void native_setZoomFactor(long _nativeRef, float newZoomFactor);
 
        @Override
        public float getMinZoomFactor()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getMinZoomFactor(this.nativeRef);
        }
        private native float native_getMinZoomFactor(long _nativeRef);
 
        @Override
        public void setMinZoomFactor(float newMinZoomFactor)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setMinZoomFactor(this.nativeRef, newMinZoomFactor);
        }
        private native void native_setMinZoomFactor(long _nativeRef, float newMinZoomFactor);
 
        @Override
        public float getMaxZoomFactor()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getMaxZoomFactor(this.nativeRef);
        }
        private native float native_getMaxZoomFactor(long _nativeRef);
 
        @Override
        public void setMaxZoomFactor(float newMaxZoomFactor)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setMaxZoomFactor(this.nativeRef, newMaxZoomFactor);
        }
        private native void native_setMaxZoomFactor(long _nativeRef, float newMaxZoomFactor);
 
        @Override
        public boolean getStickToBorder()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getStickToBorder(this.nativeRef);
        }
        private native boolean native_getStickToBorder(long _nativeRef);
 
        @Override
        public void setStickToBorder(boolean newStickToBorder)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setStickToBorder(this.nativeRef, newStickToBorder);
        }
        private native void native_setStickToBorder(long _nativeRef, boolean newStickToBorder);
 
        @Override
        public Camera getCamera()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getCamera(this.nativeRef);
        }
        private native Camera native_getCamera(long _nativeRef);
 
        @Override
        public void setCamera(Camera newCamera)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setCamera(this.nativeRef, newCamera);
        }
        private native void native_setCamera(long _nativeRef, Camera newCamera);
 
        @Override
        public boolean getRotateGestureEnabled()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getRotateGestureEnabled(this.nativeRef);
        }
        private native boolean native_getRotateGestureEnabled(long _nativeRef);
 
        @Override
        public void setRotateGestureEnabled(boolean newRotateGestureEnabled)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setRotateGestureEnabled(this.nativeRef, newRotateGestureEnabled);
        }
        private native void native_setRotateGestureEnabled(long _nativeRef, boolean newRotateGestureEnabled);
 
        @Override
        public boolean getTiltGesturesEnabled()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getTiltGesturesEnabled(this.nativeRef);
        }
        private native boolean native_getTiltGesturesEnabled(long _nativeRef);
 
        @Override
        public void setTiltGesturesEnabled(boolean newTiltGesturesEnabled)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setTiltGesturesEnabled(this.nativeRef, newTiltGesturesEnabled);
        }
        private native void native_setTiltGesturesEnabled(long _nativeRef, boolean newTiltGesturesEnabled);
 
        @Override
        public boolean getScrollGesturesEnabled()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getScrollGesturesEnabled(this.nativeRef);
        }
        private native boolean native_getScrollGesturesEnabled(long _nativeRef);
 
        @Override
        public void setScrollGesturesEnabled(boolean newScrollGesturesEnabled)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setScrollGesturesEnabled(this.nativeRef, newScrollGesturesEnabled);
        }
        private native void native_setScrollGesturesEnabled(long _nativeRef, boolean newScrollGesturesEnabled);
 
        @Override
        public boolean getZoomGesturesEnabled()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getZoomGesturesEnabled(this.nativeRef);
        }
        private native boolean native_getZoomGesturesEnabled(long _nativeRef);
 
        @Override
        public void setZoomGesturesEnabled(boolean newZoomGesturesEnabled)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setZoomGesturesEnabled(this.nativeRef, newZoomGesturesEnabled);
        }
        private native void native_setZoomGesturesEnabled(long _nativeRef, boolean newZoomGesturesEnabled);
 
        @Override
        public float getPickRadius()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getPickRadius(this.nativeRef);
        }
        private native float native_getPickRadius(long _nativeRef);
 
        @Override
        public void setPickRadius(float newPickRadius)
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            native_setPickRadius(this.nativeRef, newPickRadius);
        }
        private native void native_setPickRadius(long _nativeRef, float newPickRadius);
 
        @Override
        public ArrayList<String> getSelectedMapFeatures()
        {
            assert !this.destroyed.get() : "trying to use a destroyed object";
            return native_getSelectedMapFeatures(this.nativeRef);
        }
        private native ArrayList<String> native_getSelectedMapFeatures(long _nativeRef);
 
        public static native void setDebugFlag(DebugFlag flag, boolean on);
 
        public static native boolean getDebugFlag(DebugFlag flag);
    }
}