/// <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; } } }