private void HandleTileViewItemRestored(TileViewItem item)
 {
     if (MaximizeMode != TileViewMaximizeMode.One)
     {
         MaximizedItem = null;
         foreach (TileViewItem item2 in GetGeneratedItemContainers())
         {
             item2.TileState = TileViewItemState.Restored;
         }
         if (IsItemsAnimationEnabled)
         {
             AnimateItemSizes();
             AnimateItemsLayout();
         }
         else
         {
             UpdateItemSizes();
             UpdateItemsLayout();
         }
     }
     else
     {
         item.TileState = TileViewItemState.Maximized;
     }
 }
 private void AnimateItemSize(TileViewItem item, Size targetSize)
 {
     if (!item.SizeAnimating)
     {
         var size = new Size(item.ActualWidth, item.ActualHeight);
         item.Height = targetSize.Height;
         item.Width  = targetSize.Width;
         double totalSeconds = ResizingDuration.TimeSpan.TotalSeconds;
         var    args         = new double[4];
         args[1] = size.Height;
         args[2] = totalSeconds;
         args[3] = targetSize.Height;
         var numArray2 = new double[4];
         numArray2[1] = size.Width;
         numArray2[2] = totalSeconds;
         numArray2[3] = targetSize.Width;
         Storyboard sb =
             AnimationExtensions.Create().Animate(new FrameworkElement[] { item }).EnsureDefaultTransforms().Height
                 (args).Width(numArray2).EaseAll((ResizingEasing ?? Easings.SlideDown1)).AdjustSpeed().Instance;
         sb.Completed += (sender, e) =>
         {
             sb.Stop();
             item.SizeAnimating = false;
         };
         item.SizeAnimating = true;
         sb.Begin();
     }
 }
 protected virtual void AttachItemContainerEventHandlers(TileViewItem item)
 {
     item.TileStateChanged += TileViewItemTileStateChanged;
     if (item.TileState == TileViewItemState.Maximized)
     {
         MaximizedItem = ItemContainerGenerator.ItemFromContainer(item);
     }
 }
 protected virtual void DetachItemContainerEventHandlers(TileViewItem item)
 {
     item.TileStateChanged -= TileViewItemTileStateChanged;
     if (MaximizedItem == ItemContainerGenerator.ItemFromContainer(item))
     {
         MaximizedItem = null;
     }
 }
        private Size GetRestoredItemSize(TileViewItem item)
        {
            double num  = ((ActualWidth / _columns) - item.Margin.Left) - item.Margin.Right;
            double num2 = ((ActualHeight / _rows) - item.Margin.Top) - item.Margin.Bottom;

            num = Math.Max(0.0, num);
            return(new Size(num, Math.Max(0.0, num2)));
        }
 private void TileViewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
 {
     _draggedContainer  = null;
     MouseMove         -= TileViewMouseMove;
     MouseLeftButtonUp -= TileViewMouseLeftButtonUp;
     ReleaseMouseCapture();
     UpdateItemsLayout();
 }
 private bool IsItemMaximizedByDefault(TileViewItem item)
 {
     if (((MaximizeMode != TileViewMaximizeMode.One) || (MaximizedItem != null)) &&
         (item.TileState != TileViewItemState.Maximized))
     {
         return(MaximizedItem == ItemContainerGenerator.ItemFromContainer(item));
     }
     return(true);
 }
        private Size GetItemSize(TileViewItem item)
        {
            if (MaximizedItem == null)
            {
                return(GetRestoredItemSize(item));
            }
            var item2 = ItemContainerGenerator.ContainerFromItem(MaximizedItem) as TileViewItem;

            return(Equals(item, item2) ? GetMaximizedItemSize(item) : GetMinimizedItemSize(item));
        }
        private Size GetMaximizedItemSize(TileViewItem item)
        {
            double num  = ((ActualWidth - MinimizedColumnWidth) - item.Margin.Left) - item.Margin.Right;
            double num2 = (ActualHeight - item.Margin.Top) - item.Margin.Bottom;

            if (MinimizedItemsPosition.Equals(Dock.Bottom) || MinimizedItemsPosition.Equals(Dock.Top))
            {
                num  = (ActualWidth - item.Margin.Left) - item.Margin.Right;
                num2 = ((ActualHeight - MinimizedRowHeight) - item.Margin.Top) - item.Margin.Bottom;
            }
            num = Math.Max(0.0, num);
            return(new Size(num, Math.Max(0.0, num2)));
        }
 internal void OnItemDragging(TileViewItem draggedItem, MouseEventArgs e)
 {
     if (IsItemDraggingEnabled && CanDragItems())
     {
         CaptureMouse();
         _draggedContainer = draggedItem;
         LastDragPosition  = e.GetPosition(null);
         int currentZIndex = TileViewItem.CurrentZIndex;
         TileViewItem.CurrentZIndex = currentZIndex + 1;
         Canvas.SetZIndex(_draggedContainer, currentZIndex);
         MouseMove += TileViewMouseMove;
         AddHandler(MouseLeftButtonUpEvent, new MouseButtonEventHandler(TileViewMouseLeftButtonUp), true);
     }
 }
        private Size GetMinimizedItemSize(TileViewItem item)
        {
            double num8;
            double num9;
            var    generatedItemContainers = GetGeneratedItemContainers().ToList();
            int    num  = CountItemsWithGeneratedContainers();
            double num2 = generatedItemContainers
                          .Where(i => i.MinimizedHeight > double.Epsilon)
                          .Select(i => i.MinimizedHeight).Sum();
            double num3 = generatedItemContainers
                          .Where(i => i.MinimizedWidth > double.Epsilon)
                          .Select(i => i.MinimizedWidth).Sum();
            int num4 = num - generatedItemContainers.Count(i => i.MinimizedHeight > 0.0);
            int num5 = generatedItemContainers.Count(i => i.MinimizedWidth > 0.0);

            if (MaximizedItem != null)
            {
                var item2 = ItemContainerGenerator.ContainerFromItem(MaximizedItem) as TileViewItem;
                if ((item2 != null) && (item2.MinimizedWidth > double.Epsilon))
                {
                    num3 -= item2.MinimizedWidth;
                    num5++;
                }
                if ((item2 != null) && (item2.MinimizedHeight > double.Epsilon))
                {
                    num2 -= item2.MinimizedHeight;
                    num4++;
                }
            }
            double num6 = ActualWidth - num3;
            double num7 = ActualHeight - num2;
            bool   isDockedTopBottom = (MinimizedItemsPosition == Dock.Bottom) || (MinimizedItemsPosition == Dock.Top);

            if (isDockedTopBottom)
            {
                num8 = ((num6 / (num5 - 1)) - item.Margin.Left) - item.Margin.Right;
                num9 = (MinimizedRowHeight - item.Margin.Top) - item.Margin.Bottom;
            }
            else
            {
                num8 = (MinimizedColumnWidth - item.Margin.Left) - item.Margin.Right;
                num9 = ((num7 / (num4 - 1)) - item.Margin.Top) - item.Margin.Bottom;
            }
            num8 = ((item.MinimizedWidth > 0.0) && isDockedTopBottom) ? item.MinimizedWidth : Math.Max(0.0, num8);
            return(new Size(num8,
                            ((item.MinimizedHeight > 0.0) && !isDockedTopBottom)
                                ? item.MinimizedHeight
                                : Math.Max(0.0, num9)));
        }
        private bool ShouldAnimateItemPosition(TileViewItem item)
        {
            if (Equals(item, _draggedContainer))
            {
                return(false);
            }
            Point currentItemPosition = GetCurrentItemPosition(item);
            Point targetItemPosition  = GetTargetItemPosition(item);

            if (DoubleUtil.AreClose(targetItemPosition.X, currentItemPosition.X))
            {
                return(!DoubleUtil.AreClose(targetItemPosition.Y, currentItemPosition.Y));
            }
            return(true);
        }
        private void HandleTileViewItemMaximized(TileViewItem item)
        {
            int currentZIndex = TileViewItem.CurrentZIndex;

            TileViewItem.CurrentZIndex = currentZIndex + 1;
            Canvas.SetZIndex(item, currentZIndex);
            MaximizedItem = ItemContainerGenerator.ItemFromContainer(item);
            foreach (var item2 in GetGeneratedItemContainers())
            {
                if (!Equals(item2, item))
                {
                    item2.TileState = TileViewItemState.Minimized;
                }
            }
            UpdateItemsSizeAndPosition();
            SetItemSize(item, GetMaximizedItemSize(item));
        }
        private void SwapItems(TileViewItem itemToSwapWith)
        {
            int column = Grid.GetColumn(itemToSwapWith);
            int row    = Grid.GetRow(itemToSwapWith);

            Grid.SetColumn(itemToSwapWith, Grid.GetColumn(_draggedContainer));
            Grid.SetRow(itemToSwapWith, Grid.GetRow(_draggedContainer));
            Grid.SetColumn(_draggedContainer, column);
            Grid.SetRow(_draggedContainer, row);
            if (IsItemsAnimationEnabled)
            {
                AnimateItemsLayout();
            }
            else
            {
                UpdateItemsLayout();
            }
        }
        private bool ShouldSwapWithItem(TileViewItem item, Point currentPoint)
        {
            Point absolutePosition      = currentPoint;
            Point relativeMousePosition = GetRelativeMousePosition(absolutePosition);
            int   currentRow            = GetCurrentRow(relativeMousePosition);
            int   currentColumn         = GetCurrentColumn(relativeMousePosition);
            int   row    = Grid.GetRow(item);
            int   column = Grid.GetColumn(item);
            bool  flag   = IsMouseOverVisual(absolutePosition, item);

            if (((Equals(item, _draggedContainer)) || !flag) || item.PositionAnimating)
            {
                return(false);
            }
            if (column != currentColumn)
            {
                return(row == currentRow);
            }
            return(true);
        }
        private void TileViewMouseMove(object sender, MouseEventArgs e)
        {
            if (_draggedContainer == null)
            {
                return;
            }
            Point position = e.GetPosition(null);
            Point sanitizedDraggedItemPosition = GetSanitizedDraggedItemPosition(position);

            if (sanitizedDraggedItemPosition != GetDraggedItemCurrentPosition())
            {
                SetItemPosition(_draggedContainer, sanitizedDraggedItemPosition);
            }
            TileViewItem itemToSwapWith = GetItemToSwapWith(position);

            if (itemToSwapWith != null)
            {
                SwapItems(itemToSwapWith);
            }
        }
        private void AnimateItemPosition(TileViewItem item, Point targetPosition)
        {
            if (item.PositionAnimating)
            {
                return;
            }
            Point  currentItemPosition = GetCurrentItemPosition(item);
            double num  = targetPosition.X - currentItemPosition.X;
            double num2 = targetPosition.Y - currentItemPosition.Y;

            if (Equals(MaximizedItem, item))
            {
                int currentZIndex = TileViewItem.CurrentZIndex;
                TileViewItem.CurrentZIndex = currentZIndex + 1;
                Canvas.SetZIndex(item, currentZIndex);
            }
            double totalSeconds = ReorderingDuration.TimeSpan.TotalSeconds;
            var    args         = new double[4];

            args[1] = -num;
            args[2] = totalSeconds;
            var numArray2 = new double[4];

            numArray2[1] = -num2;
            numArray2[2] = totalSeconds;
            Storyboard sb =
                AnimationExtensions.Create().Animate(new FrameworkElement[] { item }).EnsureDefaultTransforms().MoveX(
                    args).MoveY(numArray2).Origin(0.0, 0.0).EaseAll((ReorderingEasing ?? Easings.SlideDown1)).
                AdjustSpeed().Instance;

            sb.Completed += (sender, e) =>
            {
                sb.Stop();
                item.PositionAnimating = false;
            };
            SetItemPosition(item, targetPosition);
            item.PositionAnimating = true;
            sb.Begin();
        }
 protected virtual void DetachItemContainerEventHandlers(TileViewItem item)
 {
     item.TileStateChanged -= TileViewItemTileStateChanged;
     if (MaximizedItem == ItemContainerGenerator.ItemFromContainer(item))
     {
         MaximizedItem = null;
     }
 }
 protected virtual void AttachItemContainerEventHandlers(TileViewItem item)
 {
     item.TileStateChanged += TileViewItemTileStateChanged;
     if (item.TileState == TileViewItemState.Maximized)
     {
         MaximizedItem = ItemContainerGenerator.ItemFromContainer(item);
     }
 }
 private int CalculateItemIndex(TileViewItem item)
 {
     return ((Grid.GetRow(item)*_columns) + Grid.GetColumn(item));
 }
 private void AnimateItemPosition(TileViewItem item, Point targetPosition)
 {
     if (item.PositionAnimating)
     {
         return;
     }
     Point currentItemPosition = GetCurrentItemPosition(item);
     double num = targetPosition.X - currentItemPosition.X;
     double num2 = targetPosition.Y - currentItemPosition.Y;
     if (Equals(MaximizedItem, item))
     {
         int currentZIndex = TileViewItem.CurrentZIndex;
         TileViewItem.CurrentZIndex = currentZIndex + 1;
         Canvas.SetZIndex(item, currentZIndex);
     }
     double totalSeconds = ReorderingDuration.TimeSpan.TotalSeconds;
     var args = new double[4];
     args[1] = -num;
     args[2] = totalSeconds;
     var numArray2 = new double[4];
     numArray2[1] = -num2;
     numArray2[2] = totalSeconds;
     Storyboard sb =
         AnimationExtensions.Create().Animate(new FrameworkElement[] {item}).EnsureDefaultTransforms().MoveX(
             args).MoveY(numArray2).Origin(0.0, 0.0).EaseAll((ReorderingEasing ?? Easings.SlideDown1)).
             AdjustSpeed().Instance;
     sb.Completed += (sender, e) =>
                         {
                             sb.Stop();
                             item.PositionAnimating = false;
                         };
     SetItemPosition(item, targetPosition);
     item.PositionAnimating = true;
     sb.Begin();
 }
 private void AnimateItemSize(TileViewItem item, Size targetSize)
 {
     if (!item.SizeAnimating)
     {
         var size = new Size(item.ActualWidth, item.ActualHeight);
         item.Height = targetSize.Height;
         item.Width = targetSize.Width;
         double totalSeconds = ResizingDuration.TimeSpan.TotalSeconds;
         var args = new double[4];
         args[1] = size.Height;
         args[2] = totalSeconds;
         args[3] = targetSize.Height;
         var numArray2 = new double[4];
         numArray2[1] = size.Width;
         numArray2[2] = totalSeconds;
         numArray2[3] = targetSize.Width;
         Storyboard sb =
             AnimationExtensions.Create().Animate(new FrameworkElement[] {item}).EnsureDefaultTransforms().Height
                 (args).Width(numArray2).EaseAll((ResizingEasing ?? Easings.SlideDown1)).AdjustSpeed().Instance;
         sb.Completed += (sender, e) =>
                             {
                                 sb.Stop();
                                 item.SizeAnimating = false;
                             };
         item.SizeAnimating = true;
         sb.Begin();
     }
 }
 private int CalculateItemIndex(TileViewItem item)
 {
     return((Grid.GetRow(item) * _columns) + Grid.GetColumn(item));
 }
 private void UpdateRestoredItem(TileViewItem item)
 {
     SetItemPosition(item, GetRestoredItemPosition(item));
     SetItemSize(item, GetRestoredItemSize(item));
 }
 private void HandleTileViewItemRestored(TileViewItem item)
 {
     if (MaximizeMode != TileViewMaximizeMode.One)
     {
         MaximizedItem = null;
         foreach (TileViewItem item2 in GetGeneratedItemContainers())
         {
             item2.TileState = TileViewItemState.Restored;
         }
         if (IsItemsAnimationEnabled)
         {
             AnimateItemSizes();
             AnimateItemsLayout();
         }
         else
         {
             UpdateItemSizes();
             UpdateItemsLayout();
         }
     }
     else
     {
         item.TileState = TileViewItemState.Maximized;
     }
 }
 internal void OnItemDragging(TileViewItem draggedItem, MouseEventArgs e)
 {
     if (IsItemDraggingEnabled && CanDragItems())
     {
         CaptureMouse();
         _draggedContainer = draggedItem;
         LastDragPosition = e.GetPosition(null);
         int currentZIndex = TileViewItem.CurrentZIndex;
         TileViewItem.CurrentZIndex = currentZIndex + 1;
         Canvas.SetZIndex(_draggedContainer, currentZIndex);
         MouseMove += TileViewMouseMove;
         AddHandler(MouseLeftButtonUpEvent, new MouseButtonEventHandler(TileViewMouseLeftButtonUp), true);
     }
 }
 private Size GetMinimizedItemSize(TileViewItem item)
 {
     double num8;
     double num9;
     var generatedItemContainers = GetGeneratedItemContainers().ToList();
     int num = CountItemsWithGeneratedContainers();
     double num2 = generatedItemContainers
         .Where(i => i.MinimizedHeight > double.Epsilon)
         .Select(i => i.MinimizedHeight).Sum();
     double num3 = generatedItemContainers
         .Where(i => i.MinimizedWidth > double.Epsilon)
         .Select(i => i.MinimizedWidth).Sum();
     int num4 = num - generatedItemContainers.Count(i => i.MinimizedHeight > 0.0);
     int num5 = generatedItemContainers.Count(i => i.MinimizedWidth > 0.0);
     if (MaximizedItem != null)
     {
         var item2 = ItemContainerGenerator.ContainerFromItem(MaximizedItem) as TileViewItem;
         if ((item2 != null) && (item2.MinimizedWidth > double.Epsilon))
         {
             num3 -= item2.MinimizedWidth;
             num5++;
         }
         if ((item2 != null) && (item2.MinimizedHeight > double.Epsilon))
         {
             num2 -= item2.MinimizedHeight;
             num4++;
         }
     }
     double num6 = ActualWidth - num3;
     double num7 = ActualHeight - num2;
     bool isDockedTopBottom = (MinimizedItemsPosition == Dock.Bottom) || (MinimizedItemsPosition == Dock.Top);
     if (isDockedTopBottom)
     {
         num8 = ((num6/(num5 - 1)) - item.Margin.Left) - item.Margin.Right;
         num9 = (MinimizedRowHeight - item.Margin.Top) - item.Margin.Bottom;
     }
     else
     {
         num8 = (MinimizedColumnWidth - item.Margin.Left) - item.Margin.Right;
         num9 = ((num7/(num4 - 1)) - item.Margin.Top) - item.Margin.Bottom;
     }
     num8 = ((item.MinimizedWidth > 0.0) && isDockedTopBottom) ? item.MinimizedWidth : Math.Max(0.0, num8);
     return new Size(num8,
                     ((item.MinimizedHeight > 0.0) && !isDockedTopBottom)
                         ? item.MinimizedHeight
                         : Math.Max(0.0, num9));
 }
 private Point GetTargetItemPosition(TileViewItem item)
 {
     double x = Grid.GetColumn(item)*(ActualWidth/_columns);
     return new Point(x, Grid.GetRow(item)*(ActualHeight/_rows));
 }
 private Size GetItemSize(TileViewItem item)
 {
     if (MaximizedItem == null)
     {
         return GetRestoredItemSize(item);
     }
     var item2 = ItemContainerGenerator.ContainerFromItem(MaximizedItem) as TileViewItem;
     return Equals(item, item2) ? GetMaximizedItemSize(item) : GetMinimizedItemSize(item);
 }
 private static void SetItemPosition(TileViewItem item, Point position)
 {
     Canvas.SetLeft(item, position.X);
     Canvas.SetTop(item, position.Y);
 }
 private static void SetItemSize(TileViewItem item, Size itemSize)
 {
     item.Width  = itemSize.Width;
     item.Height = itemSize.Height;
 }
 private void UpdateRestoredItem(TileViewItem item)
 {
     SetItemPosition(item, GetRestoredItemPosition(item));
     SetItemSize(item, GetRestoredItemSize(item));
 }
        private Point GetTargetItemPosition(TileViewItem item)
        {
            double x = Grid.GetColumn(item) * (ActualWidth / _columns);

            return(new Point(x, Grid.GetRow(item) * (ActualHeight / _rows)));
        }
 private Size GetMaximizedItemSize(TileViewItem item)
 {
     double num = ((ActualWidth - MinimizedColumnWidth) - item.Margin.Left) - item.Margin.Right;
     double num2 = (ActualHeight - item.Margin.Top) - item.Margin.Bottom;
     if (MinimizedItemsPosition.Equals(Dock.Bottom) || MinimizedItemsPosition.Equals(Dock.Top))
     {
         num = (ActualWidth - item.Margin.Left) - item.Margin.Right;
         num2 = ((ActualHeight - MinimizedRowHeight) - item.Margin.Top) - item.Margin.Bottom;
     }
     num = Math.Max(0.0, num);
     return new Size(num, Math.Max(0.0, num2));
 }
 private static void SetItemPosition(TileViewItem item, Point position)
 {
     Canvas.SetLeft(item, position.X);
     Canvas.SetTop(item, position.Y);
 }
 private Size GetRestoredItemSize(TileViewItem item)
 {
     double num = ((ActualWidth/_columns) - item.Margin.Left) - item.Margin.Right;
     double num2 = ((ActualHeight/_rows) - item.Margin.Top) - item.Margin.Bottom;
     num = Math.Max(0.0, num);
     return new Size(num, Math.Max(0.0, num2));
 }
 private static void SetItemSize(TileViewItem item, Size itemSize)
 {
     item.Width = itemSize.Width;
     item.Height = itemSize.Height;
 }
 private void HandleTileViewItemMaximized(TileViewItem item)
 {
     int currentZIndex = TileViewItem.CurrentZIndex;
     TileViewItem.CurrentZIndex = currentZIndex + 1;
     Canvas.SetZIndex(item, currentZIndex);
     MaximizedItem = ItemContainerGenerator.ItemFromContainer(item);
     foreach (var item2 in GetGeneratedItemContainers())
     {
         if (!Equals(item2, item))
             item2.TileState = TileViewItemState.Minimized;
     }
     UpdateItemsSizeAndPosition();
     SetItemSize(item, GetMaximizedItemSize(item));
 }
 private bool ShouldAnimateItemPosition(TileViewItem item)
 {
     if (Equals(item, _draggedContainer))
     {
         return false;
     }
     Point currentItemPosition = GetCurrentItemPosition(item);
     Point targetItemPosition = GetTargetItemPosition(item);
     if (DoubleUtil.AreClose(targetItemPosition.X, currentItemPosition.X))
     {
         return !DoubleUtil.AreClose(targetItemPosition.Y, currentItemPosition.Y);
     }
     return true;
 }
 private bool IsItemMaximizedByDefault(TileViewItem item)
 {
     if (((MaximizeMode != TileViewMaximizeMode.One) || (MaximizedItem != null)) &&
         (item.TileState != TileViewItemState.Maximized))
     {
         return (MaximizedItem == ItemContainerGenerator.ItemFromContainer(item));
     }
     return true;
 }
 private bool ShouldSwapWithItem(TileViewItem item, Point currentPoint)
 {
     Point absolutePosition = currentPoint;
     Point relativeMousePosition = GetRelativeMousePosition(absolutePosition);
     int currentRow = GetCurrentRow(relativeMousePosition);
     int currentColumn = GetCurrentColumn(relativeMousePosition);
     int row = Grid.GetRow(item);
     int column = Grid.GetColumn(item);
     bool flag = IsMouseOverVisual(absolutePosition, item);
     if (((Equals(item, _draggedContainer)) || !flag) || item.PositionAnimating)
     {
         return false;
     }
     if (column != currentColumn)
     {
         return (row == currentRow);
     }
     return true;
 }
 private void TileViewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
 {
     _draggedContainer = null;
     MouseMove -= TileViewMouseMove;
     MouseLeftButtonUp -= TileViewMouseLeftButtonUp;
     ReleaseMouseCapture();
     UpdateItemsLayout();
 }
 private void SwapItems(TileViewItem itemToSwapWith)
 {
     int column = Grid.GetColumn(itemToSwapWith);
     int row = Grid.GetRow(itemToSwapWith);
     Grid.SetColumn(itemToSwapWith, Grid.GetColumn(_draggedContainer));
     Grid.SetRow(itemToSwapWith, Grid.GetRow(_draggedContainer));
     Grid.SetColumn(_draggedContainer, column);
     Grid.SetRow(_draggedContainer, row);
     if (IsItemsAnimationEnabled)
     {
         AnimateItemsLayout();
     }
     else
     {
         UpdateItemsLayout();
     }
 }