(转).NET 不规则、可改变大小、边框半透明窗体设计

最新推荐文章于 2023-10-31 13:27:06 发布
最新推荐文章于 2023-10-31 13:27:06 发布
阅读量804 收藏
点赞数
分类专栏： c#

出处：http://www.cnblogs.com/liutao409/archive/2010/11/01/1866104.html

    做.NET WinForm的开发也有一段时间了，对.NET的界面设计也有了一定的了解。自认为自己学的这些东西都是网上看高手们的东西后总结出来的，第一次把这些东西写出来。

不好的地方请大家多多指教。

    大家先看一下做出来的效果吧！

 

网上也看过很多做.NET窗体的例子，我只是把网上的这些东西综合了一下，主要有下面这些特点：

1、边框是半透明的，透明度可根据需要自己更改；

2、可以改变窗体的大小，改变后样式不变；

3、窗体的边框是不规则的；

4、重点解决了窗体会出现闪烁的问题，在窗体移动的时候也不会闪烁；

5、使用方便，只要将AlphaFormPanel拖动到一般的窗体上就可以实现换肤；

 

设计思路说明：

一、.NET下处理一个窗体部分透明我所知道的有两种方法：

      1、用一张支持Alhpa通道的图片来处理半透明，这种方式处理出来的效果会很好，甚至可以用一张动态的图片来做背景。

           相信有人看过那个游动的鱼的程序，鱼的边缘是半透明的，就是用这种方式做的。这种方式整个窗体都是通过UpdateLayeredWindow画

           出来的，如果要在上面加控件的话，所有的控件都要自己来绘制，显然在具体的项目中用这种方式的话会大大增加开发的

           难度。有兴趣的人可以看看这个程序：

          /Files/liutao409/游动的鱼.rar

          关键的代码就是根据这种支持Alhpa通道的图片来绘制窗体

              [DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
              public static extern int UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref Point pptDst, ref Size psize,

                                      IntPtr hdcSrc, ref Point pptSrc, Int32 crKey, ref  BLENDFUNCTION pblend, Int32 dwFlags);

         public void SetBits(Bitmap bitmap)
        {
            if (!haveHandle) return;

            if (!Bitmap.IsCanonicalPixelFormat(bitmap.PixelFormat) || !Bitmap.IsAlphaPixelFormat(bitmap.PixelFormat))
                throw new ApplicationException("图片必须是32位带Alhpa通道的图片。");

            IntPtr oldBits = IntPtr.Zero;
            IntPtr screenDC = Win32.GetDC(IntPtr.Zero);
            IntPtr hBitmap = IntPtr.Zero;
            IntPtr memDc = Win32.CreateCompatibleDC(screenDC);

            try
            {
                Win32.Point topLoc = new Win32.Point(Left, Top);
                Win32.Size bitMapSize = new Win32.Size(bitmap.Width, bitmap.Height);
                Win32.BLENDFUNCTION blendFunc = new Win32.BLENDFUNCTION();
                Win32.Point srcLoc = new Win32.Point(0, 0);

                hBitmap = bitmap.GetHbitmap(Color.FromArgb(0));
                oldBits = Win32.SelectObject(memDc, hBitmap);

                blendFunc.BlendOp = Win32.AC_SRC_OVER;
                blendFunc.SourceConstantAlpha = 255;
                blendFunc.AlphaFormat = Win32.AC_SRC_ALPHA;
                blendFunc.BlendFlags = 0;

                Win32.UpdateLayeredWindow(Handle, screenDC, ref topLoc, ref bitMapSize, memDc, ref srcLoc, 0, ref blendFunc, Win32.ULW_ALPHA);
            }
            finally
            {
                if (hBitmap != IntPtr.Zero)
                {
                    Win32.SelectObject(memDc, oldBits);
                    Win32.DeleteObject(hBitmap);
                }
                Win32.ReleaseDC(IntPtr.Zero, screenDC);
                Win32.DeleteDC(memDc);
            }
        }

 

      2、用两个窗体来实现边框半透明

                后面的窗体用来做边框，前面的窗体放其他的控件，前面的窗体跟随后面的窗体移动和改变大小，这样就很容易的控制后面的窗体

          半透明显示。这种方式虽然麻烦一点，但是不用像第一种方式那样自己绘制所有的控件，所以还是可以在项目中使用的。我的这个

          例子用的就是这种方式实现的。

 二、窗体边框的处理

               我的窗体的边框是用图片来处理的，为了使窗体的边框在改变大小后的样式不改变，上下边框做成了3段式的，中间部分平铺，两端保持不变

          这样窗体任意缩放后样式都不会改变。如果对GDI+熟悉的话，也可以不用图片来处理，直接绘制渐变填充也可以。我重写的承载图片的PictureBox，

          让PictureBox将所有的消息都传给父窗体来处理，这样就可以由父窗体统一的处理窗体的缩放和移动了，具体的代码如下：

 

      

    public partial class PictureBoxEX : PictureBox
    {
        public delegate void delSetFormSize(int intInfo);
        public event delSetFormSize evtSetFormSize;

        #region 属性
        private bool _bTopLeft = false;
        public bool BTopLeft
        {
            get { return _bTopLeft; }
            set { _bTopLeft = value; }
        }

        private bool _bTop = false;
        public bool BTop
        {
            get { return _bTop; }
            set { _bTop = value; }
        }

        private bool _bTopRight = false;
        public bool BTopRight
        {
            get { return _bTopRight; }
            set { _bTopRight = value; }
        }

        private bool _bLeft = false;
        public bool BLeft
        {
            get { return _bLeft; }
            set { _bLeft = value; }
        }

        private bool _bBottomLeft = false;
        public bool BBottomLeft
        {
            get { return _bBottomLeft; }
            set { _bBottomLeft = value; }
        }

        private bool _bBottom = false;
        public bool BBottom
        {
            get { return _bBottom; }
            set { _bBottom = value; }
        }

        private bool _bRight = false;
        public bool BRight
        {
            get { return _bRight; }
            set { _bRight = value; }
        }

        private bool _bBottomRight = false;
        public bool BBottomRight
        {
            get { return _bBottomRight; }
            set { _bBottomRight = value; }
        }
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public PictureBoxEX()
        {
            ;
        }
        #endregion

        #region 重新鼠标消息
        const int WM_NCHITTEST = 0x0084;
        const int HTTRANSPARENT = -1;
        const int HTLEFT = 10;
        const int HTRIGHT = 11;
        const int HTTOP = 12;
        const int HTTOPLEFT = 13;
        const int HTTOPRIGHT = 14;
        const int HTBOTTOM = 15;
        const int HTBOTTOMLEFT = 0x10;
        const int HTBOTTOMRIGHT = 17;

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);
            switch (m.Msg)
            {
                case WM_NCHITTEST:
                    Point vPoint = new Point((int)m.LParam & 0xFFFF,
                        (int)m.LParam >> 16 & 0xFFFF);
                    vPoint = PointToClient(vPoint);
                    int intInfo = -1;
                    if (_bTopLeft)
                    {
                        if (vPoint.X <= 10)
                        {
                            intInfo = HTTOPLEFT;
                        }
                    }
                    else if (_bLeft)
                    {
                        intInfo = HTLEFT;
                    }
                    else if (_bBottomLeft)
                    {
                        intInfo = HTBOTTOMLEFT;
                    }
                    else if (_bBottom)
                    {
                        intInfo = HTBOTTOM;
                    }
                    else if (_bBottomRight)
                    {
                        intInfo = HTBOTTOMRIGHT;
                    }
                    else if (_bRight)
                    {
                        intInfo = HTRIGHT;
                    }
                    else if (_bTopRight)
                    {
                        if (vPoint.X >= ClientSize.Width - 10)
                        {
                            intInfo = HTTOPRIGHT;
                        }
                    }
                    else if (_bTop)
                    {
                        if (vPoint.Y <= 5)
                        {
                            m.Result = (IntPtr)HTTOP;
                            intInfo = HTTOP;
                        }
                    }

                    if (evtSetFormSize != null && intInfo != -1)
                    {
                        evtSetFormSize(intInfo);
                    }
                    //将消息传给父窗体来处理
                    m.Result = (IntPtr)HTTRANSPARENT;
                    break;
            }
        }
        #endregion
    }

 

