API

Switches the generated legend of a source: 'calculate' layer to categorical mode. When true, every distinct value returned by expression() becomes its own legend entry (values are grouped by value, never into ranges) and the colours come from categoricalPalette. When false the values are grouped into at most maxQntEntries ranges coloured with the sequential (blue to red) palette. Use it when the expression returns classes (land use, geology, ...) instead of a continuous number.

Colours of the legend entries of a categorical source: 'calculate' layer (see categorical), as an array of [R, G, B] triplets (0 to 255). The entries are assigned, in the sorted order of the values returned by expression(), spreading evenly over the palette. When omitted a built-in 300-colour palette is used. The palette length is also the upper limit for maxQntEntries.

Define the text that will be displayed when the mouse hover the Legend Window Title. This description applies when the 'source' of the map is 'xyz' or the Layer is a 'vector'.

Define the content that will be displayed at the Query section ("Exibir Consulta" button). This property accepts any string in HTML format. Besides that, you can also use predefined tools. Only calculated, file and tile (xyz) layers have this panel; on a published map (no source, source: 'local' or a server added with addRemoteWMSServer) it is ignored.

Define which styles will be hidden in the Style Chooser Combobox from Layers that has the 'source' property as 'local'. You need to pass the name of a style as in the GetCapabilities() xml. They follow the pattern of the map name, underline (_) and then the number of the style. (<map_name>_<number>). You can hide more than one style. For this you only need to separate their names by commas.

Define a name for a Layer Details. Between all Layers with the same ‘exclusiveGroupDetails’ name, only one Layer can have its Legend open each time.

Define which tiles will be used to render the map. All the tiles that are within the 'extents' coordinates will be used to render the map. The extents must be in EPSG:4326 (coordinates in lat,long). Also, the array values need to be in the order: [minX, minY, maxX, maxY].

A second way to declare query globals from a layer: an object whose properties become temporary globals, passed to ExtjsUtils.QUERY.setQueryGlobalProperties while the layer is interpreted. The usual form is the ExtjsUtils.QUERY.setQueryGlobalProperties({...}) && [...] chain at the top of the query; the production survey found no query using this key (zero users).

Hides the legend of the layer in its Legend Window. Set it to 'true' to hide it, 'false' to display it. It applies to every layer source: on a local layer it hides the "show legend" toggle button of the row; on a calculate, file or xyz layer it hides the generated legend container (with the legend title and the opacity slider) and the "show legend" button at the bottom of the query section, so only the descriptionHtml remains.

Hides the layer from its group's menu at the top of the screen: the list that appears when the mouse is over the group title. Set it to true to leave the layer out of that menu; false (the default) lists it.

If true, hides the metadata button in the Legend Window for this layer. The button is also hidden when the link has options=hidemetadata: either one hides it, and hideMetadata: false cannot bring it back. Calculated, file and tile (xyz) layers only have this button when their paramsButtonConfig has a {type: 'metadata'} entry.

Define if should hide the Combobox with the map possible styles that can be applied to a map in a Layer that has the 'source' 'local'.

Removes the stretched placeholder tile that is shown while the real tiles load (the OpenLayers resize transition). Set it to true for layers whose content changes between loads, such as timeline or calculated maps, to avoid the previous image being stretched before the new one appears. Applies to local and calculate layers; a composed layer also passes it on to the maps replaced with changeLayers.

Defines the opacity for the maps defined in the 'name' property. This property is an array of values which are the opacity that will be applied in the same order that the map was defined in the 'name' property. For example, the first value in the 'insideOpacity' array will define the opacity for the first map defined in the 'name' property, the second value is the opacity for the second map, and so on. The opacity value is a number between 0 and 1. 0 being transparent and 1 opaque.

Defines the text that will be displayed at the top of the 'legendhtml tool' declared at the 'descriptionHtml' property

Maximum number of legend entries generated from the values returned by expression() on a non-categorical source: 'calculate' layer; when there are more distinct values than this they are grouped into value ranges. The value is clamped to the length of the active palette. PS: the automatic grouping currently always uses the built-in limit of 18, so a custom value is kept on the layer but does not change the generated legend. Use setCalculateLegend() when you need full control over the legend entries.

Defines the maps that will be a part of the Layer. Every map defined in here will be shown when the Layer is active. Besides that, all of their information can be used to calculate a new map combining their data. In this website you will find some of the maps that can be used: http://maps.csr.ufmg.br/geonetwork/srv/por/search. You can find their name at the section "Visão geral do mapa" under its image. Those maps have the prefix "CSR:" before their names. Maps can also be uploaded by you. For that, you just need to define the 'source' property as 'file'.

Define the opacity of the Layer. The opacity is a value between 0 and 1 that is a scale for its transparency. 0 is completely transparent. 1 is completely visible.

Defines additional maps to be available for the query, which will be listed in the filtered stored capabilities. Every map included in layer definition needs to be either in 'name' property or 'otherNames' property.

PS: This property must be used along with the 'capabilities' url option, which filters the 'GetCapabilities' response with only the maps included in layer definition. (Performance Optimization, faster loading). PS2: This property is only needed outside of the editor mode.

Defines the order of which map will be rendered on top of the others. Layers with higher 'priority' will always be rendered on top of the layers with lower 'priority'.

Shows the "generating legend" loading mask visibly over the page while the layer is paused (calculating or loading a resource). By default the mask is an invisible overlay that only changes the cursor to "wait"; set it to true to make it visible. Only shown while the layer is visible. Applies to calculate and file layers.

Defines it the remove button at the top right of the Layer Legend Window show be displayed. Set it to 'true' to show it. Set it to 'false' to hide it.

Defines the source from where the maps declared at the name will be loaded from. The Source can be one of the following:

• 'local': The maps in the name will be loaded from the CSR servers

• 'calculate': The maps in the name gonna be used to calculate a new map in the expression() function and the result will be displayed as the Layer

• 'file': The map will be loaded from a file or other custom source. For this, you need to define the file type in the 'type' property and the file where the map should be loaded. For example, for a JSON file, you also need to define the 'json' property.

• 'xyz': The map will be loaded from an url by the XYZ protocol. The url property is required for this type of source. You can find more informations about the XYZ protocol at: https://developers.planet.com/docs/basemaps/tile-services/xyz/

Defines if the Legend Window should start or not. Set it to 'true' to make it start open. Set it to 'false' for it to start closed. Applies to published maps only (no source, source: 'local' or a server added with addRemoteWMSServer). Calculated, file and tile (xyz) layers ignore it: their details already start open, and paramsButtonConfig: [{type: 'query', pressed: true}] makes them start on the layer's panel instead.

Define if the Layer should start with its Legend Window visible or not. This does not make the Layer visible on the map by itself. For that, you need to set the 'visibility' property to 'true'. 'startListed' just displays the Legend Window associated with the Layer.

Defines which styles will be applied over the maps defined at the 'name' property. The styles are applied in the same order as the maps are declared in name. For example, if there are 3 maps in the 'name' property and 3 styles. The first style will be applied to the first map, the second to the second map, and so on. A style's Mappia identifier is the map name without its namespace plus _ and an index (estados published with two styles gives estados_0 and estados_1), and the styles a map really offers are the ones its published capabilities declare: open the layer's style chooser in the interface to see and pick them, or read the Style entries of the map in the WMS capabilities. Styles are created when the map is published (a QGIS style file is converted at publication time), not by the query. PS: Styles are separated by comma, one per map in name, in the same order.

Define the thumbnail image that is displayed when the mouse hovers the Legend Window title. You can define any image you would like to display as the map thumbnail. You just need to pass its URL.

Defines the Title that will be displayed at the Legend Window in the top left corner of the screen and inside the Group List at the top center of the screen.

Decides what happens when the reader changes an input of the layer's panel (a widget in descriptionHtml). true: the layer is calculated again at once. false (the default): a short countdown starts, with a button to refresh now, so several changes make one calculation. The layer is drawn either way. Applies to calculated and file layers.

HTML color to use on the group.

Define if the Layer should start visible or not. Set it to 'true' for the Layer start visible. Otherwise, set it to 'false' and the Layer will start hidden.

Recognizes someone as the platform author, showing in the "Powered by: {insert name}".

Extra CSS class added to the row of the layer in the Legend Window and to its vertical options menu (see verticalMenu), so the layer can be styled with ExtjsUtils.CSS.defineClass or a stylesheet. The same key on a viewTitle group is added to the group node instead (GroupProperties.customLayerClass).

Only the value "background" does anything: it makes the layer a basemap, drawn under every other layer and listed in the background picker instead of the layer list. Any other value is ignored (it does not group layers: groups are { title, elements: [...] } objects). To let only one of several layers be visible at a time, use toggleGroup.

Defines a geographical limit for a map rendering.

Defines the limit of the real max zoom of a given layer. When map zoom exceed this, the image is reused and stretched.

Defines the limit of the real max scale of a given layer. When the map scale value exceeds the defined one, the image is reused and stretched.

Defines the url to show custom layers metadata information. If empty, the default value is obtained from layer metadata from the WMS definition.

PS: The linked domain must have CORS headers enabled.

Defines the limit of the real min scale of a given layer. When the map scale reaches a value lower than the defined one, the image is reused and compressed.

Defines if the group starts opened, even without any visible layers. Set it true to start open, false otherwise. PS: If one layer is visible, the group will start open. It works at both levels: on a viewTitle group it makes that group start expanded; on a layer it expands every viewTitle ancestor of the layer (see GroupProperties.openGroup).

Defines how the pixels of each map of a source: 'calculate' layer are decoded into the values that expression() receives in layersVals. It is a comma-separated list with one token per map in name, in the same order; an empty token keeps that map on the default decoding (for example 'raw,,sum' leaves the second map on the default). Tokens are case and whitespace insensitive. The accepted tokens (see RawMaps.operations for the full description of each one) are:

