MapboxView.Events.cs

namespace MapboxMaui;

using System.Windows.Input;

partial class MapboxView
{
    public event EventHandler<MapTappedEventArgs> MapTapped;
    public event EventHandler<MapTappedEventArgs> MapLongTapped;
    internal void InvokeMapTapped(MapTappedPosition point)
    {
        MapTapped?.Invoke(this, new MapTappedEventArgs(point));

        if (Command?.CanExecute(point) == true)
        {
            Command.Execute(point);
        }
    }
    
    internal void InvokeMapLongTapped(MapTappedPosition position)
    {
        MapLongTapped?.Invoke(this, new MapTappedEventArgs(position));

        if (LongTapCommand?.CanExecute(position) == true)
        {
            LongTapCommand.Execute(position);
        }
    }
    
    public static readonly BindableProperty LongTapCommandProperty = BindableProperty.Create(
        nameof(LongTapCommand),
        typeof(ICommand),
        typeof(MapboxView)
    );
    public ICommand LongTapCommand
    {
        get => (ICommand)GetValue(CommandProperty);
        set => SetValue(CommandProperty, value);
    }

    public static readonly BindableProperty CommandProperty = BindableProperty.Create(
       nameof(Command),
       typeof(ICommand),
       typeof(MapboxView)
    );
    public ICommand Command
    {
        get => (ICommand)GetValue(CommandProperty);
        set => SetValue(CommandProperty, value);
    }

    public event EventHandler MapReady;
    internal void InvokeMapReady()
    {
        MapReady?.Invoke(this, EventArgs.Empty);

        if (MapReadyCommand?.CanExecute(null) == true)
        {
            MapReadyCommand.Execute(null);
        }
    }

    public static readonly BindableProperty MapReadyCommandProperty = BindableProperty.Create(
       nameof(MapReadyCommand),
       typeof(ICommand),
       typeof(MapboxView),
       default(ICommand)
    );
    public ICommand MapReadyCommand
    {
        get => (ICommand)GetValue(MapReadyCommandProperty);
        set => SetValue(MapReadyCommandProperty, value);
    }

    public event EventHandler StyleLoaded;
    internal void InvokeStyleLoaded()
    {
        StyleLoaded?.Invoke(this, EventArgs.Empty);

        if (StyleLoadedCommand?.CanExecute(null) == true)
        {
            StyleLoadedCommand.Execute(null);
        }
    }

    public static readonly BindableProperty StyleLoadedCommandProperty = BindableProperty.Create(
       nameof(StyleLoadedCommand),
       typeof(ICommand),
       typeof(MapboxView),
       default(ICommand)
    );
    public ICommand StyleLoadedCommand
    {
        get => (ICommand)GetValue(StyleLoadedCommandProperty);
        set => SetValue(StyleLoadedCommandProperty, value);
    }

    public event EventHandler MapLoaded;
    internal void InvokeMapLoaded()
    {
        MapLoaded?.Invoke(this, EventArgs.Empty);

        if (MapLoadedCommand?.CanExecute(null) == true)
        {
            MapLoadedCommand.Execute(null);
        }
    }
    public static readonly BindableProperty MapLoadedCommandProperty = BindableProperty.Create(
       nameof(MapLoadedCommand),
       typeof(ICommand),
       typeof(MapboxView),
       default(ICommand)
    );
    public ICommand MapLoadedCommand
    {
        get => (ICommand)GetValue(MapLoadedCommandProperty);
        set => SetValue(MapLoadedCommandProperty, value);
    }

    public event EventHandler MapLoadingError;
    internal void InvokeMapLoadingError()
    {
        MapLoadingError?.Invoke(this, EventArgs.Empty);

        if (MapLoadingErrorCommand?.CanExecute(null) == true)
        {
            MapLoadingErrorCommand.Execute(null);
        }
    }
    public static readonly BindableProperty MapLoadingErrorCommandProperty = BindableProperty.Create(
       nameof(MapLoadingErrorCommand),
       typeof(ICommand),
       typeof(MapboxView),
       default(ICommand)
    );
    public ICommand MapLoadingErrorCommand
    {
        get => (ICommand)GetValue(MapLoadingErrorCommandProperty);
        set => SetValue(MapLoadingErrorCommandProperty, value);
    }
}