关键代码说明：

一、用到的消息

        private const int WM_NCLBUTTONDBLCLK = 0x00A3;
        private int _intInfo = -1;       //消息回传值
        private const int HTLEFT = 10;
        private const int HTRIGHT = 11;
        private const int HTTOP = 12;
        private const int HTTOPLEFT = 13;
        private const int HTTOPRIGHT = 14;
        private const int HTBOTTOM = 15;
        private const int HTBOTTOMLEFT = 0x10;
        private const int HTBOTTOMRIGHT = 17;
        private const int WM_NCHITTEST = 0x84;
        private const int HTCLIENT = 0x01;
        private const int HTCAPTION = 0x02;

1、改变窗体大小和移动窗体的位置    

      所有的和边框有关的消息都传到后面的窗体的处理，承载边框的PictureBoxEx 会将传给它的系统消息忽略掉

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_NCHITTEST)
            {
                this.DefWndProc(ref m);

                //移动窗体位置
                if (m.Result.ToInt32() == HTCLIENT && this.WindowState != FormWindowState.Maximized)
                {
                    m.Result = new IntPtr(HTCAPTION);
                }
                else
                {
                    base.WndProc(ref m);
                }
                //改变窗体大小
                if (ChangeFormSize && _intInfo != -1 && this.WindowState != FormWindowState.Maximized)
                {
                    m.Result = (IntPtr)_intInfo;
                }
                _intInfo = -1;
            }
            //双击鼠标左键的消息
            else if (m.Msg == WM_NCLBUTTONDBLCLK)
            {
                if (ChangeFormSize)
                {
                    //相当于单击一次最大化按钮
                    btnMax_MouseClick(null, EventArgs.Empty);
                }
            }
            else
            {
                base.WndProc(ref m);
            }
        }

