private async void OnMapViewInitialized(MapViewEventArgs args)
        {
            CycloMediaLayer.ResetYears();
            LayersRemovedEvent.Subscribe(OnLayerRemoved);
            DrawCompleteEvent.Subscribe(OnDrawComplete);

            if (ContainsCycloMediaLayer(args.MapView))
            {
                await AddLayersAsync(args.MapView);
            }

            Settings settings = Settings.Instance;
            Login    login    = Login.Instance;

            settings.PropertyChanged += OnSettingsPropertyChanged;
            login.PropertyChanged    += OnLoginPropertyChanged;

            if (settings.CycloramaViewerCoordinateSystem != null)
            {
                await CoordSystemUtils.CheckInAreaCycloramaSpatialReferenceAsync();
            }

            if (!_agreement.Value)
            {
                PropertySheet.ShowDialog("streetSmartArcGISPro_optionsPropertySheet", "streetSmartArcGISPro_agreementPage");
            }
        }
Exemple #2
0
        //public void RemoveWorkListLayer(IWorkList workList)
        //{
        //	if (_layerByWorkList.ContainsKey(workList))
        //	{
        //		_layerByWorkList.Remove(workList);
        //		Layer layer = MapView.Active.Map.GetLayersAsFlattenedList()
        //		                     .First(l => l.Name == workList.Name);
        //		QueuedTask.Run(() => MapView.Active.Map.RemoveLayer(layer));
        //	}
        //}

        #region Events

        private void WireEvents()
        {
            LayersRemovingEvent.Subscribe(OnLayerRemovingAsync);
            DrawCompleteEvent.Subscribe(OnDrawCompleted);

            ProjectOpenedAsyncEvent.Subscribe(OnProjectOpendedAsync);
            ProjectSavingEvent.Subscribe(OnProjectSavingAsync);
        }
 protected override bool Initialize()
 {
     //Subscribe to event to see if the Label gallery context is set
     ProjectOpenedEvent.Subscribe(OnProjectOpened);
     ActiveMapViewChangedEvent.Subscribe(OnActiveMapViewChanged);
     DrawCompleteEvent.Subscribe(OnDrawComplete);
     LayersAddedEvent.Subscribe(OnLayersAdded);
     return(base.Initialize());
 }
 private void AddEvents()
 {
     LayersAddedEvent.Subscribe(OnLayersAdded);
     LayersMovedEvent.Subscribe(OnLayersMoved);
     LayersRemovedEvent.Subscribe(OnLayersRemoved);
     MapMemberPropertiesChangedEvent.Subscribe(OnMapMemberPropertiesChanged);
     TOCSelectionChangedEvent.Subscribe(OnTocSelectionChanged);
     DrawStartedEvent.Subscribe(OnDrawStarted);
     DrawCompleteEvent.Subscribe(OnDrawCompleted);
     ActiveToolChangedEvent.Subscribe(OnActiveToolChangedEvent);
     EditCompletedEvent.Subscribe(OnEditCompleted);
 }
