Example #1
0
        private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var obj = (IsNullOrEmptyStateTrigger)d;
            var val = e.NewValue;

            obj.IsActive = IsNullOrEmpty(val);

            if (val == null)
            {
                return;
            }

            // Try to listen for various notification events
            // Starting with INorifyCollectionChanged
            var valNotifyCollection = val as INotifyCollectionChanged;

            if (valNotifyCollection != null)
            {
                var weakEvent = new WeakEventListener <INotifyCollectionChanged, object, NotifyCollectionChangedEventArgs>(valNotifyCollection)
                {
                    OnEventAction  = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
                    OnDetachAction = (instance, weakEventListener) => instance.CollectionChanged -= weakEventListener.OnEvent
                };

                valNotifyCollection.CollectionChanged += weakEvent.OnEvent;
                return;
            }

            // Not INotifyCollectionChanged, try IObservableVector
            var valObservableVector = val as IObservableVector <object>;

            if (valObservableVector != null)
            {
                var weakEvent = new WeakEventListener <IObservableVector <object>, object, IVectorChangedEventArgs>(valObservableVector)
                {
                    OnEventAction  = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
                    OnDetachAction = (instance, weakEventListener) => instance.VectorChanged -= weakEventListener.OnEvent
                };

                valObservableVector.VectorChanged += weakEvent.OnEvent;
                return;
            }

            // Not INotifyCollectionChanged, try IObservableMap
            var valObservableMap = val as IObservableMap <object, object>;

            if (valObservableMap != null)
            {
                var weakEvent = new WeakEventListener <IObservableMap <object, object>, object, IMapChangedEventArgs <object> >(valObservableMap)
                {
                    OnEventAction  = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance),
                    OnDetachAction = (instance, weakEventListener) => instance.MapChanged -= weakEventListener.OnEvent
                };

                valObservableMap.MapChanged += weakEvent.OnEvent;
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="NetworkConnectionStateTrigger"/> class.
        /// </summary>
        public NetworkConnectionStateTrigger()
        {
            var weakEvent =
                new WeakEventListener <NetworkConnectionStateTrigger, object>(this)
            {
                OnEventAction  = (instance, source) => NetworkInformation_NetworkStatusChanged(source),
                OnDetachAction = (instance, weakEventListener) => NetworkInformation.NetworkStatusChanged -= weakEventListener.OnEvent
            };

            NetworkInformation.NetworkStatusChanged += weakEvent.OnEvent;
            UpdateState();
        }
Example #3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="OrientationStateTrigger"/> class.
 /// </summary>
 public OrientationStateTrigger()
 {
     if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
     {
         var weakEvent =
             new WeakEventListener <OrientationStateTrigger, DisplayInformation, object>(this)
         {
             OnEventAction  = OrientationStateTrigger_OrientationChanged,
             OnDetachAction = (_, weakEventListener) => DisplayInformation.GetForCurrentView().OrientationChanged -= weakEventListener.OnEvent
         };
         DisplayInformation.GetForCurrentView().OrientationChanged += weakEvent.OnEvent;
     }
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="FullScreenModeTrigger"/> class.
 /// </summary>
 public FullScreenModeTrigger()
 {
     if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
     {
         var weakEvent =
             new WeakEventListener <FullScreenModeTrigger, ApplicationView, object>(this)
         {
             OnEventAction  = (instance, source, eventArgs) => FullScreenModeTrigger_VisibleBoundsChanged(source, eventArgs),
             OnDetachAction = (instance, weakEventListener) => ApplicationView.GetForCurrentView().VisibleBoundsChanged -= weakEventListener.OnEvent
         };
         ApplicationView.GetForCurrentView().VisibleBoundsChanged += weakEvent.OnEvent;
     }
 }
Example #5
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UserInteractionModeTrigger"/> class.
 /// </summary>
 public UserInteractionModeTrigger()
 {
     if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
     {
         var weakEvent =
             new WeakEventListener <UserInteractionModeTrigger, object, WindowSizeChangedEventArgs>(this)
         {
             OnEventAction  = (instance, source, eventArgs) => UserInteractionModeTrigger_SizeChanged(source, eventArgs),
             OnDetachAction = (instance, weakEventListener) => Window.Current.SizeChanged -= weakEventListener.OnEvent
         };
         Window.Current.SizeChanged += weakEvent.OnEvent;
         UpdateTrigger(InteractionMode);
     }
 }
Example #6
0
        /// <summary>
        /// Initializes a new instance of the <see cref="AdaptiveTrigger"/> class.
        /// </summary>
        public AdaptiveTrigger()
        {
            this.RegisterPropertyChangedCallback(MinWindowHeightProperty, OnMinWindowHeightPropertyChanged);
            this.RegisterPropertyChangedCallback(MinWindowWidthProperty, OnMinWindowWidthPropertyChanged);

            var window = CoreApplication.GetCurrentView()?.CoreWindow;

            if (window != null)
            {
                var weakEvent = new WeakEventListener <AdaptiveTrigger, CoreWindow, WindowSizeChangedEventArgs>(this)
                {
                    OnEventAction  = (instance, s, e) => OnCoreWindowOnSizeChanged(s, e),
                    OnDetachAction = (instance, weakEventListener) => window.SizeChanged -= weakEventListener.OnEvent
                };
                window.SizeChanged += weakEvent.OnEvent;
            }
        }