Skip to content
import SceneView from "@arcgis/core/views/SceneView.js";
Inheritance:
SceneViewView<LayerView>Accessor
Since
ArcGIS Maps SDK for JavaScript 4.0

Overview

A SceneView displays a 3D view of a Map or WebScene instance. To render a map and its layers in 2D, see the documentation for MapView. For a general overview of views, see View.

Various scenes

For a map to be visible to the user in the DOM, a SceneView must have both a valid Map instance and a DOM element with a non-zero height and width in which to render. Note that there must be valid data in the map, such as operational layers or a Basemap with base layers, before the view will begin rendering the map.

// Create a basic SceneView instance with a basemap and world elevation
const view = new SceneView({
// An instance of Map or WebScene
map: new Map({
basemap: "hybrid"
}),
// The id of a DOM element (may also be an actual DOM element)
container: "viewDiv"
});

Known Limitations

The number of features that can be rendered in a SceneView varies depending on the qualityProfile of the view and the complexity of each feature's geometry and symbol. Layers with a large number of features are dynamically loaded and displayed as you navigate the scene. For optimal performance, the number of displayed features is adjusted based on the complexity of the symbol and device capability. As a result, some features may not be visible in the view.

SceneView does not support rendering of Multipoint geometry.

Using the view

A SceneView may not be immediately ready for display after it has been constructed. For example, map data may need to be loaded first to determine the spatialReference of the view, or the DOM container may not yet have a non-zero size. Many of the view methods (such as hitTest() or goTo()) need the view to be ready before they can be used.

Read More
// create a SceneView instance (for 3D viewing)
const view = new SceneView({
map: new Map({
basemap: "topo-vector"
}),
container: "viewDiv"
});
view.when(function() {
// SceneView is now ready for display and can be used. Here we will
// use goTo to view a particular location at a given zoom level, camera
// heading and tilt.
view.goTo({
center: [-112, 38],
zoom: 13,
heading: 30,
tilt: 60
})
})
.catch(function(err) {
// A rejected view indicates a fatal error making it unable to display,
// this usually means that WebGL is not available, or too old.
console.error("SceneView rejected:", err);
});

For live examples of view.when(), see the 2D overview map in SceneView and Toggle elevation layer samples.

SceneView navigation

The view can be navigated programmatically via goTo() and the view properties or interactively with mouse, keyboard or touch inputs. SceneView navigation is enabled by default, and includes the mouse, keyboard and touch interactions as described in the table below. Touch interactions work on any touch-enabled monitor or laptop screen.

Read More
ActionSceneView behavior
DragPan
Double-clickZoom in at the cursor
Scroll Wheel or Middle-click+DragZoom in or out at the cursor
Shift + Scroll Wheel or Shift + Middle-click+DragChange the camera field of view (focal length)
Right-click+Drag3D-rotate around the center of the view
Arrow KeysNudge the view left, right, up, or down (only supported in global scene)
B + Left-click+Drag3D-rotate around the camera's position
PMove the camera to look perpendicular to the data displayed in the view
NAdjust the SceneView to point north
WTilt camera up
ARotate camera counterclockwise
STilt camera down
DRotate camera clockwise
JMove down, closer to the view (only supported in global scene)
UMove up, higher from the view (only supported in global scene)
Drag with one fingerPan
Double-tap with one fingerZoom in at the finger position
Two finger pinch in/outZoom out/in
Move two fingers in clockwise or counterclockwise directionRotate
Drag two fingers up or down the screenTilt the scene

To disable SceneView navigation, you must call the stopPropagation() method on the event objects of the pointer or gesture events that trigger the navigation.

See our Disable view navigation sample.

SceneView navigation with Gamepad and 3DConnexion devices

Gamepad and 3Dconnexion devices, like the SpaceMouse, can be used for navigation when view.navigation.gamepad.enabled is set to true (default). Please see GamepadInputDevice for supported devices.

Read More

Gamepad

Gamepad ActionSceneView behavior
Left TriggerDescend
Right TriggerAscend
Left StickPan
Right Stick3D-rotate around the center of the view
Action ImageSpaceMouse ActionSceneView behavior
3DMousePanPush (left/right/forward/backward)Pan
3DMousePanPull upAscend
3DMousePanPush downDescend
3DMousePanRotate clockwiseRotate the view clockwise
3DMousePanRotate counterclockwiseRotate the view counterclockwise
3DMousePanTiltTilt the scene

To disable gamepad navigation, you can set view.navigation.gamepad.enabled to false.

Note: Per W3C Working Draft 29 October 2020, gamepad functionality may not be available on some or all browsers if the web application is hosted on a non-secure context (e.g. http rather than https). Future versions of the ArcGIS Maps SDK for JavaScript may explicitly disable gamepad capabilities on non-secure contexts.

Programmatic navigation

Traditional 2D mapping properties, such as scale, zoom, center and extent do not always work well in 3D. For example, a map's scale is not clear when viewed in the context of a globe. The SceneView therefore supports these properties on a best effort basis, with certain limitations (see the documentation of individual properties for more information).

Read More
// Compatibility with 2D viewing properties, such as center and zoom, allows
// convenient transitioning from the familiar use of the 2D MapView to the
// use of the SceneView for 3D viewing.
let view = new SceneView({
map: new Map({
basemap: "satellite"
}),
container: "viewDiv",
// Sets the center point of the view at a specified lon/lat
center: [-112, 38],
// Sets the zoom LOD to 13
zoom: 13
});

The nature of 3D viewing includes oblique views, z-values, and rotation, all of which add complexity to defining what is visible in the view. In contrast to 2D MapView, which are primarily defined by an extent, or center and scale, the primary view specification of the SceneView is a Camera instance. The camera is defined by a 3D Camera.position, Camera.heading and Camera.tilt. See the documentation of Camera for more details.

Because some view properties overlap (e.g. center and camera), there is a set priority in which these properties are applied during construction of the view (until the view becomes ready). The following table describes which properties have priority during view construction (properties that are overridden will have no effect during construction).

PropertyOverrides
cameraviewpoint, extent, center, scale, zoom
viewpointextent, center, scale, zoom
extentcenter, scale, zoom
scalezoom

It can be difficult to define the camera for viewing data at a particular location. The goTo() method provides a convenient way to set the view's camera based on data (geometries, graphics) you want to view and from any perspective using heading, tilt, scale or zoom. Additionally, goTo() will provide a smooth transition to the new location of the view by default.

// go to a location specified in geographic coordinates,
// from a 45 degree angle.
view.goTo({
center: [-112, 38],
heading: 45
});
// go to view all the graphics in view.graphics, while northing the
// the camera and tilting it to 60 degrees
view.goTo({
target: view.graphics,
heading: 0,
tilt: 60
});
// Set the view to show an extent at a -20 degree heading, disabling the
// animated transition
view.goTo({
target: new Extent(694942, 5596444, 1284090, 6163926, SpatialReference.WebMercator),
heading: -20
}, {
animate: false
});

Viewing modes

global vs local

The SceneView supports two different viewing modes, global (left picture above) and local (right picture above), specified by the viewingMode property. Global scenes render the earth as a globe, while local scenes render the surface on a flat plane. Local mode allows for navigation and feature display in a localized or clipped area. In both viewing modes the users may navigate the camera below the ground surface by setting the Ground.navigationConstraint.type to none.

The viewing mode (if not explicitly set by the user) is determined based on the spatial reference of the view. If the spatial reference is either Web Mercator, WGS84, CGCS2000, Mars_2000_(Sphere), GCS_Mars_2000 or GCS_Moon_2000 then the viewingMode will default to global. For any other spatial reference the viewingMode will default to local.

Supported coordinate systems

The SceneView supports following coordinate systems in a global scene:

  • SpatialReference.WGS84, SpatialReference.WebMercator and CGCS2000
  • Support for Mars_2000_(Sphere), GCS_Mars_2000 and GCS_Moon_2000 is experimental (see Visualize data on Mars sample). Scenes with these coordinate systems have the following limitations:
    • No support for dynamic layers, vector tile layers and scene layers
    • Daylight is currently not displayed correctly
    • Unable to be saved to a portal item

In a local scene the following coordinate systems are supported:

Noncached layers can be added to scenes with any spatial reference since they will be reprojected to the scene spatial reference.

Cached tiled layers and scene layers can generally only be added to scenes with the same spatial reference. There is limited support for reprojecting cached layers in WebMercator and WGS84 scenes. The following table lists supported spatial references for each viewing mode and spatial reference combination:

viewing modespatial referencetiled layer spatial referencescene layer spatial reference
globalWebMercatorWebMercatorWGS84 [1], WebMercator, CGCS2000
globalWGS84WGS84WGS84 [1], WebMercator, CGCS2000
localWebMercatorWebMercatorWebMercator [1], WGS84
localWGS84WGS84, WebMercator [2]WGS84, WebMercator
localProjected CSsame as viewsame as view [1]
globalCGCS2000CGCS2000CGCS2000 [1], WGS84, WebMercator
  • [1] the scene layer cache is optimized for this case.
  • [2] the tiling scheme of all tiled layers in a scene has to match, so mixing WGS84 and WebMercator tiled layers is not possible.

See spatialReference to learn how the spatial reference of a SceneView is derived.

Using elevation data

The SceneView will use elevation layers from the Map.ground as sources for elevation when rendering the ground surface. Similar to the Map.basemap, the Map.ground can be initialized with a well-known name, which creates it with a known set of elevation layers.

