devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt开发-Qt中的事件处理（上）_qt 修改事件

作者：Guff_9hys | 2024-08-08 19:11:24

赞

踩

qt 修改事件

一、图形界面应用程序的消息处理模型

二、Qt的事件处理

1、Qt平台将系统产生的消息转换为Qt事件（每一个系统消息对象Qt平台的一个事件）

（1）、Qt事件是一个QEvent的对象

（2）、Qt事件用于描述程序内部或者外部发生的动作

（3）、任意的QObject对象都具备事件处理的能力

2、GUI应用程序的事件处理方式

（1）、Qt事件产生后立即被分发到QWidget对象

（2）、QWidget中的event（QEvent*）进行事件处理

（3）、event()根据事件类型调用不同的事件处理函数

（4）、在事件处理函数中发送Qt中预定义的信号

（5）、调用信号关联的槽函数

3、情景分析：按钮点击

（1）、接收到鼠标事件（代表一个系统消息）

（2）、调用event(QEvent*)成员函数

（3）、调用MouseReleaseEvent(QMouseEvent*)成员函数

（4）、调用clicked()成员函数

（5）、触发信号SIGNAL(clicked())

4、事件（QEvent）和信号（SIGNAL）不同

（1）、事件由具体对象进行处理

（2）、信号由具体对象主动产生

（3）、改写事件处理函数可能导致程序行为发生改变

（4）、信号是否存在对应的槽函数不会改变程序的行为

（5）、一般而言，信号在具体的事件处理函数中产生

三、文本编辑器的关闭操作

  1. void MainWindow::closeEvent(QCloseEvent *e)//没有对应的信号来处理，只能重写事件处理函数
  2. {
  3.     preEditorChanged();
  4.  
  5.     if(!m_isTextChanged)
  6.     {
  7.         QMainWindow::closeEvent(e);//调用父类的关闭事件处理函数
  8.     }
  9.     else
  10.     {
  11.         e->ignore();//点取消的话就忽略这个对话框
  12.     }
  13. }

