/// <summary>
/// Builds group collection with the current layer map and groups
/// </summary>
/// <param name="layerMap">Selected layer map</param>
/// <param name="groups">Collection of groups</param>
/// <returns>Collection of groups with reference frame and layers</returns>
internal static List <GroupChildren> BuildGroupCollection(this LayerMap layerMap, List <GroupChildren> groups)
{
if (layerMap != null && layerMap.LayerDetails.Group != null && groups != null)
{
if (layerMap.LayerDetails.Group.Parent != null)
{
GroupChildren groupItem = groups.Where(groupValue => groupValue.Group != null && groupValue.Group.Equals(layerMap.LayerDetails.Group.Parent)).FirstOrDefault();
if (groupItem != null)
{
GroupChildren groupChildNode = groupItem.Children.Where(childNodes => childNodes.Group.Equals(layerMap.LayerDetails.Group)).FirstOrDefault();
if (groupChildNode != null)
{
layerMap.Name = LayerDetailsViewModel.GetLayerNameOnMapType(layerMap, layerMap.LayerDetails.Name);
groupChildNode.AllChildren.Add(layerMap);
}
else
{
GroupChildren childNode = AddChildNodesToGroup(layerMap);
groupItem.Children.Add(childNode);
groupItem.AllChildren.Add(childNode);
}
}
else
{
AddLayerNode(groups, layerMap);
}
}
else
{
AddLayerNode(groups, layerMap);
}
}
return(groups);
}
/// <summary>
/// Checks if the given layer is mapped with XY columns or not.
/// If X/ReverseX and Y/ReverseY are mapped and Lat/Long/RA/DEC are not mapped (X and Y are mandatory), layer will be considered as XY mapped.
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>True if RA/DEC/Lat/Long are not mapped and X and Y are mapped. False, otherwise.</returns>
internal static bool IsXYMappedLayer(this LayerMap selectedLayerMap)
{
return((selectedLayerMap.MappedColumnType.Contains(ColumnType.X) || selectedLayerMap.MappedColumnType.Contains(ColumnType.ReverseX)) &&
(selectedLayerMap.MappedColumnType.Contains(ColumnType.Y) || selectedLayerMap.MappedColumnType.Contains(ColumnType.ReverseY)) &&
!(selectedLayerMap.MappedColumnType.Contains(ColumnType.Lat) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Long) ||
selectedLayerMap.MappedColumnType.Contains(ColumnType.RA) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Dec)));
}
/// <summary>
/// This function is used to Cleanup WWT layers from layer drop down when WWT is not running.
/// This function performs the following operations:
/// 1. Remove all WWT only layers.
/// 2. Mark all Local IN WWT layer as not in sync with WWT.
/// 3. Set the Selected layer map to null if the Selected WWT layer was deleted in WWT.
/// </summary>
/// <param name="workbookMap">
/// Parent container.
/// </param>
internal static void CleanUpWWTLayers(this WorkbookMap workbookMap)
{
if (workbookMap != null)
{
// 1. Create en empty collection, since this method is called only when WWT is not running. Empty collection is needed
// to be passed for UpdateGroupStatus method.
ICollection <Group> groups = new List <Group>();
LayerMap selectedLayerMap = workbookMap.SelectedLayerMap;
// 2. Remove all WWT only layers.
workbookMap.RemoveWWTLayers();
// 3. On Cleanup, no WWT layers are connected with WWT.
workbookMap.LocalLayerMaps.ForEach(
layer =>
{
// 3.a. Set IsNotInSync.
layer.IsNotInSync = true;
// 3.b. If the group (reference frame/ Layer Group) is deleted in WWT, then set the IsDeleted flag in Group to true.
UpdateGroupStatus(layer.LayerDetails.Group, groups);
});
// 4. Set the Selected layer map to null if the Selected WWT layer was deleted in WWT.
// If the selected layer is WWT layer/is localInWWT which is not deleted, this will be selected while
if (selectedLayerMap != null && selectedLayerMap.MapType == LayerMapType.WWT && !workbookMap.Exists(selectedLayerMap.LayerDetails.ID))
{
workbookMap.SelectedLayerMap = null;
}
}
}
/// <summary>
/// Get WorkbookMap from Workbook
/// </summary>
/// <param name="workbook">workbook instance</param>
/// <returns>WorkbookMap instance</returns>
internal static WorkbookMap GetWorkbookMap(this Workbook workbook)
{
// Initialize default
var workbookMap = new WorkbookMap(workbook);
if (workbook != null)
{
string content = workbook.GetCustomXmlPart(Common.Constants.XmlNamespace);
if (!string.IsNullOrEmpty(content))
{
workbookMap = workbookMap.Deserialize(content);
workbookMap.Workbook = workbook;
if (workbookMap.SerializableLayerMaps == null)
{
workbookMap.SerializableLayerMaps = new List <LayerMap>();
}
if (workbookMap.AllLayerMaps == null)
{
workbookMap.AllLayerMaps = new List <LayerMap>();
workbookMap.AllLayerMaps.AddRange(workbookMap.SerializableLayerMaps);
}
if (workbookMap.AllLayerMaps.Count > 0)
{
// Clean all invalid named ranges.
CleanLayerMap(workbook, workbookMap);
// Loop through all the layers to check if the range address column count is different from the mapped column count
// If so, reset the mapping as excel has undergone changes without the add-in
foreach (LayerMap localLayer in workbookMap.LocalLayerMaps)
{
if (localLayer.RangeName.RefersToRange != null && localLayer.RangeName.RefersToRange.EntireColumn.Count != localLayer.MappedColumnType.Count)
{
localLayer.SetAutoMap();
localLayer.SetLayerProperties();
}
}
}
// Check if layer being removed is selected layer
if (workbookMap.SerializableSelectedLayerMap != null)
{
// Check if SelectedLayerMap is found in All local layers
LayerMap layerMap = workbookMap.AllLayerMaps
.Where(item => !string.IsNullOrEmpty(item.RangeDisplayName) && item.RangeDisplayName.Equals(workbookMap.SerializableSelectedLayerMap.RangeDisplayName)).FirstOrDefault();
workbookMap.SelectedLayerMap = (layerMap != null) ? layerMap : null;
}
}
// Clean up and update Local in WWT Layers
workbookMap.LoadWWTLayers();
}
return(workbookMap);
}
/// <summary>
/// Validates if X,Y and z column is present and lat/long or RA/DEC column is not present if so
/// remove depth and alt from columns collection
/// </summary>
private static void ValidateXYZ(LayerMap selectedLayerMap, Collection <Column> columns)
{
if (selectedLayerMap.IsXYZLayer())
{
columns.Remove(columns.Where(col => col.ColType == ColumnType.Depth).FirstOrDefault());
columns.Remove(columns.Where(col => col.ColType == ColumnType.Alt).FirstOrDefault());
columns.Remove(columns.Where(col => col.ColType == ColumnType.Distance).FirstOrDefault());
}
}
/// <summary>
/// Creates nodes and add layer to the existing node
/// </summary>
/// <param name="groups">Group collection with layer and reference frame groups</param>
/// <param name="layerMap">Selected layer map details</param>
private static void AddLayerNode(List <GroupChildren> groups, LayerMap layerMap)
{
if (layerMap != null && groups != null)
{
GroupChildren parent = CreateNode(layerMap.LayerDetails.Group, groups, layerMap);
layerMap.Name = LayerDetailsViewModel.GetLayerNameOnMapType(layerMap, layerMap.LayerDetails.Name);
// Add Layer to the parent group.
parent.AllChildren.Add(layerMap);
}
}
/// <summary>
/// Updates the layer map properties with the layer values
/// </summary>
/// <param name="layerMap">Layer map value</param>
/// <param name="layer">Layer details</param>
/// <returns>Updated layer map</returns>
internal static LayerMap UpdateLayerMapProperties(this LayerMap layerMap, Layer layer)
{
if (layerMap != null && layer != null)
{
lock (WorkflowController.LockObject)
{
layerMap.LayerDetails = layer;
layerMap.ColumnsList = ColumnExtensions.PopulateColumnList();
layerMap.SetMappedColumnType();
}
}
return(layerMap);
}
/// <summary>
/// Checks if the given layer is XYZ layer or not.
/// If X/ReverseX or Y/ReverseY or Z/ReverseZ is mapped and Lat/Long or RA/DEC is not mapped, then the layer will considered as XYZ layer.
/// </summary>
/// <param name="selectedLayerMap">Selected layer</param>
/// <returns>True, if RA/DEC/Lat/Long are not mapped and X or Y or Z is/are mapped. False, otherwise.</returns>
internal static bool IsXYZLayer(this LayerMap selectedLayerMap)
{
bool xyzLayer = false;
if (selectedLayerMap.MappedColumnType != null)
{
xyzLayer = (selectedLayerMap.MappedColumnType.Contains(ColumnType.X) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Y) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Z) ||
selectedLayerMap.MappedColumnType.Contains(ColumnType.ReverseX) || selectedLayerMap.MappedColumnType.Contains(ColumnType.ReverseY) ||
selectedLayerMap.MappedColumnType.Contains(ColumnType.ReverseZ)) && !(selectedLayerMap.MappedColumnType.Contains(ColumnType.Lat) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Long) ||
selectedLayerMap.MappedColumnType.Contains(ColumnType.RA) || selectedLayerMap.MappedColumnType.Contains(ColumnType.Dec));
}
return(xyzLayer);
}
/// <summary>
/// Add child node to existing group
/// </summary>
/// <param name="layerMap">Selected layer map</param>
/// <returns>Child node for group children</returns>
private static GroupChildren AddChildNodesToGroup(LayerMap layerMap)
{
GroupChildren childNode = new GroupChildren();
if (layerMap != null)
{
childNode.Group = layerMap.LayerDetails.Group;
childNode.Name = layerMap.LayerDetails.Group.Name;
childNode.Layers.Add(layerMap.LayerDetails);
layerMap.Name = LayerDetailsViewModel.GetLayerNameOnMapType(layerMap, layerMap.LayerDetails.Name);
childNode.AllChildren.Add(layerMap);
childNode.IsDeleted = layerMap.LayerDetails.Group.IsDeleted;
}
return(childNode);
}
private void OnSerializingMethod(StreamingContext context)
{
SerializableLayerMaps.Clear();
SerializableSelectedLayerMap = null;
SerializableLayerMaps.AddRange(LocalLayerMaps);
if (SelectedLayerMap != null && WorkflowController.IsLocalLayer(SelectedLayerMap.MapType))
{
if (SelectedLayerMap.IsValid)
{
SerializableSelectedLayerMap = SelectedLayerMap;
}
else
{
SelectedLayerMap = null;
}
}
}
/// <summary>
/// This function is used to update header details in object models.
/// </summary>
/// <param name="selectedlayer">
/// Updated layer.
/// </param>
/// <param name="selectedRange">
/// Updated range.
/// </param>
internal static void UpdateHeaderProperties(this LayerMap selectedlayer, Range selectedRange)
{
if (selectedlayer != null && selectedRange != null)
{
// Update the address of the selected layer.
selectedlayer.RangeAddress = selectedRange.Address;
// Update Header Data.
selectedlayer.HeaderRowData = selectedRange.GetHeader();
// Header Change
// 1. AutoMap the columns
selectedlayer.SetAutoMap();
// 2. Set layer properties dependent on mapping.
selectedlayer.SetLayerProperties();
}
}
/// <summary>
/// Gets the look at value from the selected layer
/// </summary>
/// <param name="layerMap">Selected layer map</param>
/// <returns>Look at value from layer</returns>
internal static string GetLookAt(this LayerMap layerMap)
{
string lookAt = Common.Constants.EarthLookAt;
if (layerMap != null)
{
var referenceFramePath = layerMap.LayerDetails.Group.Path;
if (referenceFramePath.StartsWith(Common.Constants.SkyFramePath, StringComparison.OrdinalIgnoreCase))
{
lookAt = Common.Constants.SkyLookAt;
}
else if (!referenceFramePath.StartsWith(Common.Constants.EarthFramePath, StringComparison.OrdinalIgnoreCase))
{
lookAt = Common.Constants.SolarSystemLookAt;
}
}
return(lookAt);
}
/// <summary>
/// This function is used to Load all WWT layers on the load of a workbook.
/// This function performs the following operations:
/// 1. Remove all WWT only layers.
/// 2. On load of a workbook, no layers are connected with WWT.
/// 3. Insert and update deleted WWT Layers.
/// </summary>
/// <param name="workbookMap">
/// Parent container.
/// </param>
internal static void LoadWWTLayers(this WorkbookMap workbookMap)
{
if (workbookMap != null)
{
LayerMap selectedLayerMap = workbookMap.SelectedLayerMap;
// 1. Remove all WWT only layers.
workbookMap.RemoveWWTLayers();
ICollection <Group> groups = WWTManager.GetAllWWTGroups(true);
// 2. On load of a workbook, no layers are connected with WWT.
workbookMap.LocalInWWTLayerMaps.ForEach(
layer =>
{
// 2.a. Set IsNotInSync.
layer.IsNotInSync = true;
// 2.b. Update all group references.
Group group = SearchGroup(layer.LayerDetails.Group.Name, layer.LayerDetails.Group.Path, groups);
if (group != null)
{
layer.LayerDetails.Group = group;
}
else
{
layer.LayerDetails.Group.IsDeleted = true;
}
});
// 3. Synchronize WWT Layers
workbookMap.SyncWWTLayers(groups);
// 4. Set the Selected layer map to null if the Selected WWT layer was deleted in WWT.
// If the selected layer is WWT layer/is localInWWT which is not deleted, this will be selected while
if (selectedLayerMap != null && selectedLayerMap.MapType == LayerMapType.WWT && !workbookMap.Exists(selectedLayerMap.LayerDetails.ID))
{
workbookMap.SelectedLayerMap = null;
}
}
}
/// <summary>
/// This function is used to refresh the layer drop down with the latest layers from WWT.
/// This function performs the following operations:
/// 1. Remove all WWT only layers.
/// 2. Insert and update deleted WWT Layers.
/// 3. Set the Selected layer map to null if the Selected WWT layer was deleted in WWT.
/// </summary>
/// <param name="workbookMap">
/// Parent container.
/// </param>
internal static void RefreshLayers(this WorkbookMap workbookMap)
{
if (workbookMap != null)
{
LayerMap selectedLayerMap = workbookMap.SelectedLayerMap;
ICollection <Group> groups = WWTManager.GetAllWWTGroups(true);
// 1. Remove all WWT only layers.
workbookMap.RemoveWWTLayers();
// 2. Insert and update deleted WWT Layers
workbookMap.SyncWWTLayers(groups);
// 3. Set the Selected layer map to null if the Selected WWT layer was deleted in WWT.
// If the selected layer is WWT layer/is localInWWT which is not deleted, this will be selected while
if (selectedLayerMap != null && selectedLayerMap.MapType == LayerMapType.WWT && !workbookMap.Exists(selectedLayerMap.LayerDetails.ID))
{
workbookMap.SelectedLayerMap = null;
}
}
}
/// <summary>
/// Saved workbook map into Custom xml parts in workbook
/// </summary>
/// <param name="layerMap">LayerMap instance</param>
internal static void SaveWorkbookMap(this LayerMap layerMap)
{
if (layerMap != null)
{
var workbookMap = WorkflowController.Instance.GetWorkbookMapForLayerMap(layerMap);
if (workbookMap != null)
{
// Save only local layers
if (workbookMap.LocalLayerMaps != null)
{
lock (WorkflowController.LockObject)
{
string content = workbookMap.Serialize();
if (!string.IsNullOrEmpty(content))
{
workbookMap.Workbook.AddCustomXmlPart(content, Common.Constants.XmlNamespace);
}
}
}
}
}
}
/// <summary>
/// Update the mapped column types based on the Selected Layer map.
/// </summary>
/// <param name="selectedLayerMap">
/// Selected Layer map.
/// </param>
internal static void UpdateMappedColumns(this LayerMap selectedLayerMap)
{
if (selectedLayerMap != null && selectedLayerMap.LayerDetails.Group != null)
{
Collection <ColumnType> mappedColTypes = new Collection <ColumnType>();
if (selectedLayerMap.LayerDetails.Group.IsPlanet())
{
selectedLayerMap.MappedColumnType.ToList().ForEach(columnType =>
{
if (columnType == ColumnType.RA || columnType == ColumnType.Dec)
{
mappedColTypes.Add(ColumnType.None);
}
else
{
mappedColTypes.Add(columnType);
}
});
}
else
{
selectedLayerMap.MappedColumnType.ToList().ForEach(columnType =>
{
if (columnType == ColumnType.Lat || columnType == ColumnType.Long)
{
mappedColTypes.Add(ColumnType.None);
}
else
{
mappedColTypes.Add(columnType);
}
});
}
selectedLayerMap.MappedColumnType.Clear();
selectedLayerMap.MappedColumnType = mappedColTypes;
}
}
public void ColumnsListTest()
{
InteropExcel.Application application = new InteropExcel.Application();
try
{
InteropExcel.Workbook book = application.OpenWorkbook("TestData.xlsx", false);
// Get the named range stored in the test data excel file.
Name name = book.Names.GetNamedRange("ColumnList");
LayerMap target = new LayerMap(name);
target.ColumnsList = ColumnExtensions.PopulateColumnList();
// Check the count of columns.
Assert.AreEqual(target.ColumnsList.Count, 19);
// Check the column names
Assert.AreEqual(target.ColumnsList[0].ColumnDisplayValue, "Select One");
Assert.AreEqual(target.ColumnsList[1].ColumnDisplayValue, "Latitude");
Assert.AreEqual(target.ColumnsList[2].ColumnDisplayValue, "Longitude");
Assert.AreEqual(target.ColumnsList[3].ColumnDisplayValue, "Start Date");
Assert.AreEqual(target.ColumnsList[4].ColumnDisplayValue, "End Date");
Assert.AreEqual(target.ColumnsList[5].ColumnDisplayValue, "Depth");
Assert.AreEqual(target.ColumnsList[6].ColumnDisplayValue, "Altitude");
Assert.AreEqual(target.ColumnsList[7].ColumnDisplayValue, "Distance");
Assert.AreEqual(target.ColumnsList[8].ColumnDisplayValue, "Magnitude");
Assert.AreEqual(target.ColumnsList[9].ColumnDisplayValue, "Geometry");
Assert.AreEqual(target.ColumnsList[10].ColumnDisplayValue, "Color");
Assert.AreEqual(target.ColumnsList[11].ColumnDisplayValue, "RA");
Assert.AreEqual(target.ColumnsList[12].ColumnDisplayValue, "Dec");
}
finally
{
application.Close();
}
}
public void UpdateHeaderPropertiesTest()
{
Application application = new Application();
try
{
Workbook book = application.OpenWorkbook("WorkbookTestData.xlsx", false);
// Get the named range stored in the test data excel file.
// This range refers to address "$A$1:$D$7".
Name oldName = book.Names.GetNamedRange("GetSelectedLayerWorksheet");
Name newName = book.Names.GetNamedRange("UpdateHeaderPropertiesTestRADEC");
LayerMap selectedlayer = new LayerMap(oldName);
Range selectedRange = newName.RefersToRange;
LayerMapExtensions.UpdateHeaderProperties(selectedlayer, selectedRange);
Assert.AreEqual(selectedlayer.MappedColumnType[0], ColumnType.RA);
Assert.AreEqual(selectedlayer.MappedColumnType[1], ColumnType.Dec);
}
finally
{
application.Close();
}
}
public void UpdateLayerMapPropertiesTest()
{
Layer layer = new Layer();
Layer dummyLayer = new Layer();
LayerMap expected = new LayerMap(dummyLayer);
// UpdateLayerMapProperties will set the layer in layer details.
expected.UpdateLayerMapProperties(layer);
// LayerDetails should not be dummy layer. It should be set with layer object.
Assert.AreEqual(expected.LayerDetails, layer);
}
public void CanUpdateWWTTestWWTNone()
{
LayerMap selectedlayer = new LayerMap(new Layer());
selectedlayer.MapType = LayerMapType.None;
bool expected = false;
bool actual;
actual = LayerMapExtensions.CanUpdateWWT(selectedlayer);
Assert.AreEqual(expected, actual);
}
public void IsLayerCreatedTestNoLayerID()
{
LayerMap selectedLayerMap = new LayerMap(new Layer());
bool expected = true;
bool actual;
actual = LayerMapExtensions.IsLayerCreated(selectedLayerMap);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Gets the selected layer based on drop down properties
/// </summary>
/// <param name="selectedLayer">layerDropdown Properties</param>
/// <returns>Layer map for selected layer</returns>
internal LayerMap GetSelectedLayerMap(LayerMap selectedLayer)
{
LayerMap selectedlayermap = null;
if (this.currentWorkbookMap != null && selectedLayer != null)
{
if (selectedLayer.MapType == LayerMapType.LocalInWWT)
{
selectedlayermap = this.currentWorkbookMap.LocalLayerMaps.Find(layer => !string.IsNullOrEmpty(layer.LayerDetails.ID) && layer.LayerDetails.ID.Equals(selectedLayer.LayerDetails.ID, StringComparison.OrdinalIgnoreCase));
}
else if (selectedLayer.MapType == LayerMapType.Local)
{
selectedlayermap = this.currentWorkbookMap.LocalLayerMaps.Find(layer => layer.RangeDisplayName.Equals(selectedLayer.RangeDisplayName, StringComparison.OrdinalIgnoreCase));
}
else if (selectedLayer.MapType == LayerMapType.WWT)
{
selectedlayermap = this.currentWorkbookMap.WWTLayerMaps.Find(layer => layer.LayerDetails.ID.Equals(selectedLayer.LayerDetails.ID, StringComparison.OrdinalIgnoreCase));
}
}
return selectedlayermap;
}
public void BuildGroupCollectionTest()
{
Application application = new Application();
try
{
Group parentGroup = new Group("Sun", GroupType.ReferenceFrame, null);
Group childGroup = new Group("Earth", GroupType.ReferenceFrame, parentGroup);
Layer layer = new Layer();
layer.Name = "Layer1";
layer.Group = childGroup;
Layer layerMap = new Layer();
layerMap.Name = "Layer2";
layerMap.Group = new Group("Sun", GroupType.ReferenceFrame, null);
LayerMap localLayerMap = new LayerMap(layer);
localLayerMap.MapType = LayerMapType.Local;
LayerMap wwtLayerMap = new LayerMap(layerMap);
wwtLayerMap.MapType = LayerMapType.WWT;
List<GroupChildren> wwtGroups = new List<GroupChildren>();
List<GroupChildren> localGroups = new List<GroupChildren>();
List<GroupChildren> existingGroups = new List<GroupChildren>();
List<GroupChildren> groupwithChildren = new List<GroupChildren>();
GroupChildren children = new GroupChildren();
children.Group = parentGroup;
GroupChildren children1 = new GroupChildren();
children1.Group = childGroup;
GroupChildren childNode = new GroupChildren();
childNode.Group = parentGroup;
childNode.Children.Add(children1);
existingGroups.Add(children);
groupwithChildren.Add(childNode);
LayerMapExtensions.BuildGroupCollection(wwtLayerMap, wwtGroups);
LayerMapExtensions.BuildGroupCollection(localLayerMap, localGroups);
LayerMapExtensions.BuildGroupCollection(localLayerMap, existingGroups);
LayerMapExtensions.BuildGroupCollection(localLayerMap, groupwithChildren);
Assert.AreEqual(1, wwtGroups.Count);
foreach (GroupChildren child in wwtGroups)
{
Assert.AreEqual(1, child.AllChildren.Count);
Assert.AreEqual("Sun", child.Name);
}
Assert.AreEqual(1, localGroups.Count);
foreach (GroupChildren child in localGroups)
{
Assert.AreEqual(1, child.Children.Count);
Assert.AreEqual("Sun", child.Name);
}
Assert.AreEqual(1, existingGroups.Count);
foreach (GroupChildren child in existingGroups)
{
Assert.AreEqual(1, child.Children.Count);
foreach (GroupChildren childrenVal in child.Children)
{
Assert.AreEqual("Earth", childrenVal.Name);
}
}
Assert.AreEqual(1, groupwithChildren.Count);
foreach (GroupChildren child in groupwithChildren)
{
Assert.AreEqual(1, child.Children.Count);
foreach (GroupChildren childrenVal in child.Children)
{
Assert.AreEqual(1, childrenVal.AllChildren.Count);
}
}
}
finally
{
application.Close();
}
}
/// <summary>
/// This function is used to create WWT layer if not exist.
/// </summary>
/// <param name="selectedLayerMap">
/// Selected layer map.
/// </param>
/// <returns>True, if the creation is successful; otherwise false.</returns>
private static bool CreateIfNotExist(LayerMap selectedLayerMap)
{
bool success = true;
if (string.IsNullOrEmpty(selectedLayerMap.LayerDetails.ID) && selectedLayerMap.MapType == LayerMapType.Local)
{
success = CreateLayerInWWT(selectedLayerMap);
}
else if (!string.IsNullOrEmpty(selectedLayerMap.LayerDetails.ID) && selectedLayerMap.MapType == LayerMapType.LocalInWWT)
{
// Check if the Layer is present in WWT or not.
if (!WWTManager.IsValidLayer(selectedLayerMap.LayerDetails.ID))
{
success = CreateLayerInWWT(selectedLayerMap);
}
}
return success;
}
/// <summary>
/// Sets the get layer data display name
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
private void SetGetLayerDataDisplayName(LayerMap selectedLayerMap)
{
if (selectedLayerMap != null && this.layerDetailsViewModel != null)
{
switch (selectedLayerMap.MapType)
{
case LayerMapType.Local:
case LayerMapType.WWT:
this.layerDetailsViewModel.LayerDataDisplayName = Resources.GetLayerData;
break;
case LayerMapType.LocalInWWT:
this.layerDetailsViewModel.LayerDataDisplayName = Resources.RefreshLayerData;
break;
}
}
}
public void LayerSelectionHandlerExecuteTest()
{
LayerDetailsViewModel layerDetailsViewModel = new LayerDetailsViewModel();
layerDetailsViewModel.LayerSelectionChangedEvent += new EventHandler(LayerModelLayerSelectionChangedEvent);
LayerMapDropDownViewModel layerMapDropDown = new LayerMapDropDownViewModel();
layerMapDropDown.ID = "1";
layerMapDropDown.Name = "Select One";
Layer layer = new Layer();
layer.Name = "Layer1";
LayerMap layerMap = new LayerMap(layer);
layerMap.MapType = LayerMapType.Local;
layerMap.HeaderRowData = new Collection<string>();
layerMap.MappedColumnType = new Collection<ColumnType>();
layerDetailsViewModel.Currentlayer = layerMap;
LayerDetailsViewModel_Accessor.LayerSelectionHandler target = new LayerDetailsViewModel_Accessor.LayerSelectionHandler(layerDetailsViewModel);
target.Execute(layerMapDropDown);
Assert.IsNull(layerDetailsViewModel.Currentlayer);
}
/// <summary>
/// This function is used to create layer group in WWT.
/// </summary>
/// <param name="selectedLayerMap">
/// Selected layer map.
/// </param>
/// <returns>True, if the creation is successful; otherwise false.</returns>
private static bool CreateGroupInWWT(LayerMap selectedLayerMap)
{
bool success = false;
Group group = selectedLayerMap.LayerDetails.Group;
if (group.GroupType == GroupType.LayerGroup)
{
try
{
WWTManager.CreateLayerGroup(group.Name, group.Parent != null ? group.Parent.Name : string.Empty);
success = true;
}
catch (CustomException)
{
// Could not create layer group in WWT.
Ribbon.ShowError(Properties.Resources.LayerGroupCreationError);
success = false;
}
}
else
{
// Reference Frame cannot be created in WWT.
Ribbon.ShowError(Properties.Resources.ReferenceFrameCreationError);
success = false;
}
return success;
}
internal static LayerDetailsViewModel SetLayerMap(this LayerDetailsViewModel layerDetailsModel, LayerMap selectedLayerMap)
{
// Set the ViewModel for Layer properties using the selected layer map from Core OM
// This is one place from where all the View model properties are set and bound to task pane
// This will be used when a layer is changed in the layer drop down
if (selectedLayerMap != null)
{
if (selectedLayerMap.LayerDetails != null)
{
LayerDetailsViewModel.IsPropertyChangedFromCode = true;
// Set all the user selections as well as default lists which are present only in view model
// Need to set properties which are in different format in View model from Model
layerDetailsModel.SelectedLayerName = selectedLayerMap.LayerDetails.Name;
layerDetailsModel.SelectedLayerText = LayerDetailsViewModel.GetLayerNameOnMapType(selectedLayerMap, selectedLayerMap.LayerDetails.Name);
layerDetailsModel = SetGroup(layerDetailsModel, selectedLayerMap);
// Binding the column data to the map columns
ObservableCollection <Column> columns = new ObservableCollection <Column>();
ColumnExtensions.PopulateColumnList().ToList().ForEach(col =>
{
columns.Add(col);
});
layerDetailsModel.ColumnsView = new ObservableCollection <ColumnViewModel>();
layerDetailsModel.SizeColumnList = new ObservableCollection <KeyValuePair <int, string> >();
layerDetailsModel.HoverTextColumnList = new ObservableCollection <KeyValuePair <int, string> >();
// Remove the columns based on the group selected.
layerDetailsModel.RemoveColumns(columns);
// Set the Mapped column type based on the group selected.
selectedLayerMap.UpdateMappedColumns();
// Validates if X,Y and Z columns are present and lat/long or RA/DEC columns are not present. If so,
// remove depth and alt from columns collection.
ValidateXYZ(selectedLayerMap, columns);
layerDetailsModel.PopulateColumns(selectedLayerMap, columns);
// Adding None to size column list
layerDetailsModel.SizeColumnList.Add(new KeyValuePair <int, string>(-1, Properties.Resources.NoneString));
layerDetailsModel.HoverTextColumnList.Add(new KeyValuePair <int, string>(-1, Properties.Resources.NoneString));
int index = 0;
foreach (string headerData in selectedLayerMap.HeaderRowData)
{
layerDetailsModel.SizeColumnList.Add(new KeyValuePair <int, string>(index, headerData));
layerDetailsModel.HoverTextColumnList.Add(new KeyValuePair <int, string>(index, headerData));
index++;
}
layerDetailsModel = SetSelectedSize(layerDetailsModel, selectedLayerMap);
layerDetailsModel = SetSelectedHoverText(layerDetailsModel, selectedLayerMap);
// Sets view in WWT visibility
layerDetailsModel.IsViewInWWTEnabled = (selectedLayerMap.MapType == LayerMapType.Local || (selectedLayerMap.MapType == LayerMapType.LocalInWWT && selectedLayerMap.IsNotInSync));
layerDetailsModel.IsLayerInSyncInfoVisible = (selectedLayerMap.MapType == LayerMapType.WWT || selectedLayerMap.MapType == LayerMapType.LocalInWWT) && !selectedLayerMap.IsNotInSync;
// On click of layer dropdown the callout need not be shown, the callout visibility is set to
// false on the click of the dropdown.
if (LayerDetailsViewModel.IsCallOutRequired)
{
layerDetailsModel.IsCallOutVisible = layerDetailsModel.IsViewInWWTEnabled;
if (layerDetailsModel.IsLayerInSyncInfoVisible)
{
// Start the animation for the layer in sync text.
layerDetailsModel.StartShowHighlightAnimationTimer();
}
}
else
{
layerDetailsModel.IsCallOutVisible = false;
}
// Sets if the custom task pane buttons are enabled
layerDetailsModel.IsShowRangeEnabled = GetButtonEnability(selectedLayerMap);
layerDetailsModel.IsDeleteMappingEnabled = GetButtonEnability(selectedLayerMap);
layerDetailsModel.IsGetLayerDataEnabled = (selectedLayerMap.MapType == LayerMapType.WWT || (selectedLayerMap.MapType == LayerMapType.LocalInWWT && !selectedLayerMap.IsNotInSync));
layerDetailsModel.IsUpdateLayerEnabled = GetButtonEnability(selectedLayerMap);
layerDetailsModel.IsReferenceGroupEnabled = selectedLayerMap.IsLayerCreated();
layerDetailsModel.IsFarSideShown = selectedLayerMap.LayerDetails.ShowFarSide;
SetDistanceUnit(layerDetailsModel, selectedLayerMap);
// Sets RAUnit visibility
layerDetailsModel.SetRAUnitVisibility();
layerDetailsModel.SetMarkerTabVisibility();
layerDetailsModel.SelectedFadeType = layerDetailsModel.FadeTypes.Where(fadetype => fadetype.Key == selectedLayerMap.LayerDetails.FadeType).FirstOrDefault();
layerDetailsModel.SelectedScaleRelative = layerDetailsModel.ScaleRelatives.Where(scaleRelative => scaleRelative.Key == selectedLayerMap.LayerDetails.MarkerScale).FirstOrDefault();
layerDetailsModel.SelectedScaleType = layerDetailsModel.ScaleTypes.Where(scaleType => scaleType.Key == selectedLayerMap.LayerDetails.PointScaleType).FirstOrDefault();
layerDetailsModel.SelectedMarkerType = layerDetailsModel.MarkerTypes.Where(markerType => markerType.Key == selectedLayerMap.LayerDetails.PlotType).FirstOrDefault();
layerDetailsModel.SelectedPushpinId = layerDetailsModel.PushPinTypes.Where(pushpin => pushpin.Key == selectedLayerMap.LayerDetails.MarkerIndex).FirstOrDefault();
layerDetailsModel.LayerOpacity.SelectedSliderValue = selectedLayerMap.LayerDetails.Opacity * 100;
layerDetailsModel.TimeDecay.SelectedSliderValue = GetSelectedTimeDecayValue(layerDetailsModel.TimeDecay, selectedLayerMap.LayerDetails.TimeDecay);
layerDetailsModel.ScaleFactor.SelectedSliderValue = GetSelectedTimeDecayValue(layerDetailsModel.ScaleFactor, selectedLayerMap.LayerDetails.ScaleFactor);
////Set properties directly exposed from Model
layerDetailsModel.BeginDate = selectedLayerMap.LayerDetails.StartTime;
layerDetailsModel.EndDate = selectedLayerMap.LayerDetails.EndTime;
layerDetailsModel.FadeTime = selectedLayerMap.LayerDetails.FadeSpan.ToString();
layerDetailsModel.ColorBackground = LayerDetailsViewModel.ConvertToSolidColorBrush(selectedLayerMap.LayerDetails.Color);
LayerDetailsViewModel.IsPropertyChangedFromCode = false;
}
}
return(layerDetailsModel);
}
/// <summary>
/// This function is used to check if we can update WWT or not.
/// </summary>
/// <param name="selectedlayer">
/// LayerMap in focus.
/// </param>
/// <returns>
/// True, if we can update WWT;Otherwise false.
/// </returns>
internal static bool CanUpdateWWT(this LayerMap selectedlayer)
{
return((selectedlayer != null && selectedlayer.MapType == LayerMapType.LocalInWWT && !selectedlayer.IsNotInSync) || selectedlayer.MapType == LayerMapType.WWT);
}
/// <summary>
/// Sets selected hover text based on the layer properties
/// </summary>
/// <param name="layerDetailsModel">Layer details view model</param>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>Updated layer view model</returns>
private static LayerDetailsViewModel SetSelectedHoverText(LayerDetailsViewModel layerDetailsModel, LayerMap selectedLayerMap)
{
if (selectedLayerMap.LayerDetails.NameColumn != Constants.DefaultColumnIndex)
{
layerDetailsModel.SelectedHoverText = layerDetailsModel.HoverTextColumnList.Where(item => item.Key == selectedLayerMap.LayerDetails.NameColumn).FirstOrDefault();
}
else
{
layerDetailsModel.SelectedHoverText = layerDetailsModel.HoverTextColumnList[0];
}
return(layerDetailsModel);
}
public void UpdateMappedColumnsTestNull()
{
LayerMap selectedLayerMap = new LayerMap(new Layer());
// Check what happens if we send null.
LayerMapExtensions.UpdateMappedColumns(null);
// Check what happens if we send null group.
LayerMapExtensions.UpdateMappedColumns(selectedLayerMap);
Assert.IsNull(selectedLayerMap.LayerDetails.Group);
}
/// <summary>
/// This function is used to create Layer in WWT.
/// </summary>
/// <param name="selectedLayerMap">
/// Selected layer map.
/// </param>
/// <returns>
/// True, if the creation is successful; otherwise false.
/// </returns>
private static bool CreateLayerInWWT(LayerMap selectedLayerMap)
{
bool success = true;
// Get Header Data
string headerData = string.Join("\t", selectedLayerMap.HeaderRowData);
// Set the version as 0. Serialized layers may have different version number which needs to be reset to 0 so that notification will work fine.
selectedLayerMap.LayerDetails.Version = 0;
ICollection<Group> wwtGroups = WWTManager.GetAllWWTGroups(true);
if (!WWTManager.IsValidGroup(selectedLayerMap.LayerDetails.Group, wwtGroups))
{
// If the layer group is not present in WWT, then create the layer group before creating the layer.
success = CreateGroupInWWT(selectedLayerMap);
}
if (success)
{
// if the layer is not present in WWT. Create the layer with the required Details.
// Create Named Range. && Update layer id in the selected layer details.
selectedLayerMap.LayerDetails.ID = WWTManager.CreateLayer(
selectedLayerMap.LayerDetails.Name,
selectedLayerMap.LayerDetails.Group.Name,
headerData);
selectedLayerMap.MapType = LayerMapType.LocalInWWT;
success = true;
}
return success;
}
/// <summary>
/// Sets distance unit visibility and selected distance unit.
/// </summary>
/// <param name="layerDetailsModel">Layer details view model</param>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>Updated layer view model</returns>
private static LayerDetailsViewModel SetDistanceUnit(LayerDetailsViewModel layerDetailsModel, LayerMap selectedLayerMap)
{
if (layerDetailsModel.ColumnsView != null && layerDetailsModel.ColumnsView.Count > 0)
{
ColumnViewModel depthColumn = layerDetailsModel.ColumnsView.Where(columnValue => columnValue.SelectedWWTColumn.IsDepthColumn()).FirstOrDefault();
ColumnViewModel xyzColumn = layerDetailsModel.ColumnsView.Where(columnValue => columnValue.SelectedWWTColumn.IsXYZColumn()).FirstOrDefault();
if (depthColumn != null || xyzColumn != null)
{
layerDetailsModel.IsDistanceVisible = true;
}
else
{
layerDetailsModel.IsDistanceVisible = false;
}
if (layerDetailsModel.DistanceUnits != null && layerDetailsModel.DistanceUnits.Count > 0)
{
layerDetailsModel.SelectedDistanceUnit = layerDetailsModel.DistanceUnits.Where(distanceUnit => distanceUnit.Key == selectedLayerMap.LayerDetails.AltUnit).FirstOrDefault();
}
}
return(layerDetailsModel);
}
/// <summary>
/// This function retrieves the last used and valid group.
/// </summary>
/// <param name="layerMap">Layer map object</param>
/// <param name="isWWTRunning">Whether WWT is running or not?</param>
/// <returns>
/// A Group that represents the current last used group.
/// </returns>
private static Group GetLastUsedGroup(LayerMap layerMap, bool isWWTRunning)
{
ICollection<Group> groups = null;
// Get the Groups from WWT only if WWT is running. Otherwise, initialize with an empty list.
if (isWWTRunning)
{
groups = WWTManager.GetAllWWTGroups(true);
}
else
{
groups = new List<Group>();
}
Group lastUsed = null;
if (layerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Lat).Any()
|| layerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Long).Any())
{
// if Lat/Lon are mapped
lastUsed = groups.GetDefaultEarthGroup();
}
else if (layerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.RA).Any()
|| layerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Dec).Any())
{
// if RA/Dec are mapped
lastUsed = groups.GetDefaultSkyGroup();
}
else
{
lastUsed = LastUsedGroup;
if (lastUsed == null || lastUsed.IsDeleted || !WWTManager.IsValidGroup(lastUsed, groups))
{
Perspective perspective = null;
try
{
// Get the perspective only if WWT is running.
if (isWWTRunning)
{
perspective = WWTManager.GetCameraView();
}
}
catch (CustomException)
{
// Ignore.
}
lastUsed = (perspective != null && !string.IsNullOrEmpty(perspective.ReferenceFrame)) ?
groups.SearchGroup(perspective.ReferenceFrame) : groups.GetDefaultEarthGroup();
}
}
if (LastUsedGroup != lastUsed)
{
LastUsedGroup = lastUsed;
}
return lastUsed;
}
internal void CreateLayerMap()
{
// Workflow tasks for Visualize selection
Range selectedRange = ThisAddIn.ExcelApplication.Selection as Range;
if (selectedRange != null)
{
bool isWWTRunning = WWTManager.IsValidMachine(Common.Globals.TargetMachine.MachineIP.ToString(), true);
// Gets the layer map for selected range if it already exists and selects the layer
LayerMap layerMap = GetCurrentRangeLayer(selectedRange);
if (layerMap != null)
{
this.currentWorkbookMap.SelectedLayerMap = layerMap;
this.currentWorkbookMap.SelectedLayerMap.VisualizeClickTime = DateTime.Now;
this.currentWorkbookMap.SelectedLayerMap.IsVisualizeClicked = true;
}
else
{
string selectionRangeName = ThisAddIn.ExcelApplication.ActiveWorkbook.GetSelectionRangeName();
Name namedRange = ThisAddIn.ExcelApplication.ActiveWorkbook.CreateNamedRange(selectionRangeName, selectedRange);
if (namedRange != null)
{
LayerMap newLayerMap = new LayerMap(namedRange);
newLayerMap.LayerDetails.Group = GetLastUsedGroup(newLayerMap, isWWTRunning);
// Set the scale type based on the group the layer belongs to.
newLayerMap.LayerDetails.PointScaleType = newLayerMap.LayerDetails.Group.IsPlanet() ? ScaleType.Power : ScaleType.StellarMagnitude;
// Add the layer map for newly created named range to the list of LayerMap.
this.currentWorkbookMap.AllLayerMaps.Add(newLayerMap);
// Set the current layer map to the newly created LayerMap.
this.currentWorkbookMap.SelectedLayerMap = newLayerMap;
this.currentWorkbookMap.SelectedLayerMap.VisualizeClickTime = DateTime.Now;
this.currentWorkbookMap.SelectedLayerMap.IsVisualizeClicked = true;
ThisAddIn.ExcelApplication.ActiveWorkbook.SaveWorkbookMap(this.workBookMaps);
}
}
this.BuildAndBindLayerDetailsViewModel(isWWTRunning);
if (this.ribbonInstance != null)
{
this.ribbonInstance.ViewCustomTaskPane(true);
// Set focus on custom task pane and start animation for call out
this.ribbonInstance.SetFocusCustomTaskPane();
}
this.BeginCalloutAnimation();
// reset the default tab to Map columns tab (Index: 0)
LayerDetailsViewModel.IsPropertyChangedFromCode = true;
this.layerDetailsViewModel.SelectedTabIndex = 0;
LayerDetailsViewModel.IsPropertyChangedFromCode = false;
}
}
/// <summary>
/// Checks if the layer is already created in WWT.
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>True if the layer is created in WWT;Otherwise false.</returns>
internal static bool IsLayerCreated(this LayerMap selectedLayerMap)
{
return(selectedLayerMap != null && string.IsNullOrEmpty(selectedLayerMap.LayerDetails.ID));
}
/// <summary>
/// Gets the workbook map to which the given layer map belongs to.
/// </summary>
/// <param name="currentLayerMap">LayerMap for which WorkbookMap has to be fetched</param>
/// <returns>WorkbookMap instance</returns>
internal WorkbookMap GetWorkbookMapForLayerMap(LayerMap currentLayerMap)
{
WorkbookMap layerWorkbookMap = null;
foreach (WorkbookMap workbookMap in this.workBookMaps)
{
if (workbookMap.AllLayerMaps.Where(layerMap => layerMap == currentLayerMap).FirstOrDefault() != null)
{
layerWorkbookMap = workbookMap;
break;
}
}
return layerWorkbookMap;
}
/// <summary>
/// Gets selected layer's worksheet for local in WWT layer
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>Worksheet for the selected layer's range</returns>
private static _Worksheet GetSelectedLayerWorksheet(LayerMap selectedLayerMap)
{
_Worksheet worksheet = null;
// Validates if the selected layer map's range name is valid.
if (selectedLayerMap.RangeName.IsValid() && selectedLayerMap.RangeName.RefersToRange.IsValid())
{
// Activate the sheet in which the range is present.
if (selectedLayerMap.RangeName.RefersToRange.Worksheet != ThisAddIn.ExcelApplication.ActiveSheet)
{
worksheet = ((_Worksheet)selectedLayerMap.RangeName.RefersToRange.Worksheet);
}
if (worksheet == null)
{
worksheet = (_Worksheet)ThisAddIn.ExcelApplication.ActiveSheet;
}
worksheet.Activate();
}
return worksheet;
}
public void CanUpdateWWTTestWWTLocalAndSync()
{
LayerMap selectedlayer = new LayerMap(new Layer());
selectedlayer.MapType = LayerMapType.LocalInWWT;
selectedlayer.IsNotInSync = false;
bool expected = true;
bool actual;
actual = LayerMapExtensions.CanUpdateWWT(selectedlayer);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Goes to viewpoint on view in WWT click
/// </summary>
/// <param name="selectedLayerMap">layer map object</param>
private static void GotoViewpointOnViewInWWT(LayerMap selectedLayerMap)
{
try
{
// Check if Lat/Lon, RA/Dec are mapped or not
if ((selectedLayerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Lat).Any()
&& selectedLayerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Long).Any())
|| (selectedLayerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.RA).Any()
&& selectedLayerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Dec).Any()))
{
var rowData = selectedLayerMap.RangeName.RefersToRange.GetFirstDataRow();
if (rowData != null)
{
// Build perspective based on mappings
var perspective = GetPerspectiveFromLayerRowData(selectedLayerMap, rowData);
if (perspective != null)
{
GotoViewpointFromData(perspective);
}
}
}
else if (selectedLayerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Geo).Any() || selectedLayerMap.IsXYZLayer())
{
var lookAt = selectedLayerMap.GetLookAt();
WWTManager.SetMode(lookAt);
}
}
catch (CustomException)
{
// Consume as error message should not be shown
}
}
public void CanUpdateWWTTestWWTOnly()
{
LayerMap selectedlayer = new LayerMap(new Layer());
bool expected = true;
bool actual;
actual = LayerMapExtensions.CanUpdateWWT(selectedlayer);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Shows validation error for Viewpoint from data functionality
/// </summary>
/// <param name="layerMap">layerMap instance</param>
private static void ShowViewpointFromDataValidationError(LayerMap layerMap)
{
if (layerMap.IsXYZLayer())
{
Ribbon.ShowError(Resources.GotoViewpointfromXYZError);
}
else if (layerMap.MappedColumnType.Where(columnTypeValue => columnTypeValue == ColumnType.Geo).Any())
{
Ribbon.ShowError(Resources.GotoViewpointFromGeometryDataError);
}
else
{
if (layerMap.LayerDetails.Group.IsPlanet())
{
//// Lat, Lon Error
Ribbon.ShowError(Resources.GotoViewpointFromDataForSunError);
}
else
{
// RA, Dec Error
Ribbon.ShowError(Resources.GotoViewpointFromDataForSkyError);
}
}
}
public void IsLayerCreatedTestValidLayerID()
{
LayerMap selectedLayerMap = new LayerMap(new Layer());
selectedLayerMap.LayerDetails.ID = System.Guid.NewGuid().ToString();
bool expected = false;
bool actual;
actual = LayerMapExtensions.IsLayerCreated(selectedLayerMap);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Populates columns with the view model column
/// property and rebinds the columns
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <param name="columns">Collection of columns</param>
internal void PopulateColumns(LayerMap selectedLayerMap, Collection<Column> columns)
{
this.ColumnsView = new ObservableCollection<ColumnViewModel>();
int index = 0;
foreach (string headerData in selectedLayerMap.HeaderRowData)
{
ColumnViewModel columnViewModel = new ColumnViewModel();
columnViewModel.ExcelHeaderColumn = headerData;
columnViewModel.WWTColumns = new ObservableCollection<Column>();
columns.ToList().ForEach(col => columnViewModel.WWTColumns.Add(col));
columnViewModel.SelectedWWTColumn = columns.Where(column => column.ColType == selectedLayerMap.MappedColumnType[index]).FirstOrDefault() ?? columns.Where(column => column.ColType == ColumnType.None).FirstOrDefault();
this.ColumnsView.Add(columnViewModel);
index++;
}
SetRAUnitVisibility();
}
public void UpdateHeaderPropertiesTestNull()
{
Application application = new Application();
try
{
LayerMap selectedlayer = new LayerMap(new Layer());
LayerMapExtensions.UpdateHeaderProperties(selectedlayer, null);
LayerMapExtensions.UpdateHeaderProperties(null, null);
Assert.IsNull(selectedlayer.RangeAddress);
}
finally
{
application.Close();
}
}
/// <summary>
/// Gets if the button is enable on the basis of the layer being local/local in WWT
/// </summary>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>If the button has to be enabled or not</returns>
private static bool GetButtonEnability(LayerMap selectedLayerMap)
{
return(selectedLayerMap.MapType == LayerMapType.Local || selectedLayerMap.MapType == LayerMapType.LocalInWWT);
}
public void UpdateMappedColumnsSkyTest()
{
Group skyGroup = new Group("Sky", GroupType.ReferenceFrame, null);
LayerMap selectedLayerMap = new LayerMap(new Layer());
selectedLayerMap.LayerDetails.Group = skyGroup;
Collection<ColumnType> mappedColTypes = new Collection<ColumnType>();
mappedColTypes.Add(ColumnType.RA);
mappedColTypes.Add(ColumnType.Dec);
mappedColTypes.Add(ColumnType.Lat);
mappedColTypes.Add(ColumnType.Long);
selectedLayerMap.MappedColumnType = mappedColTypes;
LayerMapExtensions.UpdateMappedColumns(selectedLayerMap);
Assert.AreEqual(selectedLayerMap.MappedColumnType[0], ColumnType.RA);
Assert.AreEqual(selectedLayerMap.MappedColumnType[1], ColumnType.Dec);
Assert.AreEqual(selectedLayerMap.MappedColumnType[2], ColumnType.None);
Assert.AreEqual(selectedLayerMap.MappedColumnType[3], ColumnType.None);
}
/// <summary>
/// This function is used to update the header properties and data in WWT.
/// </summary>
/// <param name="selectedLayerMap">
/// Selected layer map.
/// </param>
/// <returns>
/// True if the update is successfully completed;Otherwise false.
/// </returns>
private static bool UpdateWWT(LayerMap selectedLayerMap)
{
bool hasUpdated = false;
if (selectedLayerMap.RangeName.IsValid())
{
// Get data from selected range.
string[] data = selectedLayerMap.RangeName.RefersToRange.GetData();
// This is used only for Layer Property update notifications. Since the notifications are handled in background thread,
// CodeUpdate cannot be set the false here (main thread). It needs to be reset only by background thread once the
// notification is handled by the background thread.
selectedLayerMap.IsPropertyChangedFromCode = true;
// Update the header details.
// Time series is set explicitly to false only on creation of layer because
// on activate layer the time series is set to true while creating the layer even though
// the value for time series is not send through LCAPI.
if (WWTManager.UpdateLayer(selectedLayerMap.LayerDetails, true, true))
{
var lookAt = selectedLayerMap.GetLookAt();
WWTManager.SetMode(lookAt);
// Upload data in WWT.
if (WWTManager.UploadDataInWWT(selectedLayerMap.LayerDetails.ID, data, true))
{
hasUpdated = true;
}
}
}
return hasUpdated;
}
/// <summary>
/// Gets layer name with the proper suffix based on current layer map type
/// 1. Local - "not in synch"
/// 2. Local in WWT and Not in synch - "not in synch"
/// 3. Local in WWT and in synch - "in synch"
/// </summary>
/// <param name="layerMap">Selected layer map</param>
/// <param name="layerNameValue">Selected layer name</param>
/// <returns>Layer name</returns>
internal static string GetLayerNameOnMapType(LayerMap layerMap, string layerNameValue)
{
string layerName = layerNameValue;
switch (layerMap.MapType)
{
case LayerMapType.Local:
layerName += Properties.Resources.LayerLocalText;
break;
case LayerMapType.LocalInWWT:
if (layerMap.IsNotInSync)
{
layerName += Properties.Resources.LayerLocalText;
}
else if (!layerMap.IsNotInSync)
{
layerName += Properties.Resources.LayerLocalInWWTText;
}
break;
default:
break;
}
return layerName;
}
/// <summary>
/// Sets group for the view model
/// </summary>
/// <param name="layerDetailsModel">Layer details view model</param>
/// <param name="selectedLayerMap">Selected layer map</param>
/// <returns>Updated layer view model</returns>
private static LayerDetailsViewModel SetGroup(LayerDetailsViewModel layerDetailsModel, LayerMap selectedLayerMap)
{
if (selectedLayerMap.LayerDetails.Group != null)
{
layerDetailsModel.SelectedGroupText = selectedLayerMap.LayerDetails.Group.Name;
layerDetailsModel.SelectedGroup = selectedLayerMap.LayerDetails.Group;
}
return(layerDetailsModel);
}
/// <summary>
/// This function is used to update data in WWT.
/// </summary>
/// <param name="selectedRange">
/// Updated range.
/// </param>
/// <param name="selectedlayer">
/// Updated layer.
/// </param>
private static void UpdateData(Range selectedRange, LayerMap selectedlayer)
{
// Update Data based on the Header
// 1. Set layer properties dependent on mapping.
// 2. Purge the existing layer data in WWT and then push new data to WWT
if (selectedlayer.CanUpdateWWT())
{
string[] data = selectedRange.GetData();
if (!WWTManager.UploadDataInWWT(selectedlayer.LayerDetails.ID, data, true))
{
selectedlayer.IsNotInSync = true;
}
}
}
/// <summary>
/// Creates node with existing hierarchy
/// </summary>
/// <param name="group">Group in the hierarchy</param>
/// <param name="groups">Group collection</param>
/// <param name="layerMap">Selected layer map details</param>
/// <returns>Last created group children</returns>
private static GroupChildren CreateNode(Group group, List <GroupChildren> groups, LayerMap layerMap)
{
GroupChildren groupChildren = null;
if (group.Parent != null)
{
GroupChildren parent = CreateNode(group.Parent, groups, layerMap);
groupChildren = parent.Children.Where(child => child.Group != null && child.Group.Equals(group)).FirstOrDefault();
if (groupChildren == null)
{
groupChildren = new GroupChildren();
groupChildren.Group = group;
groupChildren.Name = group.Name;
groupChildren.IsDeleted = group.IsDeleted;
parent.AllChildren.Add(groupChildren);
parent.Children.Add(groupChildren);
}
}
else
{
groupChildren = groups.Where(groupValue => groupValue.Group != null && groupValue.Group.Equals(group)).FirstOrDefault();
if (groupChildren == null)
{
groupChildren = new GroupChildren();
groupChildren.Group = group;
groupChildren.Name = group.Name;
groupChildren.IsDeleted = group.IsDeleted;
groups.Add(groupChildren);
}
}
return(groupChildren);
}
/// <summary>
/// Get perspective based on the layer mapping and the row data
/// </summary>
/// <param name="layerMap">layer map object</param>
/// <param name="rowData">row data collection</param>
/// <returns>Perspective object</returns>
private static Perspective GetPerspectiveFromLayerRowData(LayerMap layerMap, Collection<string> rowData)
{
Perspective perspective = null;
if (layerMap.LayerDetails.Group != null)
{
var referenceFrame = layerMap.LayerDetails.Group.GetReferenceFrame();
var referenceFramePath = layerMap.LayerDetails.Group.Path;
if (referenceFramePath.StartsWith(Common.Constants.SkyFramePath, StringComparison.OrdinalIgnoreCase))
{
perspective = new Perspective(Common.Constants.SkyLookAt, referenceFrame, true, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.SkyZoomTextDefaultValue, string.Empty);
float hours = 0;
string rowValueForRA = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.RA)];
if (layerMap.LayerDetails.RAUnit == AngleUnit.Hours)
{
// If hours data, send it as is
perspective.RightAscention = rowValueForRA;
}
else if (float.TryParse(rowValueForRA, out hours))
{
// If degrees data, divide it by 15 and send
perspective.RightAscention = (hours / 15).ToString(System.Globalization.CultureInfo.InvariantCulture);
}
else
{
// Else send it as is as it cannot be converted to degrees
perspective.RightAscention = rowValueForRA;
}
perspective.Declination = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Dec)];
}
else
{
if (referenceFramePath.StartsWith(Common.Constants.EarthFramePath, StringComparison.OrdinalIgnoreCase))
{
perspective = new Perspective(Common.Constants.EarthLookAt, referenceFrame, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
}
else
{
perspective = new Perspective(Common.Constants.SolarSystemLookAt, referenceFrame, false, Common.Constants.LatitudeDefaultValue, Common.Constants.LongitudeDefaultValue, Common.Constants.ZoomDefaultValue, Common.Constants.RotationDefaultValue, Common.Constants.LookAngleDefaultValue, DateTime.Now.ToString(), Common.Constants.TimeRateDefaultValue, Common.Constants.EarthZoomTextDefaultValue, string.Empty);
}
perspective.Latitude = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Lat)];
perspective.Longitude = rowData[layerMap.MappedColumnType.IndexOf(ColumnType.Long)];
}
}
// Update Perspective based on current state
Perspective currentPerspective = null;
try
{
currentPerspective = WWTManager.GetCameraView();
}
catch (CustomException)
{
// Ignore.
}
if (currentPerspective != null)
{
perspective.ObservingTime = currentPerspective.ObservingTime;
perspective.TimeRate = currentPerspective.TimeRate;
perspective.Rotation = currentPerspective.Rotation;
perspective.LookAngle = currentPerspective.LookAngle;
perspective.Zoom = currentPerspective.Zoom;
}
return perspective;
}
/// <summary>
/// This function is used to update header details in object models.
/// </summary>
/// <param name="selectedlayer">
/// Updated layer.
/// </param>
private static void UpdateHeader(LayerMap selectedlayer)
{
// Integration with WWT : Update the Layer details in WWT for the changes
if (selectedlayer.CanUpdateWWT())
{
// This is used only for Layer Property update notifications. Since the notifications are handled in background thread,
// CodeUpdate cannot be set the false here (main thread). It needs to be reset only by background thread once the
// notification is handled by the background thread.
selectedlayer.IsPropertyChangedFromCode = true;
// Update the header details.
if (!WWTManager.UpdateLayer(selectedlayer.LayerDetails, true, false))
{
selectedlayer.IsNotInSync = true;
}
}
}
