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.         this.opacity = config.state.opacity;
  24.         // visibility is kept stateful by the parent. keeping an internal property
  25.         // just means we would need to keep it in synch.
  26.         // the DynamicRecord onLoad handler will set the initial state, so don't do it here.
  28.         // will also cache scale levels to avoid asynching code.  initialize here with no limits,
  29.         // then update when layer loads
  30.         this._scaleSet = {
  31.             minScale: 0,
  32.             maxScale: 0
  33.         };
  34.     }
  36.     get supportsOpacity () { return this._parent._isTrueDynamic; }
  38.     get opacity () { return this._opacity; }
  39.     set opacity (value) {
  40.         // avoid parent/child update loops by only doing work if value changed
  41.         if (this._opacity !== value) {
  42.             this._opacity = value;
  44.             if (this.supportsOpacity) {
  45.                 // only attempt to set the layer if we support that kind of magic.
  46.                 // instead of being consistent, esri using value from 0 to 100 for sublayer transparency where 100 is fully transparent
  47.                 const optionsArray = [];
  48.                 const drawingOptions = new this._parent._apiRef.layer.LayerDrawingOptions();
  49.                 drawingOptions.transparency = (value - 1) * -100;
  50.                 optionsArray[this._idx] = drawingOptions;
  51.                 this._parent._layer.setLayerDrawingOptions(optionsArray);
  52.             } else {
  53.                 // update the opacity on the parent and any sibling children
  54.                 this._parent.synchOpacity(value);
  55.             }
  56.         }
  57.     }
  59.     // returns an object with minScale and maxScale values for the feature class
  60.     getScaleSet () {
  61.         return this._scaleSet;
  62.     }
  64.     get geomType () { return this._geometryType; }
  65.     set geomType (value) { this._geometryType = value; }
  67.     get featureCount () { return this._fcount; }
  68.     set featureCount (value) { this._fcount = value; }
  70.     setVisibility (value) {
  71.         // update visible layers array
  72.         const vLayers = this._parent._layer.visibleLayers.concat();
  73.         const intIdx = parseInt(this._idx);
  74.         const vIdx = vLayers.indexOf(intIdx);
  75.         let dirty = false;
  76.         let layerVisChange = false;
  77.         if (value && vIdx === -1) {
  78.             // check for first added case
  79.             if (vLayers.length === 1 && vLayers[0] === -1) {
  80.                 vLayers.pop();
  81.                 layerVisChange = true;
  82.             }
  84.             // was invisible, now visible
  85.             vLayers.push(intIdx);
  86.             dirty = true;
  87.         } else if (!value && vIdx > -1) {
  88.             // was visible, now invisible
  89.             vLayers.splice(vIdx, 1);
  90.             if (vLayers.length === 0) {
  91.                 vLayers.push(-1); // code for no layers
  92.                 layerVisChange = true;
  93.             }
  94.             dirty = true;
  95.         }
  97.         if (dirty) {
  98.             this._parent._layer.setVisibleLayers(vLayers);
  99.             if (layerVisChange) {
  100.                 this._parent._layer.setVisibility(value);
  101.             }
  102.         }
  104.         // TODO add a timer or something to cache requests.
  105.         //      use setVisibileLayers(arry, true) to stall the redraw
  106.         //      then when timer runs out, call layer.refresh
  108.     }
  110.     // TODO extend this function to other FC's?  do they need it?
  111.     getVisibility () {
  112.         return this._parent._layer.visibleLayers.indexOf(parseInt(this._idx)) > -1;
  113.     }
  115. }
  117. module.exports = () => ({
  118.     DynamicFC
  119. });