精华内容
下载资源
问答
  • 对话框

    2008-11-02 20:46:00
     对话框窗口区别,它没有最大化按钮、没有最小化按钮、不能改变形状大小 对话框:是人机交流一种方式,用户对对话框进行设置,计算机就会执行相应命令。对话框中有单选框、复选框等。 对话框的组成 ...

    编辑词条对话框

      一种次要窗口,包含按钮和各种选项,通过它们可以完成特定命令或任务。
      对话框与窗口有区别,它没有最大化按钮、没有最小化按钮、不能改变形状大小
      对话框:是人机交流的一种方式,用户对对话框进行设置,计算机就会执行相应的命令。对话框中有单选框、复选框等。
      对话框的组成
      对话框主要由两部分组成。
      对话框资源:可以使用对话框编辑器来配置对话框的界面,如对话框的大小、位置、样式,对话框中控件的类型和位置等。另外,我们还可以在程序的执行过程中动态创建对话框资源。
      对话框类:在MFC程序中,可以使用向导帮助用户建立一个与对话框资源相关联的类,通常这个类由CDialog类派生。
      对话框的类型
      对话框可以分为模式对话框和无模式对话框两种类型。
      CDialog
      为了能够方便的操作对话框,MFC为用户提供了CDialog类。它是在屏幕上显示对话框的基类,与对话框资源紧密相关,提供了管理对话框的接口,封装了一些对话框的相关操作。
      从CDialog的定义代码可以看出,Cdialog提供了两套构建Cdialog对象的系统,分别用于模式对话框和无模式对话框。
      无模式对话框对象的构建过程,它首先调用缺省的构造函数生成对话框对象,然后调用Create函数创建和初始化对话框。Cdialog类中的Create函数有两种函数原型:
      BOOL Create( LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL );
      BOOL Create( UINT nIDTemplate, CWnd* pParentWnd = NULL );
      其中,
      参数lpszTemplateName是无模式对话框模板资源的标志符;
      参数nIDTemplat是对话框模板资源的标志符,它通常以IDD_开头(例如IDD_DIALOG1);
      参数pParentWnd是指向对话框对象所属的父窗口的指针(如果它为NULL,则表示对话框对象的父窗口是应用程序主窗口)。如果希望对话框中它的父窗口创建后马上被显示,就必须把对话框模板设置为WS_VISIBLE形式。否则,需要调用ShowWindow函数来显示对话框。
      对于模式对话框,其构造函数如下所示:
      CDialog( LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL );
      CDialog( UINT nIDTemplate, CWnd* pParentWnd = NULL );
      构造函数的参数说明与无模式对话框的Create函数类似。在模式对话框中,当创建了对话框对象后,可以通过调用DoModal函数来显示对话框。
      一般情况下,无论是模式对话框还是无模式对话框,都有两个按钮OK和CANCEL。对话框为它们提供了默认的消息处理函数OnOk和OnCancel。调用这两个函数都将关闭对话框。所不同的是,默认的OnOk函数中关闭对话框前将更新对话框数据,而默认的OnCancel函数不更新对话框数据。
      当CDialog类检测到OK或Cancel键时,它将调用::EndDialog函数。EndDialog函数虽然结束了对话框应用程序,但却并没有删除对话框对象,释放内存。这对于模式对话框来说,不是问题,它的生存时间不长,我们一般在栈上创建它们;但无模式对话框则不同,它的生存时间更长,我们通常在栈上创建它们,并且希望它在消失之前能够删除自己。因此,大多数情况下,我们需要在无模式对话框中重载OnOK和OnCancel函数,加入DestroyWindows函数来彻底地删除它。
      对话框数据交换和验证机制
      在VC中,所有的对话框函数都是使用C++代码实现的,它并没有采用特殊的资源或“奇特”的宏,但却可以很好地实现用户与应用程序之间的交互工作,这里的关键就在于对话框应用程序中广泛采用的对话框数据交换和验证机制。
      对话框数据交换(DDX,Dialog Data Exchange)用于初始化对话框中的控件并获取用户的数据输入,而对话框数据验证(DDV,Dialog Data Validation)则用于验证对话框中数据输入的有效性。MFC在每个对话框类中提供了一个用于重载的虚函数——DoDataExchange来实现对话框数据交换和验证工作。
      对话框数据交换
      如果使用DDX机制,则通常在OnInitDialog程序或对话框构造函数中设置对话框对象成员变量的初始值。在对话框即将显示前,应用程序框架的DDX机制将成员变量的值传递给对话框的控件,当对话框响应DoModal或Create而被显示时,对话框控件将“显示”这些值。Cdialog类中的OnInitDialog函数默认时将调用CWnd类的UpdateData成员函数初始化对话框中的控件。UpdateData函数的原型如下:
      BOOL UpdateData( BOOL bSaveAndValidate = TRUE );
      函数参数为TRUE,即将对话框及其控件中的数据传递给程序代码中的成员变量;
      函数参数为FALSE,即将类中的数据状态传递给对话框及其控件。
      当用户重载DoDataExchange函数时,也就为每一个数据成员(控件)指定了一个DDX函数调用。
      对话框数据验证
      除了调用DDX参数指定数据交换外,用户还可以使用DDV函数进行对话框数据验证。在调用控件的DDX函数后,必须立即调用该控件的DDV函数。大部分DDV函数的原型如下所示。
      DDV_MinMaxCustom(pDX, Data, MinData, MaxData);
      其中,参数pDX是一个指向CdataExchange对象的指针,参数Data中存放着即将被验证的数据,后两个参数用于定制数据的范围。
      CdataExchange类
      如果仅仅需要使用对话框数据,一般没有必要了解数据交换/验证的核心内容。但在了解了数据交换和验证的实质后,用户就可以编写自己的数据交换和验证代码,定制DDX/DDV.
      对话框控件
      控件是一个可以与其交互以完成输入或操作数据操作的对象,它也是一种特殊的窗口。控件通常出现在对话框或工具栏中。Windows提供了多种多样的控件,在MFC应用程序中,能够使用的控件通常可以分为三种。
      1)windows公用控件:包括编辑控件、按钮、列表框、组合框、滑动条控件等,另外也包括所有者描述的控件。
      2)ActiveX控件:既可以在对话框中使用,也可以在HTML网页中使用。
      3)由MFC提供的其他控件类
      我们主要介绍第一种类型的控件——Windows公用控件。
      Windows操作系统提供了多种windows公用控件,这些控件对象都是可编程的,Visual C++的对话框编辑器支持将这些控件对象添加到对话框中。用户可以在工具箱的对话框编辑器中看到这些windows公用控件。MFC为了更好的支持windows公用控件,提供了多种控件类,每一个控件类封装一种控件,并提供相应的成员函数来管理操作控件。
    展开全文
  • 两者的区别PopupWindowAlertDialog最大的区别:AlertDialog是非阻塞线程,AlertDialog弹出时候,后台可以做其他事情(也即弹出对话框后程序会继续向下执行);PopupWindow是阻塞线程, 这就意味着在我们退出...

    两者的区别
    PopupWindow和AlertDialog最大的区别:
    • AlertDialog是非阻塞线程的,AlertDialog弹出的时候,后台可以做其他事情(也即弹出对话框后程序会继续向下执行);
    • PopupWindow是阻塞线程的, 这就意味着在我们退出这个弹出框之前,程序会一直等待,只有当我们调用了dismiss方法之后,PopupWindow退出,程序才会向下执行。
    注意:当他们两个弹出或消失时,都不会调用Activity生命周期的任何方法

    注:自定义对话框可以用builder.setView(View,view)设置!
    注:官方不推荐直接使用Dialog创建对话框(推荐使用AlertDialog或DialogFragment),而我们公司用的对话框都是继承自Diaolog的。


    控制显示位置
    控制popupWindow显示位置的方法:
    1、showAtLocation()显示在指定位置,有两个方法重载:
    • public void showAtLocation(View parent, int gravity, int x, int y)
          如showAtLocation(parent, Gravity.RIGHT | Gravity.BOTTOM, 10,10)
      • 第一个参数指定PopupWindow的锚点view,即依附在哪个view上。
      • 第二个参数指定起始点为parent的右下角
      • 第三、四个参数设置以parent的右下角为原点,向左、上各偏移10像素。
      • 如果没有充足的空间显示PopupWindow,那么PopupWindow将裁剪
    • public void showAtLocation(IBinder token, int gravity, int x, int y)
    2、showAsDropDown()显示在一个参照物View的周围,有三个方法重载:
    • public void showAsDropDown(View anchor)
    • public void showAsDropDown(View anchor, int xoff, int yoff)
    • public void showAsDropDown(View anchor, int xoff, int yoff, int gravity)

    以上两个方法的位移参数可以通过以下方法设置:

    • 具体的值
    • 通过view.getWidth()等方法获取控件大小
    • 通过view.getLocationOnScreen(location)方法将view在屏幕上的位置取出并存放在数组location中,进而获取位移

    注意:如果不设置PopupWindow的背景,无论是点击外部区域还是Back键都无法dismiss弹框


    控制对话框显示位置:
    通过 dialog.getWindow() 获取对话框窗口对象,对此Window进行设置后再设置给dialog即可
    只能对Dialog设置,对AlertDialog我还不知道怎么设置



    dialog和pop演示布局

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:background="#fff"
        android:orientation="vertical" >
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog1"
            android:text="确定取消对话框" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog2"
            android:text="单选对话框" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog3"
            android:text="多选对话框" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog4"
            android:text="进度条对话框" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog5"
            android:text="带进度的进度条对话框" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="dialog6"
            android:text="自定义对话框显示位置" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="popup1"
            android:text="popup,出现在v的下方" />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:onClick="popup2"
            android:text="popup,出现在任意位置" />
    </LinearLayout>


    dialog和pop演示代码
    import android.content.DialogInterface.OnClickListener;
    import android.widget.LinearLayout.LayoutParams;
    public class MainActivity extends Activity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        //确定取消对话框
        public void dialog1(View view) {
            AlertDialog.Builder builder = new Builder(this);//对话框的创建器
            builder.setTitle("我是对话框");
            builder.setMessage("对话框显示的内容");
            builder.setPositiveButton("确定"new OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    //参数:dialog-The dialog that received the click.;which-The button that was clicked 
                    Toast.makeText(MainActivity.this"确定被点击了", 0).show();
                }
            });
            builder.setNegativeButton("取消"new OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    Toast.makeText(MainActivity.this"取消被点击了", 0).show();
                }
            });
            builder.setCancelable(false);//是否能不做选择,默认为true
            builder.create().show();
        }
        //单选对话框
        public void dialog2(View view) {
            AlertDialog.Builder builder = new Builder(this);
            builder.setTitle("请选择您的性别");
            final String[] items = { "男""女""未知" };
            builder.setSingleChoiceItems(items, -1, new OnClickListener() {//指定选择的是哪个,-1代表默认没有选中
                        public void onClick(DialogInterface dialog, int which) {
                            Toast.makeText(MainActivity.this"您的性别:" + items[which], 0).show();
                            dialog.dismiss();
                        }
                    });
            builder.create().show();
        }
        //多选对话框
        public void dialog3(View view) {
            AlertDialog.Builder builder = new Builder(this);
            builder.setTitle("请选择你最爱吃的水果");
            final String[] items = { "苹果""梨""菠萝""香蕉""黄瓜" };
            final boolean[] result = new boolean[] { truefalsetruefalsefalse };//对应条目默认是否被选中
            builder.setMultiChoiceItems(items, result, new OnMultiChoiceClickListener() {
                public void onClick(DialogInterface dialog, int which, boolean isChecked) {
                    String inf = "";
                    if (isChecked) {
                        inf = " 被选中了";
                    } else {
                        inf = " 被取消选中了";
                    }
                    Toast.makeText(MainActivity.this, items[which] + inf, 0).show();
                    result[which] = isChecked;
                }
            });
            builder.setPositiveButton("提交"new OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                    StringBuffer sb = new StringBuffer();
                    for (int i = 0; i < result.length; i++) {
                        if (result[i]) {
                            sb.append(items[i] + " ");
                        }
                    }
                    Toast.makeText(MainActivity.this"您选中了:" + sb.toString(), 0).show();
                }
            });
            builder.create().show();
        }
        //进度条对话框
        public void dialog4(View view) {
            ProgressDialog pd = new ProgressDialog(this);//不需要创建器
            pd.setTitle("提醒");
            pd.setMessage("正在加载数据...请稍等。");
            pd.show();
        }
        //带进度的进度条对话框
        public void dialog5(View view) {
            final ProgressDialog pd = new ProgressDialog(this);
            pd.setTitle("提醒");
            pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);//当设置此属性的值后才会有进度显示
            pd.setMax(100);
            pd.setMessage("正在加载数据...请稍等。");
            pd.show();
            new Thread() {
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                        }
                        pd.setProgress(i);//改变当前进度
                    }
                    pd.dismiss();//当进度为100%时关闭对话框,可以在任意进程中关闭
                };
            }.start();
        }


        //自定义对话框显示位置-----不推荐!
        public void dialog6(View v) {
            Dialog dialog = new Dialog(this);
            dialog.setTitle("我是对话框");
            Window dialogWindow = dialog.getWindow(); // 获取对话框窗口对象
            WindowManager.LayoutParams mLayoutParams = dialogWindow.getAttributes();//获取对话框参数对象
            dialogWindow.setGravity(Gravity.LEFT | Gravity.BOTTOM);//修改对话框的布局设置
            mLayoutParams.x = 10;// 表示相对于【原始位置】的偏移,当为Gravity.LEFT时就表示相对左边界的偏移,正值右移,负值忽略
            mLayoutParams.y = 100;//当为Gravity.BOTTOM时正值上移,负值忽略
            mLayoutParams.width = 10;//为啥根本就没用
            mLayoutParams.height = 80;
            mLayoutParams.alpha = 0.2f; // 透明度
            dialogWindow.setAttributes(mLayoutParams);
            dialog.show();
        }

        //弹出窗体,出现在v的下方
        public void popup1(View v) {
            TextView tv = new TextView(this);
            tv.setText("我是弹出窗体中的内容");
            tv.setTextColor(0xffff0000);
            tv.setGravity(Gravity.CENTER);
            tv.setBackgroundColor(0xff00ffff);
            PopupWindow popWin = new PopupWindow(tv, LayoutParams.WRAP_CONTENT, 100);
            popWin.setFocusable(true);
            popWin.setOutsideTouchable(true);
            popWin.setBackgroundDrawable(new ColorDrawable(0x00ff0000));//背景和上面的综合了,这行代码是必须要有的
            popWin.showAsDropDown(v);
        }
        //弹出窗体,出现在任意位置,值为负时会移出可视窗口
        public void popup2(View v) {
            TextView tv = new TextView(this);
            tv.setText("我是弹出窗体中的内容");
            tv.setTextColor(0xffff0000);
            tv.setGravity(Gravity.CENTER);
            tv.setBackgroundColor(0xff00ffff);
            PopupWindow popWin = new PopupWindow(tv, LayoutParams.WRAP_CONTENT, 100);
            popWin.setFocusable(true);
            popWin.setOutsideTouchable(true);
            popWin.setBackgroundDrawable(new ColorDrawable(0x00ff0000));//背景和上面的综合了,这行代码是必须要有的
            popWin.showAtLocation(v, Gravity.TOP | Gravity.RIGHT, 10, 100);
        }
    }


    Pop+ListView演示代码

    public class MainActivity extends Activity {

        private EditText et_input;//输入框
        private ImageView iv_more;//点击弹出下拉窗口
        private PopupWindow popWin;
        private ListView listView;//弹出框PopupWindow中的View
        private List<String> mList;//listView中的数据
        private ViewHolder holder;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            et_input = (EditText) findViewById(R.id.et_input);
            iv_more = (ImageView) findViewById(R.id.iv_more);
            initListView();
            
            //弹出PopupWindow
            iv_more.setOnClickListener(new OnClickListener() {
                public void onClick(View v) {
                    popWin = new PopupWindow(listViewet_input.getWidth(), LayoutParams.WRAP_CONTENT);
                    popWin.setBackgroundDrawable(new ColorDrawable(0x00888800));//背景根本没效果的!
                    popWin.setOutsideTouchable(true); // 点击popWin 以处的区域,自动关闭 popWin
                    popWin.showAsDropDown(et_input);//设置 弹出窗口显示的位置,这句代码必须放在最后,否则要么显示不出来要么有BUG
                }
            });
        }
        private void initListView() {
            mList = new ArrayList<String>();
            for (int i = 0; i < 10; i++) {
                mList.add("工号为:0123456789" + i);
            }
            listView = new ListView(this);
            listView.setBackgroundResource(R.drawable.input); //背景图为一个9path图
            //listView.setDivider(new ColorDrawable(0xffff0000)); //设置条目之间的分隔线
            listView.setDivider(new ColorDrawable(getResources().getColor(R.color.red)));
            listView.setDividerHeight(1);//对应android:dividerHeight,代码中只能设置为int
            listView.setVerticalScrollBarEnabled(false); //不显示右侧的滚动条
            listView.setAdapter(new MyListAdapter());
        }
        private class MyListAdapter extends BaseAdapter {
            @Override
            public View getView(final int position, View convertView, ViewGroup parent) {
                if (convertView == null) {
                    convertView = View.inflate(getApplicationContext(), R.layout.itemnull);
                    holder = new ViewHolder();
                    holder.tv_item_delete = (ImageView) convertView.findViewById(R.id.tv_item_delete);
                    holder.tv_item_msg = (TextView) convertView.findViewById(R.id.tv_item_msg);
                    convertView.setTag(holder);
                } else holder = (ViewHolder) convertView.getTag();
                holder.tv_item_msg.setText(mList.get(position));
                //设置View每个条目中删除图标的点击事件
                holder.tv_item_delete.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        mList.remove(position);//删除此条目在数据源中的数据                  
                        notifyDataSetChanged();//内容改变时刷新listView
                    }
                });
                //设置整个View的点击事件
                convertView.setOnClickListener(new OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        et_input.setText(mList.get(position));
                        popWin.dismiss();
                    }
                });
                return convertView;
            }
            @Override
            public int getCount() {
                return mList.size();
            }
            @Override
            public Object getItem(int position) {
                return position;
            }
            @Override
            public long getItemId(int position) {
                return position;
            }
        }
        private class ViewHolder {
            TextView tv_item_msg;
            ImageView tv_item_delete;
        }
    }





    展开全文
  • Android对话框总结

    2015-04-28 15:19:11
    查找替换对话框 对话框窗口区别,它没有最大化按钮、没有最小化按钮、大都不能改变形状大小。(“打开文件”对话框是可以改变大小对话框:是人机交流一种方式,用户对对话框进行设置,计算机就会执行...
    一、什么是对话框?
    一种次要窗口,包含按钮和各种选项,通过它们可以完成特定命令或任务。 查找和替换对话框 对话框与窗口有区别,它没有最大化按钮、没有最小化按钮、大都不能改变形状大小。(“打开文件”对话框是可以改变大小的) 对话框:是人机交流的一种方式,用户对对话框进行设置,计算机就会执行相应的命令。对话框中有单选框、复选框等。
    要我说,对话框,就是一个用于和用户进行对话的小框框。大家见到最多的那种是弹出对话框。
    二、对话框有什么用?
    对话框不会阻塞主线程,可以和用户进行简单交互,且给人一种清新的感觉,好的对话框不仅不会影响用户体验,反而会让用户喜欢上这种被打扰的感觉。

    三、怎么用?

             

    1、系统对话框
    AlertDialog
    ProgressDialog
    DatePickerDialog
    TimePickerDialog
    2、自定义对话框
    a、使用LayoutInflate和Builder的setView方法实现
    b、继承Dialog类复写setContentView实现
    实例:
    activity_main.xml
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:orientation="vertical" >

        <Button
            android:id="@+id/show1"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_margin="10dp"
            android:background="@drawable/button_background"
            android:text="dialog1" />

        <Button
            android:id="@+id/show2"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_margin="10dp"
            android:background="@drawable/button_background"
            android:text="dialog2" />

        <Button
            android:id="@+id/show3"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_margin="10dp"
            android:background="@drawable/button_background"
            android:text="dialog3" />

    </LinearLayout>

    activity_dialog.xml
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical" >

        <TextView
            android:id="@+id/textView1"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="标题"
            android:textAppearance="?android:attr/textAppearanceLarge" />

        <TextView
            android:id="@+id/textView2"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="这是一个自定义布局的AlertDialog" />

        <TextView
            android:id="@+id/textView3"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="有木有很好玩" />

        <TextView
            android:id="@+id/textView4"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="想怎么布局就怎么布局"
            android:textAppearance="?android:attr/textAppearanceMedium" />

        <Button
            android:id="@+id/button1"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:background="@drawable/button_background"
            android:text="确定" />

    </LinearLayout>

    MainActivity.java
    public class MainActivity extends Activity {
        private Button show1, show2, show3;
        DatePickerDialog m = null;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            show1 = (Button) findViewById(R.id.show1);
            show2 = (Button) findViewById(R.id.show2);
            show3 = (Button) findViewById(R.id.show3);
            show1.setOnClickListener(mClickListener);
            show2.setOnClickListener(mClickListener);
            show3.setOnClickListener(mClickListener);
        }

        private View.OnClickListener mClickListener = new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                int id = arg0.getId();
                switch (id) {
                case R.id.show1:
                    showDialog1();
                    break;
                case R.id.show2:
                    showDialog2();
                    break;
                case R.id.show3:
                    showDialog3();
                    break;
                default:
                    break;
                }
            }
        };

        private void showDialog1() {
            new AlertDialog.Builder(this).setTitle("dialog 1")
                    .setMessage("这是最简单的AlertDialog").setPositiveButton("确定", null)
                    .setNeutralButton("什么", null).setNegativeButton("取消", null)
                    .create().show();
        }

        

        private void showDialog2(){
            LayoutInflater inflater = LayoutInflater.from(this);
            View view = inflater.inflate(R.layout.activity_dialog, null);
            final AlertDialog dialog = new AlertDialog.Builder(this).setView(view).create();
            Button ok = (Button) view.findViewById(R.id.button1);
            ok.setOnClickListener(new View.OnClickListener() {
                
                @Override
                public void onClick(View arg0) {
                    // TODO Auto-generated method stub
                    dialog.dismiss();
                }
            });
            dialog.show();
        }

        
        private void showDialog3(){
            new MyDialog(this).show();
        }
        
        private class MyDialog extends Dialog{

            public MyDialog(Context context) {
                super(context);
                // TODO Auto-generated constructor stub
                this.setContentView(R.layout.activity_dialog);
                this.setTitle("標題");
                Button b = (Button) findViewById(R.id.button1);
                b.setOnClickListener(new View.OnClickListener() {
                    
                    @Override
                    public void onClick(View arg0) {
                        // TODO Auto-generated method stub
                        dismiss();
                    }
                });
            }

        }
    }

    四、注意总结
    注意:
    1、不要使对话框泛滥
    2、自定义对话框时要注意dismiss()或则不用时remove()
    3、还有一种定义对话框的方法,那就是把Activity的主题设置为Theme.Dialog
    总结:
    在这个看颜的时代,要想成为一个好的程序员,首先要成为一名好的设计师。

    展开全文
  •  线程分为界面线程工作者线程,界面实际就是一个线程画出来的东西,这个线程维护一个“消息队列”,“消息队列”也是界面线程工作者线程的最大区别,这个词应该进到你的脑子里,根深蒂固的! 如果在界面线程的...

    每个系统都有线程,而线程的最重要的作用就是并行处理,提高软件的并发率。针对界面来说,还能提高界面的响应力。

     线程分为界面线程和工作者线程,界面实际就是一个线程画出来的东西,这个线程维护一个“消息队列”,“消息队列”也是界面线程和工作者线程的最大区别,这个词应该进到你的脑子里,根深蒂固的!

    如果在界面线程的某个地方停住,这说明它处理不了窗口消息了,所以有时候我们就会看到整个界面无响应了。这种问题后面会提供一个叫 WaitForObject 的函数来解决,我们后面再谈。

    线程首先就是它的创建,创建是用下面这个函数:CreateThread; 具体的参数我不说了,自己查MSDN。其中的 Thread1 是线程函数。线程函数是一个全局函数,如下:

    DWORD WINAPI Thread1(LPVOID lpParam)
    {
      while(1)
     {
      OutputDebugString("11111");

      Sleep(10);
     }
     return 0;
    }

    // 下面这一句是创建线程
    CreateThread(NULL, 0, Thread1, 0, 0, NULL);

    当然我们不能让一个线程自生自灭,那样有可能在你退出程序的时候出现一些莫名其妙的问题,或者丢失一些数据,或者给你弹一个崩溃的对话框等等。。。

    所以我们就要对这个线程进行管理,首先就是让它退出。

    我们给它的while加上一个 BOOL 变量 g_bExitThread的判断,这样的话,线程函数就变成下面这样:

    DWORD WINAPI Thread1(LPVOID lpParam)
    {
      while(!g_bExitThread)
     {
      OutputDebugString("11111");

      Sleep(10);
     }
     return 0;
    }

    然后在需要它退出的时候把g_bExitThread设为TRUE,表示,喂,兄弟,你该退出了。

    当然我们还要知道它是否成功退出了,因为线程句柄是一个内核对象,所以我们就要用到Windows的WaitForSingleObject来等待了。创建的时候和等待它退出的代码就要改变了,多了一个 HANDLE g_hTrd的变量:

    // 创建
    g_bExitThread = FALSE;
    g_hTrd = CreateThread(NULL, 0, Thread1, 0, 0, NULL);

    // 等待线程结束
    g_bExitThread = TRUE;

     if(g_hTrd != NULL)
     {
      DWORD dwRet = WaitForSingleObject(g_hTrd, 5000);
      if(dwRet == WAIT_OBJECT_0)
      {
       AfxMessageBox("Thread exit success!");
      }
      else
      {
       DWORD dwRet = 0;
       GetExitCodeThread(g_hTrd, &dwRet);
       TerminateThread(g_hTrd, dwRet);
       AfxMessageBox("Thread exit, but not all ok!");
      }
      CloseHandle(g_hTrd);
      g_hTrd = NULL;
     }

    上面说了在界面线程里等待别的线程结束,也就是使用 WaitForSingleObject 的时候会阻塞整个窗口消息的处理,所以我们如果在界面线程里要等待别的内核对象时,我们要采用这种“等一下,处理一下界面消息”的方法。我已经写好了一个 WaitForObjectEx 的函数,如下:

    // 此函数只能用于界面线程
    static DWORD WaitForObjectEx( HANDLE hHandle, DWORD dwMilliseconds )
    {
     BOOL bRet;
     MSG msg;
     INT iWaitRet;
     int nTimeOut = 0;
     while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
     {
      if(nTimeOut++ * 20 >= dwMilliseconds)
       break;

      iWaitRet = WaitForSingleObject(hHandle, 20);
      if(iWaitRet != WAIT_TIMEOUT)
      {
       break;
      }
      if (bRet == -1)
      {
       break;
      }
      else
      {
       ::TranslateMessage(&msg);
       ::DispatchMessage(&msg);
      }
     }

     return iWaitRet;
    }

    很多时候,我们不想把线程作为一个全局函数来使用,所以这个时候我们把线程作为一个类的静态成员对象来写。当然也不能少了刚才的两个变量:退出标志和线程句柄。(设这个类是CTestThreadDlg)

    // H 文件 
    BOOL m_bExitThread;
     HANDLE m_hTrd;
     static DWORD WINAPI Thread1(LPVOID lpParam);

    // CPP文件,创建的时候把 this 指针传进去,因为类静态成员函数不能访问类的非静态成员,没有this指针
    //(C++的知识点)
     m_bExitThread = FALSE;
     m_hTrd = CreateThread(NULL, 0, Thread1, this, 0, NULL);

    线程函数变成了:

     DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
     {
      CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
      while(!pDlg->m_bExitThread)
      {
       OutputDebugString("11111");
      
       Sleep(10);
      }
      return 0;
     }

    当有几个线程一起跑的时候,我们就要注意线程的同步问题了,线程的同步一般来说,是在多个线程共用了资源的时候。比如两个线程都用到了同一个VECTOR,都对VECTOR进行插入操作,不幸的是,VECTOR不是线程安全的,这个时候程序就会崩溃,所以我们就要对VECTOR这个资源做同步,同步的意思是“我访问的时候,你等待”。程序大致如下:

    DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
     {
      CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
      while(!pDlg->m_bExitThread)
      {
       OutputDebugString("11111");
     
       pDlg->m_csForVec.Lock();
       pDlg->m_vecTest.push_back("111");
       pDlg->m_csForVec.Unlock();
     
       Sleep(10);
      }
      return 0;
     }

    DWORD WINAPI CTestThreadDlg::Thread2(LPVOID lpParam)
    {
     CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
     while(!pDlg->m_bExitThread2)
     {
      OutputDebugString("222");

      pDlg->m_csForVec.Lock();
      pDlg->m_vecTest.push_back("222");
      pDlg->m_csForVec.Unlock(); 

      Sleep(10);
     }
     return 0;
    }

    m_csForVec 是一个CCriticalSection变量,这个同步对象和其他的同步变量(事件、信号量、互斥区等)有一些不一样,例如只能在同一个进程的线程间访问、在操作系统的用户态访问,其他的必须进入核心态。所以这样导致了这种关键区的核心对象的速度要比其他的快100倍左右。。。

    上面已经说了线程的创建、管理(退出线程、等待线程)、同步等,那我们发现了什么共性呢?作为一个程序员,我们要很敏感的发现这些代码上的共性,这是我们设计代码的主要前提。

    首先我们发现上面的线程都有两个变量: 
    BOOL m_bExitThread;  // 让线程退出的标志
     HANDLE m_hTrd;  // 线程句柄

    另外我们WaitForSingleObject 的时候不能无限等待,所以要多一个 DWORD m_dwWaitTimeOut;

    由于我想把线程启动和结束封装起来,所以我设计了这几个接口:

     BOOL Start(LPVOID lpParam);  //  启动线程,线程所需要的参数从这里传进
     BOOL End(); // 结束线程
     virtual void Run(); // 重写Run函数

    所以整个的线程封装成以下的类:

    // MyThread.h

    #ifndef MY_THREAD_H
    #define MY_THREAD_H

    class CMyThread
    {
    public:
     CMyThread();
     virtual ~CMyThread();

     BOOL Start(LPVOID lpParam);
     BOOL End();
     virtual void Run();

    protected:
     static DWORD WINAPI Thread(LPVOID lpParam);
     void RunOnceEnd();

     DWORD m_dwWaitTimeOut;
     BOOL m_bExitThread;
     HANDLE m_hTrd;
     LPVOID m_lpParam;
    };

    #endif

    // MyThread.Cpp

    #include "stdafx.h"
    #include "MyThread.h"
    /
    // CMyThread
    CMyThread::CMyThread()
    {
     m_bExitThread = FALSE;
     m_hTrd = NULL;
     m_dwWaitTimeOut = 5000;
    }

    CMyThread::~CMyThread()
    {

    }

    BOOL CMyThread::Start(LPVOID lpParam)
    {
     m_lpParam = lpParam;
     m_bExitThread = FALSE;
     m_hTrd = CreateThread(NULL, 0, Thread, this, 0, NULL);

     return TRUE;
    }

    BOOL CMyThread::End()
    {
     m_bExitThread = TRUE;

     if(m_hTrd != NULL)
     {
      DWORD dwRet = WaitForSingleObject(m_hTrd, m_dwWaitTimeOut);
      if(dwRet == WAIT_OBJECT_0)
      {
       AfxMessageBox("Thread exit success!");
      }
      else
      {
       DWORD dwRet = 0;
       GetExitCodeThread(m_hTrd, &dwRet);
       TerminateThread(m_hTrd, dwRet);
       AfxMessageBox("Thread fucking exit!");
      }

      CloseHandle(m_hTrd);
      m_hTrd = NULL;
     }
     
     return TRUE;
    }

    DWORD WINAPI CMyThread::Thread(LPVOID lpParam)
    {
     CMyThread *pTrd = (CMyThread *)lpParam;
     
     while(!pTrd->m_bExitThread)
     {
      pTrd->Run();
     }

     return 0;
    }

    void CMyThread::RunOnceEnd()
    {
     m_bExitThread = TRUE;
     CloseHandle(m_hTrd);
     m_hTrd = NULL;
    }

    void CMyThread::Run()
    {
    }

    我们需要写我们自己的线程的时候就重载一下这个Run函数

    // 派生出一个类
    class CMyThread1 : public CMyThread
    {
    public:
     virtual void Run();
    };

    // 改写Run函数
    void CMyThread1::Run()
    {
     CTestThreadDlg *pDlg = (CTestThreadDlg *)m_lpParam;

     OutputDebugString("222");
     
     pDlg->m_csForVec.Lock();
     pDlg->m_vecTest.push_back("222");
     pDlg->m_csForVec.Unlock(); 
     
     Sleep(10);

     // 如果此线程只想运行一次,加上下面这句
     RunOnceEnd();
    }

    然后我们之前的两个线程的使用就变成了下面的形式:

    CMyThread1 g_t1, g_t2, g_t3;
    void CTestThreadDlg::OnButton3()
    {
     g_t1.Start(this);
     g_t2.Start(this);
     g_t3.Start(this); 
    }

    void CTestThreadDlg::OnButton4()
    {
     g_t1.End();
     g_t2.End();
     g_t3.End();  
    }


    只需要以下几步:
    1、派生自己的线程类
    2、重载Run函数
    3、调用Start启动线程
    4、调用End结束线程

    http://blog.csdn.net/dylgsy/article/details/2176160

    http://blog.sina.com.cn/s/blog_4d6c5b5e01000986.html

    工作线程与界面进程

    在MFC程序中创建一个线程,宜调用AfxBeginThread函数。该函数因参数不同而具有两种重载版本,分别对应工作者线程和用户接口(UI)线程,关于UI线程和工作者线程的分配,最好的做法是:将所有与UI相关的操作放入主线程,其它的纯粹的运算工作交给独立的数个工作者线程。


    用户接口(UI)线程:主要是用于处理用户的输入并响应各种事件和消息,他是由CWinThread派生出来的
    工作者线程:进行程序的后台任务,如计算调度等,它不需要重CWinThread类派生出来进行创建,它其实就是一个函数,这个函数完成该线程并行的工作,由其它语句调用这个线程启动。
     工作者线程

    CWinThread *AfxBeginThread(
     AFX_THREADPROC pfnThreadProc, //控制函数
     LPVOID pParam, //传递给控制函数的参数
     int nPriority = THREAD_PRIORITY_NORMAL, //线程的优先级
     UINT nStackSize = 0, //线程的堆栈大小
     DWORD dwCreateFlags = 0, //线程的创建标志
     LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL //线程的安全属性
    );

      工作者线程编程较为简单,只需编写线程控制函数和启动线程即可。下面的代码给出了定义一个控制函数和启动它的过程:

    //线程控制函数
    UINT MfcThreadProc(LPVOID lpParam)
    {
     CExampleClass *lpObject = (CExampleClass*)lpParam;  //定义一个函数指针来指向调用AfxBeginThread的命令所在的类
     if (lpObject == NULL || !lpObject->IsKindof(RUNTIME_CLASS(CExampleClass)))
      return - 1; //输入参数非法
     //线程成功启动
     while (1)
     {
      ...//
     }
     return 0;
    }
     
    eg:
    建立基于对话框的工程,建立控制函数:ThreadProc.h和ThreadProc.cpp以及建立一个基于CWinThread的类CMyUI;
    Cmytest17Dlg.CPP:
    void Cmytest17Dlg::OnBnClickedButton1()
    {
     // TODO: 在此添加控件通知处理程序代码
            CMyUI *m_pMyUIThread;  //UI线程
     CWinThread *myThread;
     m_pMyUIThread = (CMyUI *) AfxBeginThread(RUNTIME_CLASS(CMyUI));  //开始一个UI线程
     m_pMyUIThread->PostThreadMessage(WM_MYMSG_ONE,NULL,NULL);        //对UI线程发送消息
            myThread = AfxBeginThread((AFX_THREADPROC) ThreadPro,this);      //开始一个工作者线程
     myThread = NULL;
            m_pMyUIThread = NULL;
     
    }

    ThreadProc.h
    UINT ThreadPro(LPVOID wParam);

    ThreadProc.cpp
    #include "stdafx.h"
    #include "ThreadProc.h"
    #include "mytest17Dlg.h"
    #include "MyUI.h"

    UINT ThreadPro(LPVOID wParam)
    {
     Cmytest17Dlg *pDlg = (Cmytest17Dlg *) wParam;
     pDlg->m_pMyUIThread->PostThreadMessage(WM_MYMSG_ONE,NULL,NULL);
     AfxEndThread(0);  //执行完在这里结束线程序
     return 1;
    }


    MyUI.h
    pragma once
    #define WM_MYMSG_ONE   (WM_USER + 1)  //定义两个消息
    #define WM_MYMSG_TWO   (WM_USER + 2)


    // CMyUI

    class CMyUI : public CWinThread
    {
     DECLARE_DYNCREATE(CMyUI)

    protected:
     CMyUI();           // 动态创建所使用的受保护的构造函数
     virtual ~CMyUI();

    public:
     virtual BOOL InitInstance();
     virtual int ExitInstance();
     afx_msg void MsgOneProc(UINT wParam, LONG lParam);   //定义消息处理函数,头要用afx_msg  参数要用UINT wParam, LONG //lParam
     afx_msg void MsgTwoProc(UINT wParam, LONG lParam);

    protected:
     DECLARE_MESSAGE_MAP()
    };


    MyUI.CPP

    #include "stdafx.h"
    #include "mytest17.h"
    #include "MyUI.h"


    // CMyUI

    void CMyUI::MsgOneProc(UINT mParam, LONG lParam)   //前面不用加afx_msg
    {
     AfxMessageBox("this is message process one",MB_OK);
     return;
    }

    void CMyUI::MsgTwoProc(UINT mParam, LONG lParam)
    {
     AfxMessageBox("this is message process two",MB_OK);
     return;
    }

    IMPLEMENT_DYNCREATE(CMyUI, CWinThread)

    CMyUI::CMyUI()
    {
    }

    CMyUI::~CMyUI()
    {
     AfxEndThread(0);
    }

    BOOL CMyUI::InitInstance()
    {
     // TODO: 在此执行任意逐线程初始化
     return TRUE;
    }

    int CMyUI::ExitInstance()
    {
     // TODO: 在此执行任意逐线程清理
     return CWinThread::ExitInstance();
    }

    BEGIN_MESSAGE_MAP(CMyUI, CWinThread)
     ON_THREAD_MESSAGE(WM_MYMSG_ONE,MsgOneProc)   //消息映射表:前面加ON_THREAD_MESSAGE(消息名,消息处理函数)
     ON_THREAD_MESSAGE(WM_MYMSG_TWO,MsgTwoProc)   //注意这里是ON_THREAD_MESSAGE
    END_MESSAGE_MAP()

    展开全文
  • 1认识Windows2000窗口的组成 2学会窗口操作切换窗口移动窗口 改变窗口大小排列窗口 3了解对话框及其相关对象操作 区别对话框与窗口 区别对话框与窗口 e习提纲II标题栏菜单栏工具栏 窗口组成由操作或显示区域状态栏等...
  • 最近在学习C++图形化框架QT,在此进行整理。 QWidget、QMainWindow、QDialog有什么区别呢。 首先QMainWindowQDialog都继承自QWidget。...而QDialog是对话框形式的窗口,没有最大的窗口。 ...
  • XMLHTML都来自于SGML,它们都含有标记,有着相似的语法,HTMLXML的最大区别在于:HTML是一个定型的标记语言,它用固有的标记来描述,显示网页内容。比如表示首行标题,有固定的尺寸。相对的,XML则没有固定的...
  • MFC用户界面_CDialog

    2011-06-06 10:29:00
    对话框也是windows窗口中的一种,但它与普通窗口的区别是它没有最大最小化按钮。对话框由两个部分组成:对话框资源:可以用对话框编辑器来对他的大小,位置,样式等进行编辑。对话框类:在C++中对话框被封装与...
  • 若要对数据进行字符转换数字转换,...对成年病人,高热昏迷3天,不能进食饮水,尿比重1.030,应先静脉补充答:5%葡萄糖对话框是特殊类型的窗口对话框与常规窗口最明显的区别在于,大多数的对话框都无法最大化、...
  • 冬至节气01弹框是一种重要交互方式,是为了让用户回应,需要用户与之交互...模态弹框非模态弹框最大的区别就是是否强制用户交互。模态弹框会打断用户当前操作流程,强制用户必须进行操作,否则不可以进行...
  • 尽我所知,除了文中特别加以标注致谢地方外,论文中不包含其他人已经发表或撰写过研究成果,也不包含为获得东南大学或其它教育机构学位或证书而使用过材料。与我一同工作同志对本研究所做任何贡献均已...
  • TCP socketUDP socket的区别是怎样 如何用有连接方式实现聊天室 如何用无连接方式实现系统广播 如何实现Proxy服务器 如何下载网页 如何在应用程序中映射网络驱动器 如何实现电话拨号上网 如何删除Internet...
  • excel使用

    2012-11-25 17:06:01
    Ctrl+*选定的区域为:根据选定单元格向四周辐射所涉及到的有数据单元格的最大区域。这样我们可以方便准确地选取数据表格,并能有效避免使用拖动鼠标方法选取较大单元格区域时屏幕的乱滚现象。(9) 快速清除单元格...
  • WINRAR5.0正式注册版

    2013-10-10 10:14:03
    RAR ZIP 压缩文件中的最大路径长度增加到 2048 个字符。 14. 如果 命令行 RAR 检测到用户输入了错误的密码,它会返回退出码 11。只有 RAR 5.0 压缩文件才能返回此代码。对于 RAR 4.x 文件它可以区分是密码...
  • 4.3.2 不同窗口的样式 46 4.3.3 应用多个样式 47 4.3.4 Shell类的主要方法 47 4.3.5 创建多个窗口 49 4.4 SWT包类结构 51 4.5 本章小结 52 第5章 SWT基本组件 53 5.1 SWT控件类概述 53 5.1.1 窗口小...
  • 4.3.2 不同窗口的样式 46 4.3.3 应用多个样式 47 4.3.4 Shell类的主要方法 47 4.3.5 创建多个窗口 49 4.4 SWT包类结构 51 4.5 本章小结 52 第5章 SWT基本组件 53 5.1 SWT控件类概述 53 5.1.1 窗口小...
  • Visual Studio程序员箴言--详细书签版

    热门讨论 2012-10-16 20:37:39
    技巧3.2 在不打开“查找替换”窗口的情况下,使用Ctrl+F3键搜索当前选中的单词 58 技巧3.3 不自动搜索当前选中的单词 58 3.1.3 重复上次搜索 59 技巧3.4 使用F3键搜索上次的搜索内容 59 3.2 快速搜索 59...
  • windows 程序设计

    2011-07-24 21:16:30
    Windows API它的语法的最大变化来自于从16位架构向32位架构转化的过程中。Windows从版本1.0到版本3.1使用16位Intel 8086、8088、286微处理器上所谓的分段内存模式,由于兼容性的原因,从386开始的32位Intel微...
  • Visual Studio程序员箴言中文扫描PDF

    热门讨论 2010-12-28 01:04:18
    技巧3.2 在不打开“查找替换”窗口的情况下,使用ctrl+f3键搜索当前选中的单词 58 技巧3.3 不自动搜索当前选中的单词 58 3.1.3 重复上次搜索 59 技巧3.4 使用f3键搜索上次的搜索内容 59 3.2 快速搜索 59...
  • Window 消息大全

    2009-12-23 05:23:02
    WM_WINDOWPOSCHANGING = $0046 //发送此消息给那个窗口的大小位置将要被改变时,来调用setwindowpos函数或其它窗口管理函数 WM_WINDOWPOSCHANGED = $0047 //发送此消息给那个窗口的大小位置已经被改变时,来...
  • 会计理论考试题

    2012-03-07 21:04:40
    25.Windows98对话框的____C____是给用户提供输入信息。 A、列表框 B、复选框 C、文本框 D、数值框 26.在Windows98中,如果要输入GB2312-80规定以外汉字,应当____C____。 A、从Windows98CD盘上安装GBK汉字...
  • 器内容改变,而是从工程角度直接看程序运行电路工作过程结果。 对于这样仿真实验,从某种意义上讲,是弥补了实验工程应用间脱节矛 第5 页共27 页 盾现象。 3 系统详细设计: 3.1 硬件设计 3.1.1 ...
  • flash shiti

    2014-03-14 10:32:41
    11. 全等(===)运算符相同运算符基本相似,但是它们有一个很重要的区别 □ A. 全等(===)运算符执行数据类型转换 □ B. 全等(===)运算符不执行数据类型转换 □ C. 全等(===)运算符永远返回...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    outputMax.java 求两个数中的最大数 overflowExample.java 演示溢出 precedence.java 演示自加运算符的优先级 primeNumber.java 输出100-200之间的所有素数 ranking.java 评定成绩等级 rankingBySwitch.java ...
  • arcgis工具

    2012-10-22 22:37:31
    arcgis工具总结 1. 要素剪切与延伸 实用工具 TASK 任务栏 Extend/Trim ...这种方法与完全包含(Completely contain)方法的区别在于:要素间边界可以接触。例如,使用包含(Contain)方法,即使湖泊边界包含该...
  • ExtAspNet_v2.3.2_dll

    2010-09-29 14:37:08
    -修正EnableMaximize属性不能使Window最大BUG,修正了双击标题栏不能最大BUG。 -删除Button控件SystemIcon属性,比如以前这样定义SystemIcon="Close",现在需要这样定义Icon="SystemClose"。 -Window...
  • delphi 开发经验技巧宝典源码

    热门讨论 2010-08-12 16:47:23
    0058 String类型Pchar类型用法和区别 36 0059 如何捕获异常 37 0060 TStrings与TStringList使用 37 0061 如何实现窗体文件转换 37 第3章 程序算法 39 3.1 计算类算法 40 0062 如何计算1~100...
  • -修正EnableMaximize属性不能使Window最大BUG,修正了双击标题栏不能最大BUG。 -删除Button控件SystemIcon属性,比如以前这样定义SystemIcon="Close",现在需要这样定义Icon="SystemClose"。 -Window...
  • 《OceanX》播放器 Prv0.3

    2006-02-23 09:05:59
    而且视频窗口拥有四种模式调节,并且还完全支持您的任意拖拽锁定来改变视频窗口的大小!!3,全面整合了“打开/追加读取本地网络媒体”的窗口界面,并且还增加了改名功能!!4,网络歌曲选择窗口最新加入人性化...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

对话框和窗口的最大区别是