备份一个 VirtualizingWrapPanel ，支持虚拟化

最新推荐文章于 2022-09-20 07:36:36 发布
最新推荐文章于 2022-09-20 07:36:36 发布
阅读量278 收藏 1
点赞数
分类专栏： wpf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010438205/article/details/105736457
版权 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;

namespace Cal.Wpf.Controls
{
    /// <summary>
    /// 方块模式的布局，支持虚拟化
    /// ScrollOffset 每次滚动的距离
    /// <local:VirtualizingWrapPanel ScrollOffset="50" ChildHeight="200" ChildWidth="200"/>
    /// </summary>
    public class VirtualizingWrapPanel : VirtualizingPanel, IScrollInfo
    {
        #region 变量
        private TranslateTransform trans = new TranslateTransform();
        #endregion

        #region 构造函数
        public VirtualizingWrapPanel()
        {
            this.RenderTransform = trans;
        }
        #endregion

        #region 附加属性
        public static readonly DependencyProperty ChildWidthProperty = DependencyProperty.RegisterAttached("ChildWidth", typeof(double), typeof(VirtualizingWrapPanel), new FrameworkPropertyMetadata(200.0, FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsArrange));

        public static readonly DependencyProperty ChildHeightProperty = DependencyProperty.RegisterAttached("ChildHeight", typeof(double), typeof(VirtualizingWrapPanel), new FrameworkPropertyMetadata(200.0, FrameworkPropertyMetadataOptions.AffectsMeasure | FrameworkPropertyMetadataOptions.AffectsArrange));

        public static readonly DependencyProperty ScrollOffsetProperty = DependencyProperty.RegisterAttached("ScrollOffset", typeof(int), typeof(VirtualizingWrapPanel), new PropertyMetadata(10));

        /// <summary>
        /// 鼠标每一次滚动 UI上的偏移
        /// </summary>
        public int ScrollOffset
        {
            get { return Convert.ToInt32(GetValue(ScrollOffsetProperty)); }
            set { SetValue(ScrollOffsetProperty, value); }
        }

        /// <summary>
        /// 元素宽度
        /// </summary>
        public double ChildWidth
        {
            get => Convert.ToDouble(GetValue(ChildWidthProperty));
            set => SetValue(ChildWidthProperty, value);
        }

        /// <summary>
        /// 元素高度
        /// </summary>
        public double ChildHeight
        {
            get => Convert.ToDouble(GetValue(ChildHeightProperty));
            set => SetValue(ChildHeightProperty, value);
        }
        #endregion

        #region 私有方法


        int GetItemCount(DependencyObject element)
        {
            var itemsControl = ItemsControl.GetItemsOwner(element);
            return itemsControl.HasItems ? itemsControl.Items.Count : 0;
        }

        int CalculateChildrenPerRow(Size availableSize)
        {
            int childPerRow = 0;
            if (availableSize.Width == double.PositiveInfinity)
                childPerRow = this.Children.Count;
            else
                childPerRow = Math.Max(1, Convert.ToInt32(Math.Floor(availableSize.Width / this.ChildWidth)));
            return childPerRow;
        }

        /// <summary>
        /// width不超过availableSize的情况下，自身实际需要的Size(高度可能会超出availableSize)
        /// </summary>
        /// <param name="availableSize"></param>
        /// <param name="itemsCount"></param>
        /// <returns></returns>
        Size CalculateExtent(Size availableSize, int itemsCount)
        {
            int childPerRow = CalculateChildrenPerRow(availableSize);//现有宽度下 一行可以最多容纳多少个
            return new Size(childPerRow * this.ChildWidth, this.ChildHeight * Math.Ceiling(Convert.ToDouble(itemsCount) / childPerRow));
        }

