精华内容
下载资源
问答
  • 第一步:新建结构体,用于存储窗体属性 第二步:新建集合用于存储对应控件结构的属性 第三步:将控件的属性添加到集合中 第四步:计算出放大和缩小的比例 第五步:输出实际的控件大小 参考:...

    第一步:新建结构体,用于存储窗体属性
    第二步:新建集合用于存储对应控件结构的属性
    第三步:将控件的属性添加到集合中
    第四步:计算出放大和缩小的比例
    第五步:输出实际的控件大小
    参考:https://blog.csdn.net/hy6688_/article/details/19431097

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace _2DMotionPlatform.FormAutoSizi
    {
        public class FormAutoSize
        {
            // 定义一个控件编号,初始化变量为0,表示窗体本身;后续的为各个控件的编号。
            int CtrNo = 0;
            // 声明一个泛型集合,类型为保存控件属性的结构体
            public List<ControlProperty> OrigenalControl = new List<ControlProperty>();
    
            // 声明一个结构体,用于保存控件的基本属性
            public struct ControlProperty
            {
                public int Left;
                public int Top;
                public int Width;
                public int Height;
                public float FontSize;
            }
            //收集控件的属性到集合中
            public void AddControlToList(Control control)
            {
                ControlProperty Ctp = new ControlProperty();    //新建一个控件属性结构体的实例
                foreach (Control c in control.Controls) {                   //遍历当前引入的控件集
                    Ctp.Left = c.Left;
                    Ctp.Top = c.Top;
                    Ctp.Width = c.Width;
                    Ctp.Height = c.Height;
                    Ctp.FontSize = c.Font.Size;
                    OrigenalControl.Add(Ctp);
                    if (c.Controls.Count > 0) {
                        AddControlToList(c);                   //递归函数调用,防止遗漏嵌套的控件(如:Group、Panel等)
                    }
                }
            }
            // 窗体自适应分辨率
            public void ControlAutoSize(Control MainForm) {
                
                if (CtrNo == 0) {
                    ControlProperty Ctp = new ControlProperty();
                    Ctp.Left = MainForm.Left;
                    Ctp.Top = MainForm.Top;
                    Ctp.Height = MainForm.Height;
                    Ctp.Width = MainForm.Width;
                    Ctp.FontSize = MainForm.Font.Size;
                    //先把主窗体的属性加入到集合
                    OrigenalControl.Add(Ctp);
                    //添加辅窗体控件属性到集合
                    AddControlToList(MainForm);
                }
                //求取分辨率的缩放比例
                float WidthScale = (float)MainForm.Width / (float)OrigenalControl[0].Width;
                float HightScale = (float)MainForm.Height / (float)OrigenalControl[0].Height;
                CtrNo = 1; ;//第0个为窗体本身,窗体内的控件,从序号1开始
                AutoScaleControl(MainForm, WidthScale, HightScale);//窗体内其余控件还可能嵌套控件(比如panel),要单独抽出,因为要递归调用
            }
    
            private void AutoScaleControl(Control mForm, float wScale, float hScale)
            {
                int ctrLeft0, ctrTop0, ctrWidth0, ctrHeight0;
                float ctrFontSize0;
                //第1个是窗体自身的 Left,Top,Width,Height,所以窗体控件从ctrlNo=1开始
                foreach (Control c in mForm.Controls)
                {
                    //获得控件原有的位置和大小信息
                    ctrLeft0 = OrigenalControl[CtrNo].Left;
                    ctrTop0 = OrigenalControl[CtrNo].Top;
                    ctrWidth0 = OrigenalControl[CtrNo].Width;
                    ctrHeight0 = OrigenalControl[CtrNo].Height;
                    ctrFontSize0 = OrigenalControl[CtrNo].FontSize;
                    //设置控件新的位置和大小信息。
                    c.Left = (int)((ctrLeft0) * wScale);//新旧控件之间的线性比例。控件位置只相对于窗体
                    c.Top = (int)((ctrTop0) * hScale);//
                    c.Width = (int)(ctrWidth0 * wScale);//只与最初的大小相关,所以不能与现在的宽度相乘 
                    c.Height = (int)(ctrHeight0 * hScale);//
                    c.Font = new Font(c.Font.Name, (float)(ctrFontSize0 * wScale));//设置控件中字体的大小以适应控件的大小
                    CtrNo++;//累加序号
                    //**放在这里,是先缩放控件本身,后缩放控件的子控件,重点是前后要一致(与保存时)
                    if (c.Controls.Count > 0)
                        AutoScaleControl(c, wScale, hScale);//窗体内其余控件还可能嵌套控件(比如panel),要单独抽出,因为要递归调用
                }
                Debug.Write("如果对象是通过get()方法获取的,而不是new出来的,就可以通过在循环中改变对象的属性的方式来改变集合中该对象的属性值。");
            }
        }
    }
    
    
    实现窗体的自适应分辨率,只需要在窗体的Layout事件中添加如下代码:
            FormAutoSize formAutoSize = new FormAutoSize();
            private void Form1_Layout(object sender, LayoutEventArgs e)
            {
                formAutoSize.ControlAutoSize(this);
            }
    

    注意:无论是通过foreach还是通过for循环遍历的时候,如果对象是通过get()方法获取的,而不是new出来的,就可以通过在循环中改变对象的属性的方式来改变集合中该对象的属性值。因为如果不是new出来的对象,该变量中存的只是从集合中传过来的一个存储真正对象的地址,并不会有这个变量自己的对象,当然也不会占用新的存储空间,当在循环中对该变量所进行的操作,都是对该变量所指向的对象进行的操作,因而会改变集合中对应对象的属性值。
    参考代码下载地址:

    展开全文
  • 本来不爱鸡汤,今天说两句:winform开发有一个缺陷就是不能实现界面的自适应,切换不同的分辨率,或者窗体大小改变就会出现窗体显示不全的问题。这就需要自己写一个方法来实现不同情况下的自适应,WPF比Winform的一...

    今天给大家上一道硬菜。本来不爱鸡汤,今天说两句:winform开发有一个缺陷就是不能实现界面的自适应,切换不同的分辨率,或者窗体大小改变就会出现窗体显示不全的问题。这就需要自己写一个方法来实现不同情况下的自适应,WPF比Winform的一个显著优势就是可以实现自适应。今天给大家一个可以实现自适应的方案。(本篇博客代码,为本人,在本地调试通过后,手敲到博客中,难免出现敲错的状况,勿喷。代码里面的注释是比较清楚的)

    效果图:

     

    调整大小后

    新建一个AutoSizeFormClass.cs文件

    class AutoSizeFormClass
    {
        //1.声明一个结构体,记录窗体和控件的基本属性
        public struct controlRect
        {
            public string Name;
            public int Left;
            public int Top;
            public int Width;
            public int Height;
            public float FontSize;
            public FontFamily FontFamily;
        }
        //2.声明一个集合记录所有控件的属性
        //使用控件的Name作为key
        Dictionary<string,controlRect> dic=new Dictionary<string,controlRect>();
        int ctrNo=0;
        //这里是你开发环境下的分辨率
        private int ScW=1920;
        private int ScH=1080;
        //记录窗体是不是第一次加载的标记 0:第一次加载  1:重复加载
        private int IsFirstLoad=0;
        //窗体的名称
        private string FrmName=string.Empty;
        //3.创建两个函数
        //采用递归的方法将控件包含的所有控件属性记录下来(结构体的每一个属性都需要赋值)
        private void AddControl(Control ctl)
        {
            foreach(Control c in ctl.Controls)
            {
                GetCtrParameter(c);
                //使用递归函数先记录控件本身,后记录控件包含的子控件
                if(c.Controls.Count>0)
                {
                    AddControl(c);
                }
            }
        }
        //获取控件的所有属性
        private void GetCtrParameter(Control mForm)
        {
            controlRect cr;
            cr.Name=mForm.Name;
            cr.Left=mForm.Left;
            cr.Top=mForm.Top;
            cr.Width=mForm.Width;
            cr.Height=mForm.Height;
            cr.FontSize=mForm.Font.Size;
            cr.FontFamily=mForm.Font.FontFamily;
            dic.Add(cr.Name,cr);
        }
    
        //4.控件自适应大小
        public void controlAutoSize(Control mForm)
        {
            FrmName=mForm.Name;
            float wScale=0;
            float hScale=0;
            //因为有些控件和DataGridView的子空间加载时间较长,所以在Form1_SizeChanged中,
            //记录控件的原始大小和位置,第一次加载的时候先根据和开发环境的像素比例绘制窗体                
            if(IsFirstLoad==0&&ctrNo==0)
            {
                //获取当前的像素
                int SH=Screen.PrimaryScreen.Bounds.Height;
                int SW=Screen.PrimaryScreen.Bounds.Width;
                //和开发环境的像素相比获取对应的比值
                wScale=(float)SH/(float)ScH;
                hScale=(float)SW/(float)ScW;
                controlRect cR;
                cR.Name=mForm.Name;
                cR.Left=mForm.Left;
                cR.Top=mForm.Top;
                cR.Width=mForm.Width;
                cR.Height=mForm.Height;
                cR.FontSize=mForm.Font.Size;
                cR.FontFamily=mForm.Font.FontFamily;
                dic.Add(cR.Name,cR);//第一个为窗体本身
                AddControl(mForm);//递归获取所有窗体基础信息
                AutoScaleControl(mForm,wScale,hScale);//这里其实是第一次构造窗体
                IsFirstLoad=1;            
            }
            //这里是改变窗体大小时重新设置窗体的属性
            else
            {
                //新旧窗体之间的高和长的比例,与第一次加载的信息比较
                wScale=(float)mForm.Width/dic[FrmName].Width;
                hScale=(float)mForm.Height/dic[FrmName].Height;
                //将ctrNo设为1,代表为控件而非窗体
                ctrNo=1;
                //设置控件以及其嵌套的控件的比例大小,使用递归调用
                AutoScaleControl(mForm,wScale,hScale);
            }
        }
        //递归进行自适应调整
        private void AutoScaleControl(Control ctl,float wScale,float hScale)
        {
            int ctrLeft0,ctrTop0,ctrWidth0,ctrHeight0;
            float fontSize;
            FontFamily fontFamily;
            foreach(Control c in ctl.Controls)
            {
                string ctrName=c.Name;
                ctrLeft0=dic[ctrName].Left;
                ctrTop0=dic[ctrName].Top;
                ctrWidth0=dic[ctrName].Width;
                ctrHeight0=dic[ctrName].Height;
                fontSize=dic[ctrName].FontSize;
                fontFamily=dic[ctrName].FontFamily;
                //新旧控件之间的线性比例,字体大小依据高度转换
                c.Left=(int)(ctrLeft0*wScale);
                c.Top=(int)(ctrTop0*hScale);
                c.Width=(int)(ctrWidth0*wScale);
                c.Height=(int)(ctrHeight0*hScale);
                c.Font=new Font(fontFamily,fontSize*hScale);
                ctrNo++;
                //先缩放控件本身,后缩放控件的子控件
                if(c.Controls.Count>0)
                {
                    AutoScaleControl(c,wScale,hScale);
                }
                //dataGridview特殊处理
                if(c is DataGridView)
                {
                    DataGridView dgv=c as DataGridView;
                    Cursor.Current=Cursors.WaitCursor;
                    int widths=0;
                    for(int i=0;i<dgv.Columns.Count-1;i++)
                    {
                        //自动调整列宽
                        dgv.AutoResizeColumn(i,DataGridViewAutoSizeColumnMode.AllCells);
                        widths+=dgv.Columns[i].Width;
                    }
                    //如果调整列的宽度大于设定宽度
                    if(widths>ctl.Size.Width)
                    {
                                    dgv.AutoSizeColumnsMode=DataGridViewAutoSizeColumnsMode.DisplayedCells;//调整列的模式
    
                    }
                    else
                    {
                        dgv.AutoSizeColumnsMode=DataGridViewAutoSizeColumnsMode.Fill;//如果小于则填充
                       
                    }
                     Cursor.Current=Cursors.Default;
                }
            }
        }
    
    }
    

    添加一个Form1,在SizeChanged方法添加,不要在load中添加

    public partial class Form1:Form
    {
        private AutoSizeFormClass asc=new AutoSizeFormClass();
        public Form1()
        {
            InitializeComponent();
        } 
        private void Form1_SizeChanged(object sender,EventArgs e)
        {
            asc.controlAutoSize(this);
        }
    }

     

     

     

    展开全文
  • 下载后解压缩即可运行使用,代码...3.为窗体添加SizeChanged事件,并在其方法Form1_SizeChanged中,首次记录窗体和其控件初始位置和大小,之后调用类的自适应方法,完成自适应。 4.Panel,DataGridView等控件同样适用。
  • 3.为窗体添加SizeChanged事件,并在其方法Form1_SizeChanged中,首次记录窗体和其控件初始位置和大小,之后调用类的自适应方法,完成自适应。 4.Panel,DataGridView等控件同样适用。 应用代码如下: using System; ...
  • WinForm窗体及其控件的自适应,对于容器内的控件同样有效
  • winform窗体自适应

    2019-11-08 10:47:29
    2.创建一个窗体类,该类继承于原始窗体类,并在新建的这个窗体类中添加如下代码,以后创建的窗体都继承于新建的这个窗体类: #region 控件缩放 double formWidth;//窗体原始宽度 double formHeig...

    实现步骤:

    1.在窗体中放一个容器(例如:Panel),并且将容器的Dock属性设置为Fill。窗体中其他控件都放在这个容器中。

    2.创建一个窗体类,该类继承于原始窗体类,并在新建的这个窗体类中添加如下代码,以后创建的窗体都继承于新建的这个窗体类:

    #region  控件缩放
    double  formWidth; // 窗体原始宽度
    double  formHeight; // 窗体原始高度
    double  scaleX; // 水平缩放比例
    double  scaleY; // 垂直缩放比例
    Dictionary< string ,  string > controlInfo =  new  Dictionary< string ,  string >(); // 控件中心Left,Top,控件Width,控件Height,控件字体Size
    ///   <summary>
    ///  获取所有原始数据
    ///   </summary>
    protected  void  GetAllInitInfo(Control CrlContainer)
    {
         if  (CrlContainer.Parent ==  this )
        {
            formWidth = Convert.ToDouble(CrlContainer.Width);
            formHeight = Convert.ToDouble(CrlContainer.Height);
        }
         foreach  (Control item  in  CrlContainer.Controls)
        {
             if  (item.Name.Trim() !=  "" )
                controlInfo.Add(item.Name, (item.Left + item.Width /  2 ) +  " , "  + (item.Top + item.Height /  2 ) +  " , "  + item.Width +  " , "  + item.Height +  " , "  + item.Font.Size);
              if  ( (item  as  UserControl) ==  null  && item.Controls.Count >  0 )
                GetAllInitInfo(item);
        }
    }
    private  void  ControlsChangeInit(Control CrlContainer)
    {
        scaleX = (Convert.ToDouble(CrlContainer.Width) / formWidth);
        scaleY = (Convert.ToDouble(CrlContainer.Height) / formHeight);
    }
    private  void  ControlsChange(Control CrlContainer)
    {
         double [] pos =  new  double [ 5 ]; // pos数组保存当前控件中心Left,Top,控件Width,控件Height,控件字体Size
         foreach  (Control item  in  CrlContainer.Controls)
        {
             if  (item.Name.Trim() !=  "" )
            {
                  if  ( (item  as  UserControl) ==  null  && item.Controls.Count >  0 )
                    ControlsChange(item);
                 string [] strs = controlInfo[item.Name].Split( ' , ' );
                 for  ( int  j =  0 ; j <  5 ; j++)
                {
                    pos[j] = Convert.ToDouble(strs[j]);
                }
                 double  itemWidth = pos[ 2 ] * scaleX;
                 double  itemHeight = pos[ 3 ] * scaleY;
                item.Left = Convert.ToInt32(pos[ 0 ] * scaleX - itemWidth /  2 );
                item.Top = Convert.ToInt32(pos[ 1 ] * scaleY - itemHeight /  2 );
                item.Width = Convert.ToInt32(itemWidth);
                item.Height = Convert.ToInt32(itemHeight);
                item.Font =  new  Font(item.Font.Name,  float .Parse((pos[ 4 ] * Math.Min(scaleX, scaleY)).ToString()));
            }
        }
    }

    #endregion 

    3.在新建的窗体类中重写OnSizeChanged事件,并调用ControlsChangeInit和ControlsChange方法,代码如下:

    protected   override   void  OnSizeChanged(EventArgs e)
    {
         base .OnSizeChanged(e);
         if  (controlInfo.Count >  0 )
        {
            ControlsChangeInit( this .Controls[ 0 ]);
            ControlsChange( this .Controls[ 0 ]);
        }
    }

    4.在窗体的构造函数中调用GetAllInitInfo方法,代码如下:

        GetAllInitInfo( this .Controls[ 0 ]);

     

    展开全文
  • 附件为C#源码(VS2012创建的),窗体控件自适应电脑分辨率,自适应窗体大小,实测效果非常好,可以直接拿来使用
  • C#winform 窗体缩放自适应

    千次阅读 2018-09-10 11:14:00
    1. 首先在窗体上放上一个Panel容器,并将容器的Dock属性设为Fill,即所有的控件都放在了这个容器里。 using System; using System.Collections.Generic; using System.Drawing; using System.Text; using ...

    1.  首先在窗体上放上一个Panel容器,并将容器的Dock属性设为Fill,即所有的控件都放在了这个容器里。

    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Text;
    using System.Windows.Forms;
    
    namespace WindowsFormsApp2
    {
        class AutoAdaptWindowsSize
        {
            double formOriginalWidth;//窗体原始宽度
            double formOriginalHeight;//窗体原始高度
            double scaleX;//水平缩放比例
            double scaleY;//垂直缩放比例
            Dictionary<string, string> ControlsInfo = new Dictionary<string, string>();//控件中心Left,Top,控件Width,控件Height,控件字体Size
    
            private Form _form;
            public AutoAdaptWindowsSize(Form form)
            {
                _form = form;
            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="ctrlContainer">panel 控件</param>
            public void InitControlsInfo(Control ctrlContainer)
            {
                if (ctrlContainer.Parent == _form)//获取窗体的高度和宽度
                {
                    formOriginalWidth = Convert.ToDouble(ctrlContainer.Width);
                    formOriginalHeight = Convert.ToDouble(ctrlContainer.Height);
                }
                foreach (Control item in ctrlContainer.Controls)
                {
                    if (item.Name.Trim() != "")
                    {
                        //添加信息:键值:控件名,内容:据左边距离,距顶部距离,控件宽度,控件高度,控件字体。
                        ControlsInfo.Add(item.Name, (item.Left + item.Width / 2) + "," + (item.Top + item.Height / 2) + "," + item.Width + "," + item.Height + "," + item.Font.Size);
                    }
                    if ((item as UserControl) == null && item.Controls.Count > 0)
                    {
                        InitControlsInfo(item);
                    }
                }
    
            }
    
            public void FormSizeChanged()
            {
                if (ControlsInfo.Count > 0)//如果字典中有数据,即窗体改变
                {
                    ControlsZoomScale(_form.Controls[0]);//表示pannel控件
                    ControlsChange(_form.Controls[0]);
    
                }
            }
            private void ControlsZoomScale(Control ctrlContainer)
            {
                scaleX = (Convert.ToDouble(ctrlContainer.Width) / formOriginalWidth);
                scaleY = (Convert.ToDouble(ctrlContainer.Height) / formOriginalHeight);
            }
    
            /// <summary>
            /// 改变控件大小
            /// </summary>
            /// <param name="ctrlContainer"></param>
            private void ControlsChange(Control ctrlContainer)
            {
                double[] pos = new double[5];//pos数组保存当前控件中心Left,Top,控件Width,控件Height,控件字体Size
                foreach (Control item in ctrlContainer.Controls)//遍历控件
                {
                    if (item.Name.Trim() != "")//如果控件名不是空,则执行
                    {
                        if ((item as UserControl) == null && item.Controls.Count > 0)//如果不是自定义控件
                        {
                            ControlsChange(item);//循环执行
                        }
                        string[] strs = ControlsInfo[item.Name].Split(',');//从字典中查出的数据,以‘,’分割成字符串组
    
                        for (int i = 0; i < 5; i++)
                        {
                            pos[i] = Convert.ToDouble(strs[i]);//添加到临时数组
                        }
                        double itemWidth = pos[2] * scaleX;     //计算控件宽度,double类型
                        double itemHeight = pos[3] * scaleY;    //计算控件高度
                        item.Left = Convert.ToInt32(pos[0] * scaleX - itemWidth / 2);//计算控件距离左边距离
                        item.Top = Convert.ToInt32(pos[1] * scaleY - itemHeight / 2);//计算控件距离顶部距离
                        item.Width = Convert.ToInt32(itemWidth);//控件宽度,int类型
                        item.Height = Convert.ToInt32(itemHeight);//控件高度
                        item.Font = new Font(item.Font.Name, float.Parse((pos[4] * Math.Min(scaleX, scaleY)).ToString()));//字体
    
                    }
                }
    
            }
    
    
        }
    }

     

    使用:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace WindowsFormsApp2
    {
        public partial class Form1 : Form
        {
    
            AutoAdaptWindowsSize autoAdaptSize;
            public Form1()
            {
                InitializeComponent();
                #region 窗体缩放
                autoAdaptSize = new AutoAdaptWindowsSize(this);
                autoAdaptSize.InitControlsInfo(this.Controls[0]);
                #endregion
            }
    
            private void Form1_Load(object sender, EventArgs e)
            {
    
            }
            #region 窗体缩放      
           
            private void Form1_SizeChanged(object sender, EventArgs e)
            {
                if (autoAdaptSize != null)
                {
                    autoAdaptSize.FormSizeChanged();
                }
            }
    
            #endregion
    
          
        }
    }

     

    转载于:https://www.cnblogs.com/ike_li/p/9618025.html

    展开全文
  • C# Winform窗体自适应

    2021-04-23 10:58:15
    1.在From1.cs中输入如下代码 public Form1() { InitializeComponent()...#region 控件大小窗体大小等比例缩放 private float x;//定义当前窗体的宽度 private float y;//定义当前窗体的高度 private void setTag..
  • 1.项目情况:项目使用winform搭建,禁用用户放大缩小,一直全屏展示 2.问题: a.用tableLayoutPanel加panel能不能做到自适应布局呢?(保证布局不跑偏) b.如果a成立那么里面的控件如何做到按照屏幕分辨率等比缩放呢,...
  • 3个方法:  #region 控件缩放变量 double formWidth;//窗体原始宽度 double formHeight;//窗体原始高度 double scaleX;//水平缩放比例 double scaleY;//垂直缩放比例 Dictionary<string, string> Cont...
  • 在习惯了写固定大小窗体之后总是会遇到界面显示不开的问题,在自己的电脑上运行的好好的,一跑到人家电脑上就动不动少一块显示不开。这哪能行,这以后那帮人用着用着屏幕稍微小点不就得找我调软件,你说咱总不能逼...
  • Winform 窗体和控件自适应大小

    千次阅读 2018-03-01 14:27:05
    在需要自适应的Form中实例化全局变量 AutoSizeFormClass.cs源码在下方 AutoSizeFormClass asc = new AutoSizeFormClass();2.Form_Load事件中 asc.controllInitializeSize(this);3.Page_SizeChanged事件中 asc....
  • WinForm窗体跟随最大化最小化自适应C#,窗体跟随,跟随句柄, 最大化, 最小化 跟随移动 ,winform .net C#
  • Winform 窗体控件最大化自适应

    万次阅读 2018-11-08 09:00:54
    运行窗体效果如下:  默认点击最大化效果如下: 修改后最大化效果如下:控件自动缩放, 步骤实现如下: 1.在窗体中放一个容器(Panel),将容器的Dock属性设置为Fill。窗体中所有控件都放入这个容器中。 ...
  •  2012-11-30 曾经写过 《C# WinForm窗体及其控件自适应各种屏幕分辨率》 ,其中也讲解了控件自适应的原理。近期有网友说,装在panel里面的控件,没有效果?  这是控件嵌套的问题,加入即可实现。使用皮肤时,要注意...
  • //窗体内其余控件还可能嵌套控件(比如panel),要单独抽出,因为要递归调用 } } //(3.2)控件自适应大小, public void controlAutoSize(Control mForm) { SendMessage(mForm.Handle, WM_SETREDRAW, 0, IntPtr.Zero);...
  • 之前写过winform窗体自适应,不过原生控件没有圆角,最近在使用Dskin开发,所以就写了可以让窗体和控件大小,位置,字体,圆角一起自适应的方案。 调用时 在需要自适应的窗体的构造方法中, InitializeComponent...
  •  网上有很多关于此问题的博客,其中也讲解了控件自适应的原理。近期有网友说,装在panel,groupbox等容器里面的控件,没有效果?  这是控件嵌套的问题,加入即可实现。当控件在groupbox等容器中时,他就只受...
  • C# WinForm窗体及其控件自适应各种屏幕分辨率 2016年07月13日 17:12:31 source0573 阅读数 9327 1.声明AutoSizeFormClass类 using System; using System.Collections.Generic; using System....
  • WinForm窗体自适应分辨率

    万次阅读 多人点赞 2014-02-18 21:57:00
    实际上,做到这点也很简单,就是首先记录窗体和它上面控件的初始位置和大小,当窗体改变比例时,其控件的位置和大小也按此比例变化即可。因为窗体上控件的位置和大小是相对于自己所在的窗体的,也就是所谓的窗口坐标...
  •  在需要自适应大小窗体中添加如下事件  *如果是容器,最好将Anchor和Dock属性修改过来.    private void FrmPwd_Load(object sender, EventArgs e)  {  automaticSize.Width = this.Width;  ...
  • 窗体自适应,统计原始窗体的位置和大小;缩放后Resize通过计算主窗体的大小,计算出长宽伸缩比例,然后再计算出来内部控件的起始点和长宽,过程通过递归完成,简单易行!
  • private void SubForm_Load(object sender, EventArgs e) { this.WindowState = FormWindowState.Maximized; } 这句代码写在子窗体里可以让子窗体自适应父窗体大小 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 641
精华内容 256
关键字:

winform窗体大小自适应