/SuperMemory/Order/OrderPage.xaml.cs

using System;

using System.Linq;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Navigation;

using Smart.Classes.Collections;

using Smart.Classes.Extensions;

using Smart.Classes.Subjects;

using Smart.UI.Classes.Animations;

using Smart.UI.Classes.Events;

using Smart.UI.Classes.Extensions;

using Smart.UI.Classes.Extensions.StructExtensions;

using Smart.UI.Classes.Layout;

using Smart.UI.Panels;

using Smart.UI.Widgets;

using Smart.UI.Widgets.Events;

using Smart.UI.Classes.Events;



namespace SuperMemory.Order

{

    public partial class OrderPage : Page

    {

        public OrderViewModel ViewModel;



        public OrderPage()

        {

            InitializeComponent();

            Init();



        }



        // Executes when the user navigates to this page.

        protected override void OnNavigatedTo(NavigationEventArgs e)

        {

        }





        protected void Init()

        {

            if (this.Settings == null) this.Settings = this.DataContext as OrderSettings;

            this.field.DataContext = this.Settings;

            this.tools.DataContext = this.Settings;

            this.ViewModel = new OrderViewModel(this.Settings);

            this.InitEvents();

            // var r = this.field.TESTRAWS;

            // var b = this.field.BINDED;



            this.ViewModel.Start();

            this.field.RunAterNextLayoutUpdate(i => this.InitFieldResize());

        }



        #region LINES CHANGES

        //TODO : rewrite entirely



            /// <summary>

            /// NAPILNIK

            /// TODO : rewrite enitrely

            /// </summary>

            private void InitFieldResize()

            {

                this.field.SetRelativeToGrid(true).SetBottom().SetRight();

             

                this.field.ColumnDefinitions.ItemsAdded.DoOnNext += this.AddColumnHandler;

                this.field.RowDefinitions.ItemsAdded.DoOnNext += this.AddRowHandler;

                this.field.ColumnDefinitions.ItemsRemoved.DoOnNext += this.RemoveColumnHandler;

                this.field.RowDefinitions.ItemsRemoved.DoOnNext += this.RemoveRowHandler;

                //TODO :fix ADDBOTTOM AND ADDRIGHT BUGS

            

            }

        

            protected void AddRowHandler(LineDefinition ldf)

            {

                field.SetBottom(field.GetBottom() - ldf.AbsoluteValue);            

            }



            protected void RemoveRowHandler(LineDefinition ldf)

            {

                field.SetBottom(field.GetBottom() + ldf.AbsoluteValue);            

            }



            protected void AddColumnHandler(LineDefinition ldf)

            {

                field.SetRight(field.GetRight() - ldf.AbsoluteValue);            

            }



            protected void RemoveColumnHandler(LineDefinition ldf)

            {

                field.SetRight(field.GetRight() + ldf.AbsoluteValue);            

            }



        #endregion

        /// <summary>

        /// Adds events to the controls and handlers to them

        /// </summary>

        protected void InitEvents()

        {

            field.AllowDock = AlloDockHandler;

            this.AsEventsHolder().RouteEventTo<String>(OrderEvents.GO_2_STATE, ViewModel);

            

            ViewModel.AddEventHandler<MassiveRelativeResizeEvent>(OrderEvents.APPEAR, AppearHandler);

            ViewModel.AddEventHandler<string>(OrderEvents.DISAPPEAR, DisappearHandler);

            ViewModel.AddEventCallback<AnimationEvent<FrameworkElement>,double>(OrderEvents.SHOW_POPUP,ShowPopupHandler);

            ViewModel.AddEventCallback<AnimationEvent<FrameworkElement>,double>(OrderEvents.HIDE_POPUP,HidePopupHandler);

            ViewModel.AddEventCallback<MoveToCellsEvent, double>(OrderEvents.MOVE_TO_INVENTORY, MoveToInventory);                      

        }



        private Animation ShowPopupHandler(AnimationEvent<FrameworkElement> args)

