public ValidatePageViewModel(INavigationService navigationService, IPermissionService permissionService,
                                     IStringLocalizer <ValidatePageViewModel> stringLocalizer, IEventAggregator eventAggregator, IApiClient apiClient,
                                     IAppDataService appDataService, IMapper mapper, INotificationService notificationService)
            : base(navigationService, permissionService, stringLocalizer)
        {
            EventAggregator     = eventAggregator;
            ApiClient           = apiClient;
            AppDataService      = appDataService;
            Mapper              = mapper;
            NotificationService = notificationService;

            LegendItems = new ObservableCollection <ItemViewModel>();
            ((INotifyCollectionChanged)LegendItems).CollectionChanged += ObservableCollectionExtension.OnItemsAddedOrRemovedEventHandler(
                (sender, itemsAdded) =>
            {
                foreach (ItemViewModel item in itemsAdded)
                {
                    item.ItemSelected += ItemOnItemSelected;
                }
            }, (sender, itemsRemoved) =>
            {
                foreach (ItemViewModel item in itemsRemoved)
                {
                    item.ItemSelected -= ItemOnItemSelected;
                }
            }, (sender) => { Helper.RunOnMainThreadIfRequired(() => throw new InvalidOperationException()); });

            IsCorrectTappedCommand = new DelegateCommand(() =>
            {
                if (Correct != true)
                {
                    SelectedLegendItem = null;

                    foreach (ItemViewModel itemViewModel in LegendItems)
                    {
                        itemViewModel.IsSelected = false;
                    }
                }

                Correct = Correct != true ? (bool?)true : null;
            });
            IsNotCorrectTappedCommand = new DelegateCommand(() =>
            {
                if (Correct == false)
                {
                    SelectedLegendItem = null;

                    foreach (ItemViewModel itemViewModel in LegendItems)
                    {
                        itemViewModel.IsSelected = false;
                    }
                }

                Correct = Correct != false ? (bool?)false : null;
            });
        }
        public TracePeriodicViewData()
        {
            _timer.AutoReset = true;
            _timer.Elapsed  += _timer_Elapsed;

            PropertyChanged += Model_PropertyChanged;

            Model         = new TracePeriodicModel();
            Model.Payload = ObservableCollectionExtension.CreateEmpty((uint)Model.DLC);
        }
Esempio n. 3
0
        public PointHandler()
        {
            PointsOnCollectionChanged = ObservableCollectionExtension.OnItemsAddedOrRemovedEventHandler((sender, itemsAdded) =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    foreach (IPoint point in itemsAdded.OfType <IPoint>())
                    {
                        AddPoint(point);
                    }
                });
            }, (sender, itemsRemoved) =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    foreach (IPoint point in itemsRemoved.OfType <IPoint>())
                    {
                        RemovePoint(point);
                    }
                });
            }, (sender) =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    RemovePoints();
                });
            });
        }
Esempio n. 4
0
        public PointHandler()
        {
            PointsOnCollectionChanged = ObservableCollectionExtension.OnItemsAddedOrRemovedEventHandler((sender, itemsAdded) =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    foreach (IPoint point in itemsAdded.OfType <IPoint>())
                    {
                        AddPoint(point);
                    }
                });
            }, (sender, itemsRemoved) =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    foreach (IPoint point in itemsRemoved.OfType <IPoint>())
                    {
                        RemovePoint(point);
                    }
                });
            }, sender =>
            {
                Helper.RunOnMainThreadIfRequired(() =>
                {
                    // Race condition that could occur if you set a new points collection
                    if (!ReferenceEquals(sender, Points))
                    {
                        return;
                    }

                    RemovePoints();
                });
            });

            ClickGestureRecognizer = new UITapGestureRecognizer(recognizer =>
            {
                CGPoint tapPoint = recognizer.LocationInView(Map);
                CLLocationCoordinate2D tapCoordinate = Map.ConvertPoint(tapPoint, Map);
                MKMapPoint mapPoint = MKMapPoint.FromCoordinate(tapCoordinate);

                // TODO: Optimize access if necessary (use R tree, k-d tree or similar)
                MKCircle firstOrDefault = PointsToCirclesMapping.Values.FirstOrDefault(x => x.BoundingMapRect.Contains(mapPoint));

                if (firstOrDefault != null)
                {
                    if (PointsToCirclesMapping[firstOrDefault] is ISelectable selectable)
                    {
                        if (selectable.IsSelectable)
                        {
                            selectable.Selected = !selectable.Selected;
                        }
                    }
                }
                else
                {
                    OnMapClicked?.Invoke(this, EventArgs.Empty);
                }
            });
        }