2、减少窗体闪烁       

        下面的是比较常见的减少窗体闪烁的方法

        private void SetStyles()
        {
                SetStyle(
                ControlStyles.UserPaint |
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw |
                ControlStyles.SupportsTransparentBackColor, true);
            SetStyle(ControlStyles.Selectable, false);
            UpdateStyles();
        }

       还可以设置窗体双缓存在减少闪烁

         this.DoubleBuffered = true;

       在窗体控件的创建过程中，如果控件过多的话，用下面这个函数来处理控件的创建也可以减少闪烁

    public class AvoidControlFlicker
    {
        private int _paintFrozen;
        public void FreezePainting(Control toFreezeControl, bool isToFreeze)
        {
            if (null == toFreezeControl)
                throw new ArgumentNullException("toFreezeControl");

            if (isToFreeze && toFreezeControl.IsHandleCreated && toFreezeControl.Visible)
            {
                if (0 == _paintFrozen++)
                {
                    NativeMethods.SendMessage(toFreezeControl.Handle, NativeConsts.WM_SETREDRAW, 0, 0);
                }
            }
            if (!isToFreeze)
            {
                if (0 == _paintFrozen) return;
                if (0 == --_paintFrozen)
                {
                    NativeMethods.SendMessage(toFreezeControl.Handle, NativeConsts.WM_SETREDRAW, 1, 0);
                    toFreezeControl.Invalidate(true);
                }
            }
        }
    }

3、为了给初学者提供一些帮助，其它一些处理函数也写出来

        /// <summary>
        /// 窗体位置改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void formStyle_LocationChanged(object sender, EventArgs e)
        {
            if (PForm != null)
            {

                //同时改变前面的子窗体的位置
                CForm.Location = new Point(this.Location.X + pbLeft.Width, this.Location.Y + panelTop.Height);
                CForm.Update();
            }
        }

 

        /// <summary>
        /// 关闭按钮单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

       private void btnExit_MouseClick(object sender, EventArgs e)
        {
            this.Close();
        }

 

       //关闭窗体时要同时关闭窗体所在的父窗体

        protected override void OnClosing(CancelEventArgs e)
        {
            e.Cancel = true;
            base.OnClosing(e);
            Owner.Close();
        }

 

        /// <summary>
        /// 最大化按钮单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnMax_MouseClick(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Maximized)
            {            
                this.WindowState = FormWindowState.Normal;
                this.Opacity = FormOpacity;
            }
            else
            {
                this.WindowState = FormWindowState.Maximized;
                this.Opacity = 1;
            }
        }

 

        /// <summary>
        /// 最小化按钮单击事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnMin_MouseClick(object sender, EventArgs e)
        {
            this.WindowState = FormWindowState.Minimized;
        }

 

        /// <summary>
        /// 窗体大小改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void formStyle_SizeChanged(object sender, EventArgs e)
        {
            if (PForm != null)
            {

                //同时改变子窗体的大小
                CForm.Size = new Size(this.Size.Width - pbLeft.Width - pbRight.Width, this.Size.Height - panelTop.Height - panelBottom.Height);
            }
        }

 

