private void ShowDataLayer(DataLayerPanel layerPanel)
{
#if SAFETY_CHECK
if (activeLayerPanels.Contains(layerPanel))
{
Debug.LogWarning("Layer " + layerPanel.DataLayer.Name + " is already active!");
return;
}
#endif
activeLayerPanels.Add(layerPanel);
var dataLayer = layerPanel.DataLayer;
if (OnLayerVisibilityChange != null)
{
OnLayerVisibilityChange(dataLayer, true);
}
dataLayer.Show(map.CurrentLevel, map.MapCoordBounds);
bool hasPatches = dataLayer.HasPatchesInView();
if (hasPatches && !availableLayers.Contains(dataLayer))
{
availableLayers.Add(dataLayer);
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, true);
}
}
}
private void HideDataLayer(DataLayerPanel layerPanel)
{
#if SAFETY_CHECK
if (!activeLayerPanels.Remove(layerPanel))
{
Debug.LogWarning("Layer " + layerPanel.name + " is not active!");
return;
}
#else
activeLayerPanels.Remove(layerPanel);
#endif
var dataLayer = layerPanel.DataLayer;
if (availableLayers.Remove(dataLayer))
{
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, false);
}
}
dataLayer.HideLoadedPatches();
if (OnLayerVisibilityChange != null)
{
OnLayerVisibilityChange(dataLayer, false);
}
}
private void OnLayerToggleChange(DataLayerPanel panel, bool isOn)
{
if (isOn)
{
ShowDataLayer(panel);
}
else
{
HideDataLayer(panel);
}
if (panel.IsFilterToggleOn)
{
StartCoroutine(ShowFilterPanel(panel, isOn));
}
if (activeLayerPanels.Count > 0)
{
legendToggle.interactable = true;
}
else
{
legendToggle.isOn = false;
legendToggle.interactable = false;
}
}
public void AddLayer(DataLayer layer, DataLayerGroupPanel groupController)
{
// Add new layer
DataLayerPanel layerPanel = groupController.AddLayer(layerPanelPrefab, layer);
layerPanel.layerToggle.onValueChanged.AddListener((isOn) => OnLayerToggleChange(layerPanel, isOn));
layerPanel.filterToggle.onValueChanged.AddListener((isOn) => StartCoroutine(ShowOptionsPanel(layerPanel, isOn)));
if (hideInactiveLayers)
{
layerPanel.gameObject.SetActive(false);
layerPanel.EnableLayerPanel(true);
}
else
{
layerPanel.EnableLayerPanel(false);
layerPanel.gameObject.SetActive(true);
}
#if SAFETY_CHECK
if (nameToLayer.ContainsKey(layer.name))
{
Debug.LogWarning(layer.name + " appears more than once in the layers list");
}
else
#endif
{
layerPanels.Add(layerPanel);
nameToLayer.Add(layer.name, layerPanel);
}
}
private void UpdateLayerDistributionChart(DataLayerPanel layerPanel)
{
if (layerPanel.IsFilterToggleOn && layerPanel.Panel is FilterPanel)
{
var panel = layerPanel.Panel as FilterPanel;
panel.UpdateDistributionChart();
}
}
public DataLayerPanel AddLayer(DataLayerPanel prefab, DataLayer layer)
{
// Create a new instance of the layer prefab and initialize it
var layerCtrl = Instantiate(prefab);
// Important: set the parent AFTER Instantiate to allow toggles to awake
// Parent could be disabled and prevent proper initialization
layerCtrl.transform.SetParent(layersContainer, false);
layerCtrl.Init(layer);
return(layerCtrl);
}
private void UpdateLayerPanelIsActive(DataLayerPanel panel, bool active)
{
if (active)
{
activeSiteLayerPanels.Add(panel);
EnableLayerPanel(panel, true);
}
else
{
panel.layerToggle.isOn = false;
EnableLayerPanel(panel, false);
}
}
private void OnLayerToggleChange(DataLayerPanel panel, bool isOn)
{
if (isOn)
{
ShowDataLayer(panel);
}
else
{
HideDataLayer(panel);
}
if (panel.IsFilterToggleOn)
{
StartCoroutine(ShowFilterPanel(panel, isOn));
}
}
private IEnumerator ShowOptionsPanel(DataLayerPanel layerCtrl, bool show)
{
// FIX: scrollbar won't retract if value is zero.
if (!show && scrollRect.verticalScrollbar.value < 0.001f && scrollRect.verticalScrollbar.size < 1)
{
scrollRect.verticalScrollbar.value = 0.001f;
}
layerCtrl.ShowOptionsPanel(show);
yield return(null);
if (show)
{
float offset = 30f / (scrollRect.content.rect.height - scrollRect.viewport.rect.height);
while (scrollRect.verticalScrollbar.size < 0.99f &&
RectTransformUtility.RectangleContainsScreenPoint(layerCtrl.GetComponent <RectTransform>(), bottomPoint))
{
scrollRect.verticalScrollbar.value -= offset;
yield return(null);
}
}
}
private void UpdateLayerPanel(DataLayerPanel layerPanel, int level, AreaBounds bounds)
{
var dataLayer = layerPanel.DataLayer;
var site = ComponentManager.Instance.Get <SiteBrowser>().ActiveSite;
bool hasPatches;
if (layerPanel.IsLayerToggleOn)
{
dataLayer.UpdatePatches(site, level, bounds);
hasPatches = dataLayer.HasPatchesInView();
if (hasPatches && !availableLayers.Contains(dataLayer))
{
availableLayers.Add(dataLayer);
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, true);
}
}
else if (!hasPatches && availableLayers.Contains(dataLayer))
{
availableLayers.Remove(dataLayer);
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, false);
}
}
}
else
{
hasPatches = dataLayer.HasPatches(site, level, bounds.west, bounds.east, bounds.north, bounds.south);
}
// Show/hide a layer panel when only visible layers are allowed, otherwise enable/disable the layer panel
EnableLayerPanel(layerPanel, hasPatches);
}
// Helper function to show/hide or enable/disable layer depending on HideLayersWithoutVisiblePatches
public void EnableLayerPanel(DataLayerPanel layerPanel, bool enable)
{
if (hideInactiveLayers)
{
// Show the group BEFORE the layer is shown
if (hideEmptyGroups && enable && layerPanel.gameObject.activeSelf != enable)
{
GetGroupPanel(layerPanel).Show(true);
}
if (layerPanel.ShowLayerPanel(enable))
{
// Hide the group AFTER the layer is hidden (only if no other layers are visible)
if (hideEmptyGroups && !enable)
{
GetGroupPanel(layerPanel).UpdateVisibility();
}
}
}
else
{
layerPanel.EnableLayerPanel(enable);
}
}
private DataLayerGroupPanel GetGroupPanel(DataLayerPanel layerPanel)
{
return(layerPanel.transform.parent.parent.GetComponent <DataLayerGroupPanel>());
}