        {

            var target = args.Target.SetRow(1).SetColumn(2);//.SetColumnSpan(1)

            this.LayoutRoot.AddChild(target);

            target.Opacity = 0.1;

            return target.AnimateProperty(UIElement.OpacityProperty, 0.8, args.Duration).Go();

            /*

            this.AppearOne(

                new RelativeResizeEvent(target, new Point(1, 1), new TimeSpan(0, 0, 0, 2), Easings.CubicEaseInOut),

                this.LayoutRoot);

             * */

        }

     

        /// <summary>

        /// Hides popup

        /// </summary>

        /// <param name="args"></param>

        private Animation HidePopupHandler(AnimationEvent<FrameworkElement> args)

        {

            var target = args.Target;

            var ani = target.AnimateProperty(UIElement.OpacityProperty, 0.1, args.Duration);

            ani.DoOnCompleted+=()=>

                this.LayoutRoot.RemoveChild(args.Target);

            return ani.Go();

        }



        /// <summary>

        /// Let one element to appear with animation

        /// </summary>

        /// <param name="args"></param>

        /// <param name="grid"></param>

        protected void AppearOne(RelativeResizeEvent args, WidgetGrid grid)

        {

            var target = args.Target;

            grid.AddChild(target);

            field.AfterArrange.At().DoOnNext +=

                i =>

                {

                    grid.PlaceInCells(target, target.GetSlot().SetSize(10, 10));

                    target.ResizeInCellsRelatively(args.RelativeSize, args.Duration, args.Easing).Go();

                };

        }





        /// <summary>

        /// Cleanups tools and fields

        /// </summary>

        /// <param name="param"></param>

        private void DisappearHandler(string param)

        {

            this.field.RunAterNextLayoutUpdate(u =>

                                                   {

                                                       this.field.RemoveChildren(i => i is Image);

                                                       this.tools.RemoveChildren(i => i is Image);

                                                   });

        }





        /// <summary>

        /// Checks if dockin is allowed

        /// </summary>

        /// <param name="fly"></param>

        /// <returns></returns>

        protected Boolean AlloDockHandler(ObjectFly fly)

        {

            CellsRegion cells = field.MeasureCellsRegion(fly.Target);

            return this.ViewModel.MoveElementTo(new Num2D(cells.Col, cells.Row), fly.Target);





        }

       



        /// <summary>

        /// Handler that makes resizing effect for elements when they first appear on the field

        /// </summary>

        /// <param name="args"></param>

        private void AppearHandler(MassiveRelativeResizeEvent args)

        {

            args.Handled = true;

            args.Targets.ForEach(i => field.AddChild(i.Item1));

            field.AfterArrange.At().DoOnNext +=

                i =>

                {

                    args.Targets.ForEach(e => field.PlaceInCells(e.Item1, e.Item1.GetSlot().SetSize(10, 10)));

                    args.Targets.ResizeInCellsRelatively(args.Duration, args.Easing).Go();

                };

        }





        /// <summary>

        /// Handler that makes resizing effect for elements when they first appear on the field

        /// </summary>

        /// <param name="args"></param>

        private Animation MoveToInventory(MoveToCellsEvent args)

        {

            var objects = args.Targets;

            //var ani = this.tools.MoveInCellsMassive(args.Targets, args.Duration, args.Easing);

            objects.ForEach(o =>

            {

                var bounds = o.Item1.GetRelativeRect(tools);

                this.field.Children.MoveElementTo(o.Item2.SetPosition(o.Item1), this.tools.Children);

                tools.PlaceInCells(o.Item1, bounds, o.Item2);

            });





            var targets = objects.Select(s => new Tuple<FrameworkElement, Rect>(s.Item1, tools.GetCellsRect(s.Item2)));

            var ani = tools.MoveInCellsMassive(targets, new TimeSpan(0, 0, 0, 2), Easings.CubicEaseInOut);

            tools.DragEnabled = field.DragEnabled = true;

            args.Handled = true;            

            return ani.Go();

        }





        private void playBtn_Click(object sender, RoutedEventArgs e)

        {

            ViewModel.OnButtonClick();

        }

        

    }

}