        /// <summary>
        /// 更新滚动条
        /// </summary>
        /// <param name="availableSize"></param>
        void UpdateScrollInfo(Size availableSize)
        {
            var extent = CalculateExtent(availableSize, GetItemCount(this));//extent 自己实际需要
            if (extent != this.extent)
            {
                this.extent = extent;
                this.ScrollOwner.InvalidateScrollInfo();
            }
            if (availableSize != this.viewPort)
            {
                this.viewPort = availableSize;
                this.ScrollOwner.InvalidateScrollInfo();
            }
        }

        /// <summary>
        /// 获取所有item，在可视区域内第一个item和最后一个item的索引
        /// </summary>
        /// <param name="firstIndex"></param>
        /// <param name="lastIndex"></param>
        void GetVisiableRange(ref int firstIndex, ref int lastIndex)
        {
            int childPerRow = CalculateChildrenPerRow(this.extent);
            firstIndex = Convert.ToInt32(Math.Floor(this.offset.Y / this.ChildHeight)) * childPerRow;
            lastIndex = Convert.ToInt32(Math.Ceiling((this.offset.Y + this.viewPort.Height) / this.ChildHeight)) * childPerRow - 1;
            int itemsCount = GetItemCount(this);
            if (lastIndex >= itemsCount)
                lastIndex = itemsCount - 1;

        }

        /// <summary>
        /// 将不在可视区域内的item 移除
        /// </summary>
        /// <param name="startIndex">可视区域开始索引</param>
        /// <param name="endIndex">可视区域结束索引</param>
        void CleanUpItems(int startIndex, int endIndex)
        {
            var children = this.InternalChildren;
            var generator = this.ItemContainerGenerator;
            for (int i = children.Count - 1; i >= 0; i--)
            {
                var childGeneratorPosi = new GeneratorPosition(i, 0);
                int itemIndex = generator.IndexFromGeneratorPosition(childGeneratorPosi);

                if (itemIndex < startIndex || itemIndex > endIndex)
                {

                    generator.Remove(childGeneratorPosi, 1);
                    RemoveInternalChildRange(i, 1);
                }
            }
        }

        /// <summary>
        /// scroll/availableSize/添加删除元素 改变都会触发  edit元素不会改变
        /// </summary>
        /// <param name="availableSize"></param>
        /// <returns></returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            this.UpdateScrollInfo(availableSize);//availableSize更新后，更新滚动条
            int firstVisiableIndex = 0, lastVisiableIndex = 0;
            GetVisiableRange(ref firstVisiableIndex, ref lastVisiableIndex);//availableSize更新后，获取当前viewport内可放置的item的开始和结束索引  firstIdnex-lastIndex之间的item可能部分在viewport中也可能都不在viewport中。

            UIElementCollection children = this.InternalChildren;//因为配置了虚拟化，所以children的个数一直是viewport区域内的个数,如果没有虚拟化则是ItemSource的整个的个数
            IItemContainerGenerator generator = this.ItemContainerGenerator;
            //获得第一个可被显示的item的位置
            GeneratorPosition startPosi = generator.GeneratorPositionFromIndex(firstVisiableIndex);
            int childIndex = (startPosi.Offset == 0) ? startPosi.Index : startPosi.Index + 1;//startPosi在chilren中的索引
            using (generator.StartAt(startPosi, GeneratorDirection.Forward, true))
            {
                int itemIndex = firstVisiableIndex;
                while (itemIndex <= lastVisiableIndex)//生成lastVisiableIndex-firstVisiableIndex个item
                {
                    bool newlyRealized = false;
                    var child = generator.GenerateNext(out newlyRealized) as UIElement;
                    if (newlyRealized)
                    {
                        if (childIndex >= children.Count)
                            base.AddInternalChild(child);
                        else
                        {
                            base.InsertInternalChild(childIndex, child);
                        }
                        generator.PrepareItemContainer(child);
                    }
                    else
                    {
                        //处理 正在显示的child被移除了这种情况
                        if (!child.Equals(children[childIndex]))
                        {
                            base.RemoveInternalChildRange(childIndex, 1);
                        }
                    }
                    child.Measure(new Size(this.ChildWidth, this.ChildHeight));
                    //child.DesiredSize//child想要的size
                    itemIndex++;
                    childIndex++;
                }
            }
            CleanUpItems(firstVisiableIndex, lastVisiableIndex);
            return new Size(double.IsInfinity(availableSize.Width) ? 0 : availableSize.Width, double.IsInfinity(availableSize.Height) ? 0 : availableSize.Height);//自身想要的size
        }