Exemple #5
0
        //public void RemoveWorkListLayer(IWorkList workList)
        //{
        //	if (_layersByWorklistName.ContainsKey(workList.Name))
        //	{

        //	}
        //	if (_layerByWorkList.ContainsKey(workList))
        //	{
        //		_layerByWorkList.Remove(workList);
        //		Layer layer = MapView.Active.Map.GetLayersAsFlattenedList()
        //							 .First(l => l.Name == workList.Name);
        //		QueuedTask.Run(() => MapView.Active.Map.RemoveLayer(layer));
        //	}
        //}

        #region Events

        private void WireEvents()
        {
            // creating a project
            // 1. OnProjectOpened
            // 2. OnWriteSettings
            // 3. OnMapViewInitialized
            // 4. OnDrawCompleted

            //MapViewInitializedEvent.Subscribe(OnMapViewInitialized);
            LayersRemovingEvent.Subscribe(OnLayerRemovingAsync);
            DrawCompleteEvent.Subscribe(OnDrawCompleted);

            ProjectOpenedAsyncEvent.Subscribe(OnProjectOpendedAsync);
            ProjectSavingEvent.Subscribe(OnProjectSavingAsync);

            ProjectItemsChangedEvent.Subscribe(OnProjectItemsChanged);
            ProjectItemRemovingEvent.Subscribe(OnProjectItemRemoving);

            MapMemberPropertiesChangedEvent.Subscribe(OnMapMemberPropertiesChanged);
        }
        public async Task <bool> InitializeEventsAsync()
        {
            bool result = (Layer.ConnectionStatus == ConnectionStatus.Connected);

            if (result)
            {
                MapSelectionChangedEvent.Subscribe(OnMapSelectionChanged);
                DrawCompleteEvent.Subscribe(OnDrawCompleted);

                await QueuedTask.Run(() =>
                {
                    var table   = Layer.GetTable();
                    _rowChanged = RowChangedEvent.Subscribe(OnRowChanged, table);
                    _rowDeleted = RowDeletedEvent.Subscribe(OnRowDeleted, table);
                    _rowCreated = RowCreatedEvent.Subscribe(OnRowCreated, table);
                });
            }

            await LoadMeasurementsAsync();

            return(result);
        }
        public async void OnAPIReady()
        {
            if (_api != null)
            {
                GlobeSpotterConfiguration.Load();
                _api.SetMaxViewers((uint)_constants.MaxViewers);
                _api.SetCloseViewerEnabled(true);
                _api.SetViewerToolBarVisible(false);
                _api.SetViewerToolBarButtonsVisible(true);
                _api.SetViewerTitleBarVisible(false);
                _api.SetViewerWindowBorderVisible(false);
                _api.SetHideOverlaysWhenMeasuring(false);
                _api.SetImageInformationEnabled(true);
                _api.SetViewerBrightnessEnabled(true);
                _api.SetViewerSaveImageEnabled(true);
                _api.SetViewerOverlayAlphaEnabled(true);
                _api.SetViewerShowLocationEnabled(true);
                _api.SetViewerDetailImagesVisible(_settings.ShowDetailImages);
                _api.SetContextMenuEnabled(true);
                _api.SetKeyboardEnabled(true);
                _api.SetViewerRotationEnabled(true);
                _api.SetWindowingMode(MDIWindowingMode.VERTICAL);

                _api.SetMultiWindowCount((uint)_settings.CtrlClickHashTag);
                _api.SetWindowSpread((uint)_settings.CtrlClickDelta);
                _measurementList.Api = _api;

                if (GlobeSpotterConfiguration.AddLayerWfs)
                {
                    _api.SetViewerOverlayDrawDistanceEnabled(true);
                }

                if (GlobeSpotterConfiguration.MeasurePermissions)
                {
                    _api.SetMeasurementSeriesModeEnabled(true);
                }

                if (GlobeSpotterConfiguration.MeasureSmartClick)
                {
                    _api.SetMeasurementSmartClickModeEnabled(_settings.EnableSmartClickMeasurement);
                }

                DockPaneGlobeSpotter globeSpotter = (dynamic)DataContext;
                string location = globeSpotter.Location;

                globeSpotter.PropertyChanged          += OnGlobeSpotterPropertyChanged;
                _settings.PropertyChanged             += OnSettingsPropertyChanged;
                _cycloMediaGroupLayer.PropertyChanged += OnGroupLayerPropertyChanged;

                foreach (CycloMediaLayer layer in _cycloMediaGroupLayer)
                {
                    if (!_layers.Contains(layer))
                    {
                        _layers.Add(layer);
                        UpdateRecordingLayer(layer);
                        layer.PropertyChanged += OnLayerPropertyChanged;
                    }
                }

                if (string.IsNullOrEmpty(location))
                {
                    globeSpotter.Hide();
                }
                else
                {
                    await OpenImageAsync(false);
                }

                _vectorLayerList.LayerAdded   += OnAddVectorLayer;
                _vectorLayerList.LayerRemoved += OnRemoveVectorLayer;
                _vectorLayerList.LayerUpdated += OnUpdateVectorLayer;

                foreach (var vectorLayer in _vectorLayerList)
                {
                    vectorLayer.PropertyChanged += OnVectorLayerPropertyChanged;
                }

                await _vectorLayerList.LoadMeasurementsAsync();

                DrawCompleteEvent.Subscribe(OnDrawComplete);
            }
        }
Exemple #8
0
 protected override bool Initialize()
 {
     ActiveMapViewChangedEvent.Subscribe(OnActiveMapViewChanged);
     DrawCompleteEvent.Subscribe(OnDrawComplete);
     return(base.Initialize());
 }