• (empty or unknown): NORMAL, the regular WMS image, each pixel is a legend colour/category.
• raw: the value of the most centred original cell of the region covered by the pixel.
• rgba: the RGBA bytes of the pixel packed as one integer.
• sum: area-weighted sum of the covered cells.
• average: area-weighted mean of the covered cells.
• max / min: largest / smallest cell at least partially covered.
• integral: summed-area table, the sum over a rectangle from its four corners.
• areaintegral: summed-area table of the covered areas.
• area: original map area inside the covered region.
• cells: weighted count of original cells inside the covered region. Every token other than the default and rgba requires the map to be published as a Raw Map offering that operation; otherwise the console logs Error: Operation X is not defined for layer Y.

Defines what the 'X' (remove) button of the Legend Window does (see showRemoveBtn). When true the layer record is kept: the layer is only hidden and removed from the listing, so it can be listed again from the group menu at the top. When false the layer is removed from the map for good.

Places a layer in a group of layers with mutually exclusive visibility.

At most one layer of the same group will be visible, when one is shown, the others will be hidden.

If false, the layer tooltip is not shown. If a number, the layer tooltip is shown for the specified layer. (Only supported for layers with source: "calculate") Otherwise follow tooltip default behavior that varies from map source

Uses the compact layout for the Legend Window of the layer: the secondary buttons (remove, metadata, download, zoom to extents) and a vertical opacity slider move into a small options menu opened by a gear button, instead of being drawn in the row with the horizontal opacity slider. Usually used together with customLayerClass.

This function is executed right after the 'expression()' calculations. This function is only available for a Layer with a 'source' of type 'calculate' and that has defined the 'expression()' function.

This function is executed before any calculation is made in the 'expression()' function. It runs on calculated layers (source: 'calculate'), even when there is no 'expression()', and on file layers (source: 'file'), where it runs again whenever an input changes or a resource finishes loading (see VectorLayer.generateNewLegend).

This function is executed for every pixel in the map. It can be used to process the information of all maps in the Layer to create a new one. This function is called regularly to update the map.

Associate custom functions to handle events on layer callbacks such as button callbacks or any layer callbacks. These functions are scoped to the Layer and can be referenced by name on layer widget callbacks. Functions can also be accessed using this.functions['<function_name>'].

This function generates the color of each value/category of the calculated map generated by the 'expression()' function. The return value is the legend color that will be applied to the category. PS: This function callback is called in layer context.

This function is called when all inputs have been loaded and are ready. Even from Layers that aren’t visible.

This function is called whenever a Layer changes its visibility. Like, when the user toggle the value in the visibility button at the top right in the Legend Window.

Makes the row button of a paramsButtonConfig entry that mirrors a widget (an entry with associatedButtonID) a toggle (true) or a plain push button (false). PS: Once the mirrored widget is found the platform sets it from that widget (a checkbox or a toggle button makes it a toggle), so your value only counts while the widget does not exist.

Hides the text buttons at the bottom of the query and legend sections of the Legend Window ("Show query"/"Hide query" and "Show legend"/"Hide legend"). Set it to 'true' to hide them or 'false' to display them. It only works inside a paramsButtonConfig entry of type: 'query' (or in the bare object form of paramsButtonConfig, which is treated as the query entry); a hideBottomButton written directly on the layer or in a group's defaultProperties is ignored.

Define if the associated button should be hidden. Set it to 'true' to hide the button or 'false' to show it. This property only applies to the type: 'query'

Define a class that will be added to the html in the associated button.

This class can be one that has a image on it like:

• 'gxp-icon-togglevisibility' is the icon of the Show/Hide Map Button (The first icon on the Legend Window, from left to right)
• 'gxp-icon-removelayers' is the icon of the Remove Layer Button (The second icon on the Legend Window, from left to right)
• 'gxp-icon-parameters-expand' is the icon of the Show Query Button (The third icon on the Legend Window, from left to right)
• 'gxp-icon-legend-expand' is the icon of the Show Legend Button (The forth icon on the Legend Window, from left to right)
• 'gxp-icon-downloadmapbutton' is the icon of the Download Button (The fifth icon on the Legend Window, from left to right)

Defines if the button should start pressed or not. Set it to 'true' for it to start pressed or 'false' for start unpressed. For example, the 'query' button type set as pressed will display the Query region (where the descriptionHtml content is) by default instead of the Legend region. This property applies only to the types: 'query',

Defines a group for all the buttons that has the same toggleGroup name. From all the buttons on the same group, only one can be active at each time. Whenever another one is activated the previous one collapses.

Defines the help tooltip text that is displayed when the mouse hover the associated button.

Define which button will be affected by the configurations. The type can be one of the following:

• 'query': The query button shows or hides the Query panel (where the descriptionHtml is drawn).

• 'download': The download button is the one with a downward arrow. This button allows the user to download the dataset. It also defines which Layer should be downloaded when more than one Layer is shown by its internal layer index.

• 'metadata': The metadata button is the one with a script icon. This button displays a popup with more information about the maps used in the actual Layer. You can make it show one of the inside composite Layer by his index.

• 'associated': Creates a custom button that is linked to another button defined in the descriptionHtml. When one is pressed the other is also pressed.

paramsButtonConfig is normally an array of entries and each entry must declare its type (an entry without type is ignored). It may also be a single object instead of an array: it is then treated as one entry of type: 'query' (unless the object declares another type). PS: The properties are aditional, so the common must always be present, and for each type his corresponding property must be added.

Defines a function that will be called when the associated button is clicked.

This function is called whenever the associated button change its toggle state. PS: Using custom function, ignore the associatedButtonID "It doesnt have to even exists".

Where a map's styles come from: they are not written in the query. A map is published with one or more styles, and when it is published from QGIS the layer's QGIS style is converted at publication time, so the classes, colours and legend labels the map shows online are the ones set in QGIS. Each converted style becomes a Mappia style identifier - the map name without its namespace, plus _ and an index - and those identifiers are what a query selects with the styles property, what the layer's style chooser lists, and what the legend renders.

So changing how a map looks is a publication step, not a query change: restyle it in QGIS, publish again, and reference the style from the query.

Enumeration of the operations a map of a source: 'calculate' layer can be decoded with. This is what the operation layer key selects, one token per map in name; the tokens are the lower-case names below, matched case and whitespace insensitive. The values are integers; getFromString(token) and getName(value) convert between the two forms.

• NORMAL (0, an empty or unknown token): a regular WMS image, each cell is a legend colour/category and not a Raw Map.
• RAW (1, raw): each resulting cell has the value of the most centred original cell of the aggregated region.
• RGBA (2, rgba): each resulting cell is an integer packing the RGBA bytes of the pixel (input and output are integers).
• SUM (3, sum): each resulting cell is the weighted sum of the cells of the covered region, the weight being the covered fraction of each cell (VALUE * COVERED_PERCENTAGE).
• AVERAGE (4, average): each resulting cell is the weighted mean of the cells of the covered region.
• MAX (5, max): the greatest cell at least partially covered by the region.
• MIN (6, min): the smallest cell at least partially covered by the region.
• INTEGRAL (7, integral): summed-area table, so the sum inside any rectangle is obtained from its four corner cells only.
• AREAINTEGRAL (8, areaintegral): summed-area table of the covered areas (no further description in the source).
• AREA (9, area): each cell carries the original map area inside the aggregated region, so totals can be computed at any scale with full precision.
• CELLS (10, cells): weighted count of the original cells inside the region. Every operation other than NORMAL and RGBA requires the map to be published as a Raw Map that offers it.

Calls one of the layer's own functions by name with the layer as this. Extra arguments are passed through to the function.

Replaces an internal layer at a given index. PS: It's highly recommended to pass multiple configurations in an array, instead of calling this function multiple times in the same callback.

Schedules a new legend: cancels the calculations in progress, runs beforeCalc(inputs) with the current input values and, when every tile is loaded and the layer is not paused, recalculates the map and its legend. It is the supported way to force the layer to refresh itself from outside a normal calculation cycle (for example from onVisibilityChange or a {{button}} handler).

Returns the current value of every input tool declared in descriptionHtml, in declaration order (the same array beforeCalc, expression and afterCalc receive as inputs). A value can be a simple one (number, string) or a complex object (a CSV table, a picked point, ...). Use it from callbacks that do not receive inputs, such as a {{button}} handler.

Returns the OpenLayers WMS layers that compose this layer, one per map in name and in the same order (a copy of the internal array, so changing it does not affect the layer).

Returns one of the functions declared in the layer's functions object by its name (the same functions that markup tools reference by name, e.g. handler=onClick). Composed-layer twin of VectorLayer.getLayerDefinedFunctionsByName; the returned function is not bound, so call it with .call(this, ...) from a layer callback to keep the layer as this.

Returns the entries of the legend currently applied to the calculated map, in legend order. Each entry has the [R, G, B] colour of the pixels, the title shown in the legend (the value itself when no title was defined) and whether it represents the null value of the map. Returns an empty array before the first legend is generated. Use it to build a custom legend (e.g. an HTML gradient) or to map a colour back to its category.

Returns the indexes (positions in the name list) of the composing maps that are currently visible, in ascending order. Useful inside beforeCalc/expression when some of the inside maps were toggled with setInsideLayerVisibility().

Returns calculation status. True if calculations are paused, false otherwise.

Cancels the calculations in progress and pauses the start of new ones (the "generating legend" indicator is shown while paused). Call it when something the expression depends on starts loading, and resumeCalculations() when it is done. The pause is cumulative: every call needs a matching resumeCalculations() before the layer calculates again (isCalculationPaused() tells the state).

Undoes pauseAndStopCalculations(). Call it whenever a resource finished loading; when the last pending pause is released the layer is redrawn (which recalculates it).

Defines the legend of the calculated map yourself, which also skips the automatic legend calculation for this cycle. It is meant to be called inside beforeCalc, the moment right before a new legend would be computed, but it can also be called from a tool callback (e.g. a {{button}} handler). When the given entries equal the current legend nothing is redrawn.

Shows or hides the maps that compose the layer (the ones listed in name) without touching the layer itself. Pass layerIndex to change one map only, omit it to change all of them. The platform hides every inside map when the layer has an expression() (only the calculated result is shown) and shows them all otherwise; use this to reveal one of the source maps behind a calculated result.

Sets the decoding operation of one of the maps of the composed layer (the same tokens accepted by the operation layer key, e.g. 'raw', 'sum', 'average'; '' or null means the default decoding). The platform calls it from the operation key at creation; when called at runtime the new operation is only used after the map legends are read again (for example when changeLayers replaces a map).

