☰

WME FC Layer

Adds a Functional Class layer for states that publish ArcGIS FC data.

当前为 2019-01-28 提交的版本，查看 最新版本。

  1. /* global W */
  2. /* global Promise */
  3. /* global OL */
  4. /* global I18n */
  5. /* global unsafeWindow */
  6. /* global GM_info */
  7. /* global WazeWrap */
  8.  
  9. // // ==UserScript==
  10. // @name         WME FC Layer
  11. // @namespace    https://greasyfork.org/users/45389
  12. // @version      2019.01.28.001
  13. // @description  Adds a Functional Class layer for states that publish ArcGIS FC data.
  14. // @author       MapOMatic
  15. // @include      /^https:\/\/(www|beta)\.waze\.com\/(?!user\/)(.{2,6}\/)?editor\/?.*$/
  16. // @license      GNU GPLv3
  17. // @contributionURL https://github.com/WazeDev/Thank-The-Authors
  18. // @require      https://greasyfork.org/scripts/39002-bluebird/code/Bluebird.js?version=255146
  19. // @require      https://greasyfork.org/scripts/24851-wazewrap/code/WazeWrap.js
  20. // @grant        GM_xmlhttpRequest
  21. // @connect      md.gov
  22. // @connect      in.gov
  23. // @connect      arcgis.com
  24. // @connect      ncdot.gov
  25. // @connect      state.mi.us
  26. // @connect      dc.gov
  27. // @connect      la.gov
  28. // @connect      nd.gov
  29. // @connect      pa.gov
  30. // @connect      oh.us
  31. // @connect      ksdot.org
  32. // @connect      ky.gov
  33. // @connect      shelbycountytn.gov
  34. // @connect      illinois.gov
  35. // @connect      ny.gov
  36. // @connect      utah.gov
  37. // @connect      idaho.gov
  38. // @connect      wv.gov
  39. // @connect      ga.gov
  40. // @connect      uga.edu
  41. // @connect      nevadadot.com
  42. // ==/UserScript==
  43.  
  44. (function() {
  45.     'use strict';
  46.  
  47.     var _settingsStoreName = 'wme_fc_layer';
  48.     var _alertUpdate = false;
  49.     var _debugLevel = 0;
  50.     var _scriptVersion = GM_info.script.version;
  51.     var _scriptVersionChanges = [
  52.         GM_info.script.name,
  53.         'v' + _scriptVersion,
  54.         '',
  55.         'What\'s New',
  56.         '------------------------------',
  57.         ''  // Add important stuff here when _alertUpdate = true.
  58.     ].join('\n');
  59.     var _mapLayer = null;
  60.     var _isAM = false;
  61.     var _uid;
  62.     var _settings = {};
  63.     var _r;
  64.     var _mapLayerZIndex = 334;
  65.     var _betaIDs = [103400892];
  66.     var _statesHash = {
  67.         'Alabama':'AL','Alaska':'AK','American Samoa':'AS','Arizona':'AZ','Arkansas':'AR','California':'CA','Colorado':'CO','Connecticut':'CT','Delaware':'DE','District of Columbia':'DC',
  68.         'Federated States Of Micronesia':'FM','Florida':'FL','Georgia':'GA','Guam':'GU','Hawaii':'HI','Idaho':'ID','Illinois':'IL','Indiana':'IN','Iowa':'IA','Kansas':'KS',
  69.         'Kentucky':'KY','Louisiana':'LA','Maine':'ME','Marshall Islands':'MH','Maryland':'MD','Massachusetts':'MA','Michigan':'MI','Minnesota':'MN','Mississippi':'MS','Missouri':'MO',
  70.         'Montana':'MT','Nebraska':'NE','Nevada':'NV','New Hampshire':'NH','New Jersey':'NJ','New Mexico':'NM','New York':'NY','North Carolina':'NC','North Dakota':'ND',
  71.         'Northern Mariana Islands':'MP','Ohio':'OH','Oklahoma':'OK','Oregon':'OR','Palau':'PW','Pennsylvania':'PA','Puerto Rico':'PR','Rhode Island':'RI','South Carolina':'SC',
  72.         'South Dakota':'SD','Tennessee':'TN','Texas':'TX','Utah':'UT','Vermont':'VT','Virgin Islands':'VI','Virginia':'VA','Washington':'WA','West Virginia':'WV','Wisconsin':'WI','Wyoming':'WY'
  73.     };
  74.  
  75.     function reverseStatesHash(stateAbbr) {
  76.         for (var stateName in _statesHash) {
  77.             if (_statesHash[stateName] === stateAbbr) return stateName;
  78.         }
  79.     }
  80.     var _stateSettings = {
  81.         global: {
  82.             roadTypes: ['St','PS','PS2','mH','MH','Ew','Rmp','Fw'], // Ew = Expressway.  For FC's that make it uncertain if they should be MH or FW.
  83.             getFeatureRoadType: function(feature, layer) {
  84.                 var fc = feature.attributes[layer.fcPropName];
  85.                 return this.getRoadTypeFromFC(fc, layer);
  86.             },
  87.             getRoadTypeFromFC: function(fc, layer) {
  88.                 for (var roadType in layer.roadTypeMap) {
  89.                     if (layer.roadTypeMap[roadType].indexOf(fc) !== -1) {
  90.                         return roadType;
  91.                     }
  92.                 }
  93.                 return null;
  94.             },
  95.             isPermitted: function(stateAbbr) {if(_betaIDs.indexOf(_uid)!==-1)return true;var state=_stateSettings[stateAbbr];if(state.isPermitted){return state.isPermitted();}else{return(_r>=2&&_isAM)||(_r>=3);}},
  96.             getMapLayer: function(stateAbbr, layerID) {
  97.                 var returnValue;
  98.                 _stateSettings[stateAbbr].fcMapLayers.forEach(function(layer) {
  99.                     if (layer.layerID === layerID) {
  100.                         returnValue = layer;
  101.                     }
  102.                 });
  103.                 return returnValue;
  104.             }
  105.         },
  106.         DC: {
  107.             baseUrl: 'https://maps2.dcgis.dc.gov/dcgis/rest/services/DCGIS_DATA/Transportation_WebMercator/MapServer/',
  108.             supportsPagination: false,
  109.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  110.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [[],[],[],[],[],[],[],[],[],[],[]] },
  111.             fetchAllFC: false,
  112.             fcMapLayers: [
  113.                 { layerID:48, fcPropName:'FUNCTIONALCLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONALCLASS'], maxRecordCount:1000, supportsPagination:false,
  114.                  roadTypeMap:{Fw:['Interstate'],Ew:['Other Freeway and Expressway'],MH:['Principal Arterial'],mH:['Minor Arterial'],PS:['Collector']} }
  115.             ],
  116.             getFeatureRoadType: function(feature, layer) {
  117.                 if (layer.getFeatureRoadType) {
  118.                     return layer.getFeatureRoadType(feature);
  119.                 } else {
  120.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  121.                 }
  122.             },
  123.             getWhereClause: function(context) {
  124.                 return null;
  125.             }
  126.         },
  127.         FL: {
  128.             baseUrl: 'https://services1.arcgis.com/O1JpcwDW8sjYuddV/ArcGIS/rest/services/Functional_Classification_TDA/FeatureServer/',
  129.             supportsPagination: false,
  130.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  131.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [[],[],[],[],[],[],[],[],[],[],[]] },
  132.             fetchAllFC: false,
  133.             fcMapLayers: [
  134.                 { layerID:0, fcPropName:'FUNCLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCLASS'], maxRecordCount:1000, supportsPagination:false,
  135.                  roadTypeMap:{Fw:['01','11'],Ew:['02','12'],MH:['04','14'],mH:['06','16'],PS:['07','08','17','18']} }
  136.             ],
  137.             getFeatureRoadType: function(feature, layer) {
  138.                 if (layer.getFeatureRoadType) {
  139.                     return layer.getFeatureRoadType(feature);
  140.                 } else {
  141.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  142.                 }
  143.             },
  144.             getWhereClause: function(context) {
  145.                 return null;
  146.             }
  147.         },
  148.         GA: {
  149.             baseUrl: 'https://maps.itos.uga.edu/arcgis/rest/services/GDOT/GDOT_FunctionalClass/mapserver/',
  150.             supportsPagination: true,
  151.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  152.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [[],[],[],[],[],[],[],[],[],[],[]] },
  153.             fetchAllFC: false,
  154.             fcMapLayers: [
  155.                 { layerID:0, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  156.                 { layerID:1, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  157.                 { layerID:2, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  158.                 { layerID:3, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  159.                 { layerID:4, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  160.                 { layerID:5, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  161.                 { layerID:6, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID', 'FUNCTIONAL_CLASS', 'SYSTEM_CODE'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} }
  162.             ],
  163.             getFeatureRoadType: function(feature, layer) {
  164.                 if (layer.getFeatureRoadType) {
  165.                     return layer.getFeatureRoadType(feature);
  166.                 } else {
  167.                     var attr = feature.attributes;
  168.                     var fc = attr.FUNCTIONAL_CLASS;
  169.                     if (attr.SYSTEM_CODE === '1' && fc > 4) {
  170.                         return _stateSettings.global.getRoadTypeFromFC(4, layer);
  171.                     } else {
  172.                         return _stateSettings.global.getFeatureRoadType(feature, layer);
  173.                     }
  174.                 }
  175.             },
  176.             getWhereClause: function(context) {
  177.                 return null;
  178.             }
  179.         },
  180.         ID: {
  181.             baseUrl: 'https://gis.itd.idaho.gov/arcgisprod/rest/services/IPLAN/Functional_Classification/MapServer/',
  182.             supportsPagination: false,
  183.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  184.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [[],[],[],[],[],[],[],[],[],[],[]] },
  185.             fetchAllFC: true,
  186.             fcMapLayers: [
  187.                 { layerID:0, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  188.                 { layerID:1, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  189.                 { layerID:2, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  190.                 { layerID:3, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  191.                 { layerID:4, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} },
  192.                 { layerID:5, fcPropName:'FCCODE', idPropName:'OBJECTID', outFields:['OBJECTID', 'FCCODE'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6]} }
  193.             ],
  194.             getFeatureRoadType: function(feature, layer) {
  195.                 if (layer.getFeatureRoadType) {
  196.                     return layer.getFeatureRoadType(feature);
  197.                 } else {
  198.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  199.                 }
  200.             },
  201.             getWhereClause: function(context) {
  202.                 return null;
  203.             }
  204.         },
  205.         IL: {
  206.             baseUrl: 'https://ags10s1.dot.illinois.gov/ArcGIS/rest/services/AdministrativeData/Roads/MapServer/',
  207.             supportsPagination: false,
  208.             defaultColors: {Fw:'#ff00c5',Ew:'#ff00c5',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee',CH:'#ff5e0e'},
  209.             zoomSettings: { maxOffset:[30,15,8,4,2,1,1,1,1,1] },
  210.             fcMapLayers: [
  211.                 { layerID:0, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  212.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  213.                 { layerID:1, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  214.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  215.                 { layerID:2, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  216.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  217.                 { layerID:3, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  218.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  219.                 { layerID:4, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  220.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  221.                 { layerID:5, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  222.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  223.                 { layerID:6, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  224.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  225.                 { layerID:7, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  226.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false },
  227.                 { layerID:8, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','MARKED_RT','MARKED_RT2','MARKED_RT3','MARKED_RT4','CH'],
  228.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7'],CH:['8']}, maxRecordCount:1000, supportsPagination:false }
  229.             ],
  230.             isPermitted: function() { return _r >= 3; },
  231.             getWhereClause: function(context) {
  232.                 if(context.mapContext.zoom < 4) {
  233.                     return "FC<>'7' OR (FC='7' AND CH<>'0000')";
  234.                 } else {
  235.                     return null;
  236.                 }
  237.             },
  238.             getFeatureRoadType: function(feature, layer) {
  239.                 var attr = feature.attributes;
  240.                 var isUS = false;
  241.                 var isState = false;
  242.                 var isCounty = attr.CH !== '0000';
  243.                 [attr.MARKED_RT, attr.MARKED_RT2, attr.MARKED_RT3, attr.MARKED_RT4].forEach(function(rt) {
  244.                     if (!isUS) {
  245.                         isUS = /U\d+/.test(rt);
  246.                         if (!isUS && !isState) {
  247.                             isState = /S\d+/.test(rt);
  248.                         }
  249.                     }
  250.                 });
  251.                 var fc = attr.FC;
  252.                 fc = (fc > 3 && isUS) ? '3' : (fc > 4 && isState) ? '4' : (fc === '7' && isCounty) ? '8' : fc;
  253.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  254.             }
  255.         },
  256.         IN: {
  257.             baseUrl: 'https://gis.in.gov/arcgis/rest/services/DOT/INDOT_LTAP/FeatureServer/',
  258.             supportsPagination: false,
  259.             overrideUrl: '1Sbwc7e6BfHpZWSTfU3_1otXGSxHrdDYcbn7fOf1VjpA',
  260.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  261.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]], hideRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  262.             fcMapLayers: [
  263.                 { layerID:10, idPropName:'OBJECTID', fcPropName:'FUNCTIONAL_CLASS', outFields:['FUNCTIONAL_CLASS','OBJECTID','TO_DATE'],
  264.                  roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:100000, supportsPagination:false }
  265.             ],
  266.             isPermitted: function() { return true; },
  267.             getWhereClauses: function(context) {
  268.             },
  269.             getWhereClause: function(context) {
  270.                 var whereParts = [];
  271.                 if(context.mapContext.zoom < 4) {
  272.                     whereParts.push(context.layer.fcPropName + '<>7');
  273.                 }
  274.                 whereParts.push('TO_DATE IS NULL');
  275.                 return whereParts.join(' AND ');
  276.             },
  277.             getFeatureRoadType: function(feature, layer) {
  278.                 if (layer.getFeatureRoadType) {
  279.                     return layer.getFeatureRoadType(feature);
  280.                 } else {
  281.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  282.                 }
  283.             }
  284.         },
  285.         KS: {
  286.             baseUrl: 'http://wfs.ksdot.org/arcgis_web_adaptor/rest/services/Transportation/',
  287.             supportsPagination: false,
  288.             defaultColors: {Fw:'#ff00c5',Ew:'#ff00c5',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  289.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1] },
  290.             fcMapLayers: [
  291.                 { layerID:0, layerPath:'Non_State_System/MapServer/', idPropName:'ID2', fcPropName:'FUNCLASS', outFields:['FUNCLASS','ID2','ROUTE_ID'],
  292.                   roadTypeMap:{Fw:[1],MH:[2,3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  293.                 { layerID:1, layerPath:'National_Highway_System/MapServer/', idPropName:'OBJECTID', fcPropName:'FUN_CLASS_CD', outFields:['FUN_CLASS_CD','OBJECTID','INTERSTATE_ROUTES','US_ROUTES','STATE_ROUTES'],
  294.                   roadTypeMap:{Fw:["1"],MH:["2","3"],mH:["4"],PS:["5","6"],St:["7"]}, maxRecordCount:1000, supportsPagination:false },
  295.                 { layerID:0, layerPath:'State_System/MapServer/', idPropName:'OBJECTID', fcPropName:'FUN_CLASS_CD', outFields:['FUN_CLASS_CD','OBJECTID','INTERSTATE_ROUTES','US_ROUTES','STATE_ROUTES'],
  296.                   roadTypeMap:{Fw:["1"],MH:["2","3"],mH:["4"],PS:["5","6"],St:["7"]}, maxRecordCount:1000, supportsPagination:false }
  297. /*                ,{ layerID:0, layerPath:'Functional_Classification/MapServer/', idPropName:'OBJECTID', fcPropName:'FUN_CLASS', outFields:['FUN_CLASS','OBJECTID','CRND_RTE'],
  298.                   roadTypeMap:{Fw:[1],MH:[2,3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:1000, supportsPagination:false }
  299. */
  300.             ],
  301.             getWhereClause: function(context) {
  302.                 if(context.mapContext.zoom < 4) {
  303.                     return context.layer.fcPropName + "<>'7'";
  304.                 } else {
  305.                     return null;
  306.                 }
  307.             },
  308.             getFeatureRoadType: function(feature, layer) {
  309.                 if (layer.getFeatureRoadType) {
  310.                     return layer.getFeatureRoadType(feature);
  311.                 } else {
  312.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  313.                 }
  314.             },
  315.         },
  316.         KY: {
  317.             baseUrl: 'https://maps.kytc.ky.gov/arcgis/rest/services/BaseMap/System/MapServer/',
  318.             supportsPagination: false,
  319.             defaultColors: {Fw:'#ff00c5',Ew:'#ff00c5',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  320.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1] },
  321.             fcMapLayers: [
  322.                 { layerID:0, idPropName:'OBJECTID', fcPropName:'FC', outFields:['FC','OBJECTID','RT_PREFIX', 'RT_SUFFIX'],
  323.                  roadTypeMap:{Fw:['1'],Ew:['2'],MH:['3'],mH:['4'],PS:['5','6'],St:['7']}, maxRecordCount:1000, supportsPagination:false }
  324.             ],
  325.             isPermitted: function() { return true; },
  326.             getWhereClause: function(context) {
  327.                 if(context.mapContext.zoom < 4) {
  328.                     return context.layer.fcPropName + "<>'7'";
  329.                 } else {
  330.                     return null;
  331.                 }
  332.             },
  333.             getFeatureRoadType: function(feature, layer) {
  334.                 if (feature.attributes.RT_PREFIX === 'US') {
  335.                     var suffix = feature.attributes.RT_SUFFIX;
  336.                     var type = 'MH';
  337.                     if (suffix && suffix.indexOf('X') > -1) type = 'mH';
  338.                     return type;
  339.                 } else {
  340.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  341.                 }
  342.             }
  343.         },
  344.         LA: {
  345.             baseUrl: 'https://giswebnew.dotd.la.gov/arcgis/rest/services/Transportation/LA_RoadwayFunctionalClassification/FeatureServer/',
  346.             supportsPagination: false,
  347.             defaultColors: {Fw:'#4094ff',Ew:'#ffbf40',MH:'#fb674d',mH:'#6abe40',PS1:'#bf40ec',PS2:'#ffff40',St:'#a2a2a2'},
  348.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  349.             fcMapLayers: [
  350.                 { layerID:0, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  351.                 { layerID:1, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  352.                 { layerID:2, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  353.                 { layerID:3, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  354.                 { layerID:4, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  355.                 { layerID:5, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false },
  356.                 { layerID:6, fcPropName:'FunctionalSystem', idPropName:'OBJECTID', outFields:['OBJECTID','FunctionalSystem'], roadTypeMap:{Fw:[1],Ew:['2','2a','2b'],MH:[3],mH:[4],PS1:[5],PS2:[6],St:[7]}, maxRecordCount:1000, supportsPagination:false }
  357.             ],
  358.             getWhereClause: function(context) {
  359.                 if(context.mapContext.zoom < 4) {
  360.                     return context.layer.fcPropName + "<>'7'"; // OR State_Route LIKE 'US%' OR State_Route LIKE 'LA%'";
  361.                 } else {
  362.                     return null;
  363.                 }
  364.             },
  365.             getFeatureRoadType: function(feature, layer) {
  366.                 var fc = feature.attributes[layer.fcPropName];
  367.                 if (fc === '2a' || fc === '2b') { fc = 2; }
  368.                 fc = parseInt(fc);
  369.                 // var stateRoute = feature.attributes.State_Route;
  370.                 // var isBusiness = /BUS$/.test(stateRoute);
  371.                 // if (fc > 3 && /^US\s/.test(stateRoute) && !isBusiness) {
  372.                 //     fc = 3;
  373.                 // } else if (fc > 4 && /^LA\s/.test(stateRoute) && !isBusiness) {
  374.                 //     fc = 4;
  375.                 // }
  376.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  377.             }
  378.         },
  379.         MD: {
  380.             baseUrl: 'https://geodata.md.gov/imap/rest/services/Transportation/MD_HighwayPerformanceMonitoringSystem/MapServer/',
  381.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#ffff00',St:'#eeeeee'},
  382.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  383.             fcMapLayers: [
  384.                 { layerID:2, fcPropName:'FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','FUNCTIONAL_CLASS','ID_PREFIX','MP_SUFFIX'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:1000, supportsPagination:false }
  385.             ],
  386.             getWhereClause: function(context) {
  387.                 if(context.mapContext.zoom < 4) {
  388.                     return "(FUNCTIONAL_CLASS < 7 OR ID_PREFIX IN('MD'))";
  389.                 } else {
  390.                     return null;
  391.                 }
  392.             },
  393.             getFeatureRoadType: function(feature,layer) {
  394.                 var attr = feature.attributes;
  395.                 var fc = parseInt(attr.FUNCTIONAL_CLASS);
  396.                 var isState = attr.ID_PREFIX === 'MD';
  397.                 var isUS = attr.ID_PREFIX === 'US';
  398.                 var isBusiness = attr.MP_SUFFIX === 'BU';
  399.                 if (fc > 4 && isState) { fc = (isBusiness ? Math.min(fc,5) : 4); }
  400.                 else if (fc > 3 && isUS) { fc = (isBusiness ? Math.min(fc, 4) : 3 );}
  401.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  402.             }
  403.         },
  404.         MI: {
  405.             baseUrl: 'https://gisp.mcgi.state.mi.us/arcgis/rest/services/MDOT/NFC/MapServer/',
  406.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  407.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  408.             fcMapLayers: [
  409.                 { layerID:2, idPropName:'OBJECTID', fcPropName:'NFC', outFields:['NFC'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:1000, supportsPagination:false }
  410.             ],
  411.             isPermitted: function() { return true; },
  412.             getWhereClause: function(context) {
  413.                 if(context.mapContext.zoom < 4) {
  414.                     return context.layer.fcPropName + '<>7';
  415.                 } else {
  416.                     return null;
  417.                 }
  418.             },
  419.             getFeatureRoadType: function(feature, layer) {
  420.                 if (layer.getFeatureRoadType) {
  421.                     return layer.getFeatureRoadType(feature);
  422.                 } else {
  423.                     return _stateSettings.global.getFeatureRoadType(feature, layer);
  424.                 }
  425.             }
  426.         },
  427.         NC: {
  428.             baseUrl: 'https://gis11.services.ncdot.gov/arcgis/rest/services/NCDOT_FunctionalClass/MapServer/',
  429.             defaultColors: {Fw:'#ff00c5',Rmp:'#999999',Ew:'#5f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  430.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  431.             fcMapLayers: [
  432.                 { layerID:0, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[3,4,5,6,7,8,9,10], maxRecordCount:1000, supportsPagination:false }
  433.                 //{ layerID:2, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[2], maxRecordCount:1000, supportsPagination:false },
  434.                 //{ layerID:3, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[0,1], maxRecordCount:1000, supportsPagination:false },
  435.                 //{ layerID:4, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  436.                 //{ layerID:5, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false },
  437.                 //{ layerID:6, fcPropName:'FC_TYP_CD', idPropName:'OBJECTID', outFields:['OBJECTID','FC_TYP_CD','RTE_1_CLSS_CD'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, zoomLevels:[], maxRecordCount:1000, supportsPagination:false }
  438.             ],
  439.             isPermitted: function() { return _r > 1; },
  440.             getWhereClause: function(context) {
  441.                 if(context.mapContext.zoom < 4) {
  442.                     var clause = '(' + context.layer.fcPropName + " < 7 OR RTE_1_CLSS_CD IN ('I','FED','NC','RMP','US'))";
  443.                     return clause;
  444.                 } else {
  445.                     return null;
  446.                 }
  447.             },
  448.             getFeatureRoadType: function(feature, layer) {
  449.                 var fc = feature.attributes[layer.fcPropName];
  450.                 var roadType;
  451.                 switch (this.getHwySys(feature)) {
  452.                     case 'interstate':
  453.                         roadType = 'Fw';
  454.                         break;
  455.                     case 'us':
  456.                         roadType = fc <= 2 ? 'Ew' : 'MH';
  457.                         break;
  458.                     case 'state':
  459.                         roadType = fc === 2 ? 'Ew' : (fc === 3 ? 'MH' : 'mH');
  460.                         break;
  461.                     case 'ramp':
  462.                         roadType = 'Rmp';
  463.                         break;
  464.                     default:
  465.                         roadType = fc === 2 ? 'Ew' : (fc === 3 ? 'MH' : (fc === 4 ? 'mH' : (fc <= 6 ? 'PS' : 'St')));
  466.                 }
  467.                 return roadType;
  468.             },
  469.             getHwySys: function(feature) {
  470.                 var hwySys;
  471.                 switch (feature.attributes.RTE_1_CLSS_CD) {
  472.                     case 'I':
  473.                         hwySys = 'interstate';
  474.                         break;
  475.                     case 'FED':
  476.                     case 'US':
  477.                         hwySys = 'us';
  478.                         break;
  479.                     case 'NC':
  480.                         hwySys = 'state';
  481.                         break;
  482.                     case 'RMP':
  483.                         hwySys = 'ramp';
  484.                         break;
  485.                     default:
  486.                         hwySys = 'local';
  487.                 }
  488.                 return hwySys;
  489.             }
  490.         },
  491.         ND: {
  492.             baseUrl: 'https://gis.dot.nd.gov/arcgis/rest/services/external/transinfo/MapServer/',
  493.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  494.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  495.             fcMapLayers: [
  496.                 { layerID:10, fcPropName:'FUNCTION_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','FUNCTION_CLASS'], roadTypeMap:{Fw:['Interstate'],MH:['Principal Arterial'],mH:['Minor Arterial'],PS:['Major Collector','Collector'],St:['Local']},
  497.                  maxRecordCount:1000, supportsPagination:false},
  498.                 { layerID:11, fcPropName:'FUNCTION_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','FUNCTION_CLASS'], roadTypeMap:{Fw:['Interstate'],MH:['Principal Arterial'],mH:['Minor Arterial'],PS:['Major Collector','Collector'],St:['Local']},
  499.                  maxRecordCount:1000, supportsPagination:false},
  500.                 { layerID:12, fcPropName:'FUNCTION_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','FUNCTION_CLASS'], roadTypeMap:{PS:['Major Collector','Collector']},
  501.                  maxRecordCount:1000, supportsPagination:false},
  502.                 { layerID:16, fcPropName:'SYSTEM_CD', idPropName:'OBJECTID', outFields:['OBJECTID','SYSTEM_CD','SYSTEM_DESC','HIGHWAY'], roadTypeMap:{Fw:[1,11],MH:[2,14],mH:[6,7,16,19]},
  503.                  maxRecordCount:1000, supportsPagination:false}
  504.             ],
  505.             getWhereClause: function(context) {
  506.                 if(context.mapContext.zoom < 4) {
  507.                     if (context.layer.layerID !== 16) return context.layer.fcPropName + "<>'Local'";
  508.                 } else {
  509.                     return null;
  510.                 }
  511.             },
  512.             getFeatureRoadType: function(feature, layer) {
  513.                 return _stateSettings.global.getFeatureRoadType(feature, layer);
  514.             }
  515.         },
  516.         NV: {
  517.             baseUrl: 'https://gis.nevadadot.com/arcgis/rest/services/ArcGISOnline/PublicMaintenanceMap/MapServer/',
  518.             defaultColors: {Fw:'#ff00c5',Ew:'#149ece',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  519.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  520.             fcMapLayers: [
  521.                 { layerID:3, fcPropName:'FUNC_CODE', idPropName:'OBJECTID', outFields:['OBJECTID','FUNC_CODE'], roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]}, maxRecordCount:1000, supportsPagination:false }
  522.             ],
  523.             getWhereClause: function(context) {
  524.                 return null;
  525.             },
  526.             getFeatureRoadType: function(feature, layer) {
  527.                 return _stateSettings.global.getFeatureRoadType(feature, layer);
  528.             }
  529.         },
  530.         NY: {//https://gis3.dot.ny.gov/arcgis/rest/services/Basemap/MapServer/21
  531.             baseUrl: 'https://gis3.dot.ny.gov/arcgis/rest/services/',
  532.             defaultColors: {Fw:'#ff00c5',Ew:'#5f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  533.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1] },
  534.             fcMapLayers: [
  535.                 { layerID:'FC/MapServer/1', fcPropName:'FUNC_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','FUNC_CLASS','SEGMENT_NAME','ROUTE_NO'], roadTypeMap:{Fw:[1,11],Ew:[2,12],MH:[4,14],mH:[6,16],PS:[7,8,17,18]},
  536.                  maxRecordCount:1000, supportsPagination:false },
  537.                 { layerID:'Basemap/MapServer/21', idPropName:'OBJECTID', outFields:['OBJECTID','SHIELD'], maxRecordCount:1000, supportsPagination:false }
  538.             ],
  539.             getWhereClause: function(context) {
  540.                 if (context.layer.layerID === 'Basemap/MapServer/21') {
  541.                     return ("SHIELD IN ('C','CT')");
  542.                 } else {
  543.                     return null;
  544.                 }
  545.             },
  546.             getFeatureRoadType: function(feature, layer) {
  547.                 var roadType;
  548.                 if (layer.layerID === 'Basemap/MapServer/21') {
  549.                     roadType = 'PS';
  550.                 } else {
  551.                     roadType = _stateSettings.global.getFeatureRoadType(feature, layer);
  552.                     var routeNo = feature.attributes.ROUTE_NO;
  553.                     if (/^NY.*/.test(routeNo)) {
  554.                         if (roadType === 'PS') roadType = 'mH';
  555.                     } else if (/^US.*/.test(routeNo)) {
  556.                         if (roadType === 'PS' || roadType === 'mH') roadType = 'MH';
  557.                     }
  558.                 }
  559.                 return roadType;
  560.             }
  561.         },
  562.         OH: {
  563.             baseUrl: 'https://gis.dot.state.oh.us/arcgis/rest/services/TIMS/Roadway_Information/MapServer/',
  564.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  565.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  566.  
  567.             fcMapLayers: [
  568.                 { layerID:8, fcPropName:'FUNCTION_CLASS', idPropName:'ObjectID', outFields:['FUNCTION_CLASS','ROUTE_TYPE','ROUTE_NBR','ObjectID'],
  569.                  maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} }
  570.             ],
  571.             isPermitted: function() { return true; },
  572.             getWhereClause: function(context) {
  573.                 if(context.mapContext.zoom < 4) {
  574.                     var clause = '(' + context.layer.fcPropName + " < 7 OR ROUTE_TYPE IN ('CR','SR','US'))";
  575.                     return clause;
  576.                 } else {
  577.                     return null;
  578.                 }
  579.             },
  580.             getFeatureRoadType: function(feature, layer) {
  581.                 var fc = feature.attributes[layer.fcPropName];
  582.                 var prefix = feature.attributes.ROUTE_TYPE;
  583.                 var isUS = prefix === 'US';
  584.                 var isState = prefix === 'SR';
  585.                 var isCounty = prefix === 'CR';
  586.                 if (isUS && fc > 3) { fc = 3; }
  587.                 if (isState && fc > 4) { fc = 4; }
  588.                 if (isCounty && fc > 6) { fc = 6; }
  589.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  590.             }
  591.         },
  592.         OK: {
  593.             baseUrl: 'https://services6.arcgis.com/RBtoEUQ2lmN0K3GY/arcgis/rest/services/Roadways/FeatureServer/',
  594.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  595.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  596.             fcMapLayers: [
  597.                 { layerID:0, fcPropName:'NFC', idPropName:'OBJECTID', outFields:['F_PRIMARY_','NFC','OBJECTID','ROUTE_CLAS'],
  598.                  maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} }
  599.             ],
  600.             getWhereClause: function(context) {
  601.                 if(context.mapContext.zoom < 4) {
  602.                     var clause = '(' + context.layer.fcPropName + " < 7 OR ROUTE_CLAS IN ('U','S','I'))";
  603.                     return clause;
  604.                 } else {
  605.                     return null;
  606.                 }
  607.             },
  608.             getFeatureRoadType: function(feature, layer) {
  609.                 var fc = feature.attributes[layer.fcPropName];
  610.                 var route = (feature.attributes.F_PRIMARY_ || '').trim();
  611.                 var isBusinessOrSpur = /BUS$|SPR$/i.test(route);
  612.                 var prefix = isBusinessOrSpur ? route.substring(0,1) : feature.attributes.ROUTE_CLAS;
  613.                 var isInterstate = prefix === 'I';
  614.                 var isUS = prefix === 'U';
  615.                 var isState = prefix === 'S';
  616.                 if (((isUS && !isBusinessOrSpur) || (isInterstate && isBusinessOrSpur)) && fc > 3) { fc = 3; }
  617.                 if (((isUS && isBusinessOrSpur) || (isState && !isBusinessOrSpur)) && fc > 4) { fc = 4; }
  618.                 if (isState && isBusinessOrSpur && fc > 5) { fc = 5; }
  619.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  620.             }
  621.         },
  622.         PA: {
  623.             baseUrl: 'https://www.pdarcgissvr.pa.gov/penndotgis/rest/services/PennShare/PennShare/MapServer/',
  624.             supportsPagination: false,
  625.             defaultColors: {Fw:'#00ffff',Ew:'#732500',MH:'#ff0000',mH:'#00ff00',PS:'#b724ff',PS2:'#f3f300',St:'#ff9700'},
  626.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  627.             isPermitted: function() { return _r >= 3; },
  628.             fcMapLayers: [
  629.                 { layerID:3, features:new Map(), fcPropName:'FUNC_CLS', idPropName:'MSLINK', outFields:['MSLINK','FUNC_CLS'],
  630.                  maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:['01','11'],Ew:['12'],MH:['02','14'],mH:['06','16'],PS:['07','08','17'],St:['09','19']} }
  631.             ],
  632.             getWhereClause: function(context) {
  633.                 return null;
  634.             },
  635.             getFeatureRoadType: function(feature, layer) {
  636.                 if (layer.getFeatureRoadType) {
  637.                     return layer.getFeatureRoadType(feature);
  638.                 } else {
  639.                     var fc = feature.attributes[layer.fcPropName];
  640.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  641.                 }
  642.             }
  643.         },
  644.         TN: {
  645.             // NOTE: DUE TO ERRORS FROM THE SHELBY COUNTY SERVER, FC IS NOT WORKING PROPERLY HERE YET (9/23/2016)
  646.             baseUrl: 'https://testuasiportal.shelbycountytn.gov/arcgis/rest/services/MPO/Webmap_2015_04_20_TMPO/MapServer/',
  647.  
  648.             // TODO: UPDATE COLORS TO MATCH ORIGINAL TN FC MAP COLORS.
  649.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',PS2:'#cfae0e',St:'#eeeeee'},
  650.             zoomSettings: { maxOffset:[30,15,8,4,2,1,1,1,1,1] },
  651.             fcMapLayers: [
  652.                 { layerID:17, fcPropName:'FuncClass', idPropName:'OBJECTID', outFields:['OBJECTID','FuncClass'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1,11],Ew:[2,12],MH:[4,14],mH:[6,16],PS:[7,17],PS2:[8,18],St:[9,19]} }
  653.             ],
  654.             getWhereClause: function(context) {
  655.                 if(context.mapContext.zoom < 4) {
  656.                     return context.layer.fcPropName + ' NOT IN (9,19)';
  657.                 } else {
  658.                     return null;
  659.                 }
  660.             },
  661.             getFeatureRoadType: function(feature, layer) {
  662.                 if (layer.getFeatureRoadType) {
  663.                     return layer.getFeatureRoadType(feature);
  664.                 } else {
  665.                     var fc = feature.attributes[layer.fcPropName];
  666.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  667.                 }
  668.             }
  669.         },
  670.         TX: {
  671.             baseUrl: 'https://services.arcgis.com/KTcxiTD9dsQw4r7Z/ArcGIS/rest/services/TxDOT_Functional_Classification/FeatureServer/',
  672.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  673.             zoomSettings: { maxOffset:[30,15,8,4,2,1,1,1,1,1] },
  674.             fcMapLayers: [
  675.                 { layerID:0, fcPropName:'F_SYSTEM', idPropName:'OBJECTID', outFields:['OBJECTID','F_SYSTEM', 'RTE_PRFX'], maxRecordCount:1000, supportsPagination:false, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} }
  676.             ],
  677.             getWhereClause: function(context) {
  678.                 var where = " F_SYSTEM IS NOT NULL AND RTE_PRFX IS NOT NULL";
  679.                 if(context.mapContext.zoom < 4) {
  680.                     where += ' AND ' + context.layer.fcPropName + " <> 7";
  681.                 }
  682.                 return where;
  683.             },
  684.             getFeatureRoadType: function(feature, layer) {
  685.                 // On-System:
  686.                 // IH=Interstate BF=Business FM
  687.                 // US=US Highway FM=Farm to Mkt
  688.                 // UA=US Alt. RM=Ranch to Mkt
  689.                 // UP=US Spur RR=Ranch Road
  690.                 // SH=State Highway PR=Park Road
  691.                 // SA=State Alt. RE=Rec Road
  692.                 // SL=State Loop RP=Rec Rd Spur
  693.                 // SS=State Spur FS=FM Spur
  694.                 // BI=Business IH RS=RM Spur
  695.                 // BU=Business US RU=RR Spur
  696.                 // BS=Business State PA=Principal Arterial
  697.                 // Off-System:
  698.                 // TL=Off-System Tollroad CR=County Road
  699.                 // FC=Func. Classified St. LS=Local Street
  700.                 if (layer.getFeatureRoadType) {
  701.                     return layer.getFeatureRoadType(feature);
  702.                 } else {
  703.                     var fc = feature.attributes[layer.fcPropName];
  704.                     var type = feature.attributes.RTE_PRFX.substring(0,2).toUpperCase();
  705.                     if (type === 'IH' && fc > 1) {
  706.                         fc = 1;
  707.                     } else if ((type === 'US' || type === 'BI' || type === 'UA') && fc > 3) {
  708.                         fc = 3;
  709.                     } else if ((type === 'UP' || type === 'BU' || type === 'SH' || type === 'SA') && fc > 4) {
  710.                         fc = 4;
  711.                     } else if ((type === 'SL' || type === 'SS' || type === 'BS') && fc > 6) {
  712.                         fc = 6;
  713.                     }
  714.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  715.                 }
  716.             },
  717.             isPermitted: function() { return _r >= 1; }
  718.         },
  719.         UT: {
  720.             baseUrl: 'https://maps.udot.utah.gov/arcgis/rest/services/Functional_Class/MapServer/',
  721.             defaultColors: {Fw:'#ff00c5',Ew:'#4f33df',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  722.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  723.             fcMapLayers: [
  724.                 { layerID:0, fcPropName:'FC_CODE', idPropName:'OBJECTID', outFields:['*'/*'OBJECTID','FC_CODE'*/], roadTypeMap:{Fw:[1],Ew:[2,20],MH:[3,30],mH:[4,40],PS:[5,50,6,60],St:[7,77]},
  725.                  maxRecordCount:1000, supportsPagination:false }
  726.             ],
  727.             getWhereClause: function(context) {
  728.                 var clause = context.layer.fcPropName + '<=7';
  729.                 if(context.mapContext.zoom < 4) {
  730.                     clause += ' OR ' + context.layer.fcPropName + '<7';
  731.                 }
  732.                 return clause;
  733.             },
  734.             getFeatureRoadType: function(feature, layer) {
  735.                 var routeId = feature.attributes.ROUTE_ID;
  736.                 var fc = feature.attributes.FC_CODE;
  737.                 if ([6,40,50,89,91,163,189,191,491].indexOf(routeId) > -1 && fc > 3) {
  738.                     // US highway
  739.                     fc = 3;
  740.                 } else if (routeId <= 491 && fc > 4) {
  741.                     // State highway
  742.                     fc = 4;
  743.                 }
  744.                 return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  745.             }
  746.         },
  747.         VA: {
  748.             baseUrl: 'https://services.arcgis.com/p5v98VHDX9Atv3l7/arcgis/rest/services/FC_2014_FHWA_Submittal1/FeatureServer/',
  749.             defaultColors: {Fw:'#ff00c5',Ew:'#ff00c5',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  750.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  751.             fcMapLayers: [
  752.                 { layerID:0, fcPropName:'FUNCTIONAL_CLASS_ID', idPropName:'OBJECTID', outFields:['OBJECTID','FUNCTIONAL_CLASS_ID','RTE_NM'], maxRecordCount:2000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} },
  753.                 { layerID:1, fcPropName:'STATE_FUNCT_CLASS_ID', idPropName:'OBJECTID', outFields:['OBJECTID','STATE_FUNCT_CLASS_ID','RTE_NM','ROUTE_NO'], maxRecordCount:2000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} },
  754.                 { layerID:3, fcPropName:'TMPD_FC', idPropName:'OBJECTID', outFields:['OBJECTID','TMPD_FC','RTE_NM'], maxRecordCount:2000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} }
  755.             ],
  756.             srExceptions: [217,302,303,305,308,310,313,314,315,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,339,341,342,343,344,345,346,347,348,350,353,355,357,358,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,382,383,384,385,386,387,388,389,390,391,392,393,394,396,397,398,399,785,895],
  757.             getWhereClause: function(context) {
  758.                 if(context.mapContext.zoom < 4) {
  759.                     return context.layer.fcPropName + '<>7';
  760.                 } else {
  761.                     //NOTE: As of 9/14/2016 there does not appear to be any US/SR/VA labeled routes with FC = 7.
  762.                     return null;
  763.                 }
  764.             },
  765.             getFeatureRoadType: function(feature, layer) {
  766.                 if (layer.getFeatureRoadType) {
  767.                     return layer.getFeatureRoadType(feature);
  768.                 } else {
  769.                     var fc = parseInt(feature.attributes[layer.fcPropName]);
  770.                     var rtName = feature.attributes.RTE_NM;
  771.                     var match = /^R-VA\s*(US|VA|SR)(\d{5})..(BUS)?/.exec(rtName);
  772.                     var isBusiness = (match && (match !== null) && (match[3] === 'BUS'));
  773.                     var isState = (match && (match !== null) && (match[1] === 'VA' || match[1] === 'SR'));
  774.                     var rtNum = parseInt((layer.layerID === 1) ? feature.attributes.ROUTE_NO : (match ? match[2] : 99999));
  775.                     var rtPrefix = match && match[1];
  776.                     if (fc > 3 && rtPrefix === 'US') {
  777.                         fc = isBusiness ? 4 : 3;
  778.                     } else if (isState && fc > 4 && this.srExceptions.indexOf(rtNum) === -1 && rtNum < 600) {
  779.                         fc = isBusiness ? 5 : 4;
  780.                     }
  781.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  782.                 }
  783.             }
  784.         },
  785.         WV: {
  786.             baseUrl: 'https://gis.transportation.wv.gov/arcgis/rest/services/Roads_And_Highways/Publication_LRS/MapServer/',
  787.             defaultColors: {Fw:'#ff00c5',Ew:'#ff00c5',MH:'#149ece',mH:'#4ce600',PS:'#cfae0e',St:'#eeeeee'},
  788.             zoomSettings: { maxOffset: [30,15,8,4,2,1,1,1,1,1], excludeRoadTypes: [['St'],['St'],['St'],['St'],[],[],[],[],[],[],[]] },
  789.             fcMapLayers: [
  790.                 { layerID:35, fcPropName:'NAT_FUNCTIONAL_CLASS', idPropName:'OBJECTID', outFields:['OBJECTID','NAT_FUNCTIONAL_CLASS','ROUTE_ID'], maxRecordCount:1000, supportsPagination:true, roadTypeMap:{Fw:[1],Ew:[2],MH:[3],mH:[4],PS:[5,6],St:[7]} }
  791.             ],
  792.             getWhereClause: function(context) {
  793.                 if(context.mapContext.zoom < 4) {
  794.                     return context.layer.fcPropName + ' NOT IN(9,19)';
  795.                 } else {
  796.                     return null;
  797.                 }
  798.             },
  799.             getFeatureRoadType: function(feature, layer) {
  800.                 if (layer.getFeatureRoadType) {
  801.                     return layer.getFeatureRoadType(feature);
  802.                 } else {
  803.                     var fcCode = feature.attributes[layer.fcPropName];
  804.                     var fc = fcCode;
  805.                     if (fcCode===11) fc = 1;
  806.                     else if (fcCode===4 || fcCode===12) fc = 2;
  807.                     else if (fcCode===2 || fcCode===14) fc = 3;
  808.                     else if (fcCode===6 || fcCode===16) fc = 4;
  809.                     else if (fcCode===7 || fcCode===17 || fcCode===8 || fcCode===18) fc = 5;
  810.                     else fc = 7;
  811.                     var id = feature.attributes.ROUTE_ID;
  812.                     var prefix = id.substr(2,1);
  813.                     var isInterstate = false;
  814.                     var isUS = false;
  815.                     var isState = false;
  816.                     switch (prefix) {
  817.                         case '1':
  818.                             isInterstate = true;
  819.                             break;
  820.                         case '2':
  821.                             isUS = true;
  822.                             break;
  823.                         case '3':
  824.                             isState = true;
  825.                             break;
  826.                     }
  827.                     if (fc > 1 && isInterstate)
  828.                         fc = 1;
  829.                     else if (fc > 3 && isUS)
  830.                         fc = 3;
  831.                     else if (fc > 4 && isState)
  832.                         fc = 4;
  833.                     return _stateSettings.global.getRoadTypeFromFC(fc, layer);
  834.                 }
  835.             }
  836.         }
  837.     };
  838.  
  839.     function log(message, level) {
  840.         if (message && (!level || (level <= _debugLevel))) {
  841.             console.log('FC Layer: ', message);
  842.         }
  843.     }
  844.  
  845.     function dynamicSort(property) {
  846.         var sortOrder = 1;
  847.         if(property[0] === "-") {
  848.             sortOrder = -1;
  849.             property = property.substr(1);
  850.         }
  851.         return function (a,b) {
  852.             var props = property.split('.');
  853.             props.forEach(function(prop) {
  854.                 a = a[prop];
  855.                 b = b[prop];
  856.             });
  857.             var result = (a < b) ? -1 : (a > b) ? 1 : 0;
  858.             return result * sortOrder;
  859.         };
  860.     }
  861.  
  862.     function dynamicSortMultiple() {
  863.         /*
  864.      * save the arguments object as it will be overwritten
  865.      * note that arguments object is an array-like object
  866.      * consisting of the names of the properties to sort by
  867.      */
  868.         var props = arguments;
  869.         if (arguments[0] && Array.isArray(arguments[0])) {
  870.             props = arguments[0];
  871.         }
  872.         return function (obj1, obj2) {
  873.             var i = 0, result = 0, numberOfProperties = props.length;
  874.             /* try getting a different result from 0 (equal)
  875.          * as long as we have extra properties to compare
  876.          */
  877.             while(result === 0 && i < numberOfProperties) {
  878.                 result = dynamicSort(props[i])(obj1, obj2);
  879.                 i++;
  880.             }
  881.             return result;
  882.         };
  883.     }
  884.  
  885.     function generateUUID() {
  886.         var d = new Date().getTime();
  887.         var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
  888.             var r = (d + Math.random()*16)%16 | 0;
  889.             d = Math.floor(d/16);
  890.             return (c==='x' ? r : (r&0x3|0x8)).toString(16);
  891.         });
  892.         return uuid;
  893.     }
  894.  
  895.     function loadSettingsFromStorage() {
  896.         var loadedSettings = $.parseJSON(localStorage.getItem(_settingsStoreName));
  897.         var defaultSettings = {
  898.             lastVersion:null,
  899.             layerVisible:true,
  900.             activeStateAbbr:'ALL',
  901.             hideStreet:false
  902.         };
  903.         _settings = loadedSettings ? loadedSettings : defaultSettings;
  904.         for (var prop in defaultSettings) {
  905.             if (!_settings.hasOwnProperty(prop)) {
  906.                 _settings[prop] = defaultSettings[prop];
  907.             }
  908.         }
  909.     }
  910.  
  911.     function saveSettingsToStorage() {
  912.         if (localStorage) {
  913.             _settings.lastVersion = _scriptVersion;
  914.             _settings.layerVisible = _mapLayer.visibility;
  915.             localStorage.setItem(_settingsStoreName, JSON.stringify(_settings));
  916.             log('Settings saved', 1);
  917.         }
  918.     }
  919.  
  920.     function getLineWidth() {
  921.         return 12 * Math.pow(1.15, (W.map.getZoom()-1));
  922.     }
  923.  
  924.     function sortArray(array) {
  925.         array.sort(function(a, b){if (a < b)return -1;if (a > b)return 1;else return 0;});
  926.     }
  927.  
  928.     function getVisibleStateAbbrs() {
  929.         var visibleStates = [];
  930.         W.model.states.additionalInfo.forEach(function(state) {
  931.             var stateAbbr = _statesHash[state.name];
  932.             var activeStateAbbr = _settings.activeStateAbbr;
  933.             if(_stateSettings[stateAbbr] && _stateSettings.global.isPermitted(stateAbbr) && (!activeStateAbbr || activeStateAbbr === 'ALL' || activeStateAbbr === stateAbbr)) {
  934.                 visibleStates.push(stateAbbr);
  935.             }
  936.         });
  937.         return visibleStates;
  938.     }
  939.  
  940.     function getAsync(url, context) {
  941.         return new Promise(function(resolve, reject) {
  942.             GM_xmlhttpRequest({
  943.                 context:context, method:"GET", url:url,
  944.                 onload:function(res) {
  945.                     if (res.status.toString() === '200') {
  946.                         resolve({responseText: res.responseText, context:context});
  947.                     } else {
  948.                         reject({responseText: res.responseText, context:context});
  949.                     }
  950.                 },
  951.                 onerror: function() {
  952.                     reject(Error("Network Error"));
  953.                 }
  954.             });
  955.         });
  956.     }
  957.     function wait(ms){
  958.         var start = new Date().getTime();
  959.         var end = start;
  960.         while(end < start + ms) {
  961.             end = new Date().getTime();
  962.         }
  963.     }
  964.     function getUrl(context, queryType, queryParams) {
  965.         var extent = context.mapContext.extent,
  966.             zoom = context.mapContext.zoom,
  967.             layer = context.layer,
  968.             state = context.state;
  969.  
  970.         var whereParts = [];
  971.         var geometry = { xmin:extent.left, ymin:extent.bottom, xmax:extent.right, ymax:extent.top, spatialReference: {wkid: 102100, latestWkid: 3857} };
  972.         var geometryStr = JSON.stringify(geometry);
  973.         var stateWhereClause = state.getWhereClause(context);
  974.         var url = state.baseUrl + layer.layerPath + layer.layerID + '/query?geometry=' + encodeURIComponent(geometryStr);
  975.  
  976.         if (queryType === 'countOnly') {
  977.             url += '&returnCountOnly=true';
  978.         } else if (queryType === 'idsOnly') {
  979.             url += '&returnIdsOnly=true';
  980.         } else if (queryType === 'paged') {
  981.             // TODO
  982.         } else {
  983.             url += '&returnGeometry=true&maxAllowableOffset=' + state.zoomSettings.maxOffset[zoom];
  984.             url += '&outFields=' + encodeURIComponent(layer.outFields.join(','));
  985.             if (queryType === 'idRange') {
  986.                 var idPropName = context.layer.idPropName;
  987.                 whereParts.push('(' + queryParams.idFieldName + '>=' + queryParams.range[0] + ' AND ' + queryParams.idFieldName + '<=' + queryParams.range[1] + ')');
  988.             }
  989.         }
  990.         if (stateWhereClause) whereParts.push(stateWhereClause);
  991.         if (whereParts.length > 0 ) url += '&where=' + encodeURIComponent(whereParts.join(' AND '));
  992.         url += '&spatialRel=esriSpatialRelIntersects&geometryType=esriGeometryEnvelope&inSR=102100&outSR=3857&f=json';
  993.         //wait(500);  // I don't know why this was in the code.  Leaving it commented here just in case it was a hack to solve some issue.
  994.         return url;
  995.     }
  996.  
  997.     function convertFcToRoadTypeVectors(feature, state, stateAbbr, layer, zoom) {
  998.         var roadType = state.getFeatureRoadType(feature, layer);
  999.         log(feature,3);
  1000.         var zIndex = _stateSettings.global.roadTypes.indexOf(roadType) * 100;
  1001.         var vectors = [];
  1002.         var lineFeatures = [];
  1003.         var attr = {
  1004.             //fcFeatureUniqueId: stateAbbr + '-' + layer.layerID + '-' + feature.attributes[layer.idPropName],
  1005.             //fcFeatureId: feature.attributes[layer.idPropName],
  1006.             state: stateAbbr,
  1007.             layerID: layer.layerID,
  1008.             roadType: roadType,
  1009.             dotAttributes: $.extend({}, feature.attributes),
  1010.             color: state.defaultColors[roadType],
  1011.             strokeWidth: getLineWidth,
  1012.             zIndex: zIndex
  1013.         };
  1014.  
  1015.         feature.geometry.paths.forEach(function(path){
  1016.             var pointList = [];
  1017.             var newPoint = null;
  1018.             var lastPoint = null;
  1019.             path.forEach(function(point){
  1020.                 pointList.push(new OL.Geometry.Point(point[0],point[1]));
  1021.             });
  1022.             var vectorFeature = new OL.Feature.Vector(new OL.Geometry.LineString(pointList),attr);
  1023.             vectors.push(vectorFeature);
  1024.         });
  1025.  
  1026.         return vectors;
  1027.     }
  1028.  
  1029.     function fetchLayerFC(context) {
  1030.         var url = getUrl(context, 'idsOnly');
  1031.         log(url,2);
  1032.         if (!context.parentContext.cancel) {
  1033.             return getAsync(url, context).bind(context).then(function(res) {
  1034.                 var ids = $.parseJSON(res.responseText);
  1035.                 if(!ids.objectIds) ids.objectIds = [];
  1036.                 sortArray(ids.objectIds);
  1037.                 log(ids,2);
  1038.                 return ids;
  1039.             }).then(function(res) {
  1040.                 var context = this;
  1041.                 var idRanges = [];
  1042.                 if (res.objectIds) {
  1043.                     var len = res.objectIds ? res.objectIds.length : 0;
  1044.                     var currentIndex = 0;
  1045.                     var offset = Math.min(this.layer.maxRecordCount,1000);
  1046.                     while (currentIndex < len) {
  1047.                         var nextIndex = currentIndex + offset;
  1048.                         if (nextIndex >= len) nextIndex = len - 1;
  1049.                         idRanges.push({range:[res.objectIds[currentIndex], res.objectIds[nextIndex]], idFieldName:res.objectIdFieldName});
  1050.                         currentIndex = nextIndex + 1;
  1051.                     }
  1052.                     log(context.layer.layerID, 2);
  1053.                     log(idRanges,2);
  1054.                 }
  1055.                 return idRanges;
  1056.             }).map(function(idRange) {
  1057.                 var context = this;
  1058.                 if(!context.parentContext.cancel) {
  1059.                     var url = getUrl(this, 'idRange', idRange);
  1060.                     log(url,2);
  1061.                     return getAsync(url, context).then(function(res) {
  1062.                         var context = res.context;
  1063.                         if(!context.parentContext.cancel) {
  1064.                             var features = $.parseJSON(res.responseText).features;
  1065.                             // if (context.parentContext.callCount === 0 ) {
  1066.                             //     _mapLayer.removeAllFeatures();
  1067.                             // }
  1068.                             context.parentContext.callCount++;
  1069.                             log('Feature Count=' + (features ? features.length : 0),2);
  1070.                             features = features ? features : [];
  1071.                             var vectors = [];
  1072.                             features.forEach(function(feature) {
  1073.                                 if(!res.context.parentContext.cancel) {
  1074.                                     var vector = convertFcToRoadTypeVectors(feature, context.state, context.stateAbbr, context.layer, context.mapContext.zoom);
  1075.                                     //var fcFeatureUniqueId = vector[0].attributes.fcFeatureUniqueId;
  1076.                                     //context.parentContext.addedFcFeatureUniqueIds.push(fcFeatureUniqueId);
  1077.                                     if (/*!context.parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] &&*/ !(vector[0].attributes.roadType === 'St' && _settings.hideStreet)) {
  1078.                                         vectors.push(vector);
  1079.                                     }
  1080.                                 }
  1081.                             });
  1082.                             return vectors;
  1083.                         }
  1084.                     });
  1085.                 } else {
  1086.                     log('Async call cancelled',1);
  1087.                 }
  1088.             });
  1089.         }
  1090.     }
  1091.  
  1092.     function fetchStateFC(context) {
  1093.         var state = _stateSettings[context.stateAbbr];
  1094.         var contexts = [];
  1095.         state.fcMapLayers.forEach(function(layer) {
  1096.             contexts.push({parentContext:context.parentContext, layer:layer, state:state, stateAbbr:context.stateAbbr, mapContext:context.mapContext});
  1097.         });
  1098.         return Promise.map(contexts, function(context) {
  1099.             return fetchLayerFC(context);
  1100.         });
  1101.     }
  1102.  
  1103.     var _lastPromise = null;
  1104.     var _lastContext = null;
  1105.     var _fcCallCount = 0;
  1106.     function fetchAllFC() {
  1107.         if (!_mapLayer.visibility) return;
  1108.  
  1109.         if (_lastPromise) { _lastPromise.cancel(); }
  1110.         $('#fc-loading-indicator').text('Loading FC...');
  1111.  
  1112.         var mapContext = { zoom:W.map.getZoom(), extent:W.map.getExtent() };
  1113.         var contexts = [];
  1114.         var parentContext = {callCount:0,/*existingFcFeatureUniqueIds:{}, addedFcFeatureUniqueIds:[],*/ startTime:Date.now()};
  1115.         // _mapLayer.features.forEach(function(vectorFeature) {
  1116.         //     var fcFeatureUniqueId = vectorFeature.attributes.fcFeatureUniqueId;
  1117.         //     var existingFcFeatureUniqueIdArray = parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId];
  1118.         //     if (!existingFcFeatureUniqueIdArray) {
  1119.         //         existingFcFeatureUniqueIdArray = [];
  1120.         //         parentContext.existingFcFeatureUniqueIds[fcFeatureUniqueId] = existingFcFeatureUniqueIdArray;
  1121.         //     }
  1122.         //     existingFcFeatureUniqueIdArray.push(vectorFeature);
  1123.         // });
  1124.         if (_lastContext) _lastContext.cancel = true;
  1125.         _lastContext = parentContext;
  1126.         getVisibleStateAbbrs().forEach(function(stateAbbr) {
  1127.             contexts.push({ parentContext:parentContext, stateAbbr:stateAbbr, mapContext:mapContext});
  1128.         });
  1129.         var map = Promise.map(contexts, function(context) {
  1130.             return fetchStateFC(context);
  1131.         }).bind(parentContext).then(function(statesVectorArrays) {
  1132.             if (!this.cancel) {
  1133.                 _mapLayer.removeAllFeatures();
  1134.                 statesVectorArrays.forEach(function(vectorsArray) {
  1135.                     vectorsArray.forEach(function(vectors) {
  1136.                         vectors.forEach(function(vector) {
  1137.                             vector.forEach(function(vectorFeature) {
  1138.                                 _mapLayer.addFeatures(vectorFeature);
  1139.                             });
  1140.                         });
  1141.                     });
  1142.                 });
  1143.                 //buildTable();
  1144.                 // for(var fcFeatureUniqueId in this.existingFcFeatureUniqueIds) {
  1145.                 //     if(this.addedFcFeatureUniqueIds.indexOf(fcFeatureUniqueId) === -1) {
  1146.                 //         if (!this.cancel) _mapLayer.removeFeatures(this.existingFcFeatureUniqueIds[fcFeatureUniqueId]);
  1147.                 //     }
  1148.                 // }
  1149.                 log('TOTAL RETRIEVAL TIME = ' + (Date.now() - parentContext.startTime),1);
  1150.                 log(statesVectorArrays,1);
  1151.             }
  1152.             return statesVectorArrays;
  1153.         }).catch(function(e) {
  1154.             $('#fc-loading-indicator').text('FC Error! (check console for details)');
  1155.             log(e,0);
  1156.         }).finally(function() {
  1157.             _fcCallCount -= 1;
  1158.             if (_fcCallCount === 0) {
  1159.                 $('#fc-loading-indicator').text('');
  1160.             }
  1161.         });
  1162.  
  1163.         _fcCallCount += 1;
  1164.         _lastPromise = map;
  1165.     }
  1166.  
  1167.     function onLayerCheckboxChanged(checked) {
  1168.         _mapLayer.setVisibility(checked);
  1169.     }
  1170.  
  1171.     function onLayerVisibilityChanged(evt) {
  1172.         _settings.layerVisible = _mapLayer.visibility;
  1173.         saveSettingsToStorage();
  1174.         if (_mapLayer.visibility) {
  1175.             fetchAllFC();
  1176.         }
  1177.     }
  1178.  
  1179.     function onModeChanged(model, modeId, context) {
  1180.         if(!modeId || modeId === 1) {
  1181.             initUserPanel();
  1182.         }
  1183.     }
  1184.  
  1185.     function showScriptInfoAlert() {
  1186.         /* Check version and alert on update */
  1187.         if (_alertUpdate && _scriptVersion !== _settings.lastVersion) {
  1188.             alert(_scriptVersionChanges);
  1189.         }
  1190.     }
  1191.  
  1192.     function initLayer(){
  1193.         var _drawingContext = {
  1194.             getZIndex: function(feature) {
  1195.                 return feature.attributes.zIndex;
  1196.             },
  1197.             getStrokeWidth: function() { return getLineWidth(); }
  1198.         };
  1199.         var defaultStyle = new OL.Style({
  1200.             strokeColor: '${color}', //'#00aaff',
  1201.             strokeDashstyle: "solid",
  1202.             strokeOpacity: 1.0,
  1203.             strokeWidth: '${strokeWidth}',
  1204.             graphicZIndex: '${zIndex}'
  1205.         });
  1206.  
  1207.         var selectStyle = new OL.Style({
  1208.             //strokeOpacity: 1.0,
  1209.             strokeColor: '#000000'
  1210.         });
  1211.  
  1212.         _mapLayer = new OL.Layer.Vector("FC Layer", {
  1213.             uniqueName: "__FCLayer",
  1214.             displayInLayerSwitcher: false,
  1215.             rendererOptions: { zIndexing: true },
  1216.             styleMap: new OL.StyleMap({
  1217.                 'default': defaultStyle,
  1218.                 'select': selectStyle
  1219.             })
  1220.         });
  1221.  
  1222.         _mapLayer.setOpacity(0.5);
  1223.  
  1224.         I18n.translations[I18n.locale].layers.name.__FCLayer = "FC Layer";
  1225.  
  1226.         _mapLayer.displayInLayerSwitcher = true;
  1227.         _mapLayer.events.register('visibilitychanged',null,onLayerVisibilityChanged);
  1228.         _mapLayer.setVisibility(_settings.layerVisible);
  1229.  
  1230.         W.map.addLayer(_mapLayer);
  1231.         _mapLayer.setZIndex(_mapLayerZIndex);
  1232.         WazeWrap.Interface.AddLayerCheckbox('Display', 'FC Layer', _settings.layerVisible, onLayerCheckboxChanged);
  1233.         // Hack to fix layer zIndex.  Some other code is changing it sometimes but I have not been able to figure out why.
  1234.         // It may be that the FC layer is added to the map before some Waze code loads the base layers and forces other layers higher. (?)
  1235.  
  1236.         var checkLayerZIndex = function() {
  1237.             if (_mapLayer.getZIndex() != _mapLayerZIndex)  {
  1238.                 log("ADJUSTED FC LAYER Z-INDEX " + _mapLayerZIndex + ', ' + _mapLayer.getZIndex(),1);
  1239.                 _mapLayer.setZIndex(_mapLayerZIndex);
  1240.             }
  1241.         };
  1242.  
  1243.         setInterval(function(){checkLayerZIndex();}, 200);
  1244.  
  1245.         W.map.events.register("moveend",W.map,function(e){
  1246.             fetchAllFC();
  1247.             return true;
  1248.         },true);
  1249.     }
  1250.  
  1251.     function initUserPanel() {
  1252.         var $tab = $('<li>').append($('<a>', {'data-toggle':'tab', href:'#sidepanel-fc-layer'}).text('FC'));
  1253.         var $panel = $('<div>', {class:'tab-pane', id:'sidepanel-fc-layer'});
  1254.         var $stateSelect = $('<select>', {id:'fcl-state-select',class:'form-control disabled',style:'disabled'}).append($('<option>', {value:'ALL'}).text('All'));
  1255.         // $stateSelect.change(function(evt) {
  1256.         //     _settings.activeStateAbbr = evt.target.value;
  1257.         //     saveSettingsToStorage();
  1258.         //     _mapLayer.removeAllFeatures();
  1259.         //     fetchAllFC();
  1260.         // });
  1261.         for (var stateAbbr in _stateSettings) {
  1262.             if (stateAbbr !== 'global') {
  1263.                 $stateSelect.append($('<option>', {value:stateAbbr}).text(reverseStatesHash(stateAbbr)));
  1264.             }
  1265.         }
  1266.  
  1267.         var $hideStreet =  $('<div>',{id: 'fcl-hide-street-container', class:'controls-container'})
  1268.         .append($('<input>', {type:'checkbox',name:'fcl-hide-street',id:'fcl-hide-street'}).prop('checked', _settings.hideStreet).click(function() {
  1269.             _settings.hideStreet = $(this).is(':checked');
  1270.             saveSettingsToStorage();
  1271.             _mapLayer.removeAllFeatures();
  1272.             fetchAllFC();
  1273.         }))
  1274.         .append($('<label>', {for:'fcl-hide-street'}).text('Hide street highlights'));
  1275.  
  1276.         $stateSelect.val(_settings.activeStateAbbr ? _settings.activeStateAbbr : 'ALL');
  1277.  
  1278.         $panel.append(
  1279.             $('<div>', {class:'form-group'}).append(
  1280.                 $('<label>', {class:'control-label'}).text('Select a state')
  1281.             ).append(
  1282.                 $('<div>', {class:'controls', id:'fcl-state-select-container'}).append(
  1283.                     $('<div>').append($stateSelect)
  1284.                 )
  1285.             ),
  1286.             $hideStreet ,
  1287.             $('<div>', {id:'fcl-table-container'})
  1288.         );
  1289.  
  1290.         $panel.append(
  1291.             $('<div>',{style:'margin-top:10px;font-size:10px;color:#999999;'})
  1292.             .append($('<div>').text('version ' + _scriptVersion))
  1293.             .append(
  1294.                 $('<div>').append(
  1295.                     $('<a>',{href:'#' /*, target:'__blank'*/}).text('Discussion Forum (currently n/a)')
  1296.                 )
  1297.             )
  1298.         );
  1299.  
  1300.         $('#user-tabs > .nav-tabs').append($tab);
  1301.         $('#user-info > .flex-parent > .tab-content').append($panel);
  1302.         $('#fcl-state-select').change(function () {
  1303.             _settings.activeStateAbbr = this.value;
  1304.             saveSettingsToStorage();
  1305.             fetchAllFC();
  1306.         });
  1307.     }
  1308.  
  1309.     function addLoadingIndicator() {
  1310.         $('.loading-indicator').after($('<div class="loading-indicator" style="margin-right:10px" id="fc-loading-indicator">'));
  1311.     }
  1312.  
  1313.     function initGui() {
  1314.         addLoadingIndicator();
  1315.         initLayer();
  1316.         initUserPanel();
  1317.         showScriptInfoAlert();
  1318.     }
  1319.  
  1320.     function processText(text) {
  1321.         return new Promise(function(resolve, reject) {
  1322.             var newText = text.replace(/(e)/,'E');
  1323.             resolve(newText);
  1324.         });
  1325.     }
  1326.  
  1327.     function init() {
  1328.         if (_debugLevel > 0 && Promise.config) {
  1329.             Promise.config({
  1330.                 warnings: true,
  1331.                 longStackTraces: true,
  1332.                 cancellation: true,
  1333.                 monitoring: false
  1334.             });
  1335.         } else {
  1336.             Promise.config({
  1337.                 warnings: false,
  1338.                 longStackTraces: false,
  1339.                 cancellation: true,
  1340.                 monitoring: false
  1341.             });
  1342.         }
  1343.  
  1344.         var u = W.loginManager.user;
  1345.         _uid = u.id;
  1346.         _r = u.rank;
  1347.         _isAM = u.isAreaManager;
  1348.         loadSettingsFromStorage();
  1349.         String.prototype.replaceAll = function(search, replacement) {
  1350.             var target = this;
  1351.             return target.replace(new RegExp(search, 'g'), replacement);
  1352.         };
  1353.         initGui();
  1354.         W.app.modeController.model.bind('change:mode', onModeChanged);
  1355.         W.prefs.on("change:isImperial", function() {initUserPanel();loadSettingsFromStorage();});
  1356.         fetchAllFC();
  1357.         log('Initialized.', 0);
  1358.     }
  1359.  
  1360.     function bootstrap() {
  1361.         if (W && W.loginManager &&
  1362.             W.loginManager.events &&
  1363.             W.loginManager.events.register &&
  1364.             W.model && W.model.states && W.model.states.additionalInfo &&
  1365.             W.map && W.loginManager.user &&
  1366.             WazeWrap.Version) {
  1367.             log('Initializing...', 0);
  1368.  
  1369.             init();
  1370.         } else {
  1371.             log('Bootstrap failed. Trying again...', 0);
  1372.             unsafeWindow.setTimeout(function () {
  1373.                 bootstrap();
  1374.             }, 1000);
  1375.         }
  1376.     }
  1377.  
  1378.     log('Bootstrap...', 0);
  1379.     bootstrap();
  1380. })();