带有模糊背景的C#对话框窗体

下午好

只是一个简单的问题。在winforms中显示新的对话框窗体时，是否可能使父窗体模糊？如果默认情况下不可能，是否有任何解决方法？以下是我想归档的内容的示例图片：

---

我认为这是不可能的，但我在这里发现了一个类似的问题：

代码来自那边的一个答案，但我稍微修改了一下。。。您需要在启用“不安全”的情况下进行编译（请参阅项目属性的“生成”选项卡（允许使用不安全代码））

基本上，您将表单中的所有内容都放在一个面板中（代码中称为panel1）并调用blur函数。我还添加了一个unblur函数以恢复正常：

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        private PictureBox pb;

        public Form1()
        {
            InitializeComponent();

            pb = new PictureBox();
            panel1.Controls.Add(pb);
            pb.Dock = DockStyle.Fill;
        }

        private void Blur()
        {
            Bitmap bmp = Screenshot.TakeSnapshot(panel1);
            BitmapFilter.GaussianBlur(bmp, 4);

            pb.Image = bmp;
            pb.BringToFront();
        }

        private void UnBlur()
        {
            pb.Image = null;
            pb.SendToBack();
        }
    }

    public class BitmapFilter
    {
        private static bool Conv3x3(Bitmap b, ConvMatrix m)
        {
            // Avoid divide by zero errors
            if (0 == m.Factor) return false;

            Bitmap bSrc = (Bitmap)b.Clone();

            // GDI+ still lies to us - the return format is BGR, NOT RGB.
            BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            BitmapData bmSrc = bSrc.LockBits(new Rectangle(0, 0, bSrc.Width, bSrc.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

            int stride = bmData.Stride;
            int stride2 = stride * 2;
            System.IntPtr Scan0 = bmData.Scan0;
            System.IntPtr SrcScan0 = bmSrc.Scan0;

            unsafe
            {
                byte* p = (byte*)(void*)Scan0;
                byte* pSrc = (byte*)(void*)SrcScan0;

                int nOffset = stride + 6 - b.Width * 3;
                int nWidth = b.Width - 2;
                int nHeight = b.Height - 2;

                int nPixel;

                for (int y = 0; y < nHeight; ++y)
                {
                    for (int x = 0; x < nWidth; ++x)
                    {
                        nPixel = ((((pSrc[2] * m.TopLeft) + (pSrc[5] * m.TopMid) + (pSrc[8] * m.TopRight) +
                            (pSrc[2 + stride] * m.MidLeft) + (pSrc[5 + stride] * m.Pixel) + (pSrc[8 + stride] * m.MidRight) +
                            (pSrc[2 + stride2] * m.BottomLeft) + (pSrc[5 + stride2] * m.BottomMid) + (pSrc[8 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0) nPixel = 0;
                        if (nPixel > 255) nPixel = 255;

                        p[5 + stride] = (byte)nPixel;

                        nPixel = ((((pSrc[1] * m.TopLeft) + (pSrc[4] * m.TopMid) + (pSrc[7] * m.TopRight) +
                            (pSrc[1 + stride] * m.MidLeft) + (pSrc[4 + stride] * m.Pixel) + (pSrc[7 + stride] * m.MidRight) +
                            (pSrc[1 + stride2] * m.BottomLeft) + (pSrc[4 + stride2] * m.BottomMid) + (pSrc[7 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0) nPixel = 0;
                        if (nPixel > 255) nPixel = 255;

                        p[4 + stride] = (byte)nPixel;

                        nPixel = ((((pSrc[0] * m.TopLeft) + (pSrc[3] * m.TopMid) + (pSrc[6] * m.TopRight) +
                            (pSrc[0 + stride] * m.MidLeft) + (pSrc[3 + stride] * m.Pixel) + (pSrc[6 + stride] * m.MidRight) +
                            (pSrc[0 + stride2] * m.BottomLeft) + (pSrc[3 + stride2] * m.BottomMid) + (pSrc[6 + stride2] * m.BottomRight)) / m.Factor) + m.Offset);

                        if (nPixel < 0) nPixel = 0;
                        if (nPixel > 255) nPixel = 255;

                        p[3 + stride] = (byte)nPixel;

                        p += 3;
                        pSrc += 3;
                    }

                    p += nOffset;
                    pSrc += nOffset;
                }
            }

            b.UnlockBits(bmData);
            bSrc.UnlockBits(bmSrc);

            return true;
        }

        public static bool GaussianBlur(Bitmap b, int nWeight /* default to 4*/)
        {
            ConvMatrix m = new ConvMatrix();
            m.SetAll(1);
            m.Pixel = nWeight;
            m.TopMid = m.MidLeft = m.MidRight = m.BottomMid = 2;
            m.Factor = nWeight + 12;

            return BitmapFilter.Conv3x3(b, m);
        }

        public class ConvMatrix
        {
            public int TopLeft = 0, TopMid = 0, TopRight = 0;
            public int MidLeft = 0, Pixel = 1, MidRight = 0;
            public int BottomLeft = 0, BottomMid = 0, BottomRight = 0;
            public int Factor = 1;
            public int Offset = 0;
            public void SetAll(int nVal)
            {
                TopLeft = TopMid = TopRight = MidLeft = Pixel = MidRight = BottomLeft = BottomMid = BottomRight = nVal;
            }
        }
    }

    class Screenshot
    {
        public static Bitmap TakeSnapshot(Control ctl) 
        { 
            Bitmap bmp = new Bitmap(ctl.Size.Width, ctl.Size.Height);
            System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp); 
            g.CopyFromScreen(ctl.PointToScreen(ctl.ClientRectangle.Location), new Point(0, 0), ctl.ClientRectangle.Size); 
            return bmp; 
        }
    }
}

使用系统；
使用系统图；
使用系统、绘图、成像；
使用System.Windows.Forms；
命名空间Windows窗体应用程序1
{
公共部分类Form1:Form
{
私人图片盒pb；
公共表格1（）
{
初始化组件（）；
pb=新的PictureBox（）；
面板1.控件。添加（pb）；
pb.Dock=DockStyle.Fill；
}
私有虚模糊（）
{
位图bmp=屏幕截图。快照（panel1）；
GaussianBlur（bmp，4）；
pb.Image=bmp；
pb.BringToFront（）；
}
私人无效解除禁止（）
{
pb.Image=null；
pb.SendToBack（）；
}
}
公共类位图过滤器
{
专用静态bool Conv3x3（位图b、Conv3x3矩阵m）
{
//避免被零除的错误
如果（0==m.Factor）返回false；
位图bSrc=（位图）b.Clone（）；
//GDI+仍然取决于我们-返回格式是BGR，而不是RGB。
BitmapData bmData=b.LockBits（新矩形（0，0，b.宽度，b.高度），ImageLockMode.ReadWrite，PixelFormat.Format24bppRgb）；
BitmapData bmSrc=bSrc.LockBits（新矩形（0，0，bSrc.Width，bSrc.Height），ImageLockMode.ReadWrite，PixelFormat.Format24bppRgb）；
int stride=bmData.stride；
int STRIAD2=步幅*2；
System.IntPtr Scan0=bmData.Scan0；
System.IntPtr SrcScan0=bmSrc.Scan0；
不安全的
{
字节*p=（字节*）（空*）扫描0；
字节*pSrc=（字节*）（空*）SrcScan0；
int nOffset=步幅+6-b.宽度*3；
int nWidth=b.宽度-2；
int nHeight=b.高度-2；
int nPixel；
对于（整数y=0；y255）nPixel=255；
p[5+步幅]=（字节）n像素；
nPixel=（（pSrc[1]*m.toplight）+（pSrc[4]*m.TopMid）+（pSrc[7]*m.toplight）+
（pSrc[1+步幅]*m.中左）+（pSrc[4+步幅]*m.像素）+（pSrc[7+步幅]*m.中右）+
（pSrc[1+stripe2]*m.BottomLeft）+（pSrc[4+stripe2]*m.BottomMid）+（pSrc[7+stripe2]*m.BottomRight））/m.Factor）+m.Offset）；
如果（nPixel<0）nPixel=0；
如果（nPixel>255）nPixel=255；
p[4+步幅]=（字节）n像素；
nPixel=（（pSrc[0]*m.toplight）+（pSrc[3]*m.TopMid）+（pSrc[6]*m.toplight）+
（pSrc[0+步幅]*m.中左）+（pSrc[3+步幅]*m.像素）+（pSrc[6+步幅]*m.中右）+
（pSrc[0+stripe2]*m.BottomLeft）+（pSrc[3+stripe2]*m.BottomMid）+（pSrc[6+stripe2]*m.BottomRight））/m.Factor）+m.Offset）；
如果（nPixel<0）nPixel=0；
如果（nPixel>255）nPixel=255；
p[3+步幅]=（字节）n像素；
p+=3；
pSrc+=3；
}
p+=无补偿；
pSrc+=无偏移；
}
}
b、 解锁位（bmData）；
bSrc.解锁位（bmSrc）；
返回true；
}
公共静态bool GaussianBlur（位图b，int nWeight/*默认为4*/）
{
ConvMatrix m=新的ConvMatrix（）；
m、 SetAll（1）；
m、 像素=nw；
m、 TopMid=m.MidLeft=m.MidRight=m.BottomMid=2；
m、 系数=净重+12；
返回BitmapFilter.Conv3x3（b，m）；
}
公共类矩阵
{
公共int-toplight=0，TopMid=0，toplight=0；
公共int中左=0，像素=1，中右=0；
公共int BottomLeft=0，BottomMid=0，BottomRight=0；
公共整数因子=1；
公共整数偏移=0；
公共无效设置全部（内部nVal）
{
TopLeft=TopMid=TopRight=MidLeft=Pixel=MidRight=BottomLeft=BottomMid=BottomRight=nVal；
}
}
}
课堂截图
{
公共静态位图快照（控制ctl）
{ 
位图bmp=新位图（ctl.Size.Width、ctl.Size.Height）；
System.Drawing.Graphics g=System.Drawing.Graphics.FromImage（bmp）；
g、 CopyFromScreen（控制点到屏幕（控制点ClientRectangle.Location）、新点（0,0）、控制点ClientRectangle.Size）；
返回bmp；
}
}
}

这可以通过Ajax模式弹出式扩展器实现。哪个机器人