精华内容
下载资源
问答
  • swing-Java-如何创建自定义对话框?我在JFrame上有一个按钮,单击该按钮后,我希望对话框弹出并带有多个文本区域供用户输入。 我一直在四处寻找解决方法,但我一直感到困惑。 有人可以帮忙吗?6个解决方案80 votes...

    swing-Java-如何创建自定义对话框?

    我在JFrame上有一个按钮,单击该按钮后,我希望对话框弹出并带有多个文本区域供用户输入。 我一直在四处寻找解决方法,但我一直感到困惑。 有人可以帮忙吗?

    6个解决方案

    80 votes

    如果您不需要太多自定义行为,则JOptionPane可以节省大量时间。 它负责确定/取消选项的放置和本地化,并且是一种无需定义自己的类即可显示自定义对话框的快捷方法。 大多数情况下,JOptionPane中的“ message”参数是一个字符串,但您也可以传入JComponent或JComponents数组。

    例:

    JTextField firstName = new JTextField();

    JTextField lastName = new JTextField();

    JPasswordField password = new JPasswordField();

    final JComponent[] inputs = new JComponent[] {

    new JLabel("First"),

    firstName,

    new JLabel("Last"),

    lastName,

    new JLabel("Password"),

    password

    };

    int result = JOptionPane.showConfirmDialog(null, inputs, "My custom dialog", JOptionPane.PLAIN_MESSAGE);

    if (result == JOptionPane.OK_OPTION) {

    System.out.println("You entered " +

    firstName.getText() + ", " +

    lastName.getText() + ", " +

    password.getText());

    } else {

    System.out.println("User canceled / closed the dialog, result = " + result);

    }

    Sam Barnum answered 2020-08-06T16:46:36Z

    3 votes

    尝试使用以下简单类自定义您喜欢的对话框:

    import java.util.ArrayList;

    import java.util.List;

    import javax.swing.JComponent;

    import javax.swing.JLabel;

    import javax.swing.JOptionPane;

    import javax.swing.JRootPane;

    public class CustomDialog

    {

    private List components;

    private String title;

    private int messageType;

    private JRootPane rootPane;

    private String[] options;

    private int optionIndex;

    public CustomDialog()

    {

    components = new ArrayList<>();

    setTitle("Custom dialog");

    setMessageType(JOptionPane.PLAIN_MESSAGE);

    setRootPane(null);

    setOptions(new String[] { "OK", "Cancel" });

    setOptionSelection(0);

    }

    public void setTitle(String title)

    {

    this.title = title;

    }

    public void setMessageType(int messageType)

    {

    this.messageType = messageType;

    }

    public void addComponent(JComponent component)

    {

    components.add(component);

    }

    public void addMessageText(String messageText)

    {

    JLabel label = new JLabel("" + messageText + "");

    components.add(label);

    }

    public void setRootPane(JRootPane rootPane)

    {

    this.rootPane = rootPane;

    }

    public void setOptions(String[] options)

    {

    this.options = options;

    }

    public void setOptionSelection(int optionIndex)

    {

    this.optionIndex = optionIndex;

    }

    public int show()

    {

    int optionType = JOptionPane.OK_CANCEL_OPTION;

    Object optionSelection = null;

    if(options.length != 0)

    {

    optionSelection = options[optionIndex];

    }

    int selection = JOptionPane.showOptionDialog(rootPane,

    components.toArray(), title, optionType, messageType, null,

    options, optionSelection);

    return selection;

    }

    public static String getLineBreak()

    {

    return "
    ";

    }

    }

    BullyWiiPlaza answered 2020-08-06T16:46:56Z

    1 votes

    Java教程中的这一课详细说明了每个Swing组件,并提供了示例和API链接。

    bdl answered 2020-08-06T16:47:17Z

    1 votes

    如果使用NetBeans IDE(当前最新版本为6.5.1),则可以使用File-> New Project创建一个基本的GUI Java应用程序,然后选择Java类别,然后选择Java Desktop Application。

    创建后,您将拥有一个简单的裸露GUI应用程序,其中包含一个About框,可以使用菜单选择来打开该框。 您应该能够使其适应您的需求,并了解如何通过单击按钮来打开对话框。

    您将能够直观地编辑对话框。 删除其中的项目并添加一些文本区域。 试一试,如果遇到问题,还会遇到更多问题:)

    Arnold Spence answered 2020-08-06T16:47:47Z

    1 votes

    好吧,您实质上就是创建一个JDialog,添加您的文本组件并使它可见。 如果缩小所遇到的特定位可能会有所帮助。

    Neil Coffey answered 2020-08-06T16:48:07Z

    1 votes

    我创建了一个自定义对话框API。 在此处检查[https://github.com/MarkMyWord03/CustomDialog。]它支持消息和确认框。 就像joptionpane中一样,input和option对话框将很快实现。

    CUstomDialog API的示例错误对话框:CustomDialog错误消息

    MarkMyWord03 answered 2020-08-06T16:48:34Z

    展开全文
  • MyFrame: 设计思路: 1、设置底层面板并添加“测试”按钮 2、对按钮添加监听器 3、设计监听器里面的方法 3.1、添加对话框并设置其面板内容 3.2、添加lamada型简化监听器(当点击确定按钮时,对话框消失,...

    设计图:

    类MyFrame:

    设计思路:

    1、设置底层面板并添加“测试”按钮

    2、对按钮添加监听器

    3、设计监听器里面的方法

    3.1、添加对话框并设置其面板内容

    3.2、添加lamada型简化监听器(当点击确定按钮时,对话框消失,最后返回用户的textfield的输入)

     

    package swing01;
    
    import java.awt.FlowLayout;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JDialog;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.JTextField;
    
    public class MyFrame extends JFrame{
    	
    	public MyFrame(String title)
    	{
    		super(title);
    		
    		JPanel root=new JPanel();
    		this.setContentPane(root);
    		root.setLayout(new FlowLayout());
    		
    		//向根面板添加一个按钮
    		JButton testButton=new JButton("测试");
    		root.add(testButton);
    		
    		//监听器
    		testButton.addActionListener(new ActionListener() {
    
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				// TODO Auto-generated method stub
    				String str=getUserInput();
    				System.out.println("用户输入了:"+str);
    			}
    			
    		});
    	
    	}
    	public String getUserInput()
    	{
    		//创建JDialog
    		JDialog dialog=new JDialog(this,"信息框",true);
    		JPanel panel=new JPanel();
    		panel.setLayout(new FlowLayout());
    		dialog.setContentPane(panel);
    		
    		//添加控件到对话框
    		JTextField testfield=new JTextField(20);
    		JButton button=new JButton("确定");
    		panel.add(testfield);
    		panel.add(button);
    		
    		//点击按钮时,关闭对话框
    		button.addActionListener((e)->{
    			dialog.setVisible(false);
    		});
    		
    		//显示对话框(setVisible()方法会阻塞,直到对话框关闭)
    		dialog.setSize(300, 100);
    		dialog.setVisible(true);
    		
    		//对话框被关闭后,取得用户输入,并返回
    		String text=testfield.getText();
    		return text;
    		
    	}
    
    }
    

    类MyDemo: 

    package swing01;
     
    import java.awt.Container;
    import java.awt.FlowLayout;
     
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.UIManager;
    import javax.swing.UnsupportedLookAndFeelException;
     
    public class MyDemo
    {
    	private static void createGUI()
    	{
    		// JFrame指一个窗口,构造方法的参数为窗口标题
    		JFrame frame = new MyFrame("测试");
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		
    				// 设置窗口的其他参数,如窗口大小
    		frame.setSize(400, 300);
    		
    		// 显示窗口
    		frame.setVisible(true);
    	}
    	
    	public static void main(String[] args)
    	{
    		//设置界面样式 Look And Feel
    		try {
    			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException
    				| UnsupportedLookAndFeelException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		javax.swing.SwingUtilities.invokeLater(new Runnable() {
    			public void run()
    			{
    				createGUI();
    			}
    		});
     
    	}
    }
    

     

    展开全文
  • 收藏 Series60提供了一个全面的对话框类和基类集合,可以使用这些类创建自定义对话框,以及开发窗体(form)、通知(note)、查询(query)和列表对话框(list dialog)等。 所有对话框共有某些基本属性。首先,对话框都是...

     收藏
     
    Series60提供了一个全面的对话框类和基类集合,可以使用这些类创建自定义对话框,以及开发窗体(form)、通知(note)、查询(query)和列表对话框(list dialog)等。
        所有对话框共有某些基本属性。首先,对话框都是拥有窗口的控件,所有对话框类最终都派生于CCoeControl。然后,由一个对话框框架管理对话框的行为,包括布局、绘制以及用户与对话框在组件控件的交互。典型情况下,对于大多数任意复杂程度的对话框,都会在一个资源文件中完整定义,并在动态实例化之后由对话框框架从资源文件装载此定义完成对话框的创建。对话框所有元素的布局和定位都是通常是自动的,当然也可以干预它。
        Series60的对话框默认是模态和非等待的。模态/非模态无需多述;非等待对话框允许应用程序在后台继续处理,而等待对话框会阻止应用程序在该对话框关闭前执行任何进一步的处理。

    一、继承基类对话框CAknDialog
        CAknDialog是大部分Series60对话框的基类。关于对话框的使用,大体分为以下步骤:1.定义资源。2.编写对话框类。3.保存和验证对话框数据。4.动态地初始化标准对话框。5.构建和执行对话框。
    下面分别叙述之:
    1.定义资源
        使用DIALOG定义资源,资源指定了对话框的布局,在资源中定义对话框应该包含的行数、使用的控件、对话框是否为模态以及使用的软键等。下面以一个简单的例子示范:
    RESOURCE DIALOG r_simpledlg_player_name_dialog

      {

      flags=EEikDialogFlagNoDrag |

      EEikDialogFlagCbaButtons |

      EEikDialogFlagWait;

      buttons=R_AVKON_SOFTKEYS_OK_CANCEL;

      items=

         {

         DLG_LINE

             {

             id=ESimpleDlgCIdPlayerName;

             type=EEikCtLabel;

             control= LABEL

                {

                };

             },

         DLG_LINE

             {

             id=ESimpleDlgCIdPlayerNameEditor;

             type=EEikCtEdwin;

             control= EDWIN

                {

                maxlength = KMaxPlayerNameLength;

                };

             }

         };

      }

    flags说明了对话框的属性,其中的属性值可参考<uikon.hrh>
    buttons指定了使用的软键。
        最主要的是items组件,它定义了对话框包含的实际内容。需要为希望包含到对话框的每个控件分别定义一个DLG_LINE,在每个DLG_LINE中至少应该指定以下字段:
    * id :在应用程序中使用该值引用此对话框行,必须在应用程序的.hrh文件中枚举它。
    * type :此对话框行包含的控件类型(在avkon.hrh或uikon.hrh中定义)。
    * control :在此对话框中使用的控件。
    此外,还可以选择在DLG_LINE资源中指定一个itemflags字段,使用该字段决定对话框行的行为。例如弹出字段文本控件可以使用itemflags说明应该在“选择”键被按下时打开一个弹出窗口,例如EEikDlgItemTakesEnterKey。可以在uikon.hrh中找到itemflags的值。最常用的可能当属EEikDlgItemSeparatorBefore标志,用于在对话框行之前插入一个水平“分隔符”行。
    2. 编写对话框类
    接下来需要编写一个可以构建和执行此对话框、初始化控件的数据、处理从控件接收到的数据并决定如何关闭对话框的类。
    通常会提供一个用于执行对话框的静态方法,该方法包装了第一阶段构造函数和ExecuteLD() - 用于装载、显示和销毁对话框的函数。通常将该静态方法命名为RunDlgLD(),并使它传递ExecuteLD()返回的TBool。

    下面示例之:

    #include <akndialog.h>   // CAknDialog

    #include <aknquerydialog.h>

    #include <aknquerycontrol.h>

     

    class CSimpleDlgPlayerNameDialog : public CAknDialog //public CAknTextQueryDialog

      {

    public:

      // static construction and execution

      static TBool RunDlgLD(TDes& aPlayerName);

    protected:

      // from CAknDialog

      TBool OkToExitL(TInt aButtonId);

    protected:

      void PreLayoutDynInitL();

    private:

      // Constructor

      CSimpleDlgPlayerNameDialog(TDes& aPlayerName) ://CAknTextQueryDialog(aPlayerName),

          iPlayerName(aPlayerName)

         {

         }

      ;

    private:

      // data

      TDes& iPlayerName;

      };

    关于RunDlgLD()的实现:

    TBool CSimpleDlgPlayerNameDialog::RunDlgLD (TDes& aPlayerName)
    {
       CEikLabel* label =       static_cast<CEikLabel*>(ControlOrNull(ESimpleDlgCIdPlayerName));

      if (label)

         {

         HBufC* labelText = StringLoader::LoadLC(R_ENTER_NAME_TEXT);

         label->SetTextL(*labelText);

         CleanupStack::PopAndDestroy(labelText);

         }
    }
        因为对话框是模态和等待的,所以不需要使它成为成员数据,此对话框在ExecuteLD()的最后会删除自己。
        那么为什么在new之后没有将其压入清除栈呢?因为ExecuteLD()拥有改对话框的所有权,该方法包装了对其他两个方法的调用:PrepareLC()和RunLD()。   PrepareLC()会把对话框的指针放入清除栈,然后完成对话框的创建。RunLD()会显示该对话框,然后把它从清除栈中弹出。但如果在调用ExecuteLD()之前需要调用任意可能导致异常退出的代码,则应该将其放入清除栈,并在调用ExecuteLD()前把它弹出。
    但,如果对话框为非等待的,则会直接从ExecuteLD()返回而不被删除。
    3. 保存和验证对话框数据
    为了使对话框能够更新应用程序的数据,需要为它提供对这些数据的引用。对数据的验证和更新通常发生在OkToExitL()方法中进行,除“取消”外,按下任意软键时,框架都会调用此函数(通过设定对话框的flags,使之包括EEikDialogFlagNotifyEsc,可以强制要求框架在“取消”被按下时也调用OkToExitL())。如果允许对话框退出,则OkToExitL()必须返回ETrue,如果不允许退出,则返回EFalse。下面示例之:

    TBool CSimpleDlgPlayerNameDialog::OkToExitL(TInt aButtonId)
    {
      if (aButtonId == EAknSoftkeyOk)

    {

          CEikEdwin* editor =                 static_cast<CEikEdwin*>(ControlOrNull(ESimpleDlgCIdPlayerNameEditor));

         if (editor)

         {

           editor->GetText(iPlayerName);

         }

    }

    return ETrue;

    }
        通过调用CEikDialog::ControlOrNull()并传入对话框行的ID,可以获取特定控件的句柄,如果ID有效,则返回一个CCoeControl的指针,后则返回NULL。如果ID无效需要退出,可使用CEikDialog::Control(),如果ID无效,该方法会出错。
    4. 动态地初始化标准对话框
        动态地设置对话框中的项是在PreLayoutDynInitL()方法中执行。对话框框架会在对话框执行前调用该方法。
    void CSimpleDlgPlayerNameDialog::PreLayoutDynInitL()
    {
        CEikLabel* label =      static_cast<CEikLabel*>(ControlOrNull(ESimpleDlgCIdPlayerName));

      if (label)

         {

         HBufC* labelText = StringLoader::LoadLC(R_ENTER_NAME_TEXT);

         label->SetTextL(*labelText);

         CleanupStack::PopAndDestroy(labelText);

         }

    }
    如果需要,可以通过重写另外一个方法PostLayoutDynInitL(),更改对话框中控件的布局和大小,或是在显示对话框之前启动一个定时器。
    5. 构建和执行对话框
    RunDlgLD()方法封装了对话框的构建和执行。
    switch (aCommand)
    {
    case ECmdSimpleDlg:

        CSimpleDlgPlayerNameDialog::RunDlgLD(iPlayerName) ;

        break;break;
    }
    // ...
    }
        通过检查ExecuteLD()或RunDlgLD()的返回值,可以得知对话框是如何被关闭的。返回EFalse说明关闭对话框时按下的是“取消”、“后退”或“否”,其他情况下返回ETrue。

    二、继承数据查询对话框CAknTextQueryDialog

    继承数据查询对话框CAknTextQueryDialog的步骤和继承基类对话框CAknDialog大体相似,也是需要1.定义资源。2.编写对话框类。3.保存和验证对话框数据。4.动态地初始化标准对话框。5.构建和执行对话框。

    1、定义资源

     RESOURCE DIALOG r_question_data_query_dialog

        {

        flags = EGeneralQueryFlags;

        buttons = R_AVKON_SOFTKEYS_OK_CANCEL;

        items =

           {

           DLG_LINE

               {

               type = EAknCtQuery;

               id = EGeneralQuery;

               control = AVKON_DATA_QUERY

               {

                   layout = EDataLayout;

                  label = question_text;

                  control = EDWIN

                  {

                  flags = EEikEdwinNoHorizScrolling | EEikEdwinResizable;

                  default_input_mode = EAknEditorTextInputMode;

                  maxlength = KMaxQuestionLength;

                  };

                  };

               }

           };

        }

    定义的资源和CAknTextQueryDialog的定义格式相同,这里不做详细解释。

    2、编写对话框类

    #include <aknquerydialog.h>

    /**

     *  CTextDialog

     *

     */

    class CTextDialog : public CAknTextQueryDialog

        {

    public:

        //构造函数

        CTextDialog(TDes& aDataText):CAknTextQueryDialog(aDataText)

           {  

           }

        ;

        static CTextDialog* NewL(TDes& aDataText);

    private:

    protected:

        void PreLayoutDynInitL();

        };

        类CTextDialog的构造函数需要初始化基类CAknTextQueryDialog,否则会出现cannot construct CTextDialog's base class 'CAknTextQueryDialog'的错误,如何初始化基类的构造函数,可以上网去查询C++的关于如何初始化基类构造函数,这里不做详细描述。

    3、保存和验证对话框数据

        该部分需要重写OkToExitL函数,这里直接由基类OkToExitL保存和验证对话框数据。

    4、动态地初始化标准对话框

        void CTextDialog::PreLayoutDynInitL()

        {

        CAknQueryControl* control = QueryControl();

        if (control)

           control->SetTextL(iDataText);  //显示文本框初始内容

    //默认情况下,当文本框内容为空时,对话框左键不显示,使用MakeLeftSoftkeyVisible函数将显示左键

        MakeLeftSoftkeyVisible(ETrue);

        }

    5、构建和执行对话框

    switch (aCommand)

    { // code to dispatch to the AknView's menu and CBA commands is generated here

           case ECmdQeuryTextDlg:

               CTextDialog *dialog = new (ELeave)CTextDialog(iProblem);

     

               if (dialog->ExecuteLD(R_QUESTION_DATA_QUERY_DIALOG) )

                  {

                  }

               break;

               //...

           }

    }

    默认情况下,CAknTextQueryDialog的“确定”或“OK”按钮在输入对话框内容为空时会隐藏,CTextDialog对话框主要是解决能够在对话框的文本框里输入空字符串。

    总结,第一部分内容参考了《Series 60应用程序开发》中关于对话框章节的内容。第二部分是项目中需要自己写的,源代码请到CSDN:http://download.csdn.net/source/832037地址下载.


    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/doubleblue/archive/2008/12/03/3435282.aspx

    展开全文
  • Qt自定义对话框及调用方法

    千次阅读 2020-02-12 23:25:45
    自定义对话框的设计一般从 QDialog 继承,并且可以采用UI设计器可视化地设计对话框。对话框的调用一般包括创建对话框、传递数据给对话框、显示对话框获取输入、判断对话框单击按钮的返回类型、获取对话框输入数据等...

    在一个应用程序设计中,为了实现一些特定的功能,必领设计自定义对话框。

    自定义对话框的设计一般从 QDialog 继承,并且可以采用UI设计器可视化地设计对话框。对话框的调用一般包括创建对话框、传递数据给对话框、显示对话框获取输入、判断对话框单击按钮的返回类型、获取对话框输入数据等过程。

    本节将通过实例 samp6_2 来详细介绍这些原理。图 1 是实例 samp6_2 的主窗口,及其设置表格行列数的对话框。


    实例 samp6_2 主窗口及其设置表格行列数的对话框
    图 1 实例 samp6_2 主窗口及其设置表格行列数的对话框


    主窗口采用 QTableView 和 QStandardltemModel、QltemSelectionModel 构成一个通用的数据表格编辑器,设计了 3 个对话框,分别具有不同的功能,并且展示对话框不同调用方式的特点:

    • 设置表格行列数对话框 QWDialogSize
      该对话框每次动态创建,以模态方式显示(必须关闭此对话框才可以返回主窗口操作),对话框关闭后获取返回值,用于设置主窗口的表格行数和列数,并且删除对话框对象,释放内存。

      这种对话框创建和调用方式适用于比较简单,不需要从主窗口传递大量数据做初始化的对话框,调用后删除对话框对象可以节约内存。
    • 设置表头标题对话框 QWDialogHeaders
      图 2 是设置表格表头标题的对话框,该对话框在父窗口(本例中就是主窗口)存续期间只创建一次,创建时传递表格表头字符串列表给对话框,在对话框里编辑表头标题后,主窗口获取编辑之后的表头标题。


      设置表格表头标题对话框
      图 2 设置表格表头标题对话框


      注意,对话框以模态方式显示,关闭后只是隐藏,并不删除对象,下次再调用时只是打开己创建的对话框对象。

      这种创建和调用方式适用于比较复杂的对话框,需要从父窗口传递大量数据做对话框初始化。下次调用时不需要重复初始化,能提高对话框调用速度,但是会一直占用内存,直到父窗口删除时,对话框才从内存中删除。
    • 单元格定位与文字设置对话框QWDialogLocate
      图 3 是单元格定位和文字设置对话框,该对话框以非模态方式调用,显示对话框时还可以对主窗口进行操作,对话框只是浮动在窗口上方。在对话框里可以定位主窗口表格的某个单元格 并设置其文字内容,在主窗口上的表格中单击鼠标时,单元格的行号、列号也会更新在对话框中。对话框关闭后将自动删除,释放内存。


      浮动于主窗口上方的对话框,可交互操作
      图 3 浮动于主窗口上方的对话框,可交互操作


      这种对话框适用于主窗口与对话框需要交互操作的情况,例如用于查找和替换操作的对话框。

    对话框 QWDialogSize 的创建和使用

    创建对话框QWDialogSize

    实例主窗口从 QMainWindow 继承,主窗口用一个 QTableView 组件作为界面中心组件,设计几个 Action 用于创建主工具栏按钮。主窗口采用 QStandardItemModel 作为数据模型,QItemSelectionModel 作为选择模型,界面和主窗口 Model/View 结构的设计前面已经讲过,本节不再详述。

    在项目主窗口建立后,要创建如图 1 所示的设置表格行列数的对话框,单击 Qt Creator 的菜单项 File->New File or Project,选择 Qt 类别下的 “Qt Designer Form Class”,创建可视化设计的对话框类。在随后出现的向导里,选择窗口模板为 Dialog without Buttons,并设置自定义对话框的类名。

    设置创建的对话框类名称为 QWDialogSize,系统自动生成 qwdialogsize.h、qwdialogsize.cpp 和 qwdialogsize.ui 3 个文件。

    QWDialogSize 对话框的界面设计在 UI 设计器里进行,放置界面组件并设置好布局。

    对话框的调用和返回值

    设计 QWDialogSize 对话框的界面时,在上面放置了两个 QPushButton 按钮,并分别命名为 btnOK 和 btnCancel,分别是“确定”和“取消”按钮,用于获取对话框运行时用户的选择。那么,如何获得用户操作的返回值呢?

    在信号与槽编辑器里,将 btnOK 的 clicked() 信号与对话框的 accept() 槽关联,将 btnCancel 的 clicked() 信号与对话框的reject()槽关联即可,如图 4 所示。


    对话框设计时“确定”和 “取消”按钮的信号与槽关联
    图 4 对话框设计时“确定”和 “取消”按钮的信号与槽关联


    单击“确定”按钮会执行 accept() 槽(或在代码里调用 accept() 槽函数也是一样的),这会关闭对话框(默认情况下,对话框只是被隐藏,并不被删除),并返回 QDialog::Accepted 作为 exec() 函数的返回值。

    单击“取消”按钮会执行 reject() 槽函数,也会关闭对话框,并返回 QDialog::Rejected 作为 exec() 函数的返回值。

    完成后的 QWDialogSize 的类完整定义如下:

    class QWDialogSize : public QDialog
    {
        Q_OBJECT
    public:
        explicit QWDialogSize(QWidget *parent = 0);
        ~QWDialogSize();
        int     rowCount();//获取对话框输入的行数
        int     columnCount();//获取对话框输入的列数
        void    setRowColumn(int row, int column); //初始对话框上两个SpinBox的值
    private slots:
    private:
        Ui::QWDialogSize *ui;
    };

    在 QWDialogSize 的类定义中定义 3 个 public 函数,用于与对话框调用者的数据交互。因为窗体上的组件都是私有成员,外界不能直接访问界面组件,只能通过接口函数访问。

    下面是类的接口函数实现代码。在析构函数中弹出一个消息提示对话框,以便观察对话框是何时被删除的。

    QWDialogSize::~QWDialogSize、
    {
        QMessageBox::information (this,"提示","设置表格行列数对话框被删除"); delete ui;
    }
    int QWDialogSize::rowCount()
    { //用于主窗口调用获得行数的输入值
        return ui->spinBoxRow->value();
    }
    int QWDialogSize::columnCount()
    {//用于主窗口调用获得列数的输入值
        return ui->spinBoxColumn->value();
    }
    void QWDialogSize::setRowColumn(int row, int column)
    { //初始化数据显示
        ui->spinBoxRow->setValue(row);
        ui->spinBoxColumn->setValue(column);
    }

    下面是主窗口中的“设置行数列数”工具栏按钮的响应代码,用于创建、显示对话框,并读取对话框上设置的行数、列数。

    void MainWindow::on_actTab_SetSize_triggered()
    { //模态对话框,动态创建,用过后删除
        QWDialogSize *dlgTableSize=new QWDialogSize(this);
        Qt::WindowFlags flags=dlgTableSize->windowFlags();
        dlgTableSize->setWindowFlags(flags | Qt::MSWindowsFixedSizeDialogHint);
        dlgTableSize->setRowColumn(theModel->rowCount(),theModel->columnCount ());
        int ret=dlgTableSize->exec () ;// 以模态方式显示对话框
        if (ret==QDialog::Accepted)
        { //OK按钮被按下,获取对话框上的输入,设置行数和列数
            int cols=dlgTableSize->columnCount();
            theModel->setColumnCount(cols);
            int rows=dlgTableSize->rowCount();
            theModel->setRowCount(rows);
        }
        delete dlgTableSize;
    }

    从代码中可以看到,每次单击此工具栏按钮时,对话框都被重新创建。创建后用 QDialog 的 setWindowFlags() 函数将对话框设置为固定大小,然后调用对话框的自定义函数 setRowColumn(),将主窗口数据模型 theModd 的现有的行数和列数显示到对话框上的两个 SpinBox 组件里。

    调用对话框的 exec() 函数,以模态显示的方式显示对话框。模态显示方式下,用户只能在对话框上操作,不能操作主窗口,主程序也在此处等待 exec() 函数的返回结果。

    当用户单击“确定”按钮关闭对话框后,exec() 返回结果为 QDialogxAccepted,主程序获得此返回结果后,通过对话框的自定义函数 columnCount() 和 rowCount() 获得对话框上新输入的列数和行数,然后设置为数据模型的列数和行数。

    最后使用 delete 删除创建的对话框对象,释放内存。所以,关闭对话框时,会出现 QWDialogSize 析构函数里的消息提示对话框。

    注意,在对话框上单击按钮或关闭对话框时,对话框只是隐藏(缺省的),而并没有从内存中删除。如果对话框一关闭就自动删除,则在后面调用对话框的自定义函数获得输入的行数和列数时会出现严重错误。

    对话框QWDialogHeaders的创建和使用

    对话框的生存期

    对话框的生存期是指它从创建到删除的存续区间。前面介绍的设置表格行数和列数的对话框的生存期只在调用它的按钮的槽函数里,因为对话框是动态创建的,调用结束后就会被删除。

    而对于图 2 所示的设置表头标题对话框,我们希望在主窗口里首次调用时创建它,对话框关闭时并不删除,只是隐藏,下次调用时再次显示此对话框。只有在主窗口释放时该对话框才释放,所以这个对话框的生存期在主窗口存续期间。

    QWDialogHeaders的定义和实现

    设置表头标题的对话框类是 QWDialogHeaders,它也是从 QDialog 继承的可视对话框类。其界面显示使用 QListView 组件,用 QStringListModel 变量管理字符串列表数据,构成 Model/View 结构。对话框上同样有“确定”和“取消”两个按钮,设置与对话框的 accept() 和 reject() 槽关联。

    QWDialogHeaders 类的定义如下:

    class QWDialogHeaders : public QDialog
    {
        Q_OBJECT
    private:
        QStringListModel  *model;
    public:
        explicit QWDialogHeaders(QWidget *parent = 0);
        ~QWDialogHeaders();
        void setHeaderList(QStringList& headers);
        QStringList headerList();
    private:
        Ui::QWDialogHeaders *ui;
    };

    QWDialogSize 类接口函数实现的代码如下:

    QWDialogHeaders::QWDialogHeaders(QWidget *parent) :
        QDialog(parent),
        ui(new Ui::QWDialogHeaders)
    {
        ui->setupUi(this);
        model= new QStringListModel;
        ui->listView->setModel(model);
    }
    QWDialogHeaders::~QWDialogHeaders()
    {
        QMessageBox::information(this,"提示","设置表头标题对话框被删除");
        delete ui;
    }
    void QWDialogHeaders::setHeaderList(QStringList &headers)
    {
        model->setStringList(headers);
    }
    QStringList QWDialogHeaders::headerList()
    {
        return  model->stringList();
    }

    QWDialogHeaders对话框的使用

    因为要在主窗口中重复调用此对话框,所以在 MainWindow 的 private 部分定义一个 QWDialogHeaders 类型的指针变量,并且将此指针初始化设置为 NULL,用于判断对话框是否已经被创建。

    在 MainWindow 中的定义如下:

    private:
        QWDialogHeaders *dlgSetHeaders=NULL;

    下面是主窗口工具栏上的“设置表头标题”按钮的响应代码:

    void MainWindow::on_actTab_SetHeader_triggered()
    {//一次创建,多次调用,对话框关闭时只是隐藏
        if (dlgSetHeaders==NULL) //如果对象没有被创建过,就创建对象
            dlgSetHeaders = new QWDialogHeaders(this);
        if (dlgSetHeaders->headerList().count()!=theModel->columnCount())
        {//如果表头列数变化,重新初始化
            QStringList strList;
            for (int i=0;i<theModel->columnCount();i++)//获取现有的表头标题
                strList.append(theModel->headerData(i,Qt::Horizontal,Qt::DisplayRole).toString());
            dlgSetHeaders->setHeaderList(strList);//用于对话框初始化显示
        }
        int ret=dlgSetHeaders->exec();// 以模态方式显示对话框
        if (ret==QDialog::Accepted) //OK键被按下
        {
            QStringList strList=dlgSetHeaders->headerList();//获取对话框上修改后的StringList
            theModel->setHorizontalHeaderLabels(strList);// 设置模型的表头标题
        }
    }

    在这段代码中,首先判断主窗口的成员变量 dlgSetHeaders 是否为 NULL,如果为 NULL (初始化为 NULL),说明对话框还没有被创建,就创建对话框。

    初始化的工作是获取主窗口数据模型现有的表头标题,然后调用对话框的自定义函数 setHeaderList(),设置其为对话框的数据源。

    使用 exec() 函数模态显示对话框,然后在“确定”按钮被单击时获取对话框上输入的字符串列表,设置为主窗口数据模型的表头标题。

    注意,这里在结束对话框操作后,并没有使用 delete 操作删除对话框对象,这样对话框就只是隐藏,它还在内存中。关闭对话框时不会出现析构函数里的消息提示对话框。

    对话框创建时,传递主窗口的指针作为对话框的父对象,即:

    dlgSetHeaders = new QWDialogHeaders(this);

    所以,主窗口释放时才会自动删除此对话框对象,也就是程序退出时才删除此对话框,才会出现 QWDialogHeaders 析构函数里的消息提示对话框。

    对话框QWDialogLocate的创建与使用

    非模态对话框

    前面设计的两个对话框是以模态(Modal)方式显示的,即用 QDialog::exec() 函数显示。模态显示的对话框不允许鼠标再去单击其他窗口,直到对话框退出。

    若使用 QDialog::show(),则能以非模态(Modeless)方式显不对话框。非模态显示的对话框在显示后继续运行主程序,还可以在主窗口上操作,主窗口和非模态对话框之间可以交互控制,典型的例子是文字编辑软件里的“查找/替换”对话框。

    图 3 中的单元格定位与文字设置对话框以非模态方式显示,对话框类是 QWDialogLocate,它有如下的一些功能:

    • 主窗口每次调用此对话框时,就会创建此对话框对象,并以 StayOnTop 的方式显示,对话框关闭时自动删除。
    • 在对话框中可以定位主窗口上 Table View 组件的单元格,并设置单元格的文字。
    • 在主窗口的 TableView 组件中单击鼠标时,如果对话框己创建,则自动更新对话框上单元格的行号和列号 SpinBox 组件的值。
    • 主窗口上的 actTab_Locate 用于调用对话框,调用时 actTab_Locate 设置为禁用,当对话框关闭时自动使能 actTab_Locate。这样避免对话框显示时,在主窗口上再次单击“定位单元格”按钮,而在对话框关闭和释放后,按钮又恢复为可用。


    对话框 QWDialogLocate 的类定义代码如下(各接口函数的意义和实现在后面介绍):

    class QWDialogLocate : public QDialog
    {
        Q_OBJECT
    private:
        void closeEvent(QCloseEvent *event);
        void showEvent(QShowEvent *event);
    public:
        explicit QWDialogLocate(QWidget *parent = 0);
        ~QWDialogLocate();
        void    setSpinRange(int rowCount, int colCount); //设置最大值
        void    setSpinValue(int rowNo, int colNo);//设置初始值
    private slots:
        void on_btnSetText_clicked();
    private:
        Ui::QWDialogLocate *ui;
    };

    对话框的创建与调用

    对话框 QWDialogLocate 是从 QDialog 继承而来的可视化设计的对话框类,其界面设计不再详述。为了在主窗口中也能操作对话框,需要保留对话框实例对象名,所以在 MainWindow 定义对话框 QWDialogLocate 的一个指针 dlgLocate,并初始化为 NULL。

    private:
        QWDialogLocate *dlgLocate=NULL;

    主窗口上的 actTab_Locate 用于调用此对话框,其 triggered() 信号槽函数代码如下:

    void MainWindow::on_actTab_Locate_triggered()
    {//创建 StayOnTop的对话框,对话框关闭时自动删除
        //通过控制actTab_Locate的enable属性避免重复点击
        ui->actTab_Locate->setEnabled(false);
        dlgLocate = new QWDialogLocate(this); //创建对话框,传递指针
        dlgLocate->setAttribute(Qt::WA_DeleteOnClose); //对话框关闭时自动删除对话框对象,用于不需要读取返回值的对话框
        Qt::WindowFlags flags=dlgLocate->windowFlags(); //获取已有flags
        dlgLocate->setWindowFlags(flags | Qt::WindowStaysOnTopHint); //设置对话框固定大小,StayOnTop
        //对话框初始化设置
        dlgLocate->setSpinRange(theModel->rowCount(),theModel->columnCount());
        QModelIndex curIndex=theSelection->currentIndex();
        if (curIndex.isValid())
           dlgLocate->setSpinValue(curIndex.row(),curIndex.column());
        dlgLocate->show(); //非模态显示对话框
    }

    在这段代码中,使用 QWidget::setAttribute() 函数将对话框设置为关闭时自动删除:

    dlgLocate->setAttribute(Qt::WA_DeleteOnClose);

    setAttribute() 用于对窗体的一些属性进行设置,当设置为 Qt::WA_DeleteOnClose时,窗口关闭时会自动删除,以释放内存。这与前面两个对话框是不同的,前面两个对话框在关闭时缺省是隐藏自己,除非显式地使用 delete 进行删除。

    程序还调用 QWidget::setWindowFlags() 将对话框设置为 StayOnTop 显示:

    dlgLocate->setWindowFlags(flags 丨 Qt::WindowStaysOnTopHint);

    对话框窗口效果设置后,再设置其初始数据,然后调用 show() 显示对话框。显示对话框后,主程序继续运行,不会等待对话框的返回结果。鼠标可以操作主窗口上的界面,但是因为 actTab_Locate 被禁用了,不能再重复单击“定位单元格”按钮。

    对话框中操作主窗口

    在对话框上单击“设定文字”按钮,会在主窗口中定位到指定的单元格,并设定为输入的文字,按钮的代码如下:

    void QWDialogLocate::on_btnSetText_clicked()
    {//定位到单元格,并设置字符串
        int row=ui->spinBoxRow->value(); //行号
        int col=ui->spinBoxColumn->value();//列号
        MainWindow *parWind = (MainWindow*)parentWidget(); //获取主窗口
        parWind->setACellText(row,col,ui->edtCaption->text()); //设置单元格文字
        if (ui->chkBoxRow->isChecked()) //行增
            ui->spinBoxRow->setValue(1+ui->spinBoxRow->value());
        if (ui->chkBoxColumn->isChecked()) //列增
            ui->spinBoxColumn->setValue(1+ui->spinBoxColumn->value());
    }

    想要在对话框中操作主窗口,就需要获取主窗口对象,调用主窗口的函数并传递参数。在上面的代码中,通过下面一行语句获得主窗口对象:

    MainWindow *parWind = (MainWindow*)parentWidget();

    parentWidget() 是 QWidget 类的一个函数,指向父窗口。在创建此对话框时,将主窗口的指针传递给对话框的构造函数,即:

    dlgLocate = new QWDialogLocate(this);

    所以,对话框的 parentWidget 指向主窗口。然后调用主窗口的一个自定义的 public 函数 setACellText(),传递行号、列号和字符串,由主窗口更新指定单元格的文字。

    下面是主窗口的 setACellText() 函数的代码:

    void MainWindow::setACellText(int row, int column, QString text)
    {//定位到单元格,并设置字符串
        QModelIndex index=theModel->index(row,column);//获取模型索引
        theSelection->clearSelection(); //清除现有选择
        theSelection->setCurrentIndex(index,QItemSelectionModel::Select); //定位到单元格
        theModel->setData(index,text,Qt::DisplayRole);//设置单元格字符串
    }

    这样就实现了在对话框里对主窗口进行的操作,主要是获取主窗口对象,然后调用相应的函数。

    主窗口中操作对话框

    在主窗口上用鼠标单击 TableView 组件的某个单元格时,如果单元格定位对话框 dlgLocate 己经存在,就将单元格的行号、列号更新到对话框上,实现代码如下:

    void MainWindow::on_tableView_clicked(const QModelIndex &index)
    {//单击单元格时,将单元格的行号、列号设置到对话框上
        if (dlgLocate!=NULL) //对话框存在
            dlgLocate->setSpinValue(index.row(),index.column());
    }

    因为主窗口中定义了对话框的指针,只要它不为 NULL,就说明对话框存在,调用对话框的一个自定义函数 setSpinValue(),刷新对话框显示界面。QWDialogLocate 的 setSpinValue() 函数实现如下:

    void QWDialogLocate::setSpinValue(int rowNo, int colNo)
    {//设置SpinBox数值
        ui->spinBoxRow->setValue(rowNo);
        ui->spinBoxColumn->setValue(colNo);
    }

    窗口的 CloseEvent 事件

    对话框和主窗口之间互相操作的关键是要有对方对象的指针,然后才能传递参数并调用对方的函数。在对话框关闭时,还需要做一些处理:将主窗口的 actTab_Locate 重新设置为使能,将主窗口的指向对话框的指针 dlgLocate 重新设置为 NULL。

    由于对话框 dlgLocate 是以非模态方式运行的,程序无法等待对话框结束后作出响应,但是可以利用窗口的 CloseEvent 事件。

    事件(event)是由窗口系统产生的由某些操作触发的特殊函数,例如鼠标操作、键盘操作的一些事件,还有窗口显示、关闭、绘制等相关的事件。从 QWidget 继承的窗口部件常用的事件函数有如下几种:

    • closeEvent():窗口关闭时触发的事件,通常在此事件做窗口关闭时的一些处理,例如显示一个对话框询问是否关闭窗口。
    • showEvent():窗口显示时触发的事件。
    • paintEvent():窗口绘制事件,第8章介绍绘图时会用到。
    • mouseMoveEvent():鼠标移动事件。
    • mousePressEvent():鼠标键按下事件。
    • mouseReleaseEvent():鼠标键释放事件。
    • keyPressEvent():键盘按键按下事件。
    • keyReleaseEvent():键盘按键释放事件。


    要利用某个事件进行一些处理,需要在窗口类里重定义事件函数并编写响应代码。在后面的例子中,将逐渐演示一些事件的用法。

    在本例中,要利用对话框的 closeEvent() 事件,在类定义中声明了此事件的函数,其实现代码如下:

    void QWDialogLocate::closeEvent(QCloseEvent *event)
    { //窗口关闭事件,关闭时释放本窗口
        MainWindow *parWind = (MainWindow*)parentWidget(); //获取父窗口指针
        parWind->setActLocateEnable(true);//使能 actTab_Locate
        parWind->setDlgLocateNull(); //将窗口指针设置为NULL
    }

    在 closeEvent() 事件里,调用主窗口的两个函数,将 actTab_Locate 重新使能,将主窗口内指向对话框的指针设置为 NULL。主窗口中这两个函数的实现代码如下:

    void MainWindow::setActLocateEnable(bool enable)
    {
        ui->actTab_Locate->setEnabled(enable);
    }
    void MainWindow::setDlgLocateNull()
    {
        dlgLocate=NULL;
    }

    利用 closeEvent() 事件,可以询问窗口是否退出,例如为主窗口添加 closeEvent() 事件的处理,代码如下:

    void MainWindow::closeEvent(QCloseEvent *event)
    { //窗口关闭时询问是否退出
       QMessageBox::StandardButton result=QMessageBox::question(this, "确认", "确定要退出本程序吗?",QMessageBox::Yes|QMessageBox::No|QMessageBox::Cancel,QMessageBox::No);
        if (result==QMessageBox::Yes)
            event->accept();
        else
            event->ignore();
    }

    这样,主窗口关闭时就会出现一个询问对话框,如果不单击“Yes”按钮,程序就不关闭;否则应用程序结束。

    利用信号与槽实现交互操作

    前面设计的 QWDialogLocate 对话框与主窗口之间的交互釆用互相引用的方式,实现起来比较复杂。另外一种实现方式就是利用 Qt 的信号与槽机制,设计相应的信号和槽,将信号与槽关联起来,在进行某个操作时发射信号,槽函数自动响应。

    对 MainWindow 和 QWDialogLocate 稍作修改,采用信号与槽机制实现交互操作。

    下面是 MainWindow 类定义中与此相关的定义,包括两个槽函数和一个信号:

    class MainWindow : public QMainWindow
    {
        public slots:
            void setACellText (int row, int column, QString &text) ;//设置单元格内容
            void setActLocateEnable (bool enable) ; //设置 actTab_Locate 的 enabled 属性
        signals:
            void celllndexChanged(int rowNo, int colNo) ;//当前单元格发生变化
    };

    在主窗口上,“定位单元格”按钮的响应代码与前面有较大的差别。

    两个槽函数是对话框操作主窗口时,主窗口作出的响应。信号是主窗口上 tableView 的当前单 元格发生变化时发射的一个信号,以便对话框作出响应。

    下面是两个槽函数的实现,以及 tableView 的 clicked() 信号的槽函数里发射自定义信号的代码,代码中都无须引用对话框对象:

     

    void MainWindow::setACellText(int row, int column, QString text)
    {//定位到单元格,并设置字符串
        QModelIndex index=theModel->index(row,column);//获取模型索引
        theSelection->clearSelection(); //清除现有选择
        theSelection->setCurrentIndex(index,QItemSelectionModel::Select); //定位到单元格
        theModel->setData(index,text,Qt::DisplayRole);//设置单元格字符串
    }
    void MainWindow::setActLocateEnable(bool enable)
    {
        ui->actTab_Locate->setEnabled(enable);
    }
    void MainWindow::on_tableView_clicked(const QModelIndex &index)
    {//单击单元格时发射信号,传递单元格的行号、列号
        emit cellIndexChanged(index.row(),index.column());
    }

    在主窗口上,“定位单元格”按钮的响应代码与前面有较大的差别:

    void MainWindow::on_actTab_Locate_triggered()
    {//创建StayOnTop的对话框,对话框关闭时自动删除
        QWDialogLocate *dlgLocate = new QWDialogLocate(this);
        dlgLocate->setAttribute(Qt::WA_DeleteOnClose);
        Qt::WindowFlags flags=dlgLocate->windowFlags();
        dlgLocate->setWindowFlags(flags 丨 Qt::WindowStaysOnTopHint);
        dlgLocate->setSpinRange(theModel->rcwCoimt(),theModel->columnCount());
        QModelIndex curIndex=theSelection->currentIndex();
        if (curIndex.isValid())
            dlgLocate->setSpinValue(curIndex.row(),curIndex.column());
        //对话框发射信号,设置单元格文字
        connect(dlgLocate,SIGNAL(changeCellText(int, int, QString&)), this,SLOT(setACellText(int,int,QString&)));
        //对话框发射信号,设置actTab_Locate的属性
        connect(dlgLocate,SIGNAL(changeActionEnable(bool)), this, SLOT(setActLocateEnable(bool)));
        //主窗口发射信号,修改对话框上的spinBox的值
        connect(this,SIGNAL(celllndexChanged(int, int)),
        dlgLocate,SLOT(setSpinValue(int, int)));
        dlgLocate->show () ; //非模态显示对话框
    }

    在这里,对话框变量声明为了局部变量,不再需要在主窗口类里保存对话框的指针。这段代码的关键是设置了 3 对信号与槽的关联:

    在 QWDialogLocate 类定义中,与信号和槽相关的定义如下:

    class QWDialogLocate : public QDialog
    {
    private:
        void closeEvent(QCloseEvent *event);
        void showEvent(QShowEvent *event);
    private slots:
        void on_btnSetText_clicked();
    public slots:
        void setSpinValue(int rowNo, int colNo);
    signals:
        void changeCellText(int row, int column, QString &text);
        void changeActionEnable(bool en);
    };

    QWDialogLocate 自定义了一个槽函数和两个信号,还增加了 showEvent() 事件的处理,用于对话框显不时发射信号使主窗口的 actTab_Locate 失效。

    这些槽函数,以及发射信号的实现代码如下,代码中没有出现对主窗口的引用:

    void QWDialogLocate::closeEvent(QCloseEvent *event)
    {//窗口关闭事件,发射信号使actTab_Locate能用
        emit changeActionEnable(true);
    }
    void QWDialogLocate::showEvent(QShowEvent *event)
    {//窗口显示事件,发射信号使actTab_Locate不能用
        emit changeActionEnable(false);
    }
    void QWDialogLocate::setSpinValue(int rowNo, int colNo)
    {//响应主窗口信号,更新spinBox的值
        ui->spinBoxRow->setValue(rowNo);
        ui->spinBoxColumn->setValue(colNo);
    }
    void QWDialogLocate::on_btnSetText_clicked(〉
    {//发射信号,定位到单元格并运置字符串
        int row=ui->spinBoxRow->value () ; //行号
        int col=ui->spinBoxColumn->value () ;//列号
        QString text=ui->edtCaption->text () ;//文字
        emit changeCellText (row, col, text) ; //发射信号
        if (ui->chkBoxRow->isChecked () ) //行增
            ui->spinBoxRow->setValue(1+ui->spinBoxRow->value());
        if (ui->chkBoxColumn->isChecked () ) //列增
            ui->spinBoxColumn->setValue(1+ui->spinBoxColumn->value());
    }

    经过这样修改后的程序,能实现与前面的实例完全相同的主窗口与对话框交互的功能,但是与前面互相引用的方式不同,这里使用Qt的信号与槽的机制,无须获取对方的指针,程序结构上更简单一些。

    展开全文
  • android自定义对话框

    千次阅读 2018-03-13 11:59:28
    实现步骤:1、自定义需要的布局2、创建适配器,适配布局3、调用自定义对话框详解:1、自定义需要的布局我需要的布局(view_bomb_box.xml)效果是这样的其实自定义就是根据自己需要自己定义,相信大家都会布局的,...
  • QT自定义对话框

    2020-02-22 16:29:54
    自定义对话框的设计一般从 QDialog 继承,并且可以采用UI设计器可视化地设计对话框。对话框的调用一般包括创建对话框、传递数据给对话框、显示对话框获取输入、判断对话框单击按钮的返回类型、获取对话框输入数据等...
  • java自定义对话框弹出

    千次阅读 2020-04-12 20:22:49
    java自定义对话框弹出 本次实习因为写java界面,有一个自定义对话框的需求,在网上查了一些才发现了一种方法,所以记录一下。具体需求类似于这样:按下一个按钮弹出一个输入界面,输入行李的长宽高,然后进行显示。...
  • 从前面章节的介绍可以看到,不管是使用 SimpleDialog 还是 Dialog,整个对话框的布局都是...如果开发者需要使用自定义对话框,包括定制模式和非模式行为,则可通过继承 Toplevel 来实现。如果打算通过这种方式来实...
  • 自定义对话框的设计一般从 QDialog 继承,并且可以采用UI设计器可视化地设计对话框。对话框的调用一般包括创建对话框、传递数据给对话框、显示对话框获取输入、判断对话框单击按钮的返回类型、获取对话框输入数据等...
  • 本文实例为大家分享了kotlin自定义对话框的具体代码,供大家参考,具体内容如下 1.CommonDialog 创建我们自己的对话框,继承于系统的Dialog 实现构造方法 class CommonDialog(context: Context?, themeResId: Int) :...
  • Dialog自定义对话框

    2018-05-07 18:36:38
    设定自定义对话框的风格(不显示标题栏,不显示背景),由于继承了Dialog,默认添加了Dialog标题的一栏 3.找到res--&gt;values--&gt;styles.xml设置风格 4.调用含设定对话框风格参数的构造 5.对自定义对...
  • 创建自定义对话框

    千次阅读 2011-07-05 15:03:41
    创建自定义对话框,首先要创建一个Layout xml 文件,在此不啰嗦了。然后加载Layout有两种方法,也是非常熟悉的那两种方法: 1. setContentView(int resources id) 2. 利用LayoutInflater加载
  • 在一个应用程序设计中,为了实现一些特定的功能,有时候需要设计自定义对话框自定义对话框的设计一般从 QDialog 继承,并且可以采用UI设计器可视化地设计对话框。对话框的调用一般包括创建对话框、传递数据给...
  • Java实现一个自定义对话框的步骤

    千次阅读 2018-06-20 10:28:07
    1、继承JDialog,在构造方法中传入参数。2、在对话框中添加用户界面组件。3、添加事件处理4、设置对话框大小
  • 自定义对话框大全(常见的七种)

    千次阅读 2017-02-21 20:16:53
    Activities提供了一种方便管理的创建、保存、回复的对话框机制,例如 onCreateDialog(int), onPrepareDialog(int, Dialog), showDialog(int), dismissDialog(int)等方法,如果使用这些方法的话,Activity将...
  • 一:AlterDialog对话框 二:普通对话框 运行效果: 代码详情 备注:onBackPressed()事件是用户点击回退键退出软件时触发,事件有...五:自定义对话框 ...1:自定义对话框dialog.xml布局 <?xml version="1.0" encodin...
  • Qt中的信号和槽以及自定义对话框

    千次阅读 2018-02-02 14:52:42
     Qt中使用信号和槽机制来完成对象之间的协同操作,信号和槽都是函数,例如,单击窗口上的一个按钮时,想要弹出一个对话框,那么可以将这个按钮的单击信号和自定义的槽关联起来,在这个槽中创建一个对话框并且显示它...
  • 1创建MyDialog继承Dialogpackage com.example.mvpfour.dialog; import android.app.Dialog; import android.content.Context; import android.os.Bundle; import android.support.annotation.LayoutRes; import ...
  • 自定义对话框

    2019-12-27 19:32:03
    自定义对话框自定义方法,继承Dialog 自定义方法,继承Dialog class MyDialog extends Dialog { //声明控件 private TextView title; private TextView message; private Button no; private Button yes; //...
  • 对话框与自定义对话框对话框普通对话框单选对话框多选框自定义对话框水平进度条对话框圆形模糊进度对话框日期选择对话框时间选择对话框对话框创建一个继承Dialog的操作 对话框 普通对话框 //构建者 AlertDialog....
  • 第一步:创建对话框MyDialog mydlg=new MyDialog(context);第二步:获取对话框的window实例,通过window实例来控制对话框出现的位置,大小和弹出时候的场景Window dlgwindow=mydly.getWindow();设置对话框最终显示...
  • 创建自定义对话框的步骤:>创建对话框布局文件,如:android:layout_width = "wrap_content"android:layout_height = "wrap_content">android:id="@+id/dlg_priority_titlebar"android:orientation="horizontal...
  • android Dialog 自定义 继承Dialog基类

    千次阅读 2014-10-10 23:26:42
    只有一个Activity,当点击Button的时候就弹出这个自定义的Dialog 里面的几张图都比较丑,我不多会美工,随便用powerpoint画了几张图,原理是一样的,先不计较这些。下面正入正题 为了照顾到所有的码农,在...
  • 传统意义上的自定义对话框需要创建一个自定义布局,然后定义一个MyDialog类继承至Dialog。在需要Activity与Dialog之间进行信息传递的时候,往往需要通过在MyDialog中定义接口的方式,利用回调机制来实现。 这种...
  • IOS之自定义对话框

    千次阅读 2013-12-23 16:18:30
    由于通过继承UIAlterView来实现自定义对话框的方法在IOS7.0系统中不能再实现,通过查找相关资料寻找到一个相对比较简单而且有效的方法来替代之前的方法。接下来我们将学习如何利用UIView来实现自定义对话框的效果。 ...
  • Android 自定义对话框

    2019-05-15 22:55:00
    为了提高用户体验,达到理想的效果,一般不直接使用系统提供的对话框,而使用自定义对话框。 步骤: 1、创建对话框的布局文件 1 <?xml version="1.0" encoding="utf-8"?> 2 <LinearLayout xmlns:...
  • 自定义窗体及其继承

    2004-09-06 16:50:00
    在一个项目中,把项目属性->输出改为“类库”,然后“生成”->“生成”,就可以在bin下产生一个dll文件了。在另一个项目中,添加“继承的窗体”,选择该dll,添加就可以得到一个继承的窗体。
  • 对话框对话框普通对话框单选对话框多选对话框自定义内容对话框水平进度条对话框圆形进度条对话框日期选择对话框时间选择对话框自定义对话框(重难点) 对话框 普通对话框 单选对话框 多选对话框 自定义内容对话框 ...
  • 1、对话框重点总结: ...自定义Dialog 布局 dialog.xml 式样styles.xml 继承Dialog,构造方法、onCreate 值的传入和传出 2Nw==,size_16,color_FFFFFF,t_70) 2、Toast Toast是Android中用来显示信息得一种机制,和Dia

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,395
精华内容 12,558
关键字:

创建自定义对话框需要继承什么类