Internal — the pixel loop of a calculate layer: for every pixel of the tile it reads one value per inner map (colour looked up in the map's legend, or the raw cell value for raw/sum/... operations) and calls the layer's expression(layersVals, inputs) with them. Pixels that are null in every map become this.nullValue without calling the expression. The expression is invoked with this bound to this ValuesCalculation instance, which is why this.isNumeric(v) works inside an expression (ValuesCalculation.prototype.isNumeric(v) also works). Tenant code never calls this directly; the layer worker does.

Unpacks the four RGBA bytes packed in a 32-bit integer: byte 0 (lowest) is red, byte 1 green, byte 2 blue and byte 3 alpha. This is the packing the rgba map operation uses, where a pixel colour travels as one integer (the layer worker paints such results with getNonNullColorFromInt). Inside an expression function this is the ValuesCalculation instance, so this.getColorFromInt(v) works there; ValuesCalculation.prototype.getColorFromInt(v) also works, anywhere.

getColorFromInt with a null check: returns this.nullColor (null) when the packed integer is one of the values listed in nullValues, and the unpacked [r, g, b, a] otherwise. Handy when a map encodes "no data" as one or more specific colours. Inside an expression function this is the ValuesCalculation instance, so this.getNonNullColorFromInt(v, nulls) works there; ValuesCalculation.prototype.getNonNullColorFromInt(v, nulls) also works, anywhere.

Turns a legend label into the value that best represents it — the same conversion the calculation applies to every map legend before the expression sees layersVals. A numeric label ("12", "1,5", "1.000") becomes that number (a single comma is read as the decimal separator, "1.000"/"1,000" as thousands), a range ("10 - 20", "10 – 20", "10 to 20") becomes its midpoint, a leading comparison operator ("> 800", "<= 5", "> 800") is stripped first, and any other text ("Floresta") is returned unchanged. An empty label returns null. Use it to interpret legend titles you read with ExtjsUtils.LAYER.getLayerLegend the same way the layer does. Inside an expression function this is the ValuesCalculation instance, so this.getValueFromLegend(label) works there; ValuesCalculation.prototype.getValueFromLegend(label) also works, anywhere. To mark a pixel transparent, pass/return this.nullValue.

Tells whether a value represents a number: a Number, or a String that is a plain decimal/exponential number ("12", "-3.5", "1e3"). Map values read from a legend can be either a number or the legend's text (e.g. "Floresta"), so use this in an expression before doing arithmetic on layersVals[i]. Inside an expression function this is the ValuesCalculation instance, so this.isNumeric(v) works there; ValuesCalculation.prototype.isNumeric(v) also works, anywhere.

The value that stands for "no data" in a calculation: NaN. Return this.nullValue from an expression to leave the pixel transparent, and compare against it (with isNaN) when an inner map's value may be null. Inside an expression function this is the ValuesCalculation instance, so this.nullValue is the way to reach it there (ValuesCalculation.prototype.nullValue works anywhere).

Returns a shorter representation of a numeric value for display in a legend: values with an absolute value below 0.005 are written in exponential notation with 2 decimals, other values below 1 are kept to 3 significant digits and everything else is rounded to 2 decimals. Non-numeric values are returned unchanged. Useful inside afterCalc or legendTitle code that formats the legend entries of a calculated layer. Inside an expression function this is the ValuesCalculation instance, so this.simplifyLegend(n) works there (and ValuesCalculation.prototype.simplifyLegend(n) works anywhere).

Returns the loaded legend entries of a map: an array of {color: [r, g, b], title} objects in legend order, or undefined while the legend has not been loaded (or failed). This is the documented route to a map's legend — it accepts the layer object itself and is what ExtjsUtils.LAYER.getLayerLegend(composedLayer, index) uses; the inner jsonLegends.getJsonLegend(id) needs the unique id instead.

Returns the cell type (LayerWorkerUtils.CellTypes: INT32, UINT32, FLOAT32) the calculation must use to decode a map under a given operation, as declared by the map's description metadata. Falls back to INT32 when the map does not declare the operation (see hasOperation). Mostly informational for query authors; the calculation calls it itself.

Returns the key under which the reader stores a layer's legend: the string itself when given a string, the layer's id (assigned by Ext.id) when given a WMS layer object, and an empty string for anything else (a layer without params). Use it to build the id the jsonLegends manager methods expect.

Looks up the legend title of a colour in a map's legend: the title of the entry whose [r, g, b] equals the first three components of color. Returns an empty string when the map has no legend loaded, the colour is not in it, or color has fewer than three components. This is what turns a pixel colour read from an inner map into its class name (e.g. for a tooltip); for the Composed layer's own calculated legend use ExtjsUtils.LEGENDS.getColorTitle(layer, r, g, b) instead.

Tells whether a map supports a given decoding operation (see RawMaps.operations): the normal and rgba operations are always supported (they only need the WMS image), the others (raw, sum, average, ...) only when the map's description metadata declares a cell type for them. Useful to check, after the legends loaded, whether an operation you plan to set on a layer will actually work.

The legend store of the reader, keyed by layer unique id (see getLayerUniqueId: a layer's id, e.g. layer.layers[0].id for an inner map of a Composed layer). Queries reach it as layer.jsonLegendReader.jsonLegends and mostly call getJsonLegend(id); prefer the outer getJsonLegend(layer) or ExtjsUtils.LAYER.getLayerLegend(layer, index) when you hold the layer object. Its four methods: getJsonLegend(layerUniqueId) → Array<{color: [r, g, b], title: String}>|undefined — the loaded legend entries (undefined while not loaded or after remove); setJsonLegend(layerUniqueId, legendArray) — stores a legend array for that id; wasLoaded(layerUniqueId) → Boolean — whether a legend (even an empty one) is stored; remove(layerUniqueId) — forgets the stored legend, so it is fetched again next time.

Stores the legend of a layer from its JSON content, replacing whatever the reader had for it. The platform calls it when a legend request finishes; a query can call it to inject a legend for a map that has none (or to override the server's), e.g. before a calculate layer reads the legend values. A string is evaluated as JSON.

Inline data of a source: 'file' layer with type: 'json'. Either a GeoJSON object (FeatureCollection, Feature or a geometry; its projection is taken from fromProj, its crs or guessed from the coordinates) or an array of plain objects, each converted to a feature with convertJsonEntryToFeature (see coordinates/getVector). A JSON string is also accepted.

Custom loader of a source: 'file' layer with type: 'load': function(inputs, config) called with the layer as this, receiving the current input values and the layer definition. Add the features yourself (this.addFeatures, this.loadGeojson, ...) and trigger startLoadingLayer before and endLoadingLayer after every asynchronous load, so the layer knows when the data is ready (onInputsReady/onLoad depend on it).

Callback when layer visibility is changed.

PS: Is not called for the initial visibility of the layer.

Defines how a source: 'file' layer gets its features (case insensitive). One of:

'load': you load the data yourself in the loadData callback (function(inputs, config), called with the layer as this).
   The callback must trigger this.events.triggerEvent('startLoadingLayer') before and this.events.triggerEvent('endLoadingLayer') after each load (the calls are cumulative). 'csv': fetches the CSV file at url; each line becomes a feature through convertJsonEntryToFeature (see coordinates/getVector). 'json': uses the inline json data: a GeoJSON object (FeatureCollection, Feature or geometry) or an array of plain objects converted with convertJsonEntryToFeature. 'jsonurl': fetches an array of plain objects from url and converts each one with convertJsonEntryToFeature. 'geojsonurl': fetches a GeoJSON file from url (projection detected from its crs, fromProj or the coordinates). 'empty': creates no feature; the usual choice for layers that are drawn into or filled later with loadGeojson/addFeatures.

When omitted the type is 'json'; an unknown value falls back to 'jsonurl'.

URL of the data of a source: 'file' layer, used by the types csv (a CSV file), jsonurl (a JSON array of plain objects) and geojsonurl (a GeoJSON file). Relative URLs are resolved against the Mappia page. Also available inside loadData as config.url for type: 'load'.

Select polygon/line tool and enter edit mode when needed (split-button menu).

Finish sketch or deselect feature (triggers featureEditEnd when applicable).

Replace geometries on this drawable VectorLayer with id/attribute control via one options object. Only available on vector layers from VectorFileSource (e.g. drawable: true). Implementation helpers live in {@link DrawableSplit.applyGeomOp}.

Calls one of the layer's own functions by name with the layer as this; falls back to a method of the layer with that name. Extra arguments are passed through to the function.

Cancel the in-progress sketch/edit without committing changes.

AnimatedCluster options. Truthy object enables clustering even when clusterDistance is omitted.

Zoom / map state is not passed into callbacks — read it yourself via this.layer.map (call scope is the strategy) or ExtjsUtils.JS.getMap().

Defines the minimum relative distance (in pixels) to clusterize points. Set 0 to never clusterize, or a value greater than 0 to set the minimum distance. For a membership key or dynamic distance, use {@link VectorLayer.cluster} instead (or together — cluster options win; clusterDistance fills default distance). PS: When filters are applied, you can use the property 'count' on 'VectorLayer.styleMap' property to check how many points exists in the current cluster.

(Standalone doc comment: the value is read inside strategies below, which carries the cluster block, so this one is named explicitly.)

Converts a JsonObject into a Layer Feature (that can be added to layer).

Redefines the coordinate property names to {x, y}. PS: Used only if the 'VectorLayer.getVector' is not defined.

Defines the default style that will be applied to the geometry. PS: Accepts 'context' and 'rules'.
    Property 'context': allows definition of functions.
    Property 'rules': allows definition of filters (only the geometries that fit into this rule will be displayed).

Look at some examples at: http://dev.openlayers.org/examples/

Deselect the currently selected/edited feature without discarding it.

Makes a vector layer editable: users can sketch, edit and delete polygon (optionally polygon+line) features, with configurable overlap resolution. Set to true for defaults, or an object to configure:

• maxGeomCount {Number} — maximum number of features allowed on the layer.
• onFeaturesChange {Function(evt)} — fires on any feature-set change
      (add/remove/clear/load); evt.type identifies the cause.
• onGeomLimitReached {Function} — called when a draw attempt would exceed maxGeomCount.
• onEditToggle {Function(active, detail)} — sketch/edit mode turned on or off.
      detail: { active, editingIntent, reason }, reason is 'toggle' (user/tenant)
      or 'visibility' (layer show/hide).
• onDrawingStatusChange {Function(detail)} — fine-grained sketch/edit state for UI.
      detail.status: 'off'|'ready'|'drawing'|'drawing_line'|'feature_selected'|'vertex_drag',
      plus drawMode, canFinishDrawing, canApplyFeatureChanges, sketchPointCount,
      selectedFeature.
• drawModes {Array<String>} — ['polygon'] (default) or ['polygon','line'],
      the sketch tools available in edit mode. Alias: drawingTypes.
• drawingHints {String|Boolean} — false|true|'toolbar'|'bar'|'both',
      lightweight on-map edit guidance.
• onOverlap {String|Array<String>} — a single action key (applied without prompt)
      or an ordered list of keys to prompt for when a new/edited feature overlaps
      another. Defaults to merge/cut/keep ({@link DrawableSplit.OVERLAP_ACTIONS}).
      Applied by layer.resolveOverlap.
• buttons {Object} — layer-row toolbar overrides: edit, clear, removeLast, loadFile.

Exposed at runtime as layer.drawableController — see VectorLayer.activateDrawMode, VectorLayer.finishDrawing, VectorLayer.cancelDrawing, VectorLayer.deselectFeature, VectorLayer.applyFeatureChanges.

Loads (or reloads) the layer's features from a data-loading config, following its type strategy: load calls config.loadData, csv/jsonurl/ geojsonurl fetch config.url, json uses the inline config.json, empty adds nothing. Unknown types fall back to jsonurl. This is what the platform calls with the layer definition; call it yourself to swap the data at runtime.

Find a feature by the id returned from getFeatureId (fid, id, or index). Prefer this over OpenLayers getFeatureById when callers use getFeatureId ids.

Commit in-progress polygon sketch (same as double-click).

Defines the projection of the JSON (accepts only EPSG:4326 and EPSG:900913).

Runs the layer's beforeCalc(inputs) again with the current input values. It is the supported way to force a vector layer to refresh whatever beforeCalc builds (styles, filters, charts) from outside a normal cycle, for example from onVisibilityChange; the platform calls it itself when a resource finishes loading. Guard it with isCalculationPaused() and waitingRenderAndLoadAssync so it does not run while data is still loading.

Feature id currently selected for vertex edit (drawable modify control), if any.

Stable-enough id for a feature on this layer: fid, then OpenLayers id, otherwise the feature's index in layer.features (no synthetic attributes).

Returns the current value of every input tool declared in descriptionHtml, in declaration order (the same array the layer callbacks receive as inputs). Use it from callbacks that do not receive inputs, such as a {{button}} handler or onFeatureChangeCallback.

Gets the layer inner function.

Define the layer inner function at VectorLayer. Ex: {
  name: 'CSR:map_name',
  function: {
    nameFunctionExample: function(){alert('a');}
  } }

Defines the callback function to parse the layer data and get the geometry. Callback Function getVector function(attribute, config)

Defines the style that will be applied to the geometry when the mouse hovers over a selected feature. Default hover selected style is the selected style
PS: Accepts 'context' and 'rules'.
    Property 'context': allows definition of functions.
    Property 'rules': allows definition of filters (only the geometries that fit into this rule will be displayed). PS2: Hover Select depends on both 'onHover' and 'onClick' properties to work.

Look at some examples at: http://dev.openlayers.org/examples/

Defines the style that will be applied to the geometry when mouse is hovering. PS: Accepts 'context' and 'rules'.
    Property 'context': allows definition of functions.
    Property 'rules': allows definition of filters (only the geometries that fit into this rule will be displayed). PS2: Hover depends on 'onHover' property that allows to hovering.

Look at some examples at: http://dev.openlayers.org/examples/

Bounds of the features currently on the layer, recomputed automatically after features are added or removed (and extended while drawing). Despite the name it is expressed in the map projection, not in lon/lat, so it can be passed straight to map.zoomToExtent. Read-only; undefined until the first feature is added.

Function to load geojson and draw on the layer.

Called when the layer is on the map with its features loaded. If the layer is still fetching (jsonurl / geojsonurl / csv / async load), waits for that load to finish first so this.features / this.getDataExtent() are available (a failed load still calls it). this is the layer.

AddedEvent {
    element: {DOM} 'DOM element of the layer',
    layer: {OpenLayers.Layer.Vector} 'Javascript Object of the layer',
    map: {Map} 'MapPanel where the layer was added.',
    type: {String} 'Type of the event ( added )' }

Defines the callback function that is called before a layer feature is added, removed or edited. PS: If it returns false, the change operation is canceled.

Defines the callback function to the click event on Layer.

Defines the callback function to the Click Select controller. The additional parameters are listed in http://dev.openlayers.org/docs/files/OpenLayers/Control/SelectFeature-js.html.

Defines a function that is called after a layer feature is added, removed or edited.

Defines the callback function on 'Vector Layer' hover.

Called when all inputs are ready on layer.

Defines the callback function to be called after the layer is loaded or added to a map. PS: You can use 'this' to access layer properties.

Defines the callback function to the unselect feature.

Not implemented for file layers: accepted but never called (see popupTemplate). Use onClick, which receives the clicked feature.

Not implemented for file layers: the value is accepted and kept on the layer, but nothing reads it, so no popup ever opens (the template belongs to the gxp feed sources this layer does not extend). Show a feature's attributes from onClick instead - for example with ExtjsUtils.ALERTIFY.log or ExtjsUtils.TooltipHelper.CreateTooltipOnPosition.

Resolve overlaps between edited and existing polygons on this drawable VectorLayer. Uses drawable.onOverlap: a single key applies immediately; an array prompts via ALERTIFY.confirmChoice (merge / cut / keep).

The selection control created for the layer when onClick, onSelectionToggle or onHover is defined (undefined otherwise). It is the OpenLayers.Control.CustomSelectFeature instance, so you can call its select(feature), unselect(feature), unselectAll(), activate()/deactivate() from layer callbacks, e.g. to select a feature found with findFeatureById.

Defines the default style that will be applied to the selected geometry. PS: Accepts 'context' and 'rules'.
    Property 'context': allows definition of functions.
    Property 'rules': allows definition of filters (only the geometries that fit into this rule will be displayed). PS2: Selected depends on 'onClick' property that allows to select.

Look at some examples at: http://dev.openlayers.org/examples/

Defines drawing features on layers. PS: Function is available to the VectorLayer.

Shows the "generating legend" loading mask visibly over the page while the layer is paused (loading its data or another resource). By default the mask is an invisible overlay that only changes the cursor to "wait"; set it to true in the layer definition to make it visible. Only shown while the layer is visible. The same key exists for calculate layers (LayersProperties.showLoadingModal).

Customizes the layer visualization. PS: It is an advanced parameter, so it might be easier to use selectedStyle, defaultStyle and hoverStyle. PS2: The 'hover' style is applied on hover event.

Number of asynchronous resources of the layer still loading (its own data for csv, json, jsonurl, geojsonurl and load types, plus {{loadcsv}}/{{loadjson}} inputs and any startLoadingLayer you trigger yourself). It is increased on startLoadingLayer/startLoadingResource and decreased on endLoadingLayer/endLoadingResource; onInputsReady fires when it reaches 0. Read-only: use it as a guard before refreshing the layer.

Select on click. When true, clicking a feature selects it (select), clicking a selected one again unselects it when toggle is set, and clicking outside unselects all when clickout is set. The platform sets it for layers with onClick / onSelectionToggle. When false, select/unselect are no-ops.

Internal — feature-handler callback run when a feature is clicked (only registered when click is true): toggles the feature off when it was selected and toggle is set, otherwise unselects the others (unless multiple) and selects it. Tenant code normally does not call it; call select/unselect instead.

Internal — feature-handler callback run when the user clicks outside a previously clicked (selected) feature: unselects everything when the clickout option is set. Tenant code normally does not call it.

Name of the StyleMap render intent used to draw a feature that is neither hovered nor selected (getFeatureCurrentStyle returns it in that case).

Returns the name of the StyleMap render intent a feature should be drawn with right now, given whether it is selected (in layer.selectedFeatures) and whether it is hovered: selectHoverStyle when both, selectedStyle when only selected, hoverStyle when only hovered, defaultStyle otherwise. Useful when redrawing a feature yourself (layer.drawFeature(feature, style)) after changing its attributes.

Highlights a feature as if the mouse were over it, without selecting it: redraws it with hoverStyle (or selectHoverStyle when it is selected) and fires the control's beforefeaturehighlighted/featurehighlighted events — which, on a file layer, run the onHover callback with state true. Use it to mirror a hover coming from a list or chart outside the map; call unhighlight to revert.

Highlight on mouse over and unhighlight on mouse out (without selecting). The platform sets it for layers with onHover; the featurehighlighted / featureunhighlighted events of the control fire the layer's onHover callback.

Name of the StyleMap render intent used to draw a hovered, unselected feature. It matches the VectorLayer.hoverStyle entry of the layer's styleMap.

Allows more than one selected feature at a time: with false selecting a feature unselects the previous one. Pass it through onClickCfg: {multiple: true}.

Internal — feature-handler callback run when the mouse leaves a feature (only registered when hover is true): unhighlights it, redrawing with defaultStyle or, if it is selected, selectedStyle; when another select control had highlighted the feature before, that control's highlight is restored instead. Tenant code normally does not call it; call unhighlight instead.

Internal — feature-handler callback run when the mouse enters a feature (only registered when hover is true): highlights it, redrawing with hoverStyle or, if it is selected, selectHoverStyle. Tenant code normally does not call it; call highlight instead.

Selects a feature programmatically, exactly as a click would: adds it to layer.selectedFeatures, redraws it with selectedStyle (or selectHoverStyle while hovered), fires the layer's beforefeatureselected/featureselected events and calls the onSelect option — so a file layer's onClick/onSelectionToggle callback runs too. Does nothing when the control was created with click: false. Use it to select a feature from a list or a parent-page message; unselectAll() (inherited) clears the selection.

Name of the StyleMap render intent used to draw a feature that is selected AND hovered. It matches the VectorLayer.hoverSelectedStyle entry of the layer's styleMap.

Name of the StyleMap render intent used to draw a selected feature that is not hovered. The platform passes "select" for file layers (the VectorLayer.selectStyle entry of the layer's styleMap); this is the stock default otherwise.

Removes the hover highlight of a feature: redraws it with the feature's own style if it has one, else the layer's style, else defaultStyle (or selectedStyle when it is selected), and fires the control's featureunhighlighted event — which, on a file layer, runs the onHover callback with state false. When several select controls highlighted the feature, the previous control's highlight is kept.

Unselects a feature programmatically: removes it from layer.selectedFeatures, redraws it with defaultStyle (or hoverStyle while hovered), fires the layer's featureunselected event and calls the onUnselect option — so a file layer's onSelectionToggle callback runs with its unselect status. Does nothing when the control was created with click: false.

Pure drawing/status constants and helpers of the modify control (no control instance needed), reachable as OpenLayers.Control.CustomModifyFeature.Drawing. What a query uses from it is DRAWING_STATUS, the enum of the detail.status values that drawable.onDrawingStatusChange(detail) reports: OFF: "off" (not editing), READY: "ready" (editing active, nothing sketched or selected), DRAWING: "drawing" (a polygon sketch is in progress), DRAWING_LINE: "drawing_line" (a line sketch is in progress), FEATURE_SELECTED: "feature_selected" (an existing feature is selected for editing) and VERTEX_DRAG: "vertex_drag" (a vertex of the selected feature is being dragged). It also holds DRAW_MODES (POLYGON: "polygon", LINE: "line", the detail.drawMode values), the default Portuguese STATUS_LABELS per status, MIN_POLYGON_SKETCH_POINTS (4) / MIN_LINE_SKETCH_POINTS (2) and minSketchPointsForMode(drawMode). Compare against the constants instead of hard-coding the strings.

Builds the current drawing/edit status of the control on demand — the same detail object drawable.onDrawingStatusChange(detail) receives, so a host UI can read the state at any moment (e.g. when it is first shown) instead of waiting for the next change. Fields: status (one of CustomModifyFeature.Drawing.DRAWING_STATUS, never "off" here — the control only exists while editing), drawMode, isDrawing, featureSelected, vertexDrag, selectedFeature (the OpenLayers.Feature.Vector or null), sketchPointCount, canFinishDrawing, canDeselectFeature, canApplyFeatureChanges and canCancelDrawing. Reachable as layer.drawableController.modifyFeatureControl.buildStatusDetail().

The geometry mode new sketches use on this control: "polygon" (default) or "line" (only when the layer's drawable.drawModes includes it), i.e. one of CustomModifyFeature.Drawing.DRAW_MODES. Reachable as layer.drawableController.modifyFeatureControl.getActiveDrawMode(); the same value arrives as detail.drawMode in onDrawingStatusChange.

Id of the feature currently selected for editing.

Whether a feature of the layer is currently selected for editing on this control (its vertices are shown and draggable). Reachable as layer.drawableController.modifyFeatureControl.isFeatureSelected(); use getSelectedFeatureId() to know which one.

Defines a map identifier. This name should be unique.

Adds a layer to store the source.

Defines the url where the map can be fetched from. Use the ${x} ${y} ${z} as placeholder for x, y and z coordinates.

Defines the Color of the group. This is the Color of the Title and some elements inside the sub menu on the top of the screen.

Extra CSS class added to the node of a viewTitle group in the Legend Window, so the group title and its rows can be styled with ExtjsUtils.CSS.defineClass or a stylesheet. Only groups with a viewTitle create a node; on a layer the same key styles the layer row instead (ConfigLayer.customLayerClass).

Specifies properties that apply universally to all layers within a group, including nested subgroups and their respective layers. Priority is determined by specificity: a property defined at the layer level takes precedence, followed by properties defined in the nearest group, and so forth.

Defines the Layers that will be part of the Group. Each Layer can have multiple maps inside it. All maps inside a Layer will be shown together when that Layer is enabled. Besides that, all information about those maps can be used to calculate a new one using custom functions that can be writen in JavaScript.

A second way to declare query globals: an object whose properties become temporary globals, passed to ExtjsUtils.QUERY.setQueryGlobalProperties while the group is interpreted (before its layers). The usual form is the ExtjsUtils.QUERY.setQueryGlobalProperties({...}) && [...] chain at the top of the query; the production survey found no query using this key (zero users).

Defines if the 'viewTitle' should start opening or collapse. Set it to 'true' for the 'viewTitle' start open or 'false' for it to start closed. This property only applies to a group that has the 'viewTitle' property defined. If the Group View has any visible Layers or any Layer has the 'openGroup' property set to 'true', the Group View will start open. It works at both levels: on the viewTitle group it makes the group start expanded, on a layer it expands every viewTitle ancestor of that layer.

Defines the Title of the group. The Title is shown at the sub menu on the top of the screen.

Define the Title of the View that will gather together the elements inside it (Groups or other Views). If an external View has in its elements another definition of a 'viewTitle', subviews will be created, like in the second example.

Called whenever the user clicks the title of a viewTitle group in the Legend Window. It belongs on a group that has viewTitle: the handler is bound to that group's tree node, so this is the node and view.expanded tells whether the group is open after the click. When declared on a layer instead of a group, it is attached to the layer's nearest viewTitle ancestor (once per layer that declares it); on a flat layer with no viewTitle ancestor it is bound to the invisible root node, i.e. it never fires.

Called whenever a viewTitle group of the Legend Window is expanded or collapsed (by the user or by code). It belongs on a group that has viewTitle: the handler is bound to that group's tree node, so this is the node and view.expanded is true after an expand and false after a collapse. When declared on a layer instead of a group, it is attached to the layer's nearest viewTitle ancestor (once per layer that declares it); on a flat layer with no viewTitle ancestor it is bound to the invisible root node, i.e. it never fires. A typical use is hiding the layers of the collapsed group and restoring them on expand.

cls=<class> adds CSS classes to the created element. Unlike other keys, repeating it concatenates the values (with no separator — start the second one with a space, or list all classes in a single cls).

How a plain param=value is converted before reaching the tool: a value that looks like a number (10, -4.5, 1e3) becomes a JavaScript number, an empty value (param=) becomes the empty string (falsy), and anything else stays a string — tools that need arrays or objects (data, steps, values, filterLayers, backgroundColors) parse the string themselves as JSON. true/false are NOT converted: param=true is the string "true" (truthy) and param=false is rewritten to an empty value (see falseValue). A parameter written without = (|pressed|) also gets the empty string, except for the special keys listed in this group (isnumeric). The same parameter written twice keeps the last value (cls and on_<event> accumulate instead).

Write \= to put a literal = inside a value; a bare = would start a nested key (see nestedKeys). Needed above all in URLs with query strings. Inside a JavaScript string remember to double the backslash ('\\='). The value of html= is exempt: everything after its first = is kept as is.

param=false is rewritten to param= (an empty, falsy value) before parsing, because the literal text "false" would otherwise be a truthy string. Use it to switch off a boolean parameter whose default is true (unselect=false, notify=false, hideLabel=false). Only a false at the very end of the parameter is rewritten.

function=<body> stores a function whose body is the given text (function () { <body> }), evaluated with no try/catch and no lookup in the layer functions. Use the nested form param=function=<body> to assign it to a parameter (a top-level function= only sets a function key); escape any = in the body as \=. Rarely needed: the callback parameters of the tools (handler, runOnClick, onSelect...) already accept function names or inline text.

getid=ID gives access to an element created EARLIER in the same description (by any tag with that id). At the top level (|getid=slider1|) the element is stored in the tool config under getid; the common use is to attach a listener to it with getid=ID|getid=on_<event>=... (see on_event), or the nested param=getid=ID to hand the element to a parameter (scope=getid=btn). Order matters: the referenced tag must appear before the one using getid.

html= is the one key whose value is taken verbatim up to the next |: = characters inside it are kept and no nesting happens. Used by label and window.

|isnumeric| (or isnumeric=true) installs a validator that only accepts numeric text — the field is marked invalid with the localized "must be a number" message otherwise. Meant for textfield. Note that the input value is still delivered as a string; convert it with parseFloat.

a=b=c creates a nested object: the tool receives {a: {b: c}}. The innermost key=value is parsed with the same rules as a top-level one, so the special keys work at any depth — plugins=tip=... builds a slider tip plugin, scope=getid=ID assigns an element created earlier, listeners=on_change=... is not needed because getid/on_<event> already cover the common case.

on_<event>=<code> adds a listener for an Ext event (change, select, afteredit, toggle...) on an element referenced with getid — the form is getid=ID|getid=on_<event>=<code>; it cannot be used on the tag's own element. <code> is either a full function(...) {...} or a statement body; it is evaluated directly (no lookup in the layer functions or in globals) and runs with this = the referenced element and the event's own arguments. Several on_ listeners may be attached to the same element.

tip=<format> builds an Ext.slider.Tip whose text is String.format(format, thumbValue, value of thumb 0, value of thumb 1...), so {0} is the dragged thumb value. It must be assigned to a slider's plugins with the nested form plugins=tip=<format>; a top-level tip= is stored in the config but not used by the slider.

Free HTML inside a layer's descriptionHtml: everything that is not a {{tag}} is passed through to the panel untouched, so a description can carry headings, images, links, tables and the container elements a chart or a custom control needs. Widgets and HTML mix freely in the same string, and the HTML around a widget is rendered before the widget is created, so an element declared here can already be referenced by an id.

Two things to keep in mind. Inside a {{tag|...}} the pipe separates parameters, so HTML that must live in a parameter goes in html= (verbatim to the end of the value) or has its = escaped as \\=. And the description is written inside a JavaScript string in the query, so quotes have to be escaped or alternated as usual.

Reads the composed map at one screen position: one value per inner layer (decoded from the tile colours through the legend, null cells read as 0) plus one extra entry with the layer expression result for those values. The tool samples the four corners of the rectangle with it and combines them as a summed-area table (sum = minXY + maxXY - minXmaxY - maxXminY), which is why the maps must be published with the integral operation. Returns null when the layer is hidden or the position is outside the map data.

Defines the CSS class of the toggle switch icon; replace the default to restyle the switch.

Defines the id of the tool: the key used in inputs.id[ID] and the id of the container component (Ext.getCmp(id); the switch itself is Ext.getCmp(id).items.get(0)). Generated when omitted.

Set true to render the text label before (left of) the toggle switch instead of after it.

Set false to suppress the notification shown when the tool is activated.

Defines the callback run after the second click closes the rectangle, with the sums computed. Called as runOnClick(layersValues, inputs, boundingBox, pixel, lastInfo) with this = the layer: layersValues has one summed value per inner layer (see getLayerValues), inputs is layer.getInputs(), boundingBox is [minLon, minLat, maxLon, maxLat] in EPSG:4326, pixel the {x, y} of the second click and lastInfo the {first, second} {lon, lat} of the two clicks. The name is resolved as a key of the layer functions object, then as a global function, then as inline function text. The tool deactivates itself after the callback.

Defines the text shown next to the toggle switch.

Only changes the activation message (true: one selection expected, false: several); the tool always deactivates itself after the second click.

Value stored in inputs.id[ID]: the layersValues array of the tool — one summed value per inner layer of the composed map for the last rectangle (empty before the first one). The array is updated in place after the second click, so beforeCalc/expression always read the latest sums. The input is registered on the forceupdatelayer event of the switch, which the tool does not fire by itself: react inside runOnClick, or call Ext.getCmp(id).items.get(0).forceUpdateLayer() there to recalculate the layer with the new sums.

Defines the button type as toggle. Set true to use as toggle, false otherwise. PS: When its true the callback is 'toggleHandler', otherwise the callback is 'handler'.

Defines the button label.

Defines the callback function on button click event. This should be used when the enableToggle property is false. this inside the callback is the layer.

The value is resolved in this order: (1) a key of the layer functions object with that name; (2) a global function with that name (e.g. defined with setQueryGlobalProperties); (3) otherwise the text itself is evaluated as a function — either a full function(){...} expression or a plain statement body. With enableToggle=true and no toggleHandler, handler is used as the toggle handler.

Set true to create the button hidden (Ext hidden config); show it later with Ext.getCmp(id).show(). This is one example of the pass-through: every other Ext.Button config (iconCls, tooltip, cls, width, disabled, scale...) written in the markup is handed to the button unchanged.

Defines the id to identify the object.

Defines the button initial state. Set it true to start pressed (only if enableToggle = true), false otherwise.

Defines the button text.

Alias of toggleHandler: a function given as toggle= is moved to toggleHandler (unless one is already defined), so the Ext toggle() method of the button is never overwritten. Prefer toggleHandler.

Defines the callback function on button toggle event. This should be used when the enableToggle property is true. this inside the callback is the layer.

The value is resolved in this order: (1) a key of the layer functions object with that name; (2) a global function with that name (e.g. defined with setQueryGlobalProperties); (3) otherwise the text itself is evaluated as a function — either a full function(){...} expression or a plain statement body.

Set true to start checked. handler is not run for the initial state.

Defines a label at the left of the whole field (Ext fieldLabel), in addition to the text shown next to the switch. hideLabel=true removes it and its reserved space.

Fires the forceupdatelayer event of the widget. For the map-interaction tools registered as inputs (summedarea, areaintegral) this is the event the layer listens to, so calling it marks the input as changed and recalculates the layer with the values currently stored in inputs.id[ID].

Defines the callback run whenever the checkbox is checked or unchecked (by the user or by toggle()). Called as handler(checkbox, checked) with this = the layer. The value is resolved in this order: a key of the layer functions object, then a global function with that name, then the text itself evaluated as a function (a full function(){...} or a statement body). The checkbox is not a layer input: read checked here and act (e.g. setValues on an InputManager, changeLayers...). It is also called once with checked=false when the widget is removed together with its layer.

Defines the CSS class of the toggle switch icon; replace the default to restyle the switch.

Defines the id of the checkbox component (Ext.getCmp(id)), e.g. to call toggle() or setBoxLabel() from a button. Generated when omitted.

Defines the DOM value attribute of the underlying <input type="checkbox"> (useful inside an HTML form).

Set true to render the text before (left of) the toggle switch instead of after it.

Accepted for parity with the map-picking switches (pickpoint, hoverpixel...), where it controls the activation notification. A plain checkbox shows no notification, so the value has no effect here.

Changes the text shown next to the checkbox (the markup text parameter) after it was rendered. Available on every checkbox-style tool (checkbox, pickpoint, hoverpixel, summedarea, areaintegral); get the component with Ext.getCmp(id).

Defines the text shown next to the toggle switch (the checkbox boxLabel).

Checks or unchecks the checkbox from code, running its handler as if the user had clicked it. Without an argument the current state is inverted. Get the component with Ext.getCmp(id).

Accepted for parity with the map-picking switches, where it selects the activation message. A plain checkbox never unchecks itself, so the value has no effect here.

Defines the data that will be displayed in the Combobox.

Determines if the Combobox is editable. That is, if it allows the user to type inside the input field. Set it true to allow it, false otherwise.

Defines a label for the Combobox. It will be shown at the left of the Combobox, by default.

Returns the currently selected value (the text of the chosen data entry). Call it on the component (Ext.getCmp(id) or a getid= reference); inputs.id[ID] already holds the same value.

Defines if the label of the Combobox should be displayed. Set true to hide the label, false to show it.

Defines the id to identify the object.

Defines the style of the label. You can use CSS to style the label element.

Defines a callback run when the user picks an entry. It receives the Ext select event arguments (combo, record, index) — read the chosen text with record.get('value') — and this is the layer. The value is resolved as a key of the layer functions object or, failing that, the text itself is evaluated as a function (a body or a full function(){...}); unlike the other callbacks it does NOT look for a global (setQueryGlobalProperties) function of that name. PS: the layer is recalculated on select anyway; use onSelect for side effects such as changing layers or updating a window.

Selects an entry from code. Pass one of the data values; it does not fire select, so call forceRecalc() on an InputManager (or fire the event) when the layer must be recalculated.

Value stored in inputs.id[ID] (and inputs[i]): the selected entry of data as a string (the first entry is selected initially). The layer recalculates on the combobox select event (user choice).

Defines the width of the combobox in pixels.

Defines the list of events by name. Use this property to define callback functions to any of the following events.

Defines the label shown at the left of the file input (Ext fieldLabel). hideLabel=true removes the label and its reserved space; other Ext.form.Field configs are passed through unchanged.

Set true to hide the label element and the space reserved for it.

Defines the id of the input; it is the key used in inputs.id[ID] and the id of the Ext field (Ext.getCmp(id)), so it must be unique in the page.

Defines if it should ignore the widget change event. If it's false, it dispatches the update event at every file selection.

The HTML input type. It is always forced to file by the tool, so a value written in the markup is ignored (documented only to explain why it cannot be changed).

Value stored in inputs.id[ID]: not the file itself but a getter function. Call it — inputs.id[ID]() — to obtain the selected File (the first entry of the DOM files list) or undefined when nothing is selected. It is a function so the value can never be serialized to the calculation WebWorker (expression); read it in beforeCalc, in a _onchange= callback or in a button handler. The layer recalculates on the change event of the input (a new file chosen) unless ignoreUpdate=true.

Defines if the hoverPixel should start enabled. Set true to start enabled, false otherwise.

Define the text that will be displayed at the left of the toggler

Reads the values of the composed map under a mouse event: one value per inner layer (from the legend colours of the rendered tiles) plus one extra entry with the result of the layer expression for those values. This is the layerVals argument of runOnClick/runOnHover; call it from code (Ext.getCmp(id).items.get(0).getLayerValues(evt, layer)) to sample the map from any mouse event. Returns null when the layer is hidden, the legend is not loaded yet, or the mouse is outside the map data (all layers null/transparent).

Defines if the label of the HoverPixel should be displayed. Set true to hide the label, false to show it.

Defines the CSS class of the toggle switch icon; replace the default to restyle the switch.

Defines the id to identify the object.

Set true to render the text label before (left of) the toggle switch instead of after it.

Defines the style of the label at the HoverPixel toggler. You can use CSS to style the label element.

Set false to suppress the notification shown when the tool is activated ("click on the map...").

Defines a callback when the user clicks on the map.

It passes the following parameters for the callback function: handleOnClick(layerVals, inputs, coordinates, clickEvent, lastCoordinates)

True to run the callback function even when clicking outside of the layer, False to disable. (Default False)

Defines a callback when the user hovers the map.

It passes the following parameters for the callback function: handleOnClick(layerVals, inputs, coordinates, clickEvent, lastCoordinates)

True to run the callback function even when hovering outside of the layer, False to disable. (Default False)

Define the text that will be displayed at the right of the toggler

Only changes the activation message: with the default true it says a single point is expected, with false several. The hoverpixel is never deactivated automatically after a click.

Value stored in inputs.id[ID]: the lastInfo object {click, hover} with the coordinates ({lon, lat} in EPSG:4326, or null before the first event) of the last click and of the last mouse move while the tool is active. The object is updated in place, so it is always current when read in beforeCalc/expression; it is also the last argument of runOnClick/runOnHover (inside the callback it still holds the previous event — the current one is written right after the callback returns; use the coordinates argument for the current position). The input is registered on the forceupdatelayer event of the widget, which nothing fires by itself — moving the mouse or clicking does not recalculate the layer. React inside runOnClick/runOnHover (which also receive the map values) or trigger the recalculation yourself (e.g. forceRecalc() on an InputManager).

Force a legend map recalculation.

Get the stored value by his property name, if it does not exists returns null.

Defines the id of the input; it is the key used to reach the manager in inputs.id[ID] (required, the tool renders nothing visible).

Set default values to the stored elements, these values are used before any other value is defined and never update or replace another stored values.

PS: Auxiliary function to make easy wrinting the script (typically called in onInputsReady or at the start of beforeCalc). PS: This function never fire layer update.

Stores object properties for later usage.

PS: If has name property collision the older is replaced. PS: Values go to one of two buckets of the manager: global (the default — serialized and sent to expression, so it must hold plain JSON-compatible data) or _local_ (with local=true — kept in the browser only, may hold DOM elements, Ext components, functions or circular objects). getValue(key) looks in global first, then in _local_.

Value stored in inputs.id[ID]: the manager object itself, with getValue(key), setValues(obj, cancelUpdate, local), setDefaultValues(obj, local) and forceRecalc() (listed in this group) and the global bucket where the stored properties live (inputs.id[ID].global.key is a shortcut for getValue). The layer recalculates on its own change event, which setValues (unless cancelled) and forceRecalc trigger. Only the global bucket reaches expression (WebWorker); values stored with local=true are kept in a bucket that is not serialized and can therefore hold DOM/Ext references.

Extra CSS class(es) added to the <label> element.

Defines the id of the form field the label is for (rendered as the for attribute of the <label>), so clicking the label focuses that field.

Defines the content of the label as raw HTML (not escaped). Everything after html= up to the next | is the value, so it may contain = characters. text wins when both are given.

Defines the id of the label component (Ext.getCmp(id)), needed to change its text from code or to reference it with getid= in another tag. Generated when omitted.

Inline CSS applied to the <label> element. Any other Ext.form.Label/Ext.Component config (hidden, width...) is passed through unchanged.

Defines the text of the label. It is HTML-escaped, so use html when markup is needed. Update it later with Ext.getCmp(id).setText(text) (typically from an on_change= listener of a slider or textfield through getid=).

Set true (default) to let the legend panel take the width of its container; set false to give it a fixed width.

Defines an array of indexes of layers to be included in map legend (from 0 to quantity of layers). If not defined, all layer legends are shown by default. Otherwise, only the listed indexes are included.

Ex: A composed layer with three maps: name: "CSR:estados,CSR:roads,CSR:municipalities", If 'filterLayers=[0,1]' is defined in the layer object only the legends of 'CSR:estatdos' and 'CSR:roads' are shown.

Defines the id of the legend panel component (Ext.getCmp(id)), e.g. to show()/hide() it or to find the legend entries inside it. Generated when omitted. Other GeoExt.WMSLegend/Ext.Panel configs (cls, style, hidden, useScaleParameter, autoWidth...) are passed through.

Defines the legend container id. You can use this id to toggle each legend filter individually.

Defines if the user can filter the maps categories by clicking on the legend. Set it true to ignore the legend click, false otherwise.

Defines if it should sort the legend on the decreasing order. Set it true to use the decreasing order, false otherwise.

Set true to request a new legend image from the server whenever the map scale changes (GeoServer SCALE parameter), for styles that depend on the scale. Off by default: the legend is generated once and reused, which is faster and keeps the click-to-filter behaviour stable.

Pushes the two selected styles to the composed layer (changeLayers with the left style on child 0 and the right style on child 1) and makes both children visible. Called when Compare is pressed; after calling it yourself use refreshActiveSplit() so the divider clips the new child divs.

WMS layer name used with each style (e.g. CSR:precip_monthly_average). Defaults to layer.params.LAYERS when omitted.

Extra CSS class for the Compare toggle button (replaces the default clickable; the class live-composed-split-compare is always added).

Name of the Composed layer to split. If omitted, the first OpenLayers.Layer.Composed on the map is used.

Removes the split divider control from the map for good (it is recreated on the next Compare press). The panel calls it when its layer is removed; call it to force a clean state. It does not restore the single-style view — press the Compare button off (toggle(false)) for the normal close.

Comma-separated labels shown in the left/right combo boxes (required).

Id of the Compare button (wrapper id is id + "_container").

Tells whether the split comparison is currently shown on the map (Compare pressed and the divider active). Get the panel with Ext.getCmp(id + '_container'), where id is the markup id.

Comma-separated WMS style names aligned with displayNames (required). When Compare is pressed, the composed layer switches to the selected pair.

Presentation inside the layer query panel. compact (default): stacked fields that fit the ~300px layer card. inline: horizontal row (legacy Left / Right / Compare on one line).

Initial left combo value; must be one of displayNames.

Re-applies the selected styles and re-clips the split after the composed layer's children were replaced (e.g. by your own changeLayers call), keeping the divider position. Does nothing while the comparison is not active.

Initial right combo value; must be one of displayNames (and different from left).

Enables or disables the right-side combo and the swap button. The panel calls it itself (only the left combo is editable while idle; both unlock when comparing); call it to lock the choice while data loads.

Exchanges the left and right styles (combos and map) and re-clips the split, keeping the divider where it is. Does nothing while the comparison is not active — what the swap button does.

Label on the Compare toggle button (before the split is active).

Get the index of a column with the 'columnName' name.

Resolves column names to column indexes: every string entry is looked up in the header (-1 when absent) and every numeric entry is kept as it is. A single value is accepted in place of the array. This is what getLines/createIndexes do with their columns argument.

Downloads the CSV through the Mappia CORS proxy; use it for servers that do not send CORS headers.

Create indexes for faster search.

PS: Indexes are used to faster results on "getLines" calls, apply only when all [columns] are indexes.

Returns a copy of the header row — the column names, in order — so query code can discover columns instead of hard-coding indexes. The name is a historical typo of getColumnsInd, kept for compatibility (the platform and many queries call it by this spelling; there is no correctly spelled alias).

Number of data lines in the table (the header line is not counted).

Returns the lines (arrays of cell strings) whose cells in columns equal the corresponding entries of values. Columns may be given by index or by header name; to filter on several columns give one value per column, e.g. getLines([1, "Year"], ["Park A", 2024]). Values are compared as strings (the CSV is always text). Called with no arguments it returns every data line (header skipped) — a common idiom. When all filtered columns were indexed with createIndexes the lookup uses the index instead of scanning every line.

Get a value by the matrix index and column.

Defines the id of the input; it is the key used to read the table in inputs.id[ID] (required, the tool renders nothing visible).

Ignore the empty lines, removing them from the parsed CSV. True to remove the empty lines from the CSV.

Change a cell value by its cell index.

Requests that cell values be trimmed of surrounding whitespace. The flag is accepted and forwarded to the CSV parser, but the current parser ignores it (cells are stored as written, quotes removed), so trim values yourself when needed. Kept for compatibility with existing queries.

Defines the URL of the CSV file to download (required). Relative URLs are resolved against the Mappia host, so backend endpoints such as /wmtp/calc/... work; escape = inside query strings as \=. The layer waits for the download before calculating.

Value stored in inputs.id[ID]: an ExtjsUtils.CSV.CsvTable wrapping the parsed file (first row = header). Read it with the CsvTable methods listed in this group (getLines, getValue, columnNameToInd, createIndexes, getLineCount...). It is undefined until the download finishes: the layer waits for the resource and recalculates on its waitend event, so beforeCalc/expression can rely on it being loaded.

Loads the JSON through the Mappia CORS proxy (for servers without CORS headers).

Defines an id for the stored info on layerInputs.

Defines the url to load the json from.

Value stored in inputs.id[ID]: the parsed JSON (JSON.parse of the response body — an object or an array; an empty response gives []). It is undefined until the download finishes: the layer waits for the resource and recalculates on its waitend event, so beforeCalc/expression can rely on it being loaded.

Set true to apply the opacity while the thumb is being dragged instead of only when it is released.

Set true to let the slider also control the layer visibility: the layer is hidden when the slider reaches minValue and shown again when it leaves it. The layer must be visible when the slider is created.

A second layer that is hidden when the slider reaches maxValue (GeoExt option to fade between two layers). GeoExt expects a layer object here, which the markup cannot express (a string is not resolved to a layer), so this option is only usable from code; documented for completeness.

Defines the id of the slider component (Ext.getCmp(id)), e.g. to read getValue() or to hide() it. Generated when omitted. Every parameter of the tool is passed to GeoExt.LayerOpacitySlider / Ext.slider.SingleSlider unchanged (width, cls, vertical, hidden...).

Set true to make the slider work with transparency instead of opacity (100 = fully transparent).

Defines the maximum value of the slider (opacity percent at the right end).

Defines the minimum value of the slider (opacity percent at the left end).

Defines the initial slider value (opacity in percent). It is only used when the layer has no opacity yet (opacity not set on the layer): otherwise the slider starts at the layer's current opacity.

Defines if Pickpoint should start selected. Set it true to start it enabled, false otherwise.

Sets the label for the 'pickpoint' button widget.

If defined sets a color to use when drawing a geometry by this tool. Otherwise a random color will be used at each interaction.

Returns the attributes of every selected point for one of the layers of the composed map: one object per selection (in click order) holding the feature data of that layer, or {} when the click hit nothing on it (e.g. a raster). This is the usual way to read the selection in beforeCalc.

Returns the map click event handled by the last selection (its type is set to add or remove), or null before the first click. Use evt.xy for the pixel and ExtjsUtils.COORDINATE.getLatLong(evt) for the coordinate.

Returns the geographic position of the last clicked point (the marker), in the map's desired projection (normally EPSG:4326 — longitude, latitude).

Defines the CSS class of the toggle switch icon; replace the default to restyle the switch. labelBefore=true places the text before the switch, and inputValue sets the DOM value of the checkbox input (both passed through to the checkbox).

Defines the id of the tool (required). It is the key used in inputs.id[ID] and the id of the checkbox component (Ext.getCmp(id)), so it must be unique in the page.

Defines the DOM value attribute of the underlying checkbox input (useful when the tool is inside an HTML form). It does not affect what inputs.id[ID] holds.

Defines a text template drawn on the map next to each selected feature. ${attr} placeholders are replaced by the attribute values of the clicked feature (vector layers only; a raster cell has no attributes). Without it no label is drawn.

Set true to render the text label before (left of) the toggle switch instead of after it.

Defines the initial latitude (EPSG:4326, decimal degrees) of the marker shown when the tool is activated, before any click. Use it with lon; default 0.

Defines the initial longitude (EPSG:4326, decimal degrees) of the marker shown when the tool is activated, before any click. Use it with lat to start on a point of interest; default 0.

Defines by layer index which one to draw its geometry when a click event happens. (0-indexed)

Moves the marker of the last click to the position of a map mouse event. The tool calls it on every click; call it yourself only to relocate the marker from a synthetic event.

Set false to prevent the notify messages from appear (the "click on the map..." notification shown when the tool is activated).

Callback function called after clicking on a feature with this 'pickpoint' widget, once the feature info of every layer of the composed map has been received. this is the pickpoint checkbox (or scope), so this.value is the PointAttributeManager. The name is resolved as a key of the layer functions object, then as a global function, then as inline function text.

Defines if PickPoint should keep only the last feature selected. Set it true to keep only the last one, false otherwise.

Defines if Pickpoint should show where the last click was. Set it true to show, false otherwise.

Clears the whole selection: every selected feature is removed from the map and from the list returned by getAttributes. Typical use: a "Clear" button handler, followed by a recalculation.

Removes one selection (by its position in the getAttributes list) from the map and from the selection list. An invalid index changes nothing.

Alias of onMark, kept so the pickpoint accepts the same callback name as the other map tools (hoverpixel, summedarea, areaintegral). When both are written, onMark wins. See {@link PickPoint.onMark} for the callback signature.

Defines a callback function to run when clicking at the map.

Defines a callBack with following parameters function(mouseEvt, coordinates) --mouseEvt: {MouseEvent} Mouse hover event. --coordinates: {Openlayers.LatLon} Coordinate of the cursor over the map. PS: Can access the layer itself using the 'this' keyword.

True to run the callback function even when hovering outside of the layer, False to disable. (Default False)

Defines the object used as this inside the onMark/runOnClick callback. By default it is the pickpoint checkbox component (so this.value is the PointAttributeManager). From the markup it can only reference an element created earlier in the same description, with the nested getid form.

Finds, among the selected features of one layer, the first whose attribute propName equals value and returns its attributes. Useful to check whether a given feature is already selected.

Adds a feature to, or removes it from, the auxiliary vector layer where the tool draws its selections. Lets a callback draw extra geometries (an OpenLayers.Feature.Vector) with the selection, or hide one of the selected features without forgetting it.

Shows or hides the marker drawn at the last clicked position (the same marker controlled by the pointVisibility parameter).

Defines the text shown next to the toggle. When omitted the label shows the coordinate of the last click, (lat, lon), and is updated at every click.

Activates or deactivates the pick mode from code (same as clicking the switch): the map cursor, the click listeners and the marker follow the new state. Call it on the checkbox component (Ext.getCmp(id)). Without an argument the state is inverted.

Adds a set of features (one array per layer of the composed map, as returned by GetFeatureInfo) to the selection, or removes it when the same features were already selected. With onefeature=true the previous selection is cleared first. The tool calls it after every click; the returned object is what onMark receives.

Defines if Pickpoint will be automatically disabled after each click. Set it true to automatically disable, false otherwise (write unselect= or unselect=false to keep the tool active for several clicks).

Value stored in inputs.id[ID]: the PointAttributeManager of the tool, the object that keeps the selected features. Read it with getAttributes(mapIndex), searchAttribute(...), getPointPos(), getLastEvent(), and change it with removeAll(), removeAttribute(index), setPointVisibility(state), setFeatureVisibility(state, feature) (all listed in this group). The layer recalculates on the widget onmark event, fired after every click once the feature info of all layers arrived — so beforeCalc always sees the updated selection. The object holds map features, so do not send it to expression (WebWorker); extract plain values in beforeCalc.

Array of colors of background slider values, to define background slider color based in slider value. The values are defined from most to minimum with two properties each:

• color: {String} CSS color definition for the current interval. i.e. 'red','black','#FF0000', '#000000'.
• startValue: {Numeric} If defined define the initial value which above will apply this color, otherwise use theminimum slider value as default.

Ex.:
 backgroundColors: [
     {
         // Define background color to red when slider has value above 75.
         color: "red",
         startValue: 75
     },
     {
         // Define background color starting from value 0.
         // That results two intervals, from 0 to 75 as blue, and from 76 to 100 as red.
         color: "blue",
         startValue: 0
     }
 ]

Extra CSS class(es) added to the slider element (appended to the default clickable).

Set true to render the slider disabled (Ext disabled); enable it later with Ext.getCmp(id).enable().

Defines the label shown at the left of the slider (Ext fieldLabel).

Returns the current value of a single-thumb slider. Call it on the component (Ext.getCmp(id) or a getid= reference), not on inputs.id[ID], which already holds the plain value.

Returns the value of every thumb; use it for range sliders created with values=[lo, hi].

Set true to blend the backgroundColors into a continuous gradient along the filled part of the slider (each colour fading into the next from its startValue). With the default false each interval is a solid colour, with a short blend only around the thumb. Has no effect without backgroundColors.

Set true to hide the label and the space reserved for it (Ext hideLabel).

Defines the id to identify the object.

Defines the step of each increment or decrement in the actual value of the slider when being dragged.

Defines the maximum value of the slider.

Defines the minimum value of the slider.

Sets the slider value from code. Firing the change event (the default) also updates inputs.id[ID] and recalculates the layer. For a range slider pass the thumb index first: setValue(index, value).

Defines extra CSS class(es) added to the slider thumb (the draggable handle), to restyle it.

Defines the initial value of the slider (default 100).

At runtime the same value is what inputs.id[ID] (and inputs[i]) holds in beforeCalc/expression: a number, or an array [lower, upper] when the values range form is used. The layer recalculates on the slider change event (thumb released or value set from code).

Defines the slider interval limits. If defined, the slider will be displayed as a range slider. It's return at the 'inputs' parameter will be a array of two values.

Defines the slider width in pixels. Any other Ext.slider.SingleSlider config (cls, fieldLabel, hideLabel, disabled, style, keyIncrement...) is also passed through unchanged.

Creates an input of summatory in any arbitrary area.

CallBack parameters (context {OpenLayers.Layer}, layersValues {Array[Number]}, inputs {[Object]}, feature {Geometry}) runOnClick {Function} Callback called exactly after sum the map region.,

PS: 'layersValues' return the sum of each internal layer and an adittional value which is the sum of all pixels of resulting layer.

Sums, for each inner layer of the composed map, the values of the rendered cells that fall inside a polygon (values decoded from the tile colours through the layer legend, null cells skipped). This is what runOnClick receives as layersValues; call it from code (Ext.getCmp(id).items.get(0).getSummedLayerValues(layer, feature)) to sum any polygon feature. The returned array has one sum per inner layer followed by two extra entries: the number of cells read from the last layer and an array with the count of non-null cells of every layer.

Defines the CSS class of the toggle switch icon; replace the default to restyle the switch.

Defines the id of the tool: the key used in inputs.id[ID] and the id of the container component (Ext.getCmp(id); the switch itself is Ext.getCmp(id).items.get(0)). Generated when omitted.

Set true to render the text label before (left of) the toggle switch instead of after it.

Set false to suppress the notification shown when the tool is activated.

Defines the callback run when the user finishes drawing the polygon (double-click closes it), with the values already summed. Called as runOnClick(layersValues, inputs, feature) with this = the layer: layersValues is the array described in getSummedLayerValues, inputs is layer.getInputs() and feature the drawn OpenLayers.Feature.Vector polygon. The name is resolved as a key of the layer functions object, then as a global function, then as inline function text. The tool deactivates itself after the callback.

Defines the text shown next to the toggle switch.

Only changes the activation message (true: one selection expected, false: several); the tool always deactivates itself after a polygon is summed.

Value stored in inputs.id[ID]: an array meant to hold the last layersValues (one sum per inner layer, see getSummedLayerValues). In the current implementation the tool does not copy the sums into it after drawing — it stays empty — so read the results in runOnClick and store what you need with an InputManager (setValues). The input is registered on the forceupdatelayer event of the switch (Ext.getCmp(id).items.get(0).forceUpdateLayer() recalculates the layer).

Event fired once the field loses focus (blur) and its text differs from the value it had when editing started; the listener receives the TextField. Unlike keyup it fires a single time per edit, so use it for expensive reactions. Attach it with on_afteredit= through a getid= reference, or from code with Ext.getCmp(id).on('afteredit', fn).

Defines the TextField label.

Returns the text currently in the field, unprocessed (this is what inputs.id[ID] holds). Call it on the component (Ext.getCmp(id)).

Defines if it should completely hide the label element (label and separator) of the TextField. That is, if this property is set to true, the label will be hidden. Otherwise, the label will be shown by default. PS: Since the label will be shown by default, even if you do not specify a fieldLabel, the space for it will still be reserved so that the TextField will line up with other fields that do have labels. This space will be removed if you define it to be hidden.

Defines the id to identify the object.

Defines the TextField content as numeric only.

Replaces the text of the field from code. It does not fire keyup, so call forceRecalc() on an InputManager (or fire the event) when the layer must be recalculated with the new text.

Defines the TextField style properties. You can use CSS style rules to customize it.

Defines the initial value to the TextField content.

At runtime inputs.id[ID] (and inputs[i]) holds the current text exactly as typed (getRawValue(), always a string — convert it with parseFloat when isnumeric is used). The layer recalculates on every keyup (each keystroke); the widget also fires afteredit when the field loses focus with a changed value.

Defines a label for the Timeline. It will be shown at the left of the button to hide the tiemline, by default.

Returns the WMS style currently applied to the layer (layer.params.STYLES), or an empty string for the default style.

Returns the visibility the timeline has, or will have when its layer becomes visible: true may be returned while the panel is actually hidden because the layer is hidden.

Returns the main (middle) thumb of the slider — the one that selects the current step; its value is the 0-based step index. The outer thumbs (thumbs[0], thumbs[2]) bound the animation range.

Returns the position of the right (max) thumb: the last step index the animation reaches.

Returns the position of the left (min) thumb: the step index the animation restarts from.

Returns the style of a step key or, when the key has no style of its own, the style of the nearest previous key (numeric keys are compared as numbers, text keys by position in steps).

Returns the timeline panel driven by this button. The markup id identifies the button, so this is the way to reach the panel methods (getValue, updateMainThumbValue, startAnimationStep, setSteps...).