精华内容
下载资源
问答
  • 对话框的组成包括什么
    2021-07-15 04:12:27

    【小编“百花争妍”】东奥会计在线高级会计师频道提供:2017年高级职称计算机预习:对话框的组成和操作。

    对话框的组成和操作

    对话框在Windows

    XP中占有重要地位,它是用户与计算机系统之间进行信息交流的桥梁。对话框不能像窗口那样任意地改变大小,在标题栏上也没有最小化、最大化按钮,取而代之的是帮助按钮。

    2.4.1 对话框的组成和基本操作

    Windows

    XP中的对话框用于向程序提供信息。对话框通常具有多个选项和元素。例如下拉列表框、命令按钮、单选按钮、复选框和文本框等。如图所示显示了一个典型的对话框。

    1.标题栏

    2.命令按钮

    3.文本框

    4.列表框

    5.下拉式菜单

    6.单选按钮

    7.复选框

    8.数字增减框

    9.滑动杆

    10.选项卡

    包含信息较多的对话框可以由多个选项卡组成,每个选项卡对应一个主题信息,且含有不同的选项组。以下操作可以实现不同选项卡之间的切换:

    ◆直接单击选项卡标题,以切换选项卡;

    ◆单击选项卡标题,当标题名周围出现虚框线时,使用键盘上得左、右方向键可以在各个选项卡之间进行切换;

    ◆利用Ctrl+Tab组合键可以从左到右依次切换各个选项卡,而利用Ctrl+Shift+Tab组合键则可以反向顺序依次切换。

    2.4.2 确认、提醒或警告对话框

    确认、提醒或警告对话框在系统需要确认、提醒或警告时才会出现。确认对话框提示用户确认是否执行某一操作,提醒对话框用来传递系统提示信息,警告对话框提示用户执行相应操作可能带来的后果。

    (本文内容版权归东奥会计在线所有 转载请注明出处)

    相关链接:

    更多相关内容
  • 我们都知道在Android开发中,当我们的程序在与用户交互时,用户会得到一定的反馈,其中以对话框的形式的反馈还是比较常见的,接下来我们来介绍几种常见的对话框的基本使用。

    简介:

    我们都知道在Android开发中,当我们的程序在与用户交互时,用户会得到一定的反馈,其中以对话框的形式的反馈还是比较常见的,接下来我们来介绍几种常见的对话框的基本使用。

    前置准备:(文章最后附有所有代码)

    我们首先先写一个简单的页面用于测试这几种Dialog(对话框)

    代码如下,比较简单,就不做解释了

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".MainActivity">
    
        <Button
            android:id="@+id/normal_btn"
            android:text="普通对话框"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="myClick"/>
    
        <Button
            android:id="@+id/diy"
            android:text="自定义对话框"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="myClick"/>
    
        <Button
            android:id="@+id/popup_btn"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="显示弹窗"
            android:layout_gravity="center"
            android:onClick="myClick"/>
    
        <Button
            android:id="@+id/array_dialog"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="popupwindow"
            android:layout_gravity="center"
            android:onClick="myClick"/>
    
    
    </LinearLayout>

    一、提示对话框(即最普通的对话框)

    首先我们给普通对话框的按钮设置一个点击事件,然后通过AlertDialog.Builder来构造一个对象,为什么不直接Dialog一个对象,是因为Dialog是一个基类,我们尽量要使用它的子类来进行实例化对象,在实例化对象的时候,需要将当前的上下文传过去,因为我这里使用的是Activity,它本身就是一个上下文Content,所以直接传入this,如下:

    AlertDialog.Builder builder = new AlertDialog.Builder(this);

    然后我们开始设置Dialog的一些必要的属性,比如title(标题),message(里面的内容),还有确定和取消的按钮以及按钮的点击事件,代码如下:

    builder.setTitle("提示");
    builder.setMessage("您确定退出程序吗");
    builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            finish();
        }
    });
    builder.setNeutralButton("取消",null);
    builder.show(); //调用show()方法来展示对话框

     最后记得一定要调用builder.show()方法,不调用的话,我们是无法看到这个dialog的,好了我们运行程序,点击普通对话框的按钮,会出现以下的效果:

     在具体使用时我们只需要在确定和取消的按钮上设置你想实现的点击事件即可,这里仅做测试

    二、自定义对话框(使用自己设计的对话框)

    同样先给自定义的对话框设置按钮的点击事件,这里既然是自定义,那么我们就需要自己设计ui了,所以我从网上找到了一个对话框的图片,其实就是将其设置为背景图片就可以了,在layout目录下新建一个资源文件,简单书写一下dialog的样式,代码如下:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="300dp"
        android:layout_height="300dp"
        android:orientation="vertical"
        android:gravity="center_horizontal"
        android:background="@mipmap/dialog_bg">
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="你确定要退出吗"
            android:textSize="20sp"
            android:textColor="#e61414"
            android:textStyle="bold"
            android:layout_marginTop="160dp"/>
    
        <LinearLayout android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="horizontal"
            android:layout_marginTop="30dp">
            <Button
                android:id="@+id/yes"
                android:layout_width="80dp"
                android:layout_height="50dp"
                android:background="@drawable/yes_btn"
                android:text="确定"/>
            <Button
                android:id="@+id/no"
                android:layout_marginLeft="20dp"
                android:layout_width="80dp"
                android:layout_height="50dp"
                android:background="@drawable/no_btn"
                android:text="取消"/>
        </LinearLayout>
    </LinearLayout>

     大概是这个鬼样子,这里的背景大小根据自己的需要调整就好了

    此时呢,虽然我们自定义的布局文件设置好了,但是 Dialog会默认给我们加上标题,背景这些东西,会很影响用户的体验,所以我们需要重新定义一下这个布局文件的style,在values的目录下有一个叫styles.xml文件,进入到这个文件里面,新添加一个style标签,具体内容如下:

    <style name="mydialog" parent="android:style/Theme.Dialog">
    <!--        将标题去掉-->
            <item name="android:windowNoTitle">true</item>
    <!--        将背景设置为透明颜色-->
            <item name="android:windowBackground">@android:color/transparent</item>
        </style>

    其实并没有什么东西,只是设置了去掉标题,将背景色设置成透明色,这样不会影响我们的ui界面,这个style样式先写到这里,后面是需要用到的。 

    然后我们需要新建一个类去继承Dialog,在这个类里面去加载我们设计的自定义dialog布局文件,然后去处理一些点击事件,代码如下:

    package com.example.dialogdemo;
    
    import android.app.Dialog;
    import android.content.Context;
    import android.view.View;
    import android.widget.Button;
    
    import androidx.annotation.NonNull;
    
    public class MyDialog extends Dialog {
    
        private final Button yes;
        private final Button no;
    
        public MyDialog(@NonNull Context context, int themeResId) {
            super(context, themeResId);
            setContentView(R.layout.dialog_layout);
    
            //处理点击事件
            yes = findViewById(R.id.yes);
            no = findViewById(R.id.no);
    
            yes.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    System.exit(0);  //退出程序
                }
            });
    
            no.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    dismiss(); //让对话框消失
                }
            });
        }
    }
    

    代码很好理解,我们只需要让这个类去继承Dialog基类,然后重写他的有两个参数的构造函数即可,这里为什么一定要重写带两个参数的构造函数呢,是因为我们要将我们设置的style样式传递过来,让这个dialog去应用我们为他设置的style,接下来我们在MainActivity中,处理自定义对话框的点击事件,这里比较简单,只需要实例化一个MyDialog对象,将context和style样式传递过去即可,代码如下:

    MyDialog md = new MyDialog(this,R.style.mydialog);
                    md.show();

    还有就是不要忘记调用show方法,

    最后我们运行程序,点击按钮,出现如下效果:

    是不是样式比原来的更好看了一些呢 

    这次分享就结束了,欢迎各位指正!!

    展开全文
  • 对话框

    2020-10-12 11:34:26
    对话框分为模态对话框、提示对话框、文本对话框、打开文件对话框等多种类型。在wxpthon中对话框都继承自wx....#定义窗口类MyFrame,包含aboutMenu子菜单并单击创建MyDialog对话框 class MyFrame(wx.Frame): def __i

    对话框分为模态对话框、提示对话框、文本对话框、打开文件对话框等多种类型。在wxpthon中对话框都继承自wx.Dialog类。下面展示一下这些对话框。
    一、对话框的创建和使用与Frame相似,不同的对话框表示一次信息交换的活动。当完成交换后,单击对话框的按钮将关闭该对话框,对话框只是应用程序生命周期的一部分。

    #对话框的创建
    import wx
    
    #定义窗口类MyFrame,包含aboutMenu子菜单并单击创建MyDialog对话框
    class MyFrame(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u'自定义对话框',size=(300,200))
            MenuHelp = wx.Menu()
            aboutMenu = MenuHelp.Append(-1,u'关于(&A)')
            menuBar = wx.MenuBar()
            menuBar.Append(MenuHelp,u'帮助(&H)')
            self.Bind(wx.EVT_TOOL,self.ShowAboutDlg,aboutMenu)
            self.SetMenuBar(menuBar)
    
    #定义showaboutdlg(),用该函数创建显示aboutmenu菜单
        def ShowAboutDlg(self,evt):
            pos = self.GetPosition()
    
    #创建对话框dialog,并显示MyFrame的相对位置
            dialog = MyDialog(self,-1,u'关于')
            dialog.SetPosition((pos[0] + 100,pos[1] + 60))
    
    #创建了MyDialog对话框类,继承自wx.Dialog,创建 确定 按钮打开对话框
    class MyDialog(wx.Dialog):
        def __init__(self,parent,id,title):
            wx.Dialog.__init__(self,parent,id,title,size=(100,100))
            self.panel = wx.Panel(self)
            self.OkBtn = wx.Button(self,10,u'确定',pos=(10,20),size=(80,30))
            self.Bind(wx.EVT_BUTTON,self.CloseDlg,self.OkBtn)
            self.Show() #调用show()显示对话框
    
        def CloseDlg(self,evt):
            self.Close()
    
    if __name__=='__main__':
        app = wx.PySimpleApp()
        MyFrame().Show()
        app.MainLoop()
    
    #由于模态对话框的约束性,因此模态对话框通常作为获取数据的窗口。
    #只有从模态对话框中返回数据后,才能关闭对话框
    

    二、提示对话框有助于用户体验的完善,例如,退出应用程序时显示退出提示,删除数据时显示删除提示。

    #提示对话框:通常用于帮助用户进行交互式操作
    import wx
    class MyFrame(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u'对话框',size=(300,200))
            button = wx.Button(self,wx.ID_OK,u'退出',pos=(10,10))
            button.SetDefault()
            self.Bind(wx.EVT_BUTTON,self.OnClick,button)
        #创建对话框,根据wx.YES_NO,生成“是”、“否”按钮
        def OnClick(self,evt):
            #使用MessageDialog()类创建选择对话框
            dlg = wx.MessageDialog(None,u'是否退出?',u'退出',wx.YES_NO|wx.ICON_QUESTION)
            #判断用户选择的返回值
            if(dlg.ShowModal() == wx.ID_YES):
                frame.Close()   #关闭主程序
            #调用释放对话框对象
            dlg.Destroy()
    
    if __name__=='__main__':
        app = wx.PySimpleApp()
        frame = MyFrame()
        frame.Show()
        app.MainLoop()
    

    三、文本输入对话框:用于返回输入字符串的值,通常由一个静态文本框、一个输入文本框和OK、Cancel按钮组成,可由wx.TextEnTryDialog类创建。

    import wx
    class MyFrame(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,"TextEntryDialog",size=(300,200))
            panel = wx.Panel(self,-1)
    
            #创建TextCtrl实例textCtrl,并用wx.TE_PROCESS_ENTER处理回车事件
            self.textCtrl = wx.TextCtrl(panel,-1," ",pos=(10,10),style=wx.TE_PROCESS_ENTER)
            self.textCtrl.Bind(wx.EVT_TEXT_ENTER,self.OnClick,self.textCtrl)
    
        def OnClick(self,evt):
            #创建文本对话框,包含“ok”和“cancel”按钮
            self.dialog = wx.TextEntryDialog(None,u'输入文本',u'文本对话框',"",style=wx.OK|wx.CANCEL)
            #当按下OK按钮时
            if self.dialog.ShowModal() == wx.ID_OK:
                #获取文本输入内容,调用SetLabel把文本填入textCtrl控件的文本框
                self.textCtrl.SetLabel(self.dialog.GetValue())
    if __name__=='__main__':
        app = wx.PySimpleApp()
        MyFrame().Show()
        app.MainLoop()
    #创建1个TextCtrl控件,当按下回车键后,将显示TextEntryDialog对话框
    #用户输入文本后,单击“OK”按钮将把输入的值返回给TextCtrl控件
    

    四、特殊对话框:包括打开文本对话框、字体对话框、颜色选择对话框。打开文件对话框由wx.FileDialog类创建。

    #演示“打开”文件对话框的创建和使用方法
    import wx
    import os
    
    #创建打开文件对话框,显示当前目录中的文件,并可对类型进行过滤
    def ShowFileDialog():
    #文件类型的下拉列表提供“py”为后缀的文件和所有文件两种类型
        filterFile = "Python source(*.py)|*.py|All files(*.*)|*.*"  #过滤文件
        #对话框dialog。os.getcwd()获取当前文件所在的路径
        dialog = wx.FileDialog(None,u'选择文件',os.getcwd(),"",filterFile,wx.ART_FILE_OPEN)
        #以模式对话框的形式显示dialog对象
        dialog.ShowModal()
        dialog.Destroy()
    
    if __name__=='__main__':
        app = wx.PySimpleApp()
        ShowFileDialog()
        app.MainLoop()
    

    五、窗口与对话框的交互,对话框中的组件支持验证能力,而窗口不支持组件内容的验证。wx.PyValidator类的TransferWindow()和TransfromWindow()这两个方法实现窗口和对话框的交互。前者方法用于对话框打开时执行,后者方法用于对话框关闭的调用,可以实现窗口与对话框的数据交换。

    #创建Frame窗口,该窗口用于计算两个数字的和
    import wx
    class MyFrame(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self,None,-1,u"对话框的验证",size=(300,200))
            panel = wx.Panel(self,-1)
            sizer = wx.BoxSizer(wx.HORIZONTAL)
            self.addTextCtrl = wx.TextCtrl(panel,-1,"",pos=(10,10))
            addStaticText = wx.StaticText(panel,-1,"+")
            self.addTextCtrl2 = wx.TextCtrl(panel,-1,"")
            btn = wx.Button(panel,-1,u'计算')
            btn.Bind(wx.EVT_BUTTON,self.OnClick,btn)
            sizer.Add(self.addTextCtrl)
            sizer.Add(addStaticText)
            sizer.Add(self.addTextCtrl2)
            sizer.Add(btn)
            panel.SetSizer(sizer)
            panel.Fit()
        def OnClick(self,event):
        #定义字典data,把两个文本框中的数字存放到字典中
            data = {0:self.addTextCtrl.GetValue(),1:self.addTextCtrl2.GetValue()}
            dlg = MyDialog(data)
            dlg.ShowModal()
            dlg.Destroy()
    

    演示设计执行计算的对话框类,该对话框接收窗口定义的字典数据,然后进行计算。

    #演示设计执行计算的对话框类
    class MyDialog(wx.Dialog):
        def __init__(self,data):
            wx.Dialog.__init__(self,None,-1,u'验证器')
            addStaticText = wx.StaticText(self,-1,u'数字1:')
            addStaticText2 = wx.StaticText(self,-1,u'数字2:')
            self.addTextCtrl = wx.TextCtrl(self,validator = DataValidator(data,0))
            self.addTextCtrl2 = wx.TextCtrl(self,validator = DataValidator(data,1))
            btn = wx.Button(self,wx.ID_OK,u'确定')
            btn.Bind(wx.EVT_BUTTON,self.OnClick,btn)
            btn.SetDefault()
            sizer = wx.BoxSizer(wx.VERTICAL)
            gridSizer = wx.FlexGridSizer(2,2,5,5)
            gridSizer.Add(addStaticText,0,wx.ALIGN_LEFT)
            gridSizer.Add(self.addTextCtrl,0,wx.EXPAND)
            gridSizer.Add(addStaticText2,0,wx.ALIGN_LEFT)
            gridSizer.Add(self.addTextCtrl2,0,wx.EXPAND)
            sizer.Add(gridSizer,0,wx.EXPAND|wx.ALL,5)
            sizer.Add(btn,0,5)
            self.SetSize(sizer)
            sizer.Fit(self)
        def OnClick(self,evt):
            result = float(self.addTextCtrl.GetValue()) + float(self.addTextCtrl2.GetValue())
            wx.MessageBox(str(result),u'结果')
            self.Close()
    

    用DataValidator类实现创建数据的接收。

    class DataValidator(wx.PyValidator):
    #定义构造函数,用于接收data字典和相应的索引
        def __init__(self,data,key):
            wx.PyValidator.__init__(self)
            self.data = data
            self.key = key
         #覆盖close()方法,返回验证器的拷贝
        def Clone(self):    #close()方法必须实现
            return DataValidator(self.data,self.key)
        def Validata(self,w):   #验证数据
            return True
        def TransferToWindow(self): #对话框打开时调用
            textCtrl = self.GetWindow()	#获得当前组件
            #通过索引key查找当前组件的值,即把窗口文本框的内容传递给对话框的文本框
            textCtrl.SetValue(self.data.get(self.key,""))
            return True
        def TransferFromWindow(self): #对话框关闭时调用
            return True
    

    在DataValidator类的validata()方法实现对组件数据的验证,有兴趣者可以自己编写一些相关的验证规则来丰富对话框的验证功能。

    (好久没来写笔记了,希望大家勤快点哦)

    展开全文
  • 对话框和控件编程

    2022-05-11 14:28:05
    对话框和控件编程

    专栏: 基于linux和minigui的嵌入式系统软件开发指南

    第一节:MiniGUl-Threads 和 MiniGUl-Lite 的选择

    第二节:理解消息循环和窗口过程 ----------- MiniGUI编程 “ Hello World ”



    本文讲述 MiniGUI中的对话框和控件编程。首先讲解MiniGUI中的控件类和控件实例的关系,并举例说明控件子类化的概念及应用;其次讲解MiniGUI对话框的编程技术,包括对话框模板的定义和对话框回调函数的编程;最后解释模态对话框和非模态对话框之间的区别。

    前言

    对话框编程是一个快速构建用户界面的技术。通常,我们编写简单的图形用户界面时,可以通过调用CreateWindow函数直接创建所有需要的子窗口,即控件。但在图形用户界面比较复杂的情况下,每建立一个控件就调用一次
    CreateWindow函数,并传递许多复杂参数的方法很不可取。主要原因之一,就是程序代码和用来建立控件的数据混在一起,不利于维护。为此,一般的GUI系统都会提供一种机制,利用这种机制,通过指定一个模板,GUI系统就可以根据此模板建立相应的主窗口和控件。MiniGUI也提供这种方法,通过建立对话框模板,就可以建立模态或者非模态的对话框。

    本文首先讲解组成对话框的基础,即控件的基本概念,然后讲解对话模板的定义,并说明模态和非模态对话框之间的区别以及编程技术。


    一、控件和控件类

    许多人对控件(或者部件,widget)的概念已经相当熟悉了。控件可以理解为主窗口中的子窗口。这些子窗口的行为和主窗口一样,即能够接收键盘和鼠标等外部输入,也可以在自己的区域内进行输出一—只是它们的所有活动被限制在主窗口中。MiniGUI也支持子窗口,并且可以在子窗口中嵌套建立子窗口。我们将MiniGUI中的所有子窗口均称为控件。

    在 Windows或X Window 中,系统会预先定义一些控件类,当利用某个控件类创建控件之后,所有属于这个控件类的控件均会具有相同的行为和显示。利用这些技术,可以确保一致的人机操作界面,而对程序员来讲,可以像搭积木一样地组建图形用户界面。MiniGUI使用了控件类和控件的概念,并且可以方便地对已有控件进行重载,使得其有一些特殊效果。比如,需要建立一个只允许输入数字的编辑框时,就可以通过重载已有编辑框而实现,而不需要重新编写一个新的控件类。

    如果读者曾经编写过 Windows应用程序的话,应该记得在建立一个窗口之前,必须确保系统中存在新窗口所对应的窗口类。在 Windows中,程序所建立的每个窗口,都对应着某种窗口类。这一概念和面向对象编程中的类、对象的关系类似。借用面向对象的术语,Windows中的每个窗口实际都是某个窗口类的一个实例。在X Window编程中,也有类似的概念,比如我们建立的每一个Widget,实际都是某个Widget类的实例。

    这样,如果程序需要建立一个窗口,就首先要确保选择正确的窗口类,因为每个窗口类决定了对应窗口实例的表象和行为。这里的表象指窗口的外观,比如窗口边框宽度,是否有标题栏等等,行为指窗口对用户输入的响应。每一个GUI 系统都会预定义一些窗口类,常见的有按钮、列表框、滚动条、编辑框等等。如果程序要建立的窗口很特殊,就需要首先注册一个窗口类,然后建立这个窗口类一个实例。这样就大大提高了代码的可重用性。

    在MiniGUI中,我们认为主窗口通常是一种比较特殊的窗口。因为主窗口代码的可重用性一般很低,如果按照通常的方式为每个主窗口注册一个窗口类的话,则会导致额外不必要的存储空间,所以我们并没有在主窗口提供窗口类支持。但主窗口中的所有子窗口,即控件,均支持窗口类(控件类)的概念。MiniGUI提供了常用的预定义控件类,包括按钮(包括单选钮、复选钮)、静态框、列表框、进度条、滑块、编辑框等等。程序也可以定制自己的控件类,注册后再创建对应的实例。表1给出了MiniGUI预先定义的控件类和相应类名称定义。
    表1 MiniGUI预定义的控件类和对应类名称
    在这里插入图片描述
    在MiniGUI中,通过调用CreateWindow函数,可以建立某个控件类的一个实例。控件类既可以是表1中预定义 MiniGUI控件类,也可以是用户自定义的控件类。与CreateWindow函数相关的几个函数的原型如下(include/window.h):

    HWND GUIAPI CreateWindowEx(const char* spClassName,const char* spCaption,DWORD dwStyle,DWORD dwExStyle,int id,int x,int y, int w,int h,HWND hParentWnd,DWORD dwAddData);
    
    BOOL GUIAPI DestroyWindow (HWND hWnd);
    
    #define CreateWindow(class_name,caption,style,id, x, y,w, h, parent, add_data)\CreateWindowEx (class_name,caption,style,0, id,x,y,w,h, parent,add_data)
    
    

    CreateWindow函数建立一个子窗口,即控件。它指定了控件类、控件标题、控件风格,以及窗口的初始位置和大小。该函数同时指定子窗口的父窗口。
    CreateWindowEx函数的功能和CreateWindow函数一致,不过,可以通过CreateWindowEx函数指定控件的扩展风格。DestroyWindow函数用来销毁用上述两个函数建立的控件或者子窗口。

    清单1中的程序,利用预定义控件类创建控件。其中 hStaticWndl 是建立在主窗口hWnd 中的静态框;hButtonl、hButton2、hEdit1、hStaticWnd2则是建立在 hStaicWnd1内部的几个控件,并作为hStaticWnd1的子控件而存在,建立了两个按钮、一个编辑框和一个静态按钮;而hEdit2是hStaicWnd2的子控件,是hStaticWnd1的子子控件。

    清单1利用预定义控件类创建控件

    #define IDC_STATIC1 100
    #define IDC_STATIC2 150
    #define IDC_BUTTON1 110
    #define IDC_BUTTON2 120
    #define IDC_EDIT1 130
    #define IDC_EDIT2 140
    int ControlTestWinProc (HWND hWnd, int message,WPARAM wParam, LPARAMlParam)
    {
    	static HWND hStaticWnd1,hStaticWnd2, hButton1, hButton2, hEdit1,hEdit2; 
    	switch (message)
    	{
    		case MSG_CREATE:
    		{
    			hStaticWnd1 = CreateWindow (CTRL_STATIC,"This is a static control",WS_CHILD | SS_NOTIFY |SS_SIMPLE | WS_VISIBLE |WS_BORDER,IDC_STATIC1,10,10,180300, hWnd,O);
    			hButton1 = CreateWindow (CTRL_BUTTON,"Button1",WS_CHILD| BS_PUSHBUTTON|WS_VISIBLE,IDC_BUTTON1,20,20,80,20,hStaticWnd1,0);
    			hButton2 = CreateWindow (CTRL_BUTTON,"Button2",WS_CHILD| BS_PUSHBUTTON|WS_VISIBLE,IDC_BUTTON2,20,50,80,20,hStaticWnd1,0);
    			hEdit1=CreateWindow (CTRL_EDIT,"Edit Box 1",WS_CHLD| WS_VISIBLE|WS_BORDER,IDC_EDIT1,20,80,100,24,hStaticWnd1,0);
    			hStaticWnd2 = CreateWindow (CTRL_STATIC,"This is child static control",WS_CHILD | SS_NOTIFY|SS_SIMPLE|WS_VISIBLE|WS_BORDER,IDC_STATIC1,20,110,100,50, hStaticWnd1,0);
    			hEdit2= CreateWindow (CTRL_EDIT,"Edit Box 2",WS_CHILD|WS_VISIBLE|WS_BORDER,IDC_EDIT2,0,20,100,24,hStaticWnd2,0);
    			break;
    			}
    	......	
    	}		
    	return DefaultMainWinProc(hWnd,message,wParam,lParam);
    }
    
    

    用户也可以通过 RegisterWindowClass函数注册自己的控件类,并建立该控件类的控件实例。如果程序不再使用某个自定义的控件类,则应该使用
    UnregisterWindowClass 函数注销自定义的控件类。上述两个函数以及和窗口类相关函数的原型如下(include/window.h) :

    BOOL GUIAPI RegisterWindowClass (PWNDCLASS pWndClass) ;
    BOOL GUIAPI UnregisterWindowClass (const char* szClassName);
    char* GUIAPI GetClassName (HWND hWnd);
    BOOL GUIAPI GetWindowClassInfo (PWNDCLASS pWndClass);
    BOOL GUIAPI SetWindowClassInfo (const WNDCLASS* pWndClass);
    
    

    RegisterWindowClass通过pWndC1ass 结构注册一个控件类;
    UnregisterWindowClass函数则注销指定的控件类;GetClassName 活得窗口的对应窗口类名称,对主窗口而言,窗口类名称为"MAINWINDOW";
    GetWindowClassInfo分别用来获取和指定特定窗口类的属性。

    清单2中的程序,定义并注册了一个自己的控件类。该控件用来显示安装程序的步骤信息,MSG_SET_STEP_INFO消息用来定义该控件中显示的所有步骤信息,包括所有步骤名称及其简单描述。MSG_SET_CURR_STEP消息用来指定当前步骤,控件将高亮显示当前步骤。

    清单2定义并注册自定义控件类

    #define STEP_CTRL_NAME "mystep"
    #define MSG_SET_STEP_INFO (MSG_USER + 1)
    #define MSG_SET_CURR_STEP (MSG_USER + 2)static int StepControlProc (HWND hwnd,int message,WPARAM wParam,LPARAM lParam)
    {
    	HDC hdc;
    	HELPWININFO* info;
    	switch (message)
    	{
    		case MSG_PAINT:
    			hdc = BeginPaint (hwnd);/*获取步骤控件信息*/
    			info = (HELPWININFO*)GetWindowAdditionalData (hwnd);/*绘制步骤内容*/
    			......
    			EndPaint (hwnd,hdc) ;
    			break ;
    			/*控件自定义的消息:用来设置步骤信息*/
    		case MSG_SET_STEP_INFO:
    			SetWindowAdditionalData (hwnd,(DWORD)lParam);
    			InvalidateRect (hwnd,NULL,TRUE);
    			break;
    			/*控件自定义的消息:用来设置当前步骤信息*/
    		case MSG_SET_CURR_STEP:
    			InvalidateRect (hwnd,NULL,FALSE);
    			break ;
    		case MSG_DESTROY:
    			break;
    	}
    		return DefaultControlProc (hwnd,message,wParam,lParam);
    }
    static BOOL RegisterStepControl()
    {
    	int result;
    	WNDCLASS StepClass;
    	StepClass.spClassName =STEP_CTRL_NAME;
    	StepClass.dwStyle=0;
    	StepClass.hCursor= GetSystemCursor (IDC_ARROW) ;
    	StepClass. iBkColor= COLOR_lightwhite;
    	StepClass.WinProc= StepControlProc;
    	return RegisterWindowClass (&StepClass);
    }
    static void UnregisterStepControl()
    {
    	UnregisterWindowClass (STEP_CTRL_NAME);
    }
    
    

    二、控件子类化

    采用控件类和控件实例的结构,不仅可以提高代码的可重用性,而且还可以方便地对已有控件类进行扩展。比如,在需要建立一个只允许输入数字的编辑框时,就可以通过重载已有编辑框控件类而实现,而不需要重新编写一个新的控件类。在MiniGUI中,这种技术称为子类化或者窗口派生。

    子类化的方法有三种:

    1. 一种是对已经建立的控件实例进行子类化,子类化的结果是只影响这一个控件实例;
    2. 一种是对某个控件类进行子类化,将影响其后创建的所有该控件类的控件实例;
    3. 最后一种是在某个控件类的基础上新注册一个子类化的控件类,不会影响
      原有控件类。在 Windows 中,这种技术又称为超类化。

    在 MiniGUI中,控件的子类化实际是通过替换已有的窗口过程实现的。清单3中的代码就通过控件类创建了两个子类化的编辑框,一个只能输入数字,而另一个只能输入字母:

    清单3控件的子类化

    #define IDC_CTRL1 100
    #define IDC_CTRL2 110
    #define IDC_CTRL3 120
    #define IDC_CTRL4 130
    #define MY_ES_DIGIT_ONLY 0x0001
    #define MY_ES_ALPHA_ONLY Ox0002
    static WNDPROC old_edit proc;
    static int RestrictedEditBox(HWND hwnd,int message,WPARAM wParam,LPARAM lParam)
    {
    	if(message==MSG_CHAR)
    	{
    		DWORD my_style_= GetWindowAdditionalData (hwnd);
    		/*确定被屏蔽的按键类型*/
    		if ((my_style & MY_ES_DIGIT_ONLY) && (wParam< '0'|| wParam >'9'))
    		return 0;
    		else if (my_style & MY_ES_ALPHA_ONLY)
    		if (!((wParam >= 'A’&& wParam <= 'Z') || (wParam >= 'a' &&wParam <= 'z')))
    		/*收到被屏蔽的按键消息,直接返回*/
    		return 0;
    	}
    	/*由老的窗口过程处理其余消息*/
    	return (*old_edit_proc)(hwnd,message,wParam,lParam);
    }
    	static int ControlTestWinProc (HWND hWnd,int message,WPARAM wParam,LPARAM lParam)
    {
    	switch (message)
    	{
    		case MSG_CREATE:
    		{
    			HWND hWnd1,hWnd2,hWnd3;
    			CreateWindow (CTRL_STATIC,"Digit-only box:", WS_CHILDWS_VISIBLE | SS_RIGHT,0,10,10,180,24,hWnd,O);
    			hWnd1 = CreateWindow (CTRL_EDIT,"", WS_CHILD | WS_VISIBLE|WS_BORDER, IDC_CTRL1,200,10,180,24,hWnd,MY_ES_DIGIT_ONLY);
    			CreateWindow (CTRL_STATIC,"Alpha-only box:", WS_CHILDWS_VISIBLE | SS_RIGHT,0,10,40,180,24,hWnd,O);
    			hWnd2 = CreateWindow (CTRL_EDIT,"",WS_CHILD | WS_BORDERWS_VISIBLE,IDC_CTRL2,200,40,180,24,hWnd,MY_ES_ALPHA_ONLY);
    			CreateWindow (CTRL_STATIC,"Normal edit box:", WS_CHILD |WS_VISIBLE | SS_RIGHT,0,10,70,180,24,hWnd,O);
    			hWnd3 = CreateWindow (CTRL_EDIT,"",WS_CHILD | WS_BORDER|WS_VISIBLE,IDC_CTRL2,200,70,180,24,hWnd,MY_ES_ALPHA_ONLY);
    			CreateWindow ("button","Close", WS_CHILD | BS_PUSHBUTTON |WS_VISIBLE,IDC_CTRL4,100,100,60,24,hWnd,O);
    			/*_用自定义的窗口过程替换编辑框的窗口过程,并保存老的窗口过程*/
    			old_edit_proc = SetWindowCallbackProc (hWnd1,RestrictedEditBox);
    			SetWindowCallbackProc (hWnd2,RestrictedEditBox);
    			break;
    		}
    		......
    	}
    	return DefaultMainWinProc (hWnd,message,wParam,lParam);
    }
    	
    

    三、对话框和对话框模板

    在 MiniGUI中,对话框是一类特殊的主窗口,这种主窗口只关注与用户的交互一一向用户提供输出信息,但更多的是用于用户输入。对话框可以理解为子类化之后的主窗口类。它针对对话框的特殊性(即用户交互)进行了特殊设计。比如用户可以使用TAB键遍历控件、可以利用ENTER键表示默认输入等等。在MiniGUI当中,在建立对话框之前,首先需要定义一个对话框模板,该模板中定义了对话框本身的一些属性,比如位置和大小等等,同时定义了对话框中所有控件的初始信息,包括位置、大小、风格等等。在 MiniGUI中,用两个结构来表示对话框模板(src/window.h) :

    typedef struct
    {
    	char*class_name;        //control class
    	DWORD dwStyle;          // control style
    	int x,y, w,h;           // control position in
        int id;                // control identifier
    	const char* caption;   // control caption
    	DWORD dwAddData;       // additional data
    	DWORDdwExStyle;       // control extended style
    }CTRLDATA;
    typedef CTRLDATA* PCTRLDATA;
    
    typedef struct
    {
    	DWORD dwStyle;         // dialog box style
    	DWORD dwExStyle;       // dialog box extended
    	int x,y, w,h;          // dialog box position
    	const char* caption;   //dialog box caption
    	HICON hIcon;           //dialog box icon
    	HMENU hMenu;           //dialog box menu
    	int controlnr;         // number of controls
    	PCTRLDATA controls;     // poiter to control array
    	DWORD dwAddData;       // addtional data,must be
    }DLGTEMPLATE;
    typedef DLGTEMPLATE* PDLGTEMPLATE;
    
    

    结构CTRLDATA用来定义控件,DLGTEMPLATE用来定义对话框本身。在程序中,应该首先利用CTRLDATA定义对话框中所有的控件,并用数组表示。控件在该数组中的顺序,也就是对话框中用户按TAB键时的控件切换顺序。然后定义对话框,指定对话框中的控件数目,并指定DLGTEMPLATE结构中的controls 指针指向定义控件的数组。如清单4所示。

    清单4对话框模板的定义

    DLGTEMPLATE DlgInitProgress ={WS_BORDER | WS_CAPTION,WS_EX_NONE,120,150,400,130,VAM-CNC,"正在进行初始化",0,0,3,NULL,0} ;
    CTRLDATA CtrlInitProgress [] =
    {
    	{"static",WS_VISIBLE|SS_SIMPLE,10,10,380,16,IDC_PROMPTINFO,"正在...",0},
    	{"progressbar",wS_VISIBLE,locin,10,40, 380,20,IDC_PROGRESS,NULL,0},
    	{"button",WS_TABSTOP|WS_VISIBLE| BS_DEFPUSHBUTTON,170,70,60,25,IDOK,"确定",0}
    };
    
    

    在定义了对话框模板数据之后,需要定义对话框的回调函数,并调用
    DialogBoxIndirectParam函数建立对话框,如清单5所示,所建立的对话框如图1所示。

    清单5 定义对话框回调函数,并建立对话框

    /*定义对话框回调函数*/
    static int InitDialogBoxProc (HWND hDlg, int message,WPARAM wParam,LPARAM lParam)
    {
    	switch (message)
    	{
    		case MSG_INITDIALOG:
    			return 1;
    		case MSG_COMMAND:
    			switch (wParam)
    			{
    				case IDOK:
    				case IDCANCEL:
    					EndDialog (hDlg,wParam) ;
    					break;
    			}
    			break;
    	}
    	return DefaultDialogProc (hDlg,message,wParam,lParam);
    }
    static void InitDialogBox (HWND hWnd)
    {
    	/*将对话框和控件数组关联起来*/
    	DlgInitProgress.controls = CtrlInitProgress;
    	DialogBoxIndirectParam (&DlgInitProgress,hWnd,InitDialogBoxProc,OL);
    }
    

    在这里插入图片描述
    DialogBoxIndirectParam以及相关函数的原型如下:

    int GUIAPI DialogBoxIndirectParam (PDLGTEMPLATE pDlgTemplate,HWND hOwner,WNDPROC DlgProc,LPARAM lParam);
    BOOL GUIAPI EndDialog (HWND hDlg,int endCode);
    void GUIAPI DestroyAl1Controls (HWND hDlg);
    
    

    在 DialogBoxIndirectParam中,需要指定对话框模板(pDlgTemplate)、对话框的托管主窗口句柄(hOwner)、对话框回调函数地址(DlgProc),以及要传递到对话框过程的参数值(lParam)。EndDialog用来结束对话框过程。
    DestroyAllControls 用来销毁对话框(包括主窗口)中的所有子控件。
    在清单5中,对话框回调函数并没有进行任何实质性的工作,当用户按下"确定"按钮时,调用_EndDialog函数直接返回。

    四、MSG_INITDIALOG消息

    对话框回调函数是一类特殊的主窗口回调函数。用户在定义自己的对话框回调函数时,需要处理MSG_INITDIALOG 消息。该消息是在 MiniGUI建立根据对话框模板建立对话框以及控件之后,发送到对话框回调函数的。该消息的 lParam 参数包含了由DialogBoxIndirectParam 函数的第四个参数传递到对话框回调函数的值。用户可以利用该值进行对话框的初始化,或者保存起来以备后用。例如,清单7中的程序将MSG_INITDIALOG 消息的 lParam参数保存到了对话框窗口句柄的附加数据中,这样可以确保在任何需要的时候,方便地从对话框窗口的附加数据中获取这一数据。

    static int DepInfoBoxProc (HWND hDlg, int message,WPARAM wParam,LPARAMlParam)
    {
    	struct _DepInfo *info;
    	switch(message)
    	{
    		case MSG_INITDIALOG:
    		{
    			/*将对话框参数 lParam 保存为窗口的附加数据,以备后用*/
    			info = (struct_DepInfo*)lParam;
    			SetWindowAdditionalData2 (hDlg,(DWORD)lParam);
    			break;
    		}
    		case MSG_COMMAND:
    		{
    		/*从窗口的附加数据中取出保存的对话框参数*/
    			info = (struct _DepInfo*)GetWindowAdditionalData2 (hDlg);
    			switch(wParam)
    			{
    				case IDOK:
    				/*使用info 结构中的数据*/
    			 	......
    				case IDCANCEL:
    				EndDialog(hDlg, wParam);
    				break;
    			}
    		}
    		}
    	return DefaultDialogProc (hDlg,message,wParam,lParam);
    }
    

    通常而言,传递到对话框回调函数中的参数是一个结构的指针,该结构包含一些初始化对话框的数据,同时也可以将对话框的输入数据保存下来并传递到对话框之外使用。

    五、模态和非模态对话框

    简单而言,模态对话框就是显示之后,用户不能再切换到其他主窗口进行工作的对话框,而只能在关闭之后,才能使用其他的主窗口。MiniGUI中,使用
    DialogBoxIndirectParam函数建立的对话框就是模态对话框。实际上,该对话框首先根据模板建立对话框,然后禁止其托管主窗口,并在主窗口的 MSG_CREATE消息中创建控件,并发送MSG_INITDIALOG 消息给回调函数,最终建立一个新的消息循环,并进入该消息循环,直到程序调用EndDialog 函数为止。

    实际上,我们也可以在 MiniGUI中利用对话框模板建立普通的主窗口,即非模态对话框。这时,我们使用CreateMainWindowIndirect函数。该函数以及相关函数的原型如下( src/window.h) :

    HWND GUIAPI CreateMainWindowIndirect (PDLGTEMPLATE pDlgTemplate,HWND hOwner,WNDPROC WndProc);
    BOOL GUIAPI DestroyMainWindowIndirect (HWND hMainWin);
    
    

    使用CreateMainWindowIndirect根据对话框模板建立的主窗口和其他类型的普通主窗口没有任何区别。

    总结

    对话框编程是MiniGUI应用开发中使用最为常见的一种技术。通过定义一个对话框模板,就可以自动创建一个具有复杂输入输出界面的对话框。本文讲述了MiniGUI中的控件类和控件实例的关系,并举例说明控件子类化的概念及应用;然后讲解了MiniGUI 对话框的编程技术,包括对话框模板的定义和对话框回调函数的编程;最后说明了模态对话框和非模态对话框之间的区别。

    展开全文
  • QT:对话框Dialog

    2021-08-05 18:15:28
    对话框是 GUI 程序中不可或缺的组成部分。很多不能或者不适合放入主窗口的 功能组件都必须放在对话框中设置。对话框通常会是一个顶层窗口,出现在程序最上层,用于实现短期任务或者简洁的用户交互。 Qt 中使用...
  • 我有一个由两部分组成的问题.我需要添加支持打印到现有的基于对话框的MFC项目.正在打印的文档是使用HTML组成的.我知道我可以添加基于HTML的对话框,但是如何添加打印功能呢?PS.我需要这个能够根据程序的需要设置打印...
  • VC++程序设计与应用--对话框

    千次阅读 2021-12-31 23:23:59
    对话框的应用
  • MFC基于对话框编程

    2021-07-13 14:32:26
    在Visual C++中,对话框既可以单独组成一个简单的应用程序,又可以成为文档/视图结构程序的资源。 创建基于对话框的 MFC 应用程序框架 程序的创建过程: 选择“文件 | 新建 | 项目”菜单; 在“新建项目”...
  • 这类小窗口通常称作对话框,依据消息交互的过程,可将对话框分为三类:消息对话框、确认对话框、输入对话框,分别介绍如下:1、消息对话框这类对话框仅仅向用户展示一段文本,告诉用户发生了什么事情。它起到了提示...
  • 7.4 通用对话框

    2022-07-08 11:25:30
    7.4 通用对话框
  • 常用对话框:文件对话框

    千次阅读 2014-12-09 13:59:38
     文件对话框分为打开文件对话框和保存文件对话框,相信大家在Windows系统中经常见到这两种文件对话框。例如,很多编辑软件像记事本等都有“打开”选项,选择“打开”后会弹出一个对话框,让我们选择要打开文件的...
  • MFC 对话框 和 单文档 有啥区别? 这里具体的消息路径如下: 在SDI(单文档)界面中,菜单响应遵循这样一个顺序:菜单消息先由CMainFrame类接收,CMainFrame并不直接在内部寻找对应的相应函数,而是到CView类寻找。...
  • PyQt主窗口、对话框

    千次阅读 2022-01-21 16:50:52
    app.exec_() 2、输入窗口 QInputDialog   QImputDialog控件是一个标准对话框,由一个文本框和两个按钮(OK按钮和Cancel按钮)组成。当用户单击OK按钮或按Enter键后,在父窗口可以收集通过QInputDialog 控件输入的...
  • 图标选择器对话框完全可自定义的图标选择器对话框,可以轻松访问高质量的图标,而不必将其单独包含在项目中。 图标捆绑在图标包中,这些图标包作为单独的图标选择器对话框分发。完全可自定义的图标选择器对话框,...
  • 对话框-计算机文化基础第 二 章 Windows XP 操作系统 本章内容 2.1 操作系统概述 2.2 Windows XP基础 2.3 Windows XP的桌面 2.4 Windows XP的资源管理器 2.5 控制面板 2.6 Windows XP的系统维护与性能优 2.7 Windows...
  • MFC编程之文件对话框

    2018-04-27 20:22:19
    什么是文件对话框? 文件对话框分为打开文件对话框和保存文件对话框,例如很多时候我们点击下载某个文件的时候,都会弹出一个选项框“保存文件”或者“打开文件”,点击这个按钮,会弹出硬盘的目录。 二. 文件...
  • C#对话框

    2020-05-06 09:29:20
    public static DialogResult Show(string text,string caption,MessageBoxButtons buttons,MessageBoxIcon icon);... 消息框包含确定按钮 OKCancel 包含确定、取消按钮 AbortRetryIgnore ...
  • 对话框 一种次要窗口,包含按钮和各种选项,通过它们可以完成特定命令或任务。对话框与窗口有区别,它没有最大化按钮、没有最小化按钮、不能改变形状大小对话框:是人机交流的一种方式,用户对对话框进行设置,...
  • MFC学习笔记(1)--对话框

    千次阅读 2017-11-14 09:58:01
    是否带有标题栏左上角的系统菜单,包括移动、关闭等菜单项。 Title Bar: 是否带有标题栏。 Font(Size): 字体类型和字体大小。如果将其修改为非系统字体,则Use System自动改为False。而如果Use System原来...
  •  GetSingleChoice("text","title",list) list是个字符串组成的列表,返回选取字符串的值    ● 文件对话框  FileDialog(parent,"title","defaultpath","defaultfile",style) 生成一个选择文件的对话框...
  • 想要获取一个可执行文件(PE文件)里包含的资源文件,首先要解析可执行文件,得到资源存储的地址及大小,可参考 https://blog.csdn.net/zhyulo/article/details/85717711。然后,根据资源存储方式,得到各资源的数据...
  • 目录 一、文件管理 1、目录操作 1.1、QDir与QFileInfo ...1、标准输入对话框 2、标准字体对话框 3、标准颜色对话框 4、标准文件对话框 5、标准消息对话框 一、文件管理 1、目录操作 ...
  • VB讲课笔记10:菜单与对话框

    千次阅读 2018-03-14 06:46:11
    VB讲课笔记10:菜单与对话框一、用户界面设计基础用户界面是应用程序最基本的组成部分,其内容包括界面基本元素的外观设计和实现相应功能的代码编制。 1、用户界面元素(User Interface Element) 窗体是用户界面...
  • Blazor Modal对话框编辑器

    千次阅读 2021-05-17 22:49:43
    模态对话框 运行版本2 版本3 ModalResult和ModalResultType ModalOptions IModal对话 模态对话框 天气组件 天气编辑器 FetchDataModal 总结 介绍 为了设置本文的上下文,自Blazor首次发布以来,已经有...
  • js-消息对话框

    2019-10-08 02:17:27
    消息对话框1. **alert **消息对话框,输出内容,可以是字符串或变量,与document.write 相似 var mychar="I love JavaScript"; alert(mychar);2. **confirm** 消息对话框通常用于允许用户做选择的动作,如:“你对吗...
  • MFC 对话框 添加 工具栏

    千次阅读 2021-10-15 12:48:56
    MFC 对话框 添加 工具栏 MFC中如何删除工具栏中多余的图标 刚学习MFC的时候,发现在MFC资源视图里面编辑工具栏的时候,多余的图标没有删除键,其实只要把你要删除的图标按住并往外拖就可以了。 ...
  • MFC 对话框常用控件详解

    千次阅读 2019-08-19 10:24:28
    按钮控件包括命令按钮(Button)、单选按钮(Radio Button)和复选框(Check Box)等。 按钮控件会向父窗口发送通知消息,最常用的通知消息莫过于BN_CLICKED和BN_DOUBLECLICKED了。用户在按钮上单击鼠标时会向...
  • MFC——创建文件对话框

    千次阅读 2018-07-19 15:41:52
    1 创建文件对话框   2.1 文件对话框类CFileDialog  MFC使用文件对话框类CFileDialog封装了对文件对话框的操作。CFileDialog类的构造函数原型如下: explicit CFileDialog(  BOOL bOpenFileDialog,  ...
  • 单文档、多文档、对话框的区别

    千次阅读 2017-03-31 12:08:46
    只不过对话框框架程序对于控件组成的界面有更好的包装,适应于界面通过很多控件呈现的简单程序。CDialog 类提供管理对话框的接口,Visual C++ 对话框编辑器使设计对话框和创建它们的对话框模板资源更为容易,代码...
  • 文件对话框的分类

    2020-06-25 16:50:26
    文件对话框分为打开文件对话框和保存文件对话框,相信大家在Windows系统中经常见到这两种文件对话框。例如,很多编辑软件像记事本等都有“打开”选项,选择“打开”后会弹出一个对话框,让我们选择要打开文件的路径...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,542
精华内容 27,416
热门标签
关键字:

对话框的组成包括什么