private async void QueryMapAreas()
        {
            try
            {
                // Clear existing overlays
                _mapViewService.ClearOverlays();

                // Clear existing areas (in case user wants to refresh results)
                MapAreas.Clear();

                // Create new task to
                var offlineMapTask = await OfflineMapTask.CreateAsync(Map);

                // Get list of areas
                IReadOnlyList <PreplannedMapArea> preplannedMapAreas = await offlineMapTask.GetPreplannedMapAreasAsync();

                // Create UI from the areas
                foreach (var preplannedMapArea in preplannedMapAreas.OrderBy(x => x.PortalItem.Title))
                {
                    // Load area to get the metadata
                    await preplannedMapArea.LoadAsync();

                    // Using a custom model for easier visualization
                    var model = new MapAreaModel(preplannedMapArea);
                    MapAreas.Add(model);
                    // Graphic that shows the area in the map
                    var graphic = new Graphic(preplannedMapArea.AreaOfInterest, GetSymbolForColor(model.DisplayColor));
                    graphic.Attributes.Add("Name", preplannedMapArea.PortalItem.Title);
                    _areasOverlay.Graphics.Add(graphic);
                }

                if (!preplannedMapAreas.Any())
                {
                    await _windowService.ShowAlertAsync("No preplanned map areas available.");
                }
                else
                {
                    // Show the overlays on the map
                    _mapViewService.AddGraphicsOverlay(_areasOverlay);

                    // Zoom to the offline areas
                    await _mapViewService.SetViewpointGeometryAsync(_areasOverlay.Extent, 20);
                }

                // Refresh commands
                RefreshCommands();
            }
            catch (Exception ex)
            {
                await _windowService.ShowAlertAsync(ex.Message, "Couldn't query map areas");
            }
        }
Пример #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorldLOD"/> class.
        /// </summary>
        /// <param name="inData">The input data.</param>
        public WorldLOD(byte[] inData)
        {
            using (var ms = new MemoryStream(inData))
            {
                using (var br = new BinaryReader(ms))
                {
                    // Set up the two area lists with default values
                    for (var i = 0; i < 4096; ++i)
                    {
                        MapAreas.Add(null);
                        MapAreaHoles.Add(null);
                    }

                    Version = br.ReadIFFChunk <TerrainVersion>();

                    if (br.PeekChunkSignature() == TerrainWorldModelObjects.Signature)
                    {
                        WorldModelObjects = br.ReadIFFChunk <TerrainWorldModelObjects>();
                    }

                    if (br.PeekChunkSignature() == TerrainWorldModelObjectIndices.Signature)
                    {
                        WorldModelObjectIndices = br.ReadIFFChunk <TerrainWorldModelObjectIndices>();
                    }

                    if (br.PeekChunkSignature() == TerrainWorldModelObjectPlacementInfo.Signature)
                    {
                        WorldModelObjectPlacementInfo = br.ReadIFFChunk <TerrainWorldModelObjectPlacementInfo>();
                    }

                    MapAreaOffsets = br.ReadIFFChunk <WorldLODMapAreaOffsets>();

                    // Read the map areas and their holes
                    for (var y = 0; y < 64; ++y)
                    {
                        for (var x = 0; x < 64; ++x)
                        {
                            var mapAreaOffsetIndex = (y * 64) + x;
                            var mapAreaOffset      = MapAreaOffsets.MapAreaOffsets[mapAreaOffsetIndex];

                            if (mapAreaOffset > 0)
                            {
                                br.BaseStream.Position       = mapAreaOffset;
                                MapAreas[mapAreaOffsetIndex] = br.ReadIFFChunk <WorldLODMapArea>();

                                if (br.PeekChunkSignature() == WorldLODMapAreaHoles.Signature)
                                {
                                    MapAreaHoles[mapAreaOffsetIndex] = br.ReadIFFChunk <WorldLODMapAreaHoles>();
                                }
                                else
                                {
                                    MapAreaHoles[mapAreaOffsetIndex] = WorldLODMapAreaHoles.CreateEmpty();
                                }
                            }
                            else
                            {
                                MapAreas[mapAreaOffsetIndex]     = null;
                                MapAreaHoles[mapAreaOffsetIndex] = null;
                            }
                        }
                    }
                }
            }
        }