layer/layerRec/dynamicFC.js

  1. 'use strict';
  3. const attribFC = require('./attribFC.js')();
  5. /**
  6.  * @class DynamicFC
  7.  */
  8. class DynamicFC extends attribFC.AttribFC {
  9.     // dynamic child variant for feature class object.
  10.     // deals with stuff specific to dynamic children (i.e. virtual layer on client)
  12.     /**
  13.      * Create an feature class object for a feature class that is a child of a dynamic layer
  14.      * @param {Object} parent        the Record object that this Feature Class belongs to
  15.      * @param {String} idx           the service index of this Feature Class. an integer in string format. use '0' for non-indexed sources.
  16.      * @param {Object} layerPackage  a layer package object from the attribute module for this feature class
  17.      * @param {Object} config        the config object for this sublayer
  18.      */
  19.     constructor (parent, idx, layerPackage, config) {
  20.         super(parent, idx, layerPackage, config);
  22.         // store pointer to the layerinfo for this FC.
  23.         // while most information here can also be gleaned from the layer object,
  24.         // we cannot know the type (e.g. Feature Layer, Raster Layer), so this object
  25.         // is required.
  26.         // TODO revist _layerInfo and how it is used.
  27.         this._layerInfo = parent._layer.layerInfos[idx];
  29.         this.opacity = config.state.opacity;
  31.         // visibility is kept stateful by the parent. keeping an internal property
  32.         // just means we would need to keep it in synch.
  33.         // the DynamicRecord onLoad handler will set the initial state, so don't do it here.
  34.     }
  36.     get supportsOpacity () { return this._parent._isTrueDynamic; }
  38.     get opacity () { return this._opacity; }
  39.     set opacity (value) {
  40.         this._opacity = value;
  42.         if (this.supportsOpacity) {
  43.             // only attempt to set the layer if we support that kind of magic.
  44.             // instead of being consistent, esri using value from 0 to 100 for sublayer transparency where 100 is fully transparent
  45.             const optionsArray = [];
  46.             const drawingOptions = new this._parent._apiRef.layer.LayerDrawingOptions();
  47.             drawingOptions.transparency = (value - 1) * -100;
  48.             optionsArray[this._idx] = drawingOptions;
  49.             this._parent._layer.setLayerDrawingOptions(optionsArray);
  50.         }
  51.     }
  53.     // returns an object with minScale and maxScale values for the feature class
  54.     getScaleSet () {
  55.         // get the layerData promise for this FC, wait for it to load,
  56.         // then return the scale data
  57.         return this.getLayerData().then(lData => {
  58.             return {
  59.                 minScale: lData.minScale,
  60.                 maxScale: lData.maxScale
  61.             };
  62.         });
  63.     }
  65.     get geomType () { return this._geometryType; }
  66.     set geomType (value) { this._geometryType = value; }
  68.     get featureCount () { return this._fcount; }
  69.     set featureCount (value) { this._fcount = value; }
  71.     setVisibility (value) {
  72.         // update visible layers array
  73.         const vLayers = this._parent._layer.visibleLayers.concat();
  74.         const intIdx = parseInt(this._idx);
  75.         const vIdx = vLayers.indexOf(intIdx);
  76.         let dirty = false;
  77.         if (value && vIdx === -1) {
  78.             // check for first added case
  79.             if (vLayers.length === 1 && vLayers[0] === -1) {
  80.                 vLayers.pop();
  81.             }
  83.             // was invisible, now visible
  84.             vLayers.push(intIdx);
  85.             dirty = true;
  86.         } else if (!value && vIdx > -1) {
  87.             // was visible, now invisible
  88.             vLayers.splice(vIdx, 1);
  89.             if (vLayers.length === 0) {
  90.                 vLayers.push(-1); // code for no layers
  91.             }
  92.             dirty = true;
  93.         }
  95.         if (dirty) {
  96.             this._parent._layer.setVisibleLayers(vLayers);
  97.             this._parent._layer.setVisibility(value);
  98.         }
  100.         // TODO add a timer or something to cache requests.
  101.         //      use setVisibileLayers(arry, true) to stall the redraw
  102.         //      then when timer runs out, call layer.refresh
  104.         // TODO maybe alert the parent that we changed?
  106.         // this.visibleChanged(value);
  107.     }
  109.     // TODO extend this function to other FC's?  do they need it?
  110.     getVisibility () {
  111.         // TEST STATUS none
  112.         // TODO would we ever need to worry about _parent._layer.visible being false while
  113.         //      the visibleLayers array still contains valid indexes?
  114.         return this._parent._layer.visibleLayers.indexOf(parseInt(this._idx)) > -1;
  115.     }
  117. }
  119. module.exports = () => ({
  120.     DynamicFC
  121. });