完整代码：

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3. #include <QMenuBar>
  4. #include <QMenu>
  5. #include <QAction>
  6. #include <QString>
  7. #include <QtGui/QMainWindow>
  8. #include <QToolBar>
  9. #include <QIcon>
  10. #include <QSize>
  11. #include <QStatusBar>
  12. #include <QLabel>
  13. #include <QPlainTextEdit>
  14. #include <QFileDialog>
  15. class MainWindow : public QMainWindow
  16. {
  17.     Q_OBJECT
  18. private:
  19.         QPlainTextEdit mainEdit;
  20.         QLabel statusLabel;
  21.         QString m_filePath;//记得在构造函数里初始化
  22.         bool m_isTextChanged;//构造函数里初始化为false
  23.  
  24.         MainWindow(QWidget *parent = 0);
  25.         MainWindow(const MainWindow& obj);
  26.         MainWindow* operator = (const MainWindow& obj);
  27.         bool construct();
  28.  
  29.         bool initMenuBar();//菜单栏
  30.         bool initToolBar();//工具栏
  31.         bool initStatusBar();//状态栏
  32.         bool initinitMainEditor();//编辑窗口
  33.  
  34.         bool initFileMenu(QMenuBar* mb);//文件菜单
  35.         bool initEditMenu(QMenuBar* mb);//编辑菜单
  36.         bool initFormatMenu(QMenuBar* mb);//格式菜单
  37.         bool initViewMenu(QMenuBar* mb);//视图菜单
  38.         bool initHelpMenu(QMenuBar* mb);//帮助菜单
  39.  
  40.         bool initFileToolItem(QToolBar* tb);//工具选项
  41.         bool initEditToolItem(QToolBar* tb);
  42.         bool initFormatToolItem(QToolBar* tb);
  43.         bool initViewToolItem(QToolBar* tb);
  44.  
  45.  
  46.         bool makeAction(QAction*& action,QMenu* menu, QString text, int key);//菜单项
  47.         bool makeAction(QAction*& action,QToolBar* tb, QString tip, QString icon);
  48.  
  49.         QString showFileDialog(QFileDialog::AcceptMode mode, QString title);//文件对话框
  50.         void showErrorMessage(QString message);//错误消息对话框
  51.         int showQuesstionMessage(QString message);//问题消息对话框
  52.         QString saveCurrentData(QString path = "");
  53.         void preEditorChanged();
  54.  
  55. private slots:
  56.         void onFileNew();
  57.         void onFileOpen();
  58.         void onFlieSave();
  59.         void onFileSaveAs();
  60.         void onTextChanged();
  61. protected:
  62.         void closeEvent(QCloseEvent *e);//重写关闭窗口的事件处理函数
  63. public:
  64.      static MainWindow* NewInstance();
  65.     ~MainWindow();
  66. };
  67.  
  68. #endif // MAINWINDOW_H
  1. #include "MainWindow.h"
  2. #include <QDebug>
  3.  
  4. MainWindow::MainWindow(QWidget *parent)
  5.     : QMainWindow(parent), statusLabel(this)
  6. {
  7.     m_filePath = "";
  8.     m_isTextChanged = false;
  9.     setWindowTitle("NotePad-[New]");
  10. }
  11.  
  12. bool MainWindow::construct()
  13. {
  14.     bool ret = true;
  15.     ret = ret && initMenuBar();
  16.     ret = ret && initToolBar();
  17.     ret = ret && initStatusBar();
  18.     ret = ret && initinitMainEditor();
  19.     return ret;
  20. }
  21. MainWindow* MainWindow::NewInstance()
  22. {
  23.     MainWindow* ret = new MainWindow();
  24.  
  25.     if((ret==NULL) || (!ret->construct()))
  26.     {
  27.         delete ret;
  28.         ret = NULL;
  29.     }
  30.  
  31.     return ret;
  32. }
  33. bool MainWindow::initMenuBar()//菜单栏
  34. {
  35.     bool ret = true;
  36.  
  37.     QMenuBar* mb = menuBar();//一定要注意是menuBar()，这是普通成员函数，不是构造函数
  38.  
  39.     ret = ret && initFileMenu(mb);//传一个参数是为了在initFileMenu()函数将menu加入菜单栏
  40.     ret = ret && initEditMenu(mb);
  41.     ret = ret && initFormatMenu(mb);
  42.     ret = ret && initViewMenu(mb);
  43.     ret = ret && initHelpMenu(mb);
  44.  
  45.     return ret;
  46.  
  47. }
  48.  
  49. bool MainWindow::initToolBar()//工具栏
  50. {
  51.     bool ret = true;
  52.  
  53.     QToolBar* tb = addToolBar("Tool Bar");
  54.     //tb->setMovable(false);
  55.     //tb->setFloatable(false);
  56.     tb->setIconSize(QSize(16,16));
  57.  
  58.     ret = ret && initFileToolItem(tb);
  59.     tb->addSeparator();
  60.     ret = ret && initEditToolItem(tb);
  61.     tb->addSeparator();
  62.     ret = ret && initFormatToolItem(tb);
  63.     tb->addSeparator();
  64.     ret = ret && initViewToolItem(tb);
  65.  
  66.     return ret;
  67. }
  68.  
  69. bool MainWindow::initStatusBar()//状态栏
  70. {
  71.     bool ret = true;
  72.  
  73.     QStatusBar* sb = statusBar();
  74.  
  75.     QLabel* label = new QLabel("Made By LGC");
  76.  
  77.     if(label != NULL)
  78.     {
  79.         statusLabel.setMinimumWidth(200);
  80.         statusLabel.setAlignment(Qt::AlignHCenter);
  81.         statusLabel.setText("Ln:1    Col:1");
  82.  
  83.  
  84.         label->setMinimumWidth(200);
  85.         label->setAlignment(Qt::AlignHCenter);
  86.  
  87.         sb->addPermanentWidget(new QLabel());//单纯加入分隔符
  88.         sb->addPermanentWidget(&statusLabel);
  89.         sb->addPermanentWidget(label);
  90.     }
  91.     else
  92.     {
  93.         ret = false;
  94.     }
  95.     return ret;
  96. }
  97. bool MainWindow::initinitMainEditor()//编辑窗口
  98. {
  99.     bool ret = true;
  100.  
  101.     mainEdit.setParent(this);
  102.     setCentralWidget(&mainEdit);
  103.  
  104.     connect(&mainEdit, SIGNAL(textChanged()), this, SLOT(onTextChanged()));
  105.  
  106.     return ret;
  107. }
  108.  
  109. /************************************************文件菜单********************************************************/
  110. bool MainWindow::initFileMenu(QMenuBar* mb)
  111. {
  112.     bool ret = true;
  113.  
  114.     QMenu* menu = new QMenu("File(&F)");//创建文件菜单，（&F）是为了可以Alt+F打开
  115.     ret = (menu != NULL);
  116.     if(ret)
  117.     {
  118.         QAction* action = NULL;
  119.  
  120.         //New
  121.         ret = ret &&  makeAction(action, menu, "New(&N)",Qt::CTRL + Qt::Key_N);
  122.         if(ret)
  123.         {
  124.            connect(action, SIGNAL(triggered()), this, SLOT(onFileNew()));
  125.            menu->addAction(action);
  126.         }
  127.  
  128.         menu->addSeparator();
  129.  
  130.         //Open
  131.         ret = ret &&  makeAction(action,  menu,"Open(&O)...",Qt::CTRL + Qt::Key_O);
  132.         if(ret)
  133.         {
  134.            connect(action, SIGNAL(triggered()), this, SLOT(onFileOpen()));
  135.            menu->addAction(action);
  136.         }
  137.  
  138.         menu->addSeparator();
  139.  
  140.         //Save
  141.         ret = ret &&  makeAction(action,  menu,"Save(&S)",Qt::CTRL + Qt::Key_S);
  142.         if(ret)
  143.         {
  144.             connect(action, SIGNAL(triggered()), this ,SLOT(onFlieSave()));
  145.             menu->addAction(action);
  146.         }
  147.  
  148.         menu->addSeparator();
  149.  
  150.         //Save As
  151.         ret = ret &&  makeAction(action, menu, "Save As(&A)...",0);
  152.         if(ret)
  153.         {
  154.            connect(action, SIGNAL(triggered()), this, SLOT(onFileSaveAs()));
  155.            menu->addAction(action);
  156.  
  157.         }
  158.  
  159.         menu->addSeparator();
  160.  
  161.         //print
  162.         ret = ret &&  makeAction(action, menu, "Print(&P)...",Qt::CTRL + Qt::Key_P);
  163.         if(ret)
  164.         {
  165.            menu->addAction(action);
  166.         }
  167.  
  168.         menu->addSeparator();
  169.  
  170.         //Exit
  171.         ret = ret &&  makeAction(action,  menu,"Exit(&X)",0);
  172.         if(ret)
  173.         {
  174.            menu->addAction(action);//将菜单项加入到菜单
  175.         }
  176.  
  177.     }
  178.     if(ret)
  179.     {
  180.         mb->addMenu(menu);//将菜单加入到菜单栏
  181.     }
  182.     else
  183.     {
  184.         delete mb;
  185.     }
  186.     return ret;
  187. }
  188.  
  189. /************************************************编辑菜单********************************************************/
  190. bool MainWindow::initEditMenu(QMenuBar* mb)
  191. {
  192.     bool ret = true;
  193.  
  194.     QMenu* menu = new QMenu("Edit(&E)");
  195.     ret = (menu != NULL);
  196.     if(ret)
  197.     {
  198.         QAction* action = NULL;
  199.  
  200.         //Undo
  201.         ret = ret &&  makeAction(action,  menu,"Undo(&U)",Qt::CTRL + Qt::Key_Z);
  202.         if(ret)
  203.         {
  204.            menu->addAction(action);
  205.         }
  206.  
  207.         menu->addSeparator();
  208.  
  209.         //Redo
  210.         ret = ret &&  makeAction(action,  menu,"Redo(&R)...",Qt::CTRL + Qt::Key_Y);
  211.         if(ret)
  212.         {
  213.            menu->addAction(action);
  214.         }
  215.  
  216.         menu->addSeparator();
  217.  
  218.         //Cut
  219.         ret = ret &&  makeAction(action,  menu,"Cut(&T)",Qt::CTRL + Qt::Key_X);
  220.         if(ret)
  221.         {
  222.            menu->addAction(action);
  223.         }
  224.  
  225.         menu->addSeparator();
  226.  
  227.         //Copy
  228.         ret = ret &&  makeAction(action,  menu,"Copy(&C)...",Qt::CTRL + Qt::Key_C);
  229.         if(ret)
  230.         {
  231.            menu->addAction(action);
  232.         }
  233.  
  234.         menu->addSeparator();
  235.  
  236.         //Pase
  237.         ret = ret &&  makeAction(action,  menu,"Pase(&P)...",Qt::CTRL + Qt::Key_V);
  238.         if(ret)
  239.         {
  240.            menu->addAction(action);
  241.         }
  242.  
  243.         menu->addSeparator();
  244.  
  245.         //Delete
  246.         ret = ret &&  makeAction(action, menu, "Delete(&L)",Qt::Key_Delete);
  247.         if(ret)
  248.         {
  249.            menu->addAction(action);
  250.         }
  251.  
  252.         menu->addSeparator();
  253.  
  254.         //Find
  255.         ret = ret &&  makeAction(action,  menu,"Find(&F)...",Qt::CTRL + Qt::Key_F);
  256.         if(ret)
  257.         {
  258.            menu->addAction(action);
  259.         }
  260.  
  261.         menu->addSeparator();
  262.  
  263.         //Replace
  264.         ret = ret &&  makeAction(action,  menu,"Replace(&R)...",Qt::CTRL + Qt::Key_H);
  265.         if(ret)
  266.         {
  267.            menu->addAction(action);
  268.         }
  269.  
  270.         menu->addSeparator();
  271.  
  272.         //Goto
  273.         ret = ret &&  makeAction(action,  menu,"Goto(&G)",Qt::CTRL + Qt::Key_G);
  274.         if(ret)
  275.         {
  276.            menu->addAction(action);
  277.         }
  278.  
  279.         menu->addSeparator();
  280.  
  281.         //Select All
  282.         ret = ret &&  makeAction(action, menu, "Select All(&A)",Qt::CTRL + Qt::Key_A);
  283.         if(ret)
  284.         {
  285.            menu->addAction(action);
  286.         }
  287.  
  288.     }
  289.     if(ret)
  290.     {
  291.         mb->addMenu(menu);
  292.     }
  293.     else
  294.     {
  295.         delete mb;
  296.     }
  297.     return ret;
  298. }
  299.  
  300. /************************************************格式菜单********************************************************/
  301. bool MainWindow::initFormatMenu(QMenuBar* mb)
  302. {
  303.     bool ret = true;
  304.  
  305.     QMenu* menu = new QMenu("Format(&O)");
  306.     ret = (menu != NULL);
  307.     if(ret)
  308.     {
  309.         QAction* action = NULL;
  310.  
  311.         //Auto Wrap
  312.         ret = ret &&  makeAction(action,  menu,"Auto Wrap(&W)",0);
  313.         if(ret)
  314.         {
  315.            menu->addAction(action);
  316.         }
  317.  
  318.         menu->addSeparator();
  319.  
  320.         //Font
  321.         ret = ret &&  makeAction(action,  menu,"Font(&F)...",0);
  322.         if(ret)
  323.         {
  324.            menu->addAction(action);
  325.         }
  326.  
  327.     }
  328.     if(ret)
  329.     {
  330.         mb->addMenu(menu);
  331.     }
  332.     else
  333.     {
  334.         delete mb;
  335.     }
  336.     return ret;
  337. }
  338.  
  339. /************************************************视图菜单********************************************************/
  340. bool MainWindow::initViewMenu(QMenuBar* mb)
  341. {
  342.     bool ret = true;
  343.  
  344.     QMenu* menu = new QMenu("View(&V)");
  345.     ret = (menu != NULL);
  346.     if(ret)
  347.     {
  348.         QAction* action = NULL;
  349.  
  350.         //Tool Bar
  351.         ret = ret &&  makeAction(action, menu,"Tool Bar(&T)",0);
  352.         if(ret)
  353.         {
  354.            menu->addAction(action);
  355.         }
  356.  
  357.         menu->addSeparator();
  358.  
  359.         //Status Bar
  360.         ret = ret &&  makeAction(action, menu,"Status Bar(&S)",0);
  361.         if(ret)
  362.         {
  363.            menu->addAction(action);
  364.         }
  365.  
  366.     }
  367.     if(ret)
  368.     {
  369.         mb->addMenu(menu);
  370.     }
  371.     else
  372.     {
  373.         delete mb;
  374.     }
  375.     return ret;
  376. }
  377.  
  378. /************************************************帮助菜单********************************************************/
  379. bool MainWindow::initHelpMenu(QMenuBar* mb)
  380. {
  381.     bool ret = true;
  382.  
  383.     QMenu* menu = new QMenu("Help(&H)");
  384.     ret = (menu != NULL);
  385.     if(ret)
  386.     {
  387.         QAction* action = NULL;
  388.  
  389.         //User Manual
  390.         ret = ret &&  makeAction(action,  menu,"User Manual",0);
  391.         if(ret)
  392.         {
  393.            menu->addAction(action);
  394.         }
  395.  
  396.         menu->addSeparator();
  397.  
  398.         //About NotePad
  399.         ret = ret &&  makeAction(action,  menu,"About NotePad...",0);
  400.         if(ret)
  401.         {
  402.            menu->addAction(action);
  403.         }
  404.  
  405.     }
  406.     if(ret)
  407.     {
  408.         mb->addMenu(menu);
  409.     }
  410.     else
  411.     {
  412.         delete mb;
  413.     }
  414.     return ret;
  415. }
  416. /*****************************************工具************************************************************/
  417. bool MainWindow::initFileToolItem(QToolBar* tb)
  418. {
  419.     bool ret = true;
  420.     QAction* action = NULL;
  421.  
  422.     ret = ret && makeAction(action, tb, "New", ":/Res/pic/new.png");
  423.     if(ret)
  424.     {
  425.         connect(action, SIGNAL(triggered()), this, SLOT(onFileNew()));
  426.         tb->addAction(action);
  427.  
  428.     }
  429.  
  430.     ret = ret && makeAction(action,  tb,"Open", ":/Res/pic/open.png");
  431.     if(ret)
  432.     {
  433.         connect(action, SIGNAL(triggered()), this, SLOT(onFileOpen()));
  434.         tb->addAction(action);
  435.     }
  436.  
  437.     ret = ret && makeAction(action,  tb,"Save", ":/Res/pic/save.png");
  438.     if(ret)
  439.     {
  440.         connect(action, SIGNAL(triggered()), this ,SLOT(onFlieSave()));
  441.         tb->addAction(action);
  442.     }
  443.  
  444.     ret = ret && makeAction(action,  tb,"Save As", ":/Res/pic/saveas.png");
  445.     if(ret)
  446.     {
  447.         connect(action, SIGNAL(triggered()), this, SLOT(onFileSaveAs()));
  448.         tb->addAction(action);
  449.     }
  450.     ret = ret && makeAction(action, tb,"Print",  ":/Res/pic/print.png");
  451.     if(ret)
  452.     {
  453.         tb->addAction(action);
  454.     }
  455.     return ret;
  456.  
  457. }
  458. bool MainWindow::initEditToolItem(QToolBar* tb)
  459. {
  460.     bool ret = true;
  461.     QAction* action = NULL;
  462.  
  463.     ret = ret && makeAction(action, tb,"Undo",  ":/Res/pic/undo.png");
  464.     if(ret)
  465.     {
  466.         tb->addAction(action);
  467.     }
  468.     ret = ret && makeAction(action,  tb,"Redo", ":/Res/pic/redo.png");
  469.     if(ret)
  470.     {
  471.         tb->addAction(action);
  472.     }
  473.  
  474.     ret = ret && makeAction(action, tb, "Cut",  ":/Res/pic/cut.png");
  475.     if(ret)
  476.     {
  477.         tb->addAction(action);
  478.     }
  479.  
  480.     ret = ret && makeAction(action,  tb,"Copy", ":/Res/pic/copy.png");
  481.     if(ret)
  482.     {
  483.         tb->addAction(action);
  484.     }
  485.  
  486.     ret = ret && makeAction(action, tb,"Paste",  ":/Res/pic/paste.png");
  487.     if(ret)
  488.     {
  489.         tb->addAction(action);
  490.     }
  491.  
  492.     ret = ret && makeAction(action, tb,"Find",  ":/Res/pic/find.png");
  493.     if(ret)
  494.     {
  495.         tb->addAction(action);
  496.     }
  497.     ret = ret && makeAction(action, tb,"Replace",  ":/Res/pic/replace.png");
  498.     if(ret)
  499.     {
  500.         tb->addAction(action);
  501.     }
  502.     ret = ret && makeAction(action, tb,"Goto",  ":/Res/pic/goto.png");
  503.     if(ret)
  504.     {
  505.         tb->addAction(action);
  506.     }
  507.  
  508.     return ret;
  509. }
  510. bool MainWindow::initFormatToolItem(QToolBar* tb)
  511. {
  512.     bool ret = true;
  513.     QAction* action = NULL;
  514.  
  515.     ret = ret && makeAction(action, tb, "Auto Wrap", ":/Res/pic/wrap.png");
  516.     if(ret)
  517.     {
  518.         tb->addAction(action);
  519.     }
  520.     ret = ret && makeAction(action, tb,"Font",  ":/Res/pic/font.png");
  521.     if(ret)
  522.     {
  523.         tb->addAction(action);
  524.     }
  525.  
  526.     return ret;
  527. }
  528. bool MainWindow::initViewToolItem(QToolBar* tb)
  529. {
  530.     bool ret = true;
  531.     QAction* action = NULL;
  532.  
  533.     ret = ret && makeAction(action,  tb,"Tool Bar", ":/Res/pic/tool.png");
  534.     if(ret)
  535.     {
  536.         tb->addAction(action);
  537.     }
  538.     ret = ret && makeAction(action,  tb,"Status Bar", ":/Res/pic/status.png");
  539.     if(ret)
  540.     {
  541.         tb->addAction(action);
  542.     }
  543.  
  544.     return ret;
  545. }
  546.  
  547.  
  548. bool MainWindow::makeAction(QAction*& action,QMenu* menu, QString text, int key)//菜单项
  549. {
  550.     bool ret = true;
  551.     action = new QAction(text, menu);
  552.     if(action != NULL)
  553.     {
  554.         action->setShortcut(QKeySequence(key));//创建快捷键
  555.     }
  556.     else
  557.     {
  558.         ret = false;
  559.     }
  560.  
  561.     return ret;
  562. }
  563. bool MainWindow::makeAction(QAction*& action,QToolBar* tb, QString tip, QString icon)
  564. {
  565.     bool ret = true;
  566.     action = new QAction("", tb);
  567.     if(action != NULL)
  568.     {
  569.         action->setToolTip(tip);
  570.         action->setIcon(QIcon(icon));
  571.     }
  572.     else
  573.     {
  574.         ret = false;
  575.     }
  576.     return ret;
  577. }
  578. MainWindow::~MainWindow()
  579. {
  580.  
  581. }
  1. #include <QFileDialog>
  2. #include <QStringList>
  3. #include <QFile>
  4. #include <QDebug>
  5. #include <QMessageBox>
  6. #include "MainWindow.h"
  7. #include <QMap>
  8.  
  9. QString MainWindow::showFileDialog(QFileDialog::AcceptMode mode, QString title)
  10. {
  11.     QString ret = "";
  12.     QFileDialog fd;
  13.     QStringList filters;
  14.     QMap<QString, QString> map;
  15.  
  16.     const char* fileArray[][2]=
  17.     {
  18.  
  19.         {"Text(*.txt)",    ".txt"},
  20.         {"All Files(*.*)",   "*" },
  21.         {NULL,               NULL}
  22.  
  23.     };
  24.  
  25.     for(int i=0; fileArray[i][0] != NULL; i++)
  26.     {
  27.         filters.append(fileArray[i][0]);
  28.         map.insert(fileArray[i][0], fileArray[i][1]);
  29.     }
  30.  
  31.     fd.setWindowTitle(title);
  32.     fd.setAcceptMode(mode);
  33.  
  34.  
  35.     fd.setNameFilters(filters);
  36.  
  37.     if(mode==QFileDialog::AcceptOpen)
  38.     {
  39.         fd.setFileMode(QFileDialog::ExistingFile);
  40.     }
  41.  
  42.     if(fd.exec()==QFileDialog::Accepted)
  43.     {
  44.         ret = fd.selectedFiles()[0];
  45.  
  46.         QString posix = map[fd.selectedNameFilter()];//把下拉中选中的后缀对应键值取出
  47.  
  48.         if(posix != "*" && !ret.endsWith(posix))
  49.         {
  50.             ret += posix;
  51.         }
  52.     }
  53.  
  54.     return ret;
  55. }
  56.  
  57. void MainWindow::showErrorMessage(QString message)
  58. {
  59.     QMessageBox mb(this);
  60.  
  61.     mb.setWindowTitle("Quession");
  62.     mb.setText(message);
  63.     mb.setIcon(QMessageBox::Critical);
  64.     mb.setStandardButtons(QMessageBox::Ok);
  65.  
  66.     mb.exec();
  67. }
  68.  
  69. int MainWindow::showQuesstionMessage(QString message)
  70. {
  71.     QMessageBox mb(this);
  72.  
  73.     mb.setWindowTitle("Error");
  74.     mb.setText(message);
  75.     mb.setIcon(QMessageBox::Question);
  76.     mb.setStandardButtons(QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
  77.  
  78.     return  mb.exec();
  79. }
  80.  
  81. QString MainWindow::saveCurrentData(QString path)
  82. {
  83.     QString ret = path;
  84.     if(ret == "")
  85.     {
  86.         ret = showFileDialog(QFileDialog::AcceptSave, "Save");
  87.  
  88.     }
  89.  
  90.     if(ret != "")
  91.     {
  92.         QFile file(ret);
  93.         if(file.open(QIODevice::WriteOnly | QIODevice::Text))
  94.         {
  95.             QTextStream out(&file);
  96.  
  97.             out << QString(mainEdit.toPlainText());
  98.  
  99.             file.close();
  100.  
  101.             setWindowTitle("NotePad - [" + ret + "]");
  102.  
  103.             m_isTextChanged = false;//保存后修改状态值
  104.         }
  105.         else
  106.         {
  107.             showErrorMessage(QString("Open file Error!\n\n") + "\"" + m_filePath + "\"");
  108.             ret = "";
  109.         }
  110.     }
  111.  
  112.     return ret;
  113.  
  114. }
  115. void MainWindow::preEditorChanged()
  116. {
  117.     if(m_isTextChanged)
  118.     {
  119.         int r = showQuesstionMessage("Do you want to Save?");
  120.         switch (r)
  121.         {
  122.         case QMessageBox::Yes:
  123.             saveCurrentData(m_filePath);
  124.             break;
  125.         case QMessageBox::No:
  126.             m_isTextChanged = false;
  127.             break;
  128.         case QMessageBox::Cancel:
  129.             break;
  130.         }
  131.  
  132.     }
  133. }
  134. void MainWindow::onFileNew()
  135. {
  136.     preEditorChanged();
  137.     if(!m_isTextChanged)
  138.     {
  139.         mainEdit.clear();
  140.  
  141.         m_filePath = "";
  142.  
  143.         m_isTextChanged = false;
  144.  
  145.         setWindowTitle("NotePad-[New]");
  146.     }
  147. }
  148. void MainWindow::onFileOpen()
  149. {
  150.  
  151.     preEditorChanged();
  152.  
  153.     if(!m_isTextChanged)
  154.     {
  155.         QString path = showFileDialog(QFileDialog::AcceptOpen, "open");
  156.  
  157.         if(path != "")
  158.         {
  159.             QFile file(path);
  160.             if(file.open(QIODevice::ReadOnly | QIODevice::Text))
  161.             {
  162.                 mainEdit.setPlainText(QString(file.readAll()));
  163.  
  164.                 file.close();
  165.  
  166.                 m_filePath = path;//报存当前文件路径
  167.  
  168.                 setWindowTitle("NotePad - [" + m_filePath + "]");
  169.             }
  170.             else
  171.             {
  172.                 showErrorMessage(QString("Open file Error!\n\n") + "\"" + m_filePath + "\"");
  173.             }
  174.         }
  175.     }
  176.  
  177. }
  178.  
  179. void MainWindow::onFlieSave()
  180. {
  181.     QString path = saveCurrentData(m_filePath);
  182.  
  183.     if(path != "")
  184.     {
  185.         m_filePath = path;
  186.     }
  187. }
  188.  
  189. void MainWindow::onFileSaveAs()
  190. {
  191.     QString path = saveCurrentData();//使用默认参数
  192.  
  193.     if(path != "")
  194.     {
  195.         m_filePath = path;
  196.     }
  197.  
  198. }
  199. void MainWindow::onTextChanged()
  200. {
  201.     if(!m_isTextChanged)
  202.     {
  203.         setWindowTitle("*" + windowTitle());
  204.     }
  205.     m_isTextChanged = true;
  206.  
  207. }
  208.  
  209. void MainWindow::closeEvent(QCloseEvent *e)//没有对应的信号来处理，只能重写事件处理函数
  210. {
  211.     preEditorChanged();
  212.  
  213.     if(!m_isTextChanged)
  214.     {
  215.         QMainWindow::closeEvent(e);//调用父类的关闭事件处理函数
  216.     }
  217.     else
  218.     {
  219.         e->ignore();//点取消的话就忽略这个对话框
  220.     }
  221. }
  1. #include <QtGui/QApplication>
  2. #include "MainWindow.h"
  3. #include <QTextCodec>
  4.  
  5.  
  6. int main(int argc, char *argv[])
  7. {
  8.     QTextCodec::setCodecForLocale(QTextCodec::codecForName("GBK")); //路径名支持中文
  9.     QTextCodec::setCodecForTr(QTextCodec::codecForName("GBK")); //QString支持中文
  10.     QTextCodec::setCodecForCStrings(QTextCodec::codecForName("GBK")); //string支持中文
  11.     QApplication a(argc, argv);
  12.     MainWindow* w = MainWindow::NewInstance();
  13.     int ret = -1;
  14.     if(w != NULL)
  15.     {
  16.         w->show();
  17.         ret = a.exec();
  18.     }
  19.  
  20.     delete w;
  21.     return ret;
  22. }

四、小结

（1）、事件（QEvent）和信号（SIGNAL）不同

（2）、事件由QObject对象进行处理

（3）、信号由QObject对象触发

（4）、重写事件处理函数可能改变程序行为

（5）、信号的触发不会对程序行为造成影响

（6）、事件处理是在实际工程开发中的应用非常普遍

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/949523
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号