        protected override Size ArrangeOverride(Size finalSize)
        {
            Debug.WriteLine("----ArrangeOverride");
            var generator = this.ItemContainerGenerator;
            UpdateScrollInfo(finalSize);
            int childPerRow = CalculateChildrenPerRow(finalSize);
            double availableItemWidth = finalSize.Width / childPerRow;
            for (int i = 0; i <= this.Children.Count - 1; i++)
            {
                var child = this.Children[i];
                int itemIndex = generator.IndexFromGeneratorPosition(new GeneratorPosition(i, 0));
                int row = itemIndex / childPerRow;//current row
                int column = itemIndex % childPerRow;
                double xCorrdForItem = 0;

                xCorrdForItem = column * availableItemWidth + (availableItemWidth - this.ChildWidth) / 2;

                Rect rec = new Rect(xCorrdForItem, row * this.ChildHeight, this.ChildWidth, this.ChildHeight);
                child.Arrange(rec);
            }
            return finalSize;
        }

        protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
        {
            base.OnRenderSizeChanged(sizeInfo);
            this.SetVerticalOffset(this.VerticalOffset);
        }

        protected override void OnClearChildren()
        {
            base.OnClearChildren();
            this.SetVerticalOffset(0);
        }

        protected override void BringIndexIntoView(int index)
        {
            if (index < 0 || index >= Children.Count)
                throw new ArgumentOutOfRangeException();
            int row = index / CalculateChildrenPerRow(RenderSize);
            SetVerticalOffset(row * this.ChildHeight);
        }

        #endregion

        #region IScrollInfo Interface
        public bool CanVerticallyScroll { get; set; }
        public bool CanHorizontallyScroll { get; set; }

        private Size extent = new Size(0, 0);
        public double ExtentWidth => this.extent.Width;

        public double ExtentHeight => this.extent.Height;

        private Size viewPort = new Size(0, 0);
        public double ViewportWidth => this.viewPort.Width;

        public double ViewportHeight => this.viewPort.Height;

        private Point offset;
        public double HorizontalOffset => this.offset.X;

        public double VerticalOffset => this.offset.Y;

        public ScrollViewer ScrollOwner { get; set; }

        public void LineDown()
        {
            this.SetVerticalOffset(this.VerticalOffset + this.ScrollOffset);
        }

        public void LineLeft()
        {
            throw new NotImplementedException();
        }

        public void LineRight()
        {
            throw new NotImplementedException();
        }

        public void LineUp()
        {
            this.SetVerticalOffset(this.VerticalOffset - this.ScrollOffset);
        }

        public Rect MakeVisible(Visual visual, Rect rectangle)
        {
            return new Rect();
        }

        public void MouseWheelDown()
        {
            this.SetVerticalOffset(this.VerticalOffset + this.ScrollOffset);
        }

        public void MouseWheelLeft()
        {
            throw new NotImplementedException();
        }

        public void MouseWheelRight()
        {
            throw new NotImplementedException();
        }

        public void MouseWheelUp()
        {
            this.SetVerticalOffset(this.VerticalOffset - this.ScrollOffset);
        }

        public void PageDown()
        {
            this.SetVerticalOffset(this.VerticalOffset + this.viewPort.Height);
        }

        public void PageLeft()
        {
            throw new NotImplementedException();
        }

        public void PageRight()
        {
            throw new NotImplementedException();
        }

        public void PageUp()
        {
            this.SetVerticalOffset(this.VerticalOffset - this.viewPort.Height);
        }

        public void SetHorizontalOffset(double offset)
        {
            throw new NotImplementedException();
        }