let view = new SceneView({
map: new Map({
basemap: "satellite",
// A ground preset containing a single elevation layer, sourced from
// https://elevation3d.arcgis.com/arcgis/rest/services/WorldElevation3D/Terrain3D/ImageServer
ground: "world-elevation"
},
container: "viewDiv"
});

Local elevation layers can be added to the Ground.layers to merge multiple elevation sources into a single surface. See 3D Map With Elevation Services for an example.

Handling events

When users interact with the SceneView, their actions trigger events that you can listen and respond to. For example, you can listen when a user moves the mouse over the map and display the coordinates at the mouse location. This is called a @pointer-move event. See the SceneView events section for a list of all the events.

Read More

It is important to note that some events are dependent on each other and the timing of the user interaction can influence the type of event that gets triggered. For example, a single click triggers a series of events: @pointer-down when the user presses the mouse button, @pointer-up when they release the mouse button. An @immediate-click event gets triggered right after the @pointer-up event. @immediate-click should be used for responding to user interaction without delay. The @click event is only triggered after making sure that the user doesn't click a second time (in which case it would trigger a @double-click event).

Various events

In the case of a double-click, the same event chain is repeated after the first click. However, if the user clicks a second time within a close time range, then the @click event is not emitted anymore, but the @pointer-down, @pointer-up and @immediate-click events are triggered again. After two @immediate-click events, a @double-click event gets triggered along with an @immediate-double-click event. The difference between the two is that an @immediate-double-click cannot be prevented by the use of stopPropagation on the @immediate-click event and can therefore be used to react to double-clicking independently of usage of the @immediate-click event.

These events are also used internally for navigation, popups or different interactive tools like measurement or sketch. In some use cases, adding additional event listeners might interfere with the default event listeners. For example, adding an immediate-click event to open up a popup, will interfere with the default click event that also opens up a popup.

See the Event explorer sample, to visualize the different events that get triggered when you interact with the view.

See also

Constructors

Constructor

Constructor
Parameters
ParameterTypeDescriptionRequired
properties
See the properties table for a list of all the properties that may be passed into the constructor.
Example
// Typical usage
let view = new SceneView({
// ID of DOM element containing the view
container: "viewDiv",
// Map/WebScene object
map: new Map()
});

Properties

Any properties can be set, retrieved or listened to. See the Watch for changes topic.
PropertyTypeClass
views
readonly inherited static
allLayerViews
readonly inherited
animation
readonly
animationsEnabled
inherited
aria
inherited
attributionHeight
readonly inherited
attributionItems
readonly inherited
ReadonlyArray<AttributionItem>
attributionMode
inherited
"dark" | "light" | null | undefined
attributionVisible
inherited
basemapView
inherited
breakpoints
inherited
canZoomIn
readonly inherited
canZoomOut
readonly inherited
container
inherited
declaredClass
readonly inherited
fatalError
inherited
focused
readonly inherited
graphics
inherited
groundView
readonly
height
readonly inherited
heightBreakpoint
inherited
highlights
inherited
input
readonly inherited
interacting
readonly inherited
layerViews
readonly inherited
magnifier
readonly inherited
map
inherited
navigating
readonly inherited
navigation
inherited
orientation
readonly inherited
padding
inherited
performanceInfo
readonly
popup
inherited
popupEnabled
inherited
"low" | "medium" | "high"
ready
readonly inherited
readyState
readonly inherited
"loading" | "missing-map" | "missing-container" | "empty-map" | "map-content-error" | "rendering-error" | "ready"
resizing
readonly inherited
resolution
readonly inherited
selectionManager
readonly inherited
size
readonly inherited
[ number, number ]
stationary
readonly inherited
suspended
readonly inherited
theme
inherited
tileInfo
readonly
timeExtent
inherited
type
readonly
"3d"
ui
inherited
updating
readonly inherited
"global" | "local"
visibleArea
readonly
width
readonly inherited
widthBreakpoint
inherited

views

readonlyinheritedstatic Property
Type
Collection<View<any>>
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.11

Contains the collection of active views on the page. Only views that are ready appear in the collection.

allLayerViews

readonlyinherited Property
Type
ReadonlyCollection
Inherited from: View

Collection containing a flat list of all the created LayerViews related to the basemap, operational layers, and group layers in this view.

See also

alphaCompositingEnabled

Property
Type
boolean
Since
ArcGIS Maps SDK for JavaScript 4.8

Allows the view to be partially or fully transparent when composited with the webpage elements behind it.

This property can only be set once at construction time. When alpha compositing is enabled, web scenes are less performant. It is important to set this property to true only when you need to apply transparency on the view.

Default value
false
Example
// create a view with a fully transparent background
let view = new SceneView({
map: map,
alphaCompositingEnabled: true,
environment: {
background: {
type: "color",
color: [0, 0, 0, 0]
},
starsEnabled: false,
atmosphereEnabled: false
}
})

analyses

autocast Property
Type
Collection<Analysis>

A collection of analyses associated with the view.

Examples
// Adds an analysis to the View
view.analyses.add(lineOfSightAnalysis);
// Removes an analysis from the View
view.analyses.remove(lineOfSightAnalysis);

animation

readonly Property
Type
ViewAnimation | null | undefined

Represents an ongoing view animation initialized by goTo(). You may watch this property to be notified of animation state changes.

See also
Example
view.goTo(target, { speedFactor: 0.1 });
reactiveUtils.watch(
() => view.animation?.state,
(state) => {
switch (state) {
case "finished":
console.log("Animation finished.");
break;
case "stopped":
console.log("Animation stopped.");
break;
}
}
);

animationsEnabled

inherited Property
Type
boolean
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.34

Indicates whether animations are enabled in the view. This includes animated symbols (animated CIMSymbol, PictureMarkerSymbol from a GIF/animated PNG), animated renderers (FlowRenderer), animated layers (MediaLayer, VideoLayer), and animations triggered by view navigation (for example, MapView.goTo()). Setting this property to false disables all animations in the view.

Default value
true

aria

inherited Property
Type
DOMContainerAria
Inherited from: DOMContainer
Since
ArcGIS Maps SDK for JavaScript 4.34

The ARIA attributes for the view container.

See also

attributionHeight

readonlyinherited Property
Type
number
Inherited from: DOMContainer
Since
ArcGIS Maps SDK for JavaScript 5.0

The height of the attribution in pixels. The value is practical to adjust the bottom padding of other UI elements. The value changes when the attribution is expanded or collapsed.

attributionItems

readonlyinherited Property
Type
ReadonlyArray<AttributionItem>
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 5.0

The array of attribution items to be displayed in the view's attribution. This property is populated once the view has finished updating. Items are ordered based on descending score with higher scored items appearing first in the attribution.

attribution

Example
// Access the attributionItems property after the view is finished updating to get the array of attribution items to be displayed in the view's attribution
reactiveUtils.when(
() => !view.updating,
() => {
const attributionText = view.attributionItems
.map((item) => item.text)
.join(" | ");
console.log(attributionText);
}
);

attributionMode

inherited Property
Type
"dark" | "light" | null | undefined
Inherited from: DOMContainer
Since
ArcGIS Maps SDK for JavaScript 5.0

The light or dark mode used to display the attribution. By default, the mode is inherited from the Calcite's mode. You can override the value to style the attribution alongside the map or scene content.

attributionVisible

inherited Property
Type
boolean
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 5.0

Indicates whether the attribution is visible in the view.

Esri requires that when you use an ArcGIS Online basemap in your app, the map must include Esri attribution and you must be licensed to use the content. For detailed guidelines on working with attribution, please visit the official attribution in your app documentation. For information, see the Terms of Use documentation.

Default value
true

basemapView

inherited Property
Type
BasemapView
Inherited from: View

Represents the view for a single basemap after it has been added to the map.

breakpoints

inherited Property
Type
Breakpoints
Inherited from: BreakpointsOwner

A convenience property used for defining the breakpoints on the height and width of the view. The sizes specified here determine the values of the widthBreakpoint and heightBreakpoint properties depending on the view's size.

Setting up breakpoints can aid in responsive app design. It does this by watching width and height breakpoints. This is helpful as it removes the need for multiple @media calls. Instead of listening for the view's size and/or resizes property, you can set up a watch handler for either the widthBreakpoint or heightBreakpoint properties of the view.

Please refer to the styling guide for additional information on working with this.

See also
Example
// Instead of watching the size or resizing properties
reactiveUtils.watch(() => view.size, () => {});
reactiveUtils.watch(() => view.resizing, () => {});
// Set up a watch handle for breakpoint
reactiveUtils.watch(
() => view.widthBreakpoint,
(breakpoint) => {
switch (breakpoint) {
case "xsmall":
// do something
break;
case "small":
case "medium":
case "large":
case "xlarge":
// do something else
break;
default:
}
}
);

camera

autocast Property
Type
Camera

The observation point from which the visible portion (or perspective) of the SceneView is determined. Contains properties including the elevation, tilt, and heading (in degrees) of the current view. Setting the camera immediately changes the current view. For animating the view, see goTo().

When set in the constructor, this property overrides the viewpoint, extent, center, scale, and zoom properties.

The camera property contains an internal reference which may be modified in the future. To persist or modify the camera, create a clone using Camera.clone().

Z-values defined in a geographic or metric coordinate system are expressed in meters. However, in local scenes that use a projected coordinate system, vertical units are assumed to be the same as the horizontal units specified by the service.

See also
Examples
// Initializes the view at the given (x, y, z) position with a heading of 95 degrees.
// The position of the camera is a Point which will autocast in the sample
// below. Note that the default Point spatial reference is WGS84 which
// will only work if the SceneView has a Web Mercator or WGS84 spatial
// reference. For other spatial references, create a new position Point
// with an explicit spatial reference.
const view = new SceneView({
camera: {
position: [
-122, // lon
38, // lat
50000 // elevation in meters
],
heading: 95
}
});
// Initializes the view at the given position with a tilt of 65 degrees
const view = new SceneView({
camera: {
position: {
x: -100, // lon
y: 45, // lat
z: 10654 // elevation in meters
},
tilt: 65
}
});
// Clone the camera to modify its properties
const camera = view.camera.clone();
// Set new values for heading and tilt
camera.heading = 180;
camera.tilt = 45;
// Set the new properties on the view's camera
view.camera = camera;
// Set the view's camera to a new position, heading and tilt with the goTo() method
view.goTo({
target: [-122, 38, 50000],
heading: 180,
tilt: 45
});

canZoomIn

readonlyinherited Property
Type
boolean
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 5.0

Indicates if the view can zoom in.

canZoomOut

readonlyinherited Property
Type
boolean
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 5.0

Indicates if the view can zoom out.

center

autocast Property
Type
Point

Represents the view's center point; when setting the center you may pass a Point instance or an array of numbers representing a longitude/latitude pair ([-100.4593, 36.9014]). Setting the center immediately changes the current view. For animating the view, see goTo().

If set in the constructor, this property will be ignored if the viewpoint, camera, or extent properties are also set in the constructor.

The center property contains an internal reference which may be modified in the future. To persist or modify the center, create a clone using center.clone().

Z-values defined in a geographic or metric coordinate system are expressed in meters. However, in local scenes that use a projected coordinate system, vertical units are assumed to be the same as the horizontal units specified by the service.

See also
Examples
// Sets the initial center point of the view to long/lat coordinates
let view = new SceneView({
center: [-112, 38]
});
// Updates the view's center point to a pre-determined Point object
view.center = new Point({
x: 12804.24,
y: -1894032.09,
z: 12000,
spatialReference: 2027
});
// view.center needs to be set (not modified in place) to have an effect.
// To modify only the center.x, first clone the current center, modify
// the .x property and then set it on the view.
let center = view.center.clone();
// Offset the center 1km to the east
center.x += 1000;
view.center = center;

clippingArea

autocast Property
Type
Extent | null | undefined

Represents an optional clipping area used to define the visible Extent of a local scene. The clipping area cannot have z-values.

If defined, only features that intersect the area will be displayed. The clipping area applies to all layer types, including the ground and the basemap. The clipping area will not increase the area beyond the union of the extents of all layers, including the ground and the basemap. To do so, add a GraphicsLayer with a custom fullExtent to the scene.

The clippingArea property only applies to local scenes.

scene-clipping-area

The clippingArea property contains an internal reference which may be modified in the future. To persist or modify the clippingArea, create a clone using clippingArea.clone().

See also
Example
let extent = view.extent.clone();
// Expand the extent in place, reducing it to 50% of its original size and set it as the clippingArea
view.clippingArea = extent.expand(0.5);

constraints

autocast Property
Type
Constraints

Specifies constraints for Camera tilt and altitude that may be applied to the SceneView. See the object specification table below for details.

See also

container

autocast inherited Property
Type
HTMLDivElement | null | undefined
Inherited from: DOMContainer

The id or node representing the DOM element containing the view. This is typically set in the view's constructor.

Examples
// Sets container to the DOM id
let view = new MapView({
container: "viewDiv" // ID of the HTML element that holds the view
});
// Sets container to the node
let viewNode = document.getElementById("viewDiv");
let view = new SceneView({
container: viewNode
});

declaredClass

readonlyinherited Property
Type
string
Inherited from: Accessor
Since
ArcGIS Maps SDK for JavaScript 4.7

The name of the class. The declared class name is formatted as esri.folder.className.

displayFilterEnabled

inherited Property
Type
boolean
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.32

Indicates whether displayFilters are honored across all layers in the view. If false, display filters are ignored on all layers and all features are rendered. To ignore display filters on a per-layer basis, set the layer's displayFilterEnabled property to false.

Default value
true

environment

autocast Property
Type
Environment

Specifies various properties of the environment's visualization in the view. The SceneView will redraw automatically when any property of the environment changes.

Modifying the lighting:

let view = new SceneView({
map: map,
container: "viewDiv"
});
// Set the light source position to reflect the current sun position at that time
view.environment.lighting = {
type: "sun",
date: new Date("January 1, 2022 12:00:00 UTC")
};
// Change the lighting to virtual, so that everything in the scene is nicely lit:
view.environment.lighting = {
type: "virtual"
};
// Enable displaying shadows cast by the light source
view.environment.lighting.directShadowsEnabled = true;

Setting the background:

// Set a background color
let view = new SceneView({
container: "viewDiv",
map: map,
environment: {
background: {
type: "color",
color: [255, 252, 244, 1]
},
starsEnabled: false,
atmosphereEnabled: false
}
});

Changing the weather in the scene:

let view = new SceneView({
container: "viewDiv",
map: new Map({
basemap: "satellite",
ground: "world-elevation"
}),
environment: {
weather: {
type: "cloudy" // autocasts as new CloudyWeather()
}
}
});

extent

autocast Property
Type
Extent

The extent represents the visible portion of a Map within the view as an instance of an Extent. Setting the extent immediately changes the view without animation. To animate the view, see goTo().

Rather than using extent to change the visible portion of the Map in a SceneView, you should use camera since it easily allows you to define the heading, elevation and tilt of the observation point from which the view's perspective is created.

When set in the constructor, this property overrides the center, scale, and zoom properties. This property will be ignored if the viewpoint or camera are also set in the constructor.

The extent property contains an internal reference which may be modified in the future. To persist or modify the extent, create a clone using Extent.clone().

Z-values defined in a geographic or metric coordinate system are expressed in meters. However, in local scenes that use a projected coordinate system, vertical units are assumed to be the same as the horizontal units specified by the service.

See also

fatalError

inherited Property
Type
EsriError | null | undefined
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.12

A fatal Error returned when the view loses its WebGL context. watch() this property to properly handle the error and attempt to recover the WebGL context.

See also
Example
reactiveUtils.when(
() => view.fatalError,
() => {
console.error("Fatal Error! View has lost its WebGL context. Attempting to recover...");
view.tryFatalErrorRecovery();
}
);

floors

autocast Property
Type
Collection<string>
Since
ArcGIS Maps SDK for JavaScript 4.19

Applies a display filter on the view for a specific set of floor levels. It filters the scene display on floor-aware layers by zero or more level IDs.

focused

readonlyinherited Property
Type
boolean
Inherited from: DOMContainer
Since
ArcGIS Maps SDK for JavaScript 4.7

Indicates if the browser focus is on the view.

graphics

autocast inherited Property
Type
Collection<Graphic>
Inherited from: View

Allows for adding graphics directly to the default graphics in the View.

See also
Examples
// Adds a graphic to the View
view.graphics.add(pointGraphic);
// Removes a graphic from the View
view.graphics.remove(pointGraphic);

groundView

readonly Property
Type
GroundView
Since
ArcGIS Maps SDK for JavaScript 4.7

The view for the ground of the map.

height

readonlyinherited Property
Type
number
Inherited from: DOMContainer

The height of the view in pixels read from the view container element.

The view container needs to have a height greater than 0 to be displayed.

Default value
0

heightBreakpoint

inherited Property
Type
BreakpointSize
Inherited from: BreakpointsOwner

A convenience property indicating the general size of the view's height. This value is determined based on where the view's height falls in the ranges defined in the breakpoints property. See the table below for a list of possible values. Use the breakpoints property to override the default thresholds.

Please refer to the styling guide for additional information on working with this.

Possible ValueDescriptionDefault thresholds (pixels)
xsmallThe height of the view is smaller than the value set in the xsmall breakpoint.< 545
smallThe height of the view is between the values set in the xsmall and small breakpoints.545 - 768
mediumThe height of the view is between the values set in the small and medium breakpoints.769 - 992
largeThe height of the view is between the values set in the medium and large breakpoints.993 - 1200
xlargeThe height of the view is larger than the value set in the large breakpoint.> 1200
See also
Example
reactiveUtils.watch(
() => view.heightBreakpoint === "xsmall",
() => {
// clear the view's default UI components if
// the app is used on a mobile device
view.ui.components = [];
}
);

highlights

autocast inherited Property
Type
Collection<HighlightOptions>
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.32

Represents a collection of HighlightOptions objects which can be used to highlight features throughout an application. Highlighting works by applying highlight options to one or more features. You can configure these options (such as color or opacity) to define how a feature will be visually emphasized.

A maximum of six HighlightOptions objects are supported in the collection, and they can be added, removed, and reordered freely. Their order in the collection determines priority, with the last object having the highest priority. If you apply more than one highlight to a feature, the one that is last within the collection will be applied. The HighlightOptions object must be part of this collection in order to be applied to features.

To highlight a feature, use the highlight method on the relevant LayerView instance. To apply specific HighlightOptions, include the name in the highlight() method's options parameter. If no name is provided, the feature will use the default highlight options.

The table below shows the default highlight options in the View's highlights collection if the collection has not been modified:

Highlight options nameDescriptionDefault settings
defaultThe default highlight options. Used when layerView.highlight() is called without specifying any particular highlight options. { name: "default", color: "cyan", haloOpacity: 1, fillOpacity: 0.25, shadowColor: "black", shadowOpacity: 0.4, shadowDifference: 0.2}
temporaryThe temporary highlight options, pre-configured for common use cases such as hovering over a feature in the view.{ name: "temporary", color: "yellow", haloOpacity: 1, fillOpacity: 0.25, shadowColor: "black", shadowOpacity: 0.4, shadowDifference: 0.2 }
See also
Examples
// Use the default highlights collection to apply a highlight to features when you hover over them
// A handler can be used to remove any previous highlight when applying a new one
let hoverHighlight;
view.on("pointer-move", (event) => {
// Search for the first feature in the featureLayer at the hovered location
view.hitTest(event, { include: featureLayer }).then((response) => {
if (response.results[0]) {
const graphic = response.results[0].graphic;
view.whenLayerView(graphic.layer).then((layerView) => {
// Remove any previous highlight, if it exists
hoverHighlight?.remove();
// Highlight the hit features with the temporary highlight options, which are pre-configured for this use case
hoverHighlight = layerView.highlight(graphic, { name: "temporary"});
});
}
});
});
// Override the default highlights collection
const view = new MapView({
map: map,
container: "viewDiv",
// Set the highlight options to be used in the view
highlights: [
{ name: "default", color: "orange" },
{ name: "temporary", color: "magenta" },
{ name: "table", color: "cyan", fillOpacity: 0.5, haloOpacity: 0}
]
});
// Add highlight options to the collection after initialization
const selectionHighlightOptions = {
name: "selection",
color: "#ff00ff", // bright fuchsia
haloOpacity: 0.8,
fillOpacity: 0.2
};
// Add the options to the highlights collection at the first position
view.highlights.add(selectionGroup, 0);

input

readonlyinherited Property
Type
Input
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.9

Options to configure input handling of the View.

Example
// Make gamepad events to emit independently of focus.
view.input.gamepad.enabledFocusMode = "none";

interacting

readonlyinherited Property
Type
boolean
Inherited from: View

Indication whether the view is being interacted with (for example when panning or by an interactive tool).

Default value
false

layerViews

readonlyinherited Property
Type
Collection
Inherited from: View

A collection containing a hierarchical list of all the created LayerViews of the operational layers in the map.

See also

magnifier

readonlyinherited Property
Type
Magnifier
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.19

The magnifier allows for showing a portion of the view as a magnifier image on top of the view.

map

autocast inherited Property
Type
EsriMap | null | undefined
Inherited from: View

An instance of a Map object to display in the view. A view may only display one map at a time. On the other hand, one Map may be viewed by multiple MapViews and/or SceneViews simultaneously.

This property is typically set in the constructor of the MapView or SceneView. See the class description for examples demonstrating the relationship between the map and the view.

readonlyinherited Property
Type
boolean
Inherited from: View

Indication whether the view is being navigated (for example when panning).

Default value
false
autocast inherited Property
Type
Navigation
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.9

Options to configure the navigation behavior of the View.

Example
// Disable the gamepad usage, single touch panning, panning momentum and mouse wheel zooming.
const view = new MapView({
container: "viewDiv",
map: new Map({
basemap: "satellite"
}),
center: [176.185, -37.643],
zoom: 13,
navigation: {
gamepad: {
enabled: false
},
actionMap: {
dragSecondary: "none", // Disable rotating the view with the right mouse button
mouseWheel: "none" // Disable zooming with the mouse wheel
},
browserTouchPanEnabled: false,
momentumEnabled: false,
}
});

orientation

readonlyinherited Property
Type
BreakpointOrientation
Inherited from: BreakpointsOwner

A convenience property indicating the view's orientation. See the table below for a list of possible values.

Please refer to the styling guide for additional information on working with this.

Possible ValueDescription
landscapeThe width of the view is greater than its height.
portraitThe width of the view is equal to or smaller than its height.

padding

inherited Property
Type
ViewPadding
Inherited from: View

Use the padding property to make the center, and extent, etc. work off a subsection of the full view. This is particularly useful when layering UI elements or semi-transparent content on top of portions of the view.

Default value
{left: 0, top: 0, right: 0, bottom: 0}

performanceInfo

readonly Property
Type
SceneViewPerformanceInfo
Since
ArcGIS Maps SDK for JavaScript 4.15

This property contains performance information in a SceneView like global memory usage and additional details for layers about memory consumption and number of features.

This property is experimental and should be used for debugging purposes only. Its interface will change in future releases.

See also
autocast inherited Property
Type
Popup | null | undefined
Inherited from: PopupView

A Popup object that displays general content or attributes from layers in the map.

By default, the popup property is an empty object that allows you to set the popup options. A Popup instance is automatically created and assigned to the view's popup when the user clicks on the view and popupEnabled is true, when the openPopup method is called, or when some widgets need the popup, such as Search. If popup is null, the popup instance will not be created.

See also
Examples
// Set the view's popup to a new Popup instance.
// The popup will show anytime a popup is called such as when selecting features or displaying a Search result.
view.popup = new Popup();
// Set the popup to a PopupOptions object with popup properties set such as the dock options.
// The popup will show anytime a popup is called.
view.popup = {
dockEnabled: true,
dockOptions: {
position: "top-left",
breakpoint: false
}
};
// Set the popup to null. This disables the popup so it will never show up.
view.popup = null;

popupEnabled

inherited Property
Type
boolean
Inherited from: PopupView
Since
ArcGIS Maps SDK for JavaScript 4.27

Controls whether the popup opens when users click on the view.

When true, a Popup instance is created and assigned to popup the first time the user clicks on the view, unless popup is null. The popup then processes the click event.

When false, the click event is ignored and popup is not created for features but will open for other scenarios that use a popup, such as displaying Search results.

See also
Default value
true
Example
// Disable the popup from automatically appearing and
// open the popup manually using a click event.
view.popupEnabled = false;
view.on("click", (event)=> {
view.openPopup({
// Set properties for the manually opened popup
...
});
});

qualityProfile

Property
Type
"low" | "medium" | "high"

SceneView can draw scenes in three different quality modes: high, medium and low.

qualityProfile is evaluated and set automatically when SceneView loads depending on the detected device, to optimize stability and performance across different hardware and browsers. In most scenarios it is recommended to not set qualityProfile, but let it be evaluated automatically. qualityProfile should only be set when the target devices and their capabilities that the application runs on are clear, and are known to work well with the chosen profile. Applications should also consider providing an option to change the quality profile, such that users can select the profile that works best with their specific devices.

The quality profiles have increasingly higher settings for the memory limit and rendering quality.

The memory limit defines the maximum amount of memory which the view is allowed to use. Complex web scenes with many layers will hit the memory limit. When this happens, the view will reduce the level of detail and the number of features that are loaded, as well as the rendering resolution of the view and of draped content. This will make the application less likely crash due to out of memory errors.

The rendering quality settings impacts the level of detail and the maximum number of features that are loaded by all layers. A higher quality profile also enables more rendering features, providing better visuals. Furthermor, it increases the resolution of shadows, rasterized content such as icons and text, as well as the overall rendering resolution on HiDPI displays.

A higher quality profile improves visual quality and detail, but can have a negative impact on drawing performance and stability.

SceneView performance depends on the amount of data being displayed, the quality profile and the device type. performanceInfo can be used to inspect the memory consumption and the number of features that are displayed for a specific scene. The SceneView memory resources sample shows how this property can be used.

The default value is based on the detected browser:

  • low for all browsers on iPhones
  • medium for any other browser and device
Example
let view = new SceneView({
qualityProfile: "high"
});

ready

readonlyinherited Property
Type
boolean
Inherited from: View

When true, this property indicates whether the view successfully satisfied all dependencies, signaling that the following conditions are met.

When a view becomes ready it will resolve itself and invoke the callback defined in when() where code can execute on a working view. Subsequent changes to a view's readiness would typically be handled by watching view.ready and providing logic for cases where the map or container change.

See also
Default value
false

readyState

readonlyinherited Property
Type
"loading" | "missing-map" | "missing-container" | "empty-map" | "map-content-error" | "rendering-error" | "ready"
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.32

Provides more granular information about the view's process of becoming ready. This property helps manage view properties when the view fails to become ready, such as when the basemap fails to load.

The following are the possible expected values and their descriptions:

ValueDescription
loadingThe view is currently loading information from the map.
readyThe view is ready. This is similar to the ready property.
missing-mapThe view is missing a map. Set the view's map property.
missing-containerThe view is missing a container. Set the view's container property.
empty-mapThe view's map has no layers. Add layers to the map.
rendering-errorThe view failed to render. This is similar to the fatalError property.
map-content-errorThe view failed to find information from the map and couldn't derive the spatialReference. Verify that the map correctly loaded with the loadError property, as well as its basemap, and the first layer in the map's layers collection. Alternatively, set a valid center, scale, and spatialReference.
Default value
"loading"
Examples
// Watch the view's readyState immediately after its initialization.
reactiveUtils.watch(
() => view.readyState,
(state) => {
switch (state) {
case "missing-map":
// Map is missing. Set a default map.
view.map = new Map({ basemap: "streets" });
break;
}
},
{
initial: true // fire the callback immediately after initialization.
}
);
const view = new MapView({
container: "viewDiv",
map: new Map({
basemap: {
baseLayers: [
new TileLayer({
url: "my-failing-tiled-service"
})
]
}
});
reactiveUtils.watch(() => view.readyState, (state) => {
switch (state) {
case "map-content-error":
// Defaults to a different map in case of failure
view.map = new Map({ basemap: "streets" });
break;
case "rendering-error":
view.tryFatalErrorRecovery();
break;
default:
console.log("View is not ready:", state);
}
});

resizing

readonlyinherited Property
Type
boolean
Inherited from: DOMContainer

Indicates whether the view is being resized.

Default value
false

resolution

readonlyinherited Property
Type
number
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.9

Represents the current value of one pixel in the unit of the view's spatialReference. The value of resolution is calculated by dividing the view's extent width by its width.

scale

Property
Type
number

Represents an approximation of the map scale. Setting the scale immediately changes the current view. For animating the view, see goTo().

When set in the constructor, this property overrides the zoom property. This property will be ignored if the viewpoint, camera, or extent properties are also set in the constructor.

See also
Example
// Set the approximate map scale to 1:24,000
view.scale = 24000;

selectionManager

readonlyinherited Property
Type
SelectionManager
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 5.0
beta

The default SelectionManager for this view. Used to manage selections of features across layers.

size

readonlyinherited Property
Type
[ number, number ]
Inherited from: DOMContainer

An array containing the width and height of the view in pixels, e.g. [width, height].

spatialReference

autocast Property
Type
SpatialReference

The spatial reference of the view.

This indicates the projected or geographic coordinate system used to locate geographic features in the map. In a SceneView the following coordinate systems are available.

The spatial reference can either be set explicitly or automatically derived from the following:

In case the spatial reference is determined from the map layers or the ground layers and they are in WGS84 or Web Mercator, the following rule also applies: the first layer that does not support server side reprojection (tiled layers) determines the spatial reference of the view and all the other layers are reprojected.

If no spatial reference can be derived, then the view does not resolve and the ready property is false.

stationary

readonlyinherited Property
Type
boolean
Inherited from: View

Indication whether the view is animating, being navigated with or resizing.

suspended

readonlyinherited Property
Type
boolean
Inherited from: DOMContainer

Indicates if the view is visible on the page. When true, the view is not visible and it stops rendering and updating data. Set to true when one of the following conditions are met:

  • if the view does not have a container,
  • if the view's height or width equal to 0,
  • if the view container's css style display is set to none (display:none).

When the view container's css style visibility is set to hidden, this property is set to false, and the view is hidden but it stills renders and updates data.

Default value
true

theme

autocast inherited Property
Type
Theme | null | undefined
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.28

This property specifies the base colors used by some widgets and components to render graphics and labels. This only affects those components that would otherwise use the default orange pattern.

See also
Example
// Update the theme to use purple graphics
// and slightly transparent green text
view.theme = new Theme({
accentColor: "purple",
textColor: [125, 255, 13, 0.9]
});

tileInfo

readonly Property
Type
TileInfo | null | undefined

The tiling scheme information of the view.

timeExtent

autocast inherited Property
Type
TimeExtent | null | undefined
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.12

The view's time extent. Time-aware layers display their temporal data that falls within the view's time extent. Setting the view's time extent is similar to setting the spatial extent because once the time extent is set, the view updates automatically to conform to the change.

Example
// Create a csv layer from an online spreadsheet.
let csvLayer = new CSVLayer({
url: "http://test.com/daily-magazines-sold-in-new-york.csv",
timeInfo: {
startField: "SaleDate" // The csv field contains date information.
}
});
// Create a mapview showing sales for the last week of March 2019 only.
const view = new MapView({
map: map,
container: "viewDiv",
timeExtent: {
start: new Date("2019, 2, 24"),
end: new Date("2019, 2, 31")
}
});

type

readonly Property
Type
"3d"

The type of the view.

ui

autocast inherited Property
Type
DefaultUI
Inherited from: DOMContainer

Exposes the default widgets available in the view and allows you to toggle them on and off. See DefaultUI for more details.

Examples
let toggle = new BasemapToggle({
view: view,
nextBasemap: "hybrid"
});
// Adds an instance of BasemapToggle widget to the
// top right of the view.
view.ui.add(toggle, "top-right");
// Moves the zoom and BasemapToggle widgets to the
// bottom left of the view.
view.ui.move([ "zoom", toggle ], "bottom-left");
// Removes all the widgets from the bottom left of the view
view.ui.empty("bottom-left");
// Removes the compass widget from the view
view.ui.remove("compass");
// Removes all default UI components, except Attribution.
// Passing an empty array will remove all components.
view.ui.components = [ "attribution" ];

updating

readonlyinherited Property
Type
boolean
Inherited from: View

Indicates whether the view is being updated by additional data requests to the network, or by processing received data.

Default value
false

viewingMode

autocast Property
Type
"global" | "local"

The viewing mode (local or global). Global scenes render the earth as a sphere. Local scenes render the earth on a flat plane and allow for navigation and feature display in a localized or clipped area. Users may also navigate the camera of a local scene below the surface of a basemap.

ValueExampleDescription
globalscene-globalGlobal scenes allow the entire globe to render in the view, showing the curvature of the earth.
localscene-localLocal scenes render the earth on a flat surface. They can be constrained to only show a "local" area by setting the clippingArea property. Local scenes also allow for displaying and exploring data that would otherwise be hidden by the surface of the earth.

Depending on the viewing mode different supported coordinate systems are available.

See also
Default value
"global"

viewpoint

autocast Property
Type
Viewpoint

Represents the current view as a Viewpoint or point of observation on the view. In SceneViews, camera should be used in favor of viewpoint for watching or changing the point of view. Setting the viewpoint immediately changes the current view. For animating the view, see goTo().

When set in the constructor, this property overrides the extent, center, scale, and zoom properties. This property will be ignored if camera is also set in the constructor.

The viewpoint property contains an internal reference which may be modified in the future. To persist or modify the viewpoint, create a clone using Viewpoint.clone().

See also

visibleArea

readonly Property
Type
Polygon | null | undefined
Since
ArcGIS Maps SDK for JavaScript 4.31

The visibleArea represents the visible portion of a Map within the view as an instance of a Polygon. The polygon is a 2D approximation of the 3D frustum projected onto the ground surface. This can give more precise results than the view extent, although it is still only an approximation of the 3D visible volume. An example use of the visible area is to spatially filter visible features in a layer view query.

This property does not consider occlusions caused by terrain features (e.g. hills, mountains) or 3D structures (e.g. buildings). Consequently, the visible area may include areas that are actually hidden from the user's view.

The visible area may contain multiple rings, for example the view intersects with the international date line or the poles.

See also

width

readonlyinherited Property
Type
number
Inherited from: DOMContainer

The width of the view in pixels read from the view container element.

The view container needs to have a width greater than 0 to be displayed.

Default value
0

widthBreakpoint

inherited Property
Type
BreakpointSize
Inherited from: BreakpointsOwner

A convenience property indicating the general size of the view's width. This value is determined based on where the view's width falls in the ranges defined in the breakpoints property. See the table below for a list of possible values. Use the breakpoints property to override the default thresholds.

Please refer to the styling guide for additional information on working with this.

Possible ValueDescriptionDefault thresholds (pixels)
xsmallThe width of the view is smaller than the value set in the xsmall breakpoint.< 545
smallThe width of the view is between the values set in the xsmall and small breakpoints.545 - 768
mediumThe width of the view is between the values set in the small and medium breakpoints.769 - 992
largeThe width of the view is between the values set in the medium and large breakpoints.993 - 1200
xlargeThe width of the view is larger than the value set in the large breakpoint.> 1200
See also
Example
reactiveUtils.when(
() => view.widthBreakpoint === "xsmall",
() => {
// clear the view's default UI components if
// the app is used on a mobile device
view.ui.components = [];
}
);

zoom

Property
Type
number

Represents the level of detail (LOD) at the center of the view. Setting the zoom immediately changes the current view. For animating the view, see goTo().

Setting this property in conjunction with center is a convenient way to set the initial extent of the view.

If set in the constructor, this property will be ignored if the viewpoint, camera, extent, or scale properties are also set in the constructor.

See also
Examples
view.zoom = 3; // Sets the LOD to 3 (small map scale)
view.zoom = 18; // Sets the LOD to 18 (large map scale)
// Set the zoom level and center in the constructor
let view = new SceneView({
zoom: 10,
center: [-120, 34],
map: map
});

Methods

MethodSignatureClass
closePopup
inherited
closePopup(): void
destroy
inherited
destroy(): void
emit
inherited
emit<Type extends EventNames<this>>(type: Type, event?: this["@eventTypes"][Type]): boolean
focus
inherited
focus(): void
goTo(target: GoToTarget3D, options?: GoToOptions3D): Promise<void>
hasEventListener
inherited
hasEventListener<Type extends EventNames<this>>(type: Type): boolean
hitTest(screenPoint: ScreenPoint | MouseEvent, options?: HitTestOptions3D): Promise<SceneViewHitTestResult>
isFulfilled
inherited
isFulfilled(): boolean
isRejected
inherited
isRejected(): boolean
isResolved
inherited
isResolved(): boolean
on
on<Type extends EventNames<this>>(type: Type, listener: (event: this["@eventTypes"][Type]) => void): ResourceHandle
on
on<Type extends EventNames<this>>(type: Type, modifiers: string[], listener: (event: this["@eventTypes"][Type]) => void): ResourceHandle
openPopup
inherited
openPopup(options?: ViewPopupOpenOptions): Promise<void>
takeScreenshot(options?: Partial<ScreenshotUserSettings>): Promise<Screenshot>
toMap(screenPoint: ScreenPoint | MouseEvent, options?: HitTestOptions3D): Point | null | undefined
toScreen(point: Point): ScreenPoint
tryFatalErrorRecovery(): void
when
inherited
when<TResult1 = this, TResult2 = never>(onFulfilled?: OnFulfilledCallback<this, TResult1> | null | undefined, onRejected?: OnRejectedCallback<TResult2> | null | undefined): Promise<TResult1 | TResult2>
whenAnalysisView<AnalysisType extends Analysis>(analysis: AnalysisType): Promise<AnalysisView3DFor<AnalysisType>>
whenLayerView<TLayer extends Layer>(layer: TLayer): Promise<Layer extends TLayer ? LayerView : LayerView3DFor<TLayer>>
zoomIn(): Promise<void>
zoomOut(): Promise<void>

closePopup

inherited Method
Signature
closePopup (): void
Inherited from: PopupView
Since
ArcGIS Maps SDK for JavaScript 4.27

Closes the popup.

See also
Returns
void
Example
// Closes the popup if it's open
if(view.popup.visible){
view.closePopup();
}

destroy

inherited Method
Signature
destroy (): void
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.17

Destroys the view, and any associated resources, including its map, popup, and ui elements. These can no longer be used once the view has been destroyed. To prevent these components from being destroyed, remove them from the view before calling destroy().

// remove popup and legend from the view so that they are not destroyed
const popup = view.popup;
view.popup = null;
view.ui.remove(legend);
// unset map from the view so that it is not destroyed
const map = view.map;
view.map = null;
// destroy the view and any remaining associated resources
view.destroy();
See also
Returns
void

emit

inherited Method
Signature
emit <Type extends EventNames<this>>(type: Type, event?: this["@eventTypes"][Type]): boolean
Type parameters
<Type extends EventNames<this>>
Inherited from: EventedMixin
Since
ArcGIS Maps SDK for JavaScript 4.5

Emits an event on the instance. This method should only be used when creating subclasses of this class.

Parameters
ParameterTypeDescriptionRequired
type
Type

The name of the event.

event
this["@eventTypes"][Type]

The event payload.

Returns
boolean

true if a listener was notified

focus

inherited Method
Signature
focus (): void
Inherited from: DOMContainer
Since
ArcGIS Maps SDK for JavaScript 4.5

Sets the focus on the view.

Returns
void

goTo

Method
Signature
goTo (target: GoToTarget3D, options?: GoToOptions3D): Promise<void>

Sets the view to a given target. The target parameter can be one of the following:

  • [longitude, latitude] pair of coordinates
  • Geometry (or array of Geometry[])
  • Graphic (or array of Graphic[])
  • Viewpoint
  • Camera
  • Object with a combination of target, center, scale, position, heading and tilt properties (with target being any of the types listed above). The center property is provided as a convenience to animate the center and is the equivalent of specifying the target with the center Point. The target must be provided in the spatial reference of the view.

This function returns a promise which resolves as soon as the new view has been set to the target. If the transition is animated, then the ongoing animation can be obtained using animation. If setting the view to the new target fails, the promise returned by the goTo() method rejects with an error. Use a catch statement, to handle the error:

view.goTo({
center: [-126, 49]
})
.catch(function(error) {
if (error.name != "AbortError") {
console.error(error);
}
});

If the given target is far away from the current camera position, then heading and tilt will be automatically set to their neutral values (facing north, looking top down). Tilt and heading can always be explicitly set to override this behavior.

See also
Parameters
ParameterTypeDescriptionRequired
target

The target location/viewpoint to go to. When using an object for target, use the properties defined in GoToTarget3D.

options

View transition options. See the specification defined in GoToOptions3D for more information.

Returns
Promise<void>

A promise that resolves when the view's extent updates to the extent defined in target.

Examples
view.goTo({
center: [-126, 49],
heading: 180, // set the heading to point South
tilt: view.camera.tilt, // maintain tilt value
});
// go to a location defined by a Camera object
let cam = new Camera({
position: new Point({
x: -100.23, // lon
y: 65, // lat
z: 10000, // elevation in meters
}),
heading: 180, // facing due south
tilt: 45 // bird's eye view
});
view.goTo(cam);
// go to a point using center, zoom, tilt, and heading
view.goTo({
center: [-126, 49],
zoom: 13,
tilt: 75,
heading: 105
});
// goTo returns a Promise which resolves when the animation has finished.
// This promise may be chained to create a sequence of animations.
view.goTo(graphic1)
.then(function() {
return view.goTo(graphic2);
})
.then(function() {
return view.goTo(graphic3);
});

hasEventListener

inherited Method
Signature
hasEventListener <Type extends EventNames<this>>(type: Type): boolean
Type parameters
<Type extends EventNames<this>>
Inherited from: EventedMixin

Indicates whether there is an event listener on the instance that matches the provided event name.

Parameters
ParameterTypeDescriptionRequired
type
Type

The name of the event.

Returns
boolean

Returns true if the class supports the input event.

hitTest

Method
Signature
hitTest (screenPoint: ScreenPoint | MouseEvent, options?: HitTestOptions3D): Promise<SceneViewHitTestResult>

Returns hit test results from each layer that intersects the specified screen coordinates. The results are organized as an array of objects containing different result types.

The following layer types will return all features if a hit is made on intersecting features: GraphicsLayer, FeatureLayer, SceneLayer, BuildingSceneLayer, PointCloudLayer, CSVLayer, StreamLayer, GeoJSONLayer, OGCFeatureLayer, and graphics.

The MediaLayer hit test result contains all media elements if the hit is made on intersecting elements. The RouteLayer hit test result contains all route elements if the hit is made on intersecting elements.

The VoxelLayer hit test result contains information about the intersecting voxel if a hit is made.

If no options are specified, graphics that are behind the ground surface will not be returned unless the ground surface is semi-transparent. Otherwise, using the Map.ground in the include and exclude options determines whether the ground surface prevents hit testing graphics that are under it.

Release-specific changes:

  • At version 4.24, SceneViewHitTestResult returns an array of objects containing graphic, media element, and route.
  • Starting with version 4.11, if a label intersects the specified screen coordinates then the result of the hitTest will contain the graphic associated with that label.
See also
Parameters
ParameterTypeDescriptionRequired
screenPoint

The screen coordinates (or native mouse event) of the click on the view.

options

Intersection test options. By default the Map.ground is excluded if its opacity is smaller than one.

Returns
Promise<SceneViewHitTestResult>

When resolved, returns an array of objects containing different result types.

Example
// Get the screen point from the view's click event
view.on("click", function(event) {
// Search for graphics at the clicked location. View events can be used
// as screen locations as they expose an x,y coordinate that conforms
// to the ScreenPoint definition.
view.hitTest(event).then(function(response) {
let result = response.results[0];
if (result?.type === "graphic") {
let lon = result.mapPoint.longitude;
let lat = result.mapPoint.latitude;
console.log("Hit graphic at (" + lon + ", " + lat + ")", result.graphic);
} else {
console.log("Did not hit any graphic");
}
});
});

isFulfilled

inherited Method
Signature
isFulfilled (): boolean
Inherited from: EsriPromiseMixin

isFulfilled() may be used to verify if creating an instance of the class is fulfilled (either resolved or rejected). If it is fulfilled, true will be returned.

Returns
boolean

Indicates whether creating an instance of the class has been fulfilled (either resolved or rejected).

isRejected

inherited Method
Signature
isRejected (): boolean
Inherited from: EsriPromiseMixin

isRejected() may be used to verify if creating an instance of the class is rejected. If it is rejected, true will be returned.

Returns
boolean

Indicates whether creating an instance of the class has been rejected.

isResolved

inherited Method
Signature
isResolved (): boolean
Inherited from: EsriPromiseMixin

isResolved() may be used to verify if creating an instance of the class is resolved. If it is resolved, true will be returned.

Returns
boolean

Indicates whether creating an instance of the class has been resolved.

on

Method
Signature
on <Type extends EventNames<this>>(type: Type, listener: (event: this["@eventTypes"][Type]) => void): ResourceHandle
Type parameters
<Type extends EventNames<this>>

Registers an event handler on the instance. Call this method to hook an event with a listener. See the Events summary table for a list of listened events.

Parameters
ParameterTypeDescriptionRequired
type
Type

The name of the event or events to listen for.

listener
(event: this["@eventTypes"][Type]) => void

The function to call when the event is fired, if modifiers were specified.

Returns
ResourceHandle

Returns an event handler with a remove() method that can be called to stop listening for the event.

PropertyTypeDescription
removeFunctionWhen called, removes the listener from the event.
Examples
view.on("click", function(event){
// event is the event handle returned after the event fires.
console.log(event.mapPoint);
});
// Fires `pointer-move` event when user clicks on "Shift"
// key and moves the pointer on the view.
view.on("pointer-move", ["Shift"], function(event){
let point = view.toMap({x: event.x, y: event.y});
bufferPoint(point);
});
view.on("click", function(event){
// event is the event handle returned after the event fires.
console.log(event.mapPoint);
});

on

Method
Signature
on <Type extends EventNames<this>>(type: Type, modifiers: string[], listener: (event: this["@eventTypes"][Type]) => void): ResourceHandle
Type parameters
<Type extends EventNames<this>>

Registers an event handler on the instance. Call this method to hook an event with a listener.

Parameters
ParameterTypeDescriptionRequired
type
Type

The name of the event or events to listen for.

modifiers
string[]

Additional modifier keys to filter events. Please see Key Values for possible values. All the standard key values are supported. Alternatively, if no modifiers are required, the function will call when the event fires.

The following events don't support modifier keys: blur, focus, layerview-create, layerview-destroy, resize.

listener
(event: this["@eventTypes"][Type]) => void

The function to call when the event is fired, if modifiers were specified.

Returns
ResourceHandle

Returns an event handler with a remove() method that should be called to stop listening for the event(s).

PropertyTypeDescription
removeFunctionWhen called, removes the listener from the event.
Example
view.on("click", function(event){
// event is the event handle returned after the event fires.
console.log(event.mapPoint);
});

openPopup

inherited Method
Signature
openPopup (options?: ViewPopupOpenOptions): Promise<void>
Inherited from: PopupView
Since
ArcGIS Maps SDK for JavaScript 4.27

Opens the popup at the given location with content defined either explicitly with content or driven from the PopupTemplate of input features. This method sets the popup's visible property to true. Users can alternatively open the popup by directly setting the visible property to true.

A Popup instance is created and assigned to popup the first time openPopup() is called, unless popup is null. The popup then processes the click event.

When calling this method, to prevent the popup from opening when clicking on the view, set popupEnabled to false to stop event propagation on the view.

The popup will only display if the view's size constraints in dockOptions are met or the location property is set to a geometry.

See also
Parameters
ParameterTypeDescriptionRequired
options

Defines the location and content of the popup when opened.

Returns
Promise<void>

Resolves when the popup is opened. Calling openPopup() or closePopup() again rejects the Promise.

Examples
// Opens a popup manually depending on where the user clicks with specified title and content.
view.on("click", (event)=>{
view.openPopup({
location: event.mapPoint,
title: "You clicked here",
content: "This is a point of interest"
});
});
// Opens popup at the location of the click event and displays
// content for the selected features if a popupTemplate is defined.
view.on("click", (event)=>{
view.openPopup({
location: event.mapPoint,
fetchFeatures: true
});
});
// Opens popup with the properties specified at the location of the click event
// and updates the popup location based on the selected feature's geometry.
view.openPopup({
title: "You clicked here",
content: "This is a point of interest",
location: event.mapPoint,
updateLocationEnabled: true
});
// Opens popup with the specified array of graphics and displays the
// features in a list (feature menu) at the location of the first graphic in the array.
view.openPopup({
features: graphics,
featureMenuOpen: true,
location: graphics[0].geometry
});

takeScreenshot

Method
Signature
takeScreenshot (options?: Partial<ScreenshotUserSettings>): Promise<Screenshot>
Since
ArcGIS Maps SDK for JavaScript 4.9

Create a screenshot of the current view. Screenshots include only elements that are rendered on the canvas (all geographical elements), but excludes overlaid DOM elements (UI, popups, etc.). By default, a screenshot of the whole view is created. Different options allow for creating different types of screenshots, including taking screenshots at different aspect ratios, different resolutions and creating thumbnails.

Screenshots are always taken inside the padded area of the view (see padding).

See also
Parameters
ParameterTypeDescriptionRequired
options

Screenshot options.

Returns
Promise<Screenshot>

When resolved, returns an object containing an encoded dataUrl and raw image data.

Examples
// Take a screenshot at the same resolution of the current view
view.takeScreenshot().then(function(screenshot) {
let imageElement = document.getElementById("screenshotImage");
imageElement.src = screenshot.dataUrl;
});
// Create a square thumbnail from the current view
let options = {
width: 200,
height: 200
};
view.takeScreenshot(options).then(function(screenshot) {
let imageElement = document.getElementById("screenshotImage");
imageElement.src = screenshot.dataUrl;
});
// Take a high resolution, square screenshot
let options = {
width: 2048,
height: 2048
};
view.takeScreenshot(options).then(function(screenshot) {
let imageElement = document.getElementById("screenshotImage");
imageElement.src = screenshot.dataUrl;
});
// Take a screenshot of a small area at the center of the view
// Compute the size of the view excluding potential padding
let padding = view.padding;
let innerWidth = view.width - padding.left - padding.right;
let innerHeight = view.height - padding.top - padding.bottom;
// Desired size of the area
let width = 200;
let height = 200;
let options = {
area: {
x: (innerWidth - width) / 2,
y: (innerHeight - height) / 2,
width: width,
height: height
}
};
view.takeScreenshot(options).then(function(screenshot) {
let imageElement = document.getElementById("screenshotImage");
imageElement.src = screenshot.dataUrl;
});
// Takes a high-resolution screenshot for display on a HiDPI screen
// The pixelRatio indicates the display has 2x the pixel density of typical screens
let pixelRatio = 2;
view.takeScreenshot({ width: view.width * pixelRatio, height: view.height * pixelRatio });
// Takes a high-resolution screenshot for display on a HiDPI screen
// The pixelRatio is the resolution of the display capturing the image
let pixelRatio = window.devicePixelRatio;
view.takeScreenshot({ width: view.width * pixelRatio, height: view.height * pixelRatio });

toMap

Method
Signature
toMap (screenPoint: ScreenPoint | MouseEvent, options?: HitTestOptions3D): Point | null | undefined

Converts the given screen point to a map point.

Parameters
ParameterTypeDescriptionRequired
screenPoint

The location on the screen (or native mouse event) to convert.

options

Intersection test options. By default only the Map.ground and any IntegratedMeshLayer and IntegratedMesh3DTilesLayer are included.

Returns
Point | null | undefined

The map point corresponding to the given screen point.

toScreen

Method
Signature
toScreen (point: Point): ScreenPoint

Converts the given map point to a screen point.

Parameters
ParameterTypeDescriptionRequired
point

A point geometry.

Returns
ScreenPoint

The screen point corresponding to the given map point.

tryFatalErrorRecovery

inherited Method
Signature
tryFatalErrorRecovery (): void
Inherited from: View
Since
ArcGIS Maps SDK for JavaScript 4.12

Call this method to clear any fatal errors resulting from a lost WebGL context.

See also
Returns
void
Example
reactiveUtils.when(
() => view.fatalError,
() => view.tryFatalErrorRecovery()
);

when

inherited Method
Signature
when <TResult1 = this, TResult2 = never>(onFulfilled?: OnFulfilledCallback<this, TResult1> | null | undefined, onRejected?: OnRejectedCallback<TResult2> | null | undefined): Promise<TResult1 | TResult2>
Type parameters
<TResult1 = this, TResult2 = never>
Inherited from: EsriPromiseMixin
Since
ArcGIS Maps SDK for JavaScript 4.6

when() may be leveraged once an instance of the class is created. This method takes two input parameters: an onFulfilled function and an onRejected function. The onFulfilled executes when the instance of the class loads. The onRejected executes if the instance of the class fails to load.

Parameters
ParameterTypeDescriptionRequired
onFulfilled

The function to call when the promise resolves.

onRejected

The function to execute when the promise fails.

Returns
Promise<TResult1 | TResult2>

Returns a new promise for the result of onFulfilled that may be used to chain additional functions.

Example
// Although this example uses MapView, any class instance that is a promise may use when() in the same way
let view = new MapView();
view.when(function(){
// This function will execute once the promise is resolved
}, function(error){
// This function will execute if the promise is rejected due to an error
});

whenAnalysisView

Method
Signature
whenAnalysisView <AnalysisType extends Analysis>(analysis: AnalysisType): Promise<AnalysisView3DFor<AnalysisType>>
Type parameters
<AnalysisType extends Analysis>

Gets the analysis view created for the given analysis object. The returned promise resolves when the view for the given analysis has been created, or rejects with an error (for example if the analysis does not belong to analyses.

Parameters
ParameterTypeDescriptionRequired
analysis
AnalysisType

The analysis for which to obtain the analysis view.

Returns
Promise<AnalysisView3DFor>

Resolves to an instance of the analysis view for the provided analysis.

Example
// Create a slice analysis
let analysis = new SliceAnalysis();
// add to the sceneview
view.analyses.add(analysis);
view.whenAnalysisView(analysis)
.then((analysisView) => {
// The analysis view for the analysis
})
.catch((error) => {
// An error occurred during the analysis view creation
});

whenLayerView

Method
Signature
whenLayerView <TLayer extends Layer>(layer: TLayer): Promise<Layer extends TLayer ? LayerView : LayerView3DFor<TLayer>>
Type parameters
<TLayer extends Layer>

Gets the LayerView created on the view for the given layer. The returned promise resolves when the layer view for the given layer has been created, or rejects with an error (for example if the layer is not part of the view, or if the layer type is not supported in this view).

See also
Parameters
ParameterTypeDescriptionRequired
layer
TLayer

The layer for which to obtain its LayerView.

Returns
Promise<Layer extends TLayer ? LayerView : LayerView3DFor>

Resolves to an instance of LayerView for the specified layer.

Examples
// Create a feature layer from a url pointing to a Feature Service
let layer = new FeatureLayer(url);
map.add(layer);
view.whenLayerView(layer)
.then(function(layerView) {
// The layerview for the layer
})
.catch(function(error) {
// An error occurred during the layerview creation
});
// Create a feature layer from a url pointing to a Feature Service
let layer = new FeatureLayer(url);
map.add(layer);
view.whenLayerView(layer)
.then(function(layerView) {
// The layerview for the layer
})
.catch(function(error) {
// An error occurred during the layerview creation
});

zoomIn

Method
Signature
zoomIn (): Promise<void>
Since
ArcGIS Maps SDK for JavaScript 5.0

Zooms in the view by a factor of 2.

Returns
Promise<void>

A promise that resolves when the view has been zoomed in.

zoomOut

Method
Signature
zoomOut (): Promise<void>
Since
ArcGIS Maps SDK for JavaScript 5.0

Zooms out the view by a factor of 2.

Returns
Promise<void>

A promise that resolves when the view has been zoomed out.

Events

analysis-view-create

inherited Event
analysis-view-create: CustomEvent<AnalysisViewCreateEvent>
Inherited from: AnalysisViewEvents
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires when the view for an Analysis is created.

See also
bubbles composed cancelable

analysis-view-create-error

inherited Event
analysis-view-create-error: CustomEvent<AnalysisViewCreateErrorEvent>
Inherited from: AnalysisViewEvents
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires when an error occurs during the creation of an Analysis after an analysis is added to the view.

See also
bubbles composed cancelable

analysis-view-destroy

inherited Event
analysis-view-destroy: CustomEvent<AnalysisViewDestroyEvent>
Inherited from: AnalysisViewEvents
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after an analysis view is destroyed.

bubbles composed cancelable

blur

inherited Event
Inherited from: ViewEventTypes

Fires when browser focus is moved away from the view.

bubbles composed cancelable

click

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a user clicks on the view. This event emits slightly slower than an View.@immediate-click event to make sure that a View.@double-click event isn't triggered instead. The View.@immediate-click event can be used for responding to a click event without delay.

See also
bubbles composed cancelable
Examples
view.on("click", function(event){
// event is the event object returned after the event fires
// Prints the map coordinates of the clicked location
console.log(event.mapPoint);
});
// Set up a click event handler and retrieve the screen point
view.on("click", function(event) {
// the hitTest() checks to see if any graphics in the view
// intersect the given screen x, y coordinates
view.hitTest(event)
.then(getGraphics);
});
view.on("click", function(event) {
// you must overwrite default click-for-popup
// behavior to display your own popup
view.popupEnabled = false;
// Get the coordinates of the click on the view
let lat = Math.round(event.mapPoint.latitude * 1000) / 1000;
let lon = Math.round(event.mapPoint.longitude * 1000) / 1000;
view.popup.open({
// Set the popup's title to the coordinates of the location
title: "Reverse geocode: [" + lon + ", " + lat + "]",
location: event.mapPoint // Set the location of the popup to the clicked location
content: "This is a point of interest" // content displayed in the popup
});
});

double-click

inherited Event
double-click: CustomEvent<DoubleClickEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after double-clicking on the view.

bubbles composed cancelable
Example
view.on("double-click", function(event) {
// The event object contains the mapPoint and the screen coordinates of the location
// that was clicked.
console.log("screen point", event.x, event.y);
console.log("map point", event.mapPoint);
});

double-tap-drag

inherited Event
double-tap-drag: CustomEvent<DoubleTapDragEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires while the pointer is drag following a double-tap gesture on the view.

bubbles composed cancelable
Example
view.on("double-tap-drag", (event) => {
// Display the distance moved from the drag origin.
console.log("x distance:", event.x, "y distance:", event.y);
});

drag

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires during a pointer drag on the view.

bubbles composed cancelable
Example
view.on("drag", function(event){
// Print out the current state of the
// drag event.
console.log("drag state", event.action);
});

focus

inherited Event
Inherited from: ViewEventTypes

Fires when browser focus is on the view.

bubbles composed cancelable

hold

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after holding either a mouse button or a single finger on the view for a short amount of time.

bubbles composed cancelable
Example
view.on("hold", function(event) {
// The event object contains the mapPoint and the screen coordinates of the location
// that was clicked.
console.log("hold at screen point", event.x, event.y);
console.log("hold at map point", event.mapPoint);
});

immediate-click

inherited Event
immediate-click: CustomEvent<ImmediateClickEvent>
Inherited from: ViewEventTypes

Fires right after a user clicks on the view. In contrast to the View.@click event, the immediate-click event is emitted as soon as the user clicks on the view, and is not inhibited by a View.@double-click event. This event is useful for interactive experiences that require feedback without delay.

bubbles composed cancelable
Example
// Set up an immediate-click event handler and retrieve the screen point
view.on("immediate-click", function(event) {
// the hitTest() checks to see if any graphics in the view
// intersect the given screen x, y coordinates
view.hitTest(event)
.then(getGraphics);
});

immediate-double-click

inherited Event
immediate-double-click: CustomEvent<ImmediateDoubleClickEvent>
Inherited from: ViewEventTypes

Is emitted after two consecutive View.@immediate-click events. In contrast to View.@double-click, an immediate-double-click cannot be prevented by use of stopPropagation on the View.@immediate-click event and can therefore be used to react to double-clicking independently of usage of the View.@immediate-click event.

bubbles composed cancelable

key-down

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a keyboard key is pressed.

bubbles composed cancelable
Example
// Zoom in when user clicks on "a" button
// Zoom out when user clicks on "s" button
view.on("key-down", function(event){
console.log("key-down", event);
if (event.key === "a"){
let zm = view.zoom + 1;
view.goTo({
target: view.center,
zoom: zm
});
}
else if(event.key == "s"){
let zm = view.zoom - 1;
view.goTo({
target: view.center,
zoom: zm
});
}
});

key-up

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a keyboard key is released.

bubbles composed cancelable

layerview-create

inherited Event
layerview-create: CustomEvent<LayerViewCreateEvent>
Inherited from: ViewBaseEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after each layer in the map has a corresponding LayerView created and rendered in the view.

See also
bubbles composed cancelable
Example
// This function fires each time a layer view is created for a layer in
// the map of the view.
view.on("layerview-create", function(event) {
// The event contains the layer and its layer view that has just been
// created. Here we check for the creation of a layer view for a layer with
// a specific id, and log the layer view
if (event.layer.id === "satellite") {
// The LayerView for the desired layer
console.log(event.layerView);
}
});

layerview-create-error

inherited Event
layerview-create-error: CustomEvent<LayerViewCreateErrorEvent>
Inherited from: ViewBaseEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires when an error occurs during the creation of a LayerView after a layer has been added to the map.

See also
bubbles composed cancelable
Example
// This function fires each time an error occurs during the creation of a layerview
view.on("layerview-create-error", function(event) {
console.error("LayerView failed to create for layer with the id: ", event.layer.id);
});

layerview-destroy

inherited Event
layerview-destroy: CustomEvent<LayerViewDestroyEvent>
Inherited from: ViewBaseEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a LayerView is destroyed and is no longer rendered in the view. This happens for example when a layer is removed from the map of the view.

bubbles composed cancelable

mouse-wheel

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires when a wheel button of a pointing device (typically a mouse) is scrolled on the view.

bubbles composed cancelable
Example
view.on("mouse-wheel", function(event){
// deltaY value is positive when wheel is scrolled up
// and it is negative when wheel is scrolled down.
console.log(event.deltaY);
});

pointer-down

inherited Event
pointer-down: CustomEvent<PointerDownEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a mouse button is pressed, or a finger touches the display.

bubbles composed cancelable

pointer-enter

inherited Event
pointer-enter: CustomEvent<PointerEnterEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a mouse cursor enters the view, or a display touch begins.

bubbles composed cancelable

pointer-leave

inherited Event
pointer-leave: CustomEvent<PointerLeaveEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a mouse cursor leaves the view, or a display touch ends.

bubbles composed cancelable

pointer-move

inherited Event
pointer-move: CustomEvent<PointerMoveEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after the mouse or a finger on the display moves.

bubbles composed cancelable
Example
// Fires `pointer-move` event when user clicks on "Shift"
// key and moves the pointer on the view.
view.on('pointer-move', ["Shift"], function(event){
let point = view.toMap({x: event.x, y: event.y});
bufferPoint(point);
});

pointer-up

inherited Event
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires after a mouse button is released, or a display touch ends.

bubbles composed cancelable

resize

inherited Event
Inherited from: ViewBaseEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires when the view's size changes.

See also
bubbles composed cancelable

vertical-two-finger-drag

inherited Event
vertical-two-finger-drag: CustomEvent<VerticalTwoFingerDragEvent>
Inherited from: ViewEventTypes
Since
ArcGIS Maps SDK for JavaScript 5.0

Fires while the two pointers are dragged on the view.

bubbles composed cancelable
Example
view.on("vertical-two-finger-drag", (event) => {
// Display the distance moved vertically from the drag origin.
console.log("y distance:", event.y);
});