最后，提供一下这个控件以及示例代码给大家下载：

/Files/liutao409/边框半透明窗体.rar


_lee_chong
关注
专栏目录
Kotlin - 单例、伴生对象、对象表达式 object
HugMua的博客
05-17 4452
Kotlin却极度弱化了静态方法这个概念，提供了比静态方法更好用的语法特性，同样是通过【类名.函数名】来调用。适合写“全是静态方法的工具类”。假设定义顶层函数 method() 的文件名为 Helper.kt，编译器会创建一个 HelperKt.java，在Java中就可以 HelperKt.method() 调用了。
kotlin中companion object关键字
zhangmiaoping23的专栏
02-17 1125
转：kotlin中object和companion object关键字_鸿鹄的博客-CSDN博客_companion object 1.2 companion object companion object 修饰为伴生对象,伴生对象在类中只能存在一个，类似于java中的静态方法 Java 中使用类访问静态成员，静态方法。 companion object { private val TAG = "DemoManager" fun b() { Log.e(TAG,"
一篇文章搞明白Kotlin的companion object
热门推荐
华 英雄
05-08 1万+
很多人简单的Kotlin的object简单理解为静态。 一般情况下是没有问题的， 但是更准确的理解是object修饰的类是Singleton（单例）。 在类的内部object 前加上 companion， 可以做成属于这个类的Singleton。 class Hoge { object A { val fizz = "fizz" fun foo() { ... } } companion object { val buzz = "buzz" f.
java 根据类名示例化类_Java类类getEnclosingMethod（）方法及示例
cumt30111的博客
06-30 1227
java 根据类名示例化类 类类getEnclosingMethod()方法 (Class class getEnclosingMethod() method) getEnclosingMethod() method is available in java.lang package. getEnclosingMethod()方法在java.lang包中可用。 getEnclosingMethod...
Kotlin 静态内部类单例模式的正确实现方式
qq_40987010的博客
01-14 5486
本篇是对现网上流传的 Kotlin 实现静态内部类单例模式的纠正，为了把原理说清楚，文章前奏可能会有些长，熟悉静态内部类单例模式原理的朋友，可以直接跳转到文章最后，直接看结果即可。 最近在整理基础库的时候，需要一个基础类来存储初始化的数据，例如应用的 Application Context，用户的登录 token 等等信息，这些基本都是应用全局类的信息，在应用的整个生命周期都会用到，因此我将这个基础类设计为单例模式来优化性能。 我知道的单例模式就有6钟，饿汉式、懒汉式、线程安全的懒汉式，volatile.
kotlin-object关键字与单例模式
大模型学习路线
01-12 2704
`object` 关键字有三种不同的语义：匿名内部类、伴生对象、单例模式。因为 Kotlin 的设计者认为，这三种语义本质上都是在***定义一个类的同时还创建了对象***。在这样的情况下，与其分别定义三种不同的关键字，还不如将它们统一成 `object` 关键字。
Kotlin实现单例模式
heweigzf的博客
07-24 873
前言 前三篇主要讲了下Kotlin语言的基本用法，以后在写关于Kotlin文章的时候可以java和Kotlin一起写，对比起来看会比较好。这篇文章主要讲一下Kotlin中单例模式的用法，主要以代码为主。 1.饿汉式 java的写法比较简单 public class SingletonJ { public static SingletonJ singletonJ = new Si...
Kotlin的5种单例模式
Jason_Lee155的博客
01-30 9841
kotlin的饿汉式、懒汉式、线程安全的懒汉式、双重校验锁式、静态内部类式
Kotlin与Java的几种单例模式
weixin_45828419的博客
10-22 1128
一、饿汉式(线程安全，调用效率高，但是不能延时加载) JAVA例子： public class Test { private static Test test = new Test(); private Test() {} public static Test getInstance() { return test; } // 忽略方法printTest()，仅用来输出 public void printTest() { Sys
【CodeWorld】kotlin带参数的单例模式封装实现
guangdeshishe的博客
08-21 976
【代码】【CodeWorld】kotlin带参数的单例模式封装实现。
Kotlin学习笔记：Kotlin中五种单例模式的实现
李益
03-20 529
1、 饿汉式 在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题，但是会使类加载变慢。 Java实现 public class SingletonDemo { private SingletonDemo () { } // 在类加载时就完成了初始化，使得类加载较慢 private static SingletonDemo ins...
Kotlin下的5种单例模式
郭霖
09-25 4050
/ 今日科技快讯 /近日字节跳动公司发表声明称，根据《中华人民共和国技术进出口管理条例》和《中国禁止出口限制出口技术目录》规定，已经向北京市商务局提交了许可申请，正在等待北京市商...
kotlin实现单例模式
最新发布
天花板的随笔
10-31 1531
类加载的时机，或者说类的初始化（两者是类加载到内存中达到可用状态的两个阶段），包括：创建类的实例对象，或者类的静态成员访问，类的反射，父类中的子类初始化的时候，虚拟机特定类。所以并不是程序初始化的时候就会加载所有的类，声明一个类型的变量时也不会加载该类，而是真的使用该类的时候才会去加载。通过伴生对象实现类似于static的静态变量，同时通过by lazy，实现了属性委托，延迟初始化，即在使用instance属性字段的时候，才会去初始化。同时，由于by lazy是线程安全的，也就实现了多线程的校验功能。
【Android,kotlin设计模式】Java的单例在Kotlin的5种实现
weixin_42473228的博客
12-22 1990
Java的单例在Kotlin的5种实现饿汉式懒汉式线程安全的懒汉式双重校验锁式静态内部类式 饿汉式 Java public class Singleton { private static Singleton instance=new Singleton(); private SingletonDemo(){ } public static SingletonDemo getInstance(){ return instance; } }
kotlin实现java的单例模式
AdrianAndroid的专栏
08-30 1435
【代码】kotlin实现java的单例模式。
Kotlin中的object 与companion object的区别
Goals1989的博客
10-19 410
修饰为伴生对象,伴生对象在类中只能存在一个，类似于java中的静态方法 Java 中使用类访问静态成员，静态方法。在java中我们写一个静态方法，如果需要调用成员变量，是无法调用到的。由此可以看出来，java中静态方法调用成员变量，要求成员变量必须是。将所引用的成员变量也修饰静态的，这样就可以引用到了。修饰的类为静态类，里面的方法和变量都为。中调用非静态的成员变量也是调用不到的。， 在kotlin 中也是一样，所以当。事件是一个匿名类的对象，用。类内部的对象声明，没有被。修饰的内部类都是静态的。
java和kotlin实现单例模式
安妍妍的博客
08-24 573
定义及使用场景 定义：确保某个类只有一个实例，而且自行实例化提供给外部使用。 使用场景：某个类型的对象实例应该有且只有一个，或者避免创建多个对象实例消耗过多的资源时。如：网络库，访问IO，数据库时要考虑单例模式。 单例模式的实现方式 1.饿汉式 优点：简单，线程安全 缺点：在类加载的时候就创建，不管需不需要都会创建，不能传参 适用场景：单例的创建开销小 java： public class HungrySingleton { //在类加载的时候创建单例 private static Hung
每日一问：Java与Kotlin的单例实现
Android、HTML、CSS、JS、JAVA、Kotlin、PHP等技术
06-18 378
Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问（这里不考虑反射）。这种写法lazy loading很明显，但是是在多线程不能安全。为了确保线程安全，可以在getInstance方法上加同步锁 这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。 4.静态内部类 这种方式也利用了classloder的机制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值