        public void SetVerticalOffset(double offset)
        {
            if (offset < 0 || this.viewPort.Height >= this.extent.Height)
                offset = 0;
            else
                if (offset + this.viewPort.Height >= this.extent.Height)
                offset = this.extent.Height - this.viewPort.Height;

            this.offset.Y = offset;
            this.ScrollOwner?.InvalidateScrollInfo();
            this.trans.Y = -offset;
            this.InvalidateMeasure();
            //接下来会触发MeasureOverride()
        }
        #endregion
    }
}

 

吃奶嘴的路飞
关注
专栏目录
VMware 虚拟化编程(13) — VMware 虚拟机的备份方案设计
烟云的计算
10-22 3415
目录目录 前文列表 备份思路 备份算法 备份细节 连接到 vCenter 还是 ESXi 如何选择快照类型 是否开启 CBT 如何获取备份数据 如何提高备份数据的传输率前文列表VMware 虚拟化编程(1) — VMDK/VDDK/VixDiskLib/VADP 概念简析 VMware 虚拟化编程(2) — 虚拟磁盘文件类型详解 VMware 虚拟化编程(3) —VMware vSphere W
VMware 虚拟化编程(11) — VMware 虚拟机的全量备份与增量备份方案
烟云的计算
10-21 4267
目录目录 前文列表 全量备份数据的获取方式 增量备份数据的获取过程前文列表VMware 虚拟化编程(1) — VMDK/VDDK/VixDiskLib/VADP 概念简析 VMware 虚拟化编程(2) — 虚拟磁盘文件类型详解 VMware 虚拟化编程(3) —VMware vSphere Web Service API 解析 VMware 虚拟化编程(4) — VDDK 安装 VMwar
WPF图片列表实现
09-30
WPF ListBox绑定图片列表示例代码，演示图片添加、删除等。
【WPF】UI虚拟化之------自定义VirtualizingWrapPanel
catshitone的专栏
12-15 7337
前言前几天QA报了一个关于OOM的bug，在排查的过程中发现，ListBox控件中被塞入了过多的Item，而ListBox又定义了两种样式的ItemsPanelTemplate。一种用的是虚拟化的VirtualizingStackPanel，另一种没有考虑虚拟化用的是WrapPanel。所以当ListBox切换到第二种Template，而且有很多Item的时候，内存就爆掉然后直接挂了。然后就想着有没
VirtualizingWrapPanel:WPF运行.NET Framework 4.5+或.NET Core 3.0+的VirtualizingWrapPanel的实现
05-16
虚拟化包装面板 为运行.NET Framework 4.5+或.NET Core 3.0+的WPF实现VirtualizingWrapPanel和基于它的一些其他控件。 特征 水平和垂直方向 按页面，项目或像素缓存 集装箱回收 分组（实验性） GridView控件（易于使用的开箱即用体验） GridDetailsView控件（带有项目扩展的网格视图） VirtualizingItemsControl 资源 下载
WPF技术触屏上的应用系列（五）: 图片列表异步加载、手指进行缩小、放大、拖动 、惯性滑入滑出等效果...
weixin_34055787的博客
04-10 511
原文: WPF技术触屏上的应用系列（五）: 图片列表异步加载、手指进行缩小、放大、拖动 、惯性滑入滑出等效果         去年某客户单位要做个大屏触屏应用，要对档案资源进行展示之用。客户端是Window7操作系统，54寸大屏电脑电视一体机。要求有很炫的展示效果，要有一定的视觉冲击力，可触控操作。当然满足客户的要求也可以有其它途径。但鉴于咱是搞 .NE...
【WPF】UI虚拟化之------自定义VirtualizingWrapPanel-附件资源
03-02
【WPF】UI虚拟化之------自定义VirtualizingWrapPanel-附件资源
浅议云计算环境下的服务器虚拟化与备份技术.pdf
07-17
服务器虚拟化是云计算的一个核心支撑技术，它涉及在物理服务器上建立多个虚拟机，这些虚拟机可以在同一物理服务器上共存，而彼此之间保持独立。虚拟化技术的出现显著提高了资源的利用率和灵活性，使得虚拟服务器的...
VMware vsphere6.7 虚拟化完整详细配置手册
12-05
版本号中的每一个数字都代表了特定的含义，它能够反映软件的新功能、性能改进、安全更新以及对硬件平台的支持。 2. vCenter Server：vCenter Server是管理vSphere环境的核心组件。它负责集中管理多个ESXi主机和...
一个开源的系统虚拟化模块------KVM虚拟机
ZhangPengFeiToWinner的博客
03-13 5248
1.首先我们简单的了解以下什么是KVM: KVM是Kernel-based Virtual Machine(基于内核的虚拟机)的简称，是一个开源的系统虚拟化模块，自Linux 2.6.20之后集成在Linux的各个主要发行版本中。它使用Linux自身的调度器进行管理，所以相对于Xen，其核心源码很少。KVM目前已成为学术界的主流VMM之一。 KVM的虚拟化需要硬件支持（如Intel VT技术或者A...
WPF 滑动界面（图片列表）
01-21
WOF 界面滑动，画片列表触摸，鼠标滑动
WPF加载和分页显示的图片列表，可多选，带水纹特效
06-02
截图效果地址：https://blog.csdn.net/XING861000/article/details/80549069 WPF加载和分页显示的图片列表，可多选，带水纹特效，效果非常好，编译前可以自己修改默认加载图片路径
wpf WrapPanel虚拟化
09-29
网上找了个虚拟化的WrapPanel，自己又改了下，可以设置每个Item的大小，上下间距，每次的滚动距离。
WrapPanel 实现虚拟化
dotNET跨平台
09-20 234
WrapPanel 实现虚拟化控件名：VirtualizingWrapPanel作者：WPFDevelopersOrg原文链接： https://github.com/WPFDevelopersOrg/WPFDevelopers框架使用大于等于.NET40；Visual Studio 2022;项目使用 MIT 开源许可协议；众所周知 WPF 的 StackPanel 在加载大量数据时性...
WPF自定义控件与样式(12)-缩略图ThumbnailImage /gif动画图/图片列表
weixin_34268843的博客
12-01 163
一．前言 　　申明：WPF自定义控件与样式是一个系列文章，前后是有些关联的，但大多是按照由简到繁的顺序逐步发布的等，若有不明白的地方可以参考本系列前面的文章，文末附有部分文章链接。 　　本文主要针对WPF项目开发中图片的各种使用问题，经过总结，把一些经验分享一下。内容包括： WPF常用图像数据源ImageSource的创建； 自定义缩略图控件ThumbnailImage，支持...
WPF 虚拟化 VirtualizingWrapPanel 和 VirtualLizingTilePanel
weixin_33933118的博客
11-01 210
一、 UI  上两个扩展 public class VirtualizingWrapPanel : VirtualizingPanel, IScrollInfo { #region Fields UIElementCollection _children; ItemsControl _itemsControl; ...
【WPF学习手记】显示图片列表
Taosy
07-29 7282
目的：制作一个图片列表，单击图片触发对应事件。 效果图 xaml代码 <Window x:Class="WPF_ImageList.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.micro...
WPF ListBox绑定图片列表
sdhongjun的专栏
09-30 5332
1.图片列表定义 图片列表使用BindingList而不使用List，因List未实现绑定相关联操作，在用户改变列表时无法更改ListBox中的内容。 工程添加System.ComponentModel;引用来引入BindingList。 2.XAML绑定代码 &lt;ListBox Grid.Row="1" Name="lbImgs" VerticalAlignment="Stretch" Sc...
备份一体机备份vmware虚拟化
最新发布
05-08
备份一体机是一种能够在一个设备上同时实现备份、存储、恢复等功能的设备，可以有效地保护企业数据的安全。而备份虚拟化环境中的VMware虚拟机，通常需要使用特定的虚拟化备份软件，支持对虚拟机进行全量备份、增量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值