QT Widgets模組原始碼解析與技巧

QT界面美化發表於2024-09-22
QT原始碼

QT Widgets模組原始碼解析與技巧
使用AI技術輔助生成

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

1 第一章_QT_Widgets模組概述

1.1 1_1_QT_Widgets模組簡介

1.1.1 1_1_QT_Widgets模組簡介

1_1_QT_Widgets模組簡介
1_1_QT_Widgets模組簡介
QTWidgets模組是QT框架的核心模組之一，它提供了一系列的UI元素（如按鈕、對話方塊、工具欄等）和佈局管理器，使開發者能夠快速地建立美觀且功能豐富的桌面應用程式。QTWidgets模組基於QT的核心模組，提供了豐富的視窗系統、事件處理機制、訊號與槽機制等，為開發者提供了一種高效且易於使用的程式設計介面。
在QTWidgets模組中，主要包含了以下幾個部分,

  1. 視窗系統,QTWidgets模組提供了一系列的視窗類，如QMainWindow、QWidget、QDialog等，用於建立應用程式的視窗介面。視窗系統還提供了視窗布局、視窗屬性設定、視窗狀態管理等功能。
  2. 控制元件（Widget）,控制元件是QTWidgets模組中的基本元素，用於顯示資料和接收使用者輸入。QTWidgets模組提供了豐富的控制元件，如QPushButton、QLabel、QTextEdit等，可以滿足開發者在建立應用程式介面時的各種需求。
  3. 佈局管理器,佈局管理器用於控制控制元件在視窗中的位置和大小，QTWidgets模組提供了幾種佈局管理器，如QHBoxLayout、QVBoxLayout、QGridLayout等，可以幫助開發者輕鬆地建立複雜的介面佈局。
  4. 事件處理機制,QTWidgets模組提供了一套完整的事件處理機制，包括滑鼠事件、鍵盤事件、定時事件等。開發者可以透過重寫事件處理函式或者使用訊號與槽機制來響應使用者操作，實現應用程式的功能。
  5. 訊號與槽機制,QTWidgets模組的核心特性之一是訊號與槽機制，它提供了一種優雅的解決方案來處理物件之間的通訊。透過訊號與槽機制，開發者可以輕鬆地實現控制元件之間的資料傳遞和事件通知。
    在本書中，我們將深入解析QTWidgets模組的原始碼，探討其內部實現原理和技巧，幫助讀者更好地理解和應用這個模組。我們將從視窗系統、控制元件、佈局管理器、事件處理機制和訊號與槽機制等方面入手，逐步剖析QTWidgets模組的內部結構和實現方法。透過學習這些原理和技巧，讀者可以更好地設計出優秀的桌面應用程式，提升自己的程式設計水平。

1.2 1_2_QT_Widgets模組的主要類

1.2.1 1_2_QT_Widgets模組的主要類

1_2_QT_Widgets模組的主要類
1.2 QT Widgets模組的主要類
QTWidgets模組是Qt框架的核心模組之一，它提供了用於建立和管理GUI應用程式所需的一套UI元素（稱為控制元件）和容器。在QTWidgets模組中，主要類可以分為幾個層次結構，包括視窗、控制元件、佈局、事件處理等。下面我們將介紹一些最主要的類。

  1. 視窗類
    視窗是使用者介面的主要構件，可以包含其他控制元件和子視窗。QTWidgets模組中最基本的視窗類是QWidget，它是所有視窗和控制元件的基類。
  • QMainWindow,主視窗類，通常用於包含選單欄、工具欄、狀態列和其他控制元件。
  • QDialog,對話方塊視窗類，通常用於與使用者進行互動。
  • QWidget,基本的視窗類，可以作為其他控制元件的容器。
  1. 控制元件類
    控制元件是使用者介面中最基本的元素，使用者可以透過它們與應用程式進行互動。QTWidgets模組提供了豐富的控制元件類。
  • QLabel,用於顯示文字或影像的控制元件。
  • QLineEdit,允許使用者輸入單行文字的控制元件。
  • QPushButton,按鈕控制元件，使用者可以點選它執行操作。
  • QComboBox,允許使用者從下拉選單中選擇一個選項的控制元件。
  • QCheckBox,核取方塊控制元件，使用者可以勾選或取消勾選它。
  • QRadioButton,單選按鈕控制元件，使用者可以在多個選項中選擇一個。
  • QSlider,滑塊控制元件，使用者可以透過拖動滑塊來選擇一個值。
  • QSpinBox,微調框控制元件，使用者可以透過點選按鈕或拖動滑塊來選擇一個值。
  1. 佈局類
    佈局用於控制控制元件在視窗中的位置和大小，QTWidgets模組提供了多種佈局類。
  • QHBoxLayout,水平佈局類，用於將控制元件水平排列。
  • QVBoxLayout,垂直佈局類，用於將控制元件垂直排列。
  • QGridLayout,網格佈局類，用於建立表格形式的佈局。
  • QFormLayout,表單佈局類，用於建立帶有標籤和控制元件的表單。
  • QBoxLayout,盒子佈局類，用於建立包含多個控制元件的垂直或水平盒子。
  1. 事件處理類
    事件處理是GUI應用程式的核心部分，QTWidgets模組提供了事件處理類來響應使用者的操作。
  • QEvent,事件基類，所有事件類都繼承自這個類。
  • QMouseEvent,滑鼠事件類，用於處理滑鼠點選、移動、拖動等事件。
  • QKeyEvent,鍵盤事件類，用於處理鍵盤按鍵、釋放等事件。
  • QWheelEvent,滑鼠滾輪事件類，用於處理滑鼠滾輪滾動事件。
    這些類只是QTWidgets模組中眾多類的一部分，要深入學習QTWidgets模組，需要掌握這些類的屬性和方法，以及如何使用它們來建立豐富的使用者介面。在後續的章節中，我們將對這些類進行詳細的介紹和示例演示。

1.3 1_3_QT_Widgets模組的架構

1.3.1 1_3_QT_Widgets模組的架構

1_3_QT_Widgets模組的架構
1_3_QT_Widgets模組的架構
QTWidgets模組是QT框架的核心模組之一，它提供了一系列的控制元件（widgets），以及用於佈局、事件處理、樣式和動畫等方面的功能。在QTWidgets模組中，主要的類和元件可以分為以下幾個層次,

  1. 頂層類,頂層類包括QApplication、QWidget、QMainWindow、QDialog等，它們是構建應用程式的基礎。QApplication負責管理應用程式的生命週期和上下文資訊，QWidget是所有控制元件的基類，QMainWindow和QDialog則是視窗類和對話方塊類。
  2. 控制元件類,控制元件類是QTWidgets模組中最重要的類，它們提供了各種使用者介面元素。控制元件類可以分為以下幾個子類,
    • 基礎控制元件,包括QLabel、QPushButton、QCheckBox、QRadioButton、QComboBox、QLineEdit等，它們用於顯示和輸入資料。
    • 佈局控制元件,包括QHBoxLayout、QVBoxLayout、QGridLayout等，它們用於對控制元件進行佈局管理。
    • 容器控制元件,包括QGroupBox、QFrame、QTabWidget等，它們用於組織和分組其他控制元件。
    • 選單控制元件,包括QMenu、QMenuBar、QToolBar等，它們用於建立選單和工具欄。
    • 對話方塊控制元件,包括QMessageBox、QFileDialog、QColorDialog等，它們用於建立各種型別的對話方塊。
  3. 事件處理,QTWidgets模組提供了事件處理機制，使得開發者可以對使用者的操作進行響應。事件處理包括訊號和槽機制，槽是函式或方法，用於處理事件。每個控制元件都會產生一些訊號，當事件發生時，這些訊號會被髮射出去，然後開發者可以透過連線訊號和槽來實現事件處理。
  4. 樣式和動畫,QTWidgets模組提供了樣式和動畫功能，使得開發者可以自定義控制元件的外觀和行為。樣式可以使用QSS（QT Style Sheets）來定義，它是一種CSS（Cascading Style Sheets）的變體，用於美化控制元件的外觀。動畫可以使用QPropertyAnimation、QAbstractAnimation等類來實現，它們可以用於建立平滑的動畫效果。
  5. 國際化,QTWidgets模組支援國際化，使得開發者可以建立多語言的應用程式。國際化可以使用QTranslator類來實現，它可以將應用程式的文字資訊翻譯成不同的語言。
    總的來說，QTWidgets模組提供了一個豐富的使用者介面庫，它包括了一系列的控制元件、佈局管理器、事件處理機制、樣式和動畫功能，以及國際化支援。透過這些功能，開發者可以快速地建立出功能豐富、介面美觀的應用程式。

1.4 1_4_QT_Widgets模組的安裝與配置

1.4.1 1_4_QT_Widgets模組的安裝與配置

1_4_QT_Widgets模組的安裝與配置
1.4 QT Widgets模組的安裝與配置
QTWidgets是QT框架的核心模組之一，它提供了一系列的控制元件（例如按鈕、對話方塊、工具欄等）和佈局，使開發者能夠快速地建立桌面應用程式。本節將介紹如何在你的開發環境中安裝和配置QT Widgets模組。
1.4.1 安裝QTWidgets模組
首先，確保你已經安裝了QT框架。如果你使用的是QT官方網站提供的安裝包，那麼在安裝QT時，Widgets模組通常是預設安裝的。如果你使用的是原始碼編譯QT，那麼需要確保在編譯時包含了Widgets模組。
在編譯QT原始碼時，可以使用以下命令來包含Widgets模組,
bash
qmake QT=widgets
或者，如果你使用的是._configure指令碼，可以在命令列中新增-widgets選項,
bash
._configure -widgets
接著，按照正常的編譯步驟繼續進行。
1.4.2 配置QTWidgets模組
在QT Creator中，配置QTWidgets模組通常是非常簡單的。當你建立一個新專案時，選擇合適的QT版本和構建套件，Widgets模組通常會自動包含在內。
如果你需要確保Widgets模組被包含在專案中，可以在QT Creator的.pro檔案中手動新增以下行,
pro
QT += widgets
這行程式碼會告訴QT Creator你的專案中需要包含Widgets模組。
1.4.3 驗證QTWidgets模組安裝
安裝完成後，你可以透過建立一個簡單的QT Widgets應用程式來驗證Widgets模組是否正確安裝。在QT Creator中，你可以使用模板建立一個新的 Widgets 應用程式。
選擇應用程式->QT Widgets應用程式->通用應用程式或最小應用程式，然後點選下一步。配置你的專案名稱和位置，然後點選完成。QT Creator將建立一個包含基本Widgets應用程式程式碼的專案。
執行你的專案，如果看到一個帶有按鈕和其他控制元件的基本視窗，那麼恭喜你，QT Widgets模組已經成功安裝並配置好了。
1.4.4 常見問題解決
如果在安裝或配置過程中遇到問題，以下是一些常見的故障排除步驟,

  1. 檢查QT版本一致性,確保你的開發環境中的QT版本與你安裝的Widgets模組版本一致。
  2. 清理並重新編譯,如果編譯過程中出現錯誤，嘗試清理構建目錄後重新編譯。
  3. 檢視錯誤資訊,遇到問題時，仔細檢視控制檯輸出的錯誤資訊，它們通常會提供問題的線索。
  4. 查閱官方文件,QT的官方文件是解決問題的好資源，其中包含了詳細的安裝和配置指南。
  5. 社群支援,如果你遇到的問題仍然無法解決，可以考慮向QT社群尋求幫助。
    透過以上步驟，你應該能夠成功安裝和配置QT Widgets模組，從而開始開發你的桌面應用程式。

1.5 1_5_實用技巧與經驗分享

1.5.1 1_5_實用技巧與經驗分享

1_5_實用技巧與經驗分享
1_5_實用技巧與經驗分享
技巧1,最佳化列表檢視的滾動效能
在開發中，我們經常會遇到列表檢視（QListView）滾動時卡頓的情況，特別是在列表項非常多的時候。為了最佳化這種情況，我們可以採用以下幾種方法,

  1. 減少繪製次數,透過降低檢視的更新頻率來減少繪製次數。可以使用setViewportUpdateMode函式，設定為QAbstractView::BufferedUpdate模式，這樣只有當必要的繪製時，檢視才會更新。
  2. 最佳化渲染,對於列表項的渲染，可以使用QSS（Qt Style Sheets）來簡化繪製過程，例如使用border-image來複用影像，減少繪製開銷。
  3. 虛擬化,對於非常大的列表，可以使用虛擬化技術，只渲染使用者可見的部分。這可以透過自定義渲染器實現，例如使用QAbstractItemView的render()函式。
    技巧2,使用訊號與槽提高程式碼的可維護性
    Qt的訊號與槽機制是物件導向程式設計中的一個亮點，它可以有效提高程式碼的可維護性和可讀性。以下是一些經驗分享,
  4. 避免使用全域性變數,儘可能避免使用全域性變數來傳遞資料，而是透過訊號和槽來傳遞，這樣可以在一定程度上降低元件間的耦合。
  5. 使用元物件,利用Qt的元物件系統，如Q_OBJECT宏，可以讓訊號和槽的宣告被元物件系統識別，從而在文件生成工具中自動生成文件。
  6. 訊號與槽的連線時機,儘可能在物件建立時就連線訊號和槽，這樣可以避免潛在的執行緒安全問題。
    技巧3,合理使用事件過濾器
    事件過濾器是Qt中一種較為高階的技術，它可以讓我們在不需要修改原有物件事件處理邏輯的情況下，對其進行增強或修改。以下是一些使用技巧,
  7. 減少事件處理的開銷,透過事件過濾器，我們可以減少重複的事件處理程式碼，特別是在處理滑鼠、鍵盤事件時。
  8. 跨元件事件處理,有時候我們可能需要在多個元件之間共享事件處理邏輯，使用事件過濾器可以很方便地實現這一點。
  9. 提高事件處理的靈活性,透過過濾器，我們可以在不修改原有物件的前提下，動態地改變事件處理的行為。
    經驗分享,自定義控制元件的封裝與重用
    在Qt開發中，封裝和重用是非常重要的。以下是一些自定義控制元件封裝與重用的經驗,
  10. 遵循設計模式,在建立自定義控制元件時，可以參考Qt官方提供的設計模式，如裝飾器模式、代理模式等，這樣可以提高控制元件的可擴充套件性和可維護性。
  11. 提供充分的文件,為了讓其他開發者能夠更好地使用你的控制元件，提供充分且清晰的文件是非常必要的。
  12. 使用元物件系統,透過Q_OBJECT宏，讓你的控制元件支援元物件系統，這樣可以在Qt Designer中拖拽你的控制元件，並且自動生成屬性視窗。
    透過以上的技巧和經驗，我相信你可以更好地理解和掌握Qt Widgets模組的開發，寫出更加高效、穩定和可維護的程式碼。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

2 第二章_事件處理

2.1 2_1_事件機制概述

2.1.1 2_1_事件機制概述

2_1_事件機制概述
2.1 事件機制概述
Qt框架的事件機制是其核心特性之一，它允許應用程式響應使用者的輸入裝置操作，如滑鼠點選、鍵盤敲擊，以及系統事件，如視窗狀態改變。在Qt中，事件是程式響應動態互動的基礎。
事件的概念
在Qt中，事件是程式執行過程中發生的任何事情，可能是使用者的行為，如移動滑鼠或按鍵，也可能是系統產生的通知，比如視窗需要重繪。每個事件都有一個特定的型別，Qt預定義了許多事件型別，例如QMouseEvent、QKeyEvent、QCloseEvent等。
事件處理
Qt的事件處理機制是基於事件傳遞模型的。當一個事件發生時，Qt會生成一個相應的事件物件，然後將其傳遞給應用程式的事件迴圈。在事件迴圈中，Qt會找到能夠處理該事件的物件，並呼叫該物件的虛擬函式來處理事件。
事件傳遞流程

  1. 事件生成,當使用者進行操作或系統產生一個事件時，Qt會生成一個事件物件。
  2. 事件傳遞,Qt將事件物件新增到事件佇列中。
  3. 事件處理,Qt的事件迴圈遍歷事件佇列，找到目標物件。
  4. 呼叫處理函式,Qt呼叫目標物件的事件處理函式來響應事件。
    事件過濾
    在Qt中，事件過濾是一種機制，允許一個物件攔截並處理另一個物件的事件。這可以在不需要直接繼承或修改事件處理函式的情況下，增加額外的事件處理邏輯。事件過濾通常用於繼承QObject的子類中。
    事件型別
    Qt定義了豐富的事件型別，以處理不同的互動場景。一些常用的事件型別包括,
  • 滑鼠事件,如QMouseEvent，它包含了滑鼠點選、移動、拖動等事件。
  • 鍵盤事件,如QKeyEvent，它包含了按鍵按下、釋放和字元輸入等事件。
  • 視窗事件,如QWindowStateChangeEvent，它包含了視窗狀態的變化，如最大化和最小化。
  • 繪圖事件,如QPaintEvent，它通知物件需要重新繪製。
    小技巧
  1. 事件優先順序,在某些情況下，你可能想要改變事件的處理順序。Qt中可以透過重寫event或特定事件處理函式來調整優先順序。
  2. 事件過濾器,在不直接處理事件的情況下，可以使用事件過濾來減少事件處理的複雜性。
  3. 事件委託,在複雜的使用者介面設計中，可以透過委託方式，將事件處理委託給父物件或兄弟物件，以簡化子物件的事件處理邏輯。
    透過深入瞭解Qt的事件機制，開發者可以設計出既反應靈敏又高效的使用者介面，提升使用者體驗。在下一節中，我們將詳細探討Qt中的事件型別及其處理方法。

2.2 2_2_事件處理流程

2.2.1 2_2_事件處理流程

2_2_事件處理流程
2.2 事件處理流程
在Qt中，事件是使用者與應用程式互動的結果，如滑鼠點選、鍵盤輸入等。每個Qt應用程式都是由事件驅動的。本節將詳細解析Qt中事件處理的流程。
2.2.1 事件分類
Qt將事件分為兩大類,視窗系統和自定義事件。視窗系統事件是由作業系統產生的，例如滑鼠點選、鍵盤輸入等。自定義事件是由應用程式本身產生的，例如使用者定義的訊號等。
2.2.2 事件處理機制
Qt的事件處理機制是基於事件傳遞和事件處理器的。事件首先由視窗系統產生，然後傳遞給相應的視窗物件。視窗物件會根據自己的狀態和屬性判斷是否需要處理該事件，如果需要處理，則呼叫相應的事件處理函式（即事件處理器）。事件處理器執行相應的操作，例如更新介面、響應使用者操作等。
2.2.3 事件處理流程
Qt的事件處理流程如下,

  1. 視窗系統產生事件併傳送給相應的視窗物件。
  2. 視窗物件接收到事件後，首先判斷事件是否被阻止。如果事件被阻止，則不再繼續處理。
  3. 視窗物件判斷是否需要處理該事件。如果需要處理，則呼叫相應的事件處理函式。
  4. 事件處理函式執行相應的操作，例如更新介面、響應使用者操作等。
  5. 事件處理完成後，視窗物件將事件傳遞給其父物件，直到事件被處理或者傳遞到根物件。
    在Qt中，大部分事件都可以被阻止，即可以透過設定事件的accept屬性來阻止事件進一步傳遞。此外，Qt還提供了一些事件過濾器，可以在事件傳遞過程中對事件進行攔截和處理。
    2.2.4 事件處理技巧
    在處理事件時，有以下幾個技巧可以幫助我們更好地控制事件處理流程,
  6. 使用事件過濾器,透過設定事件過濾器，可以在事件傳遞過程中攔截和處理事件，從而減少事件處理函式的數量。
  7. 合理使用事件的accept屬性,在事件處理函式中，可以根據需要設定事件的accept屬性，以控制事件是否繼續傳遞。
  8. 使用事件委託,在某些情況下，可以將事件處理函式委託給其他物件，以實現事件處理的分離和複用。
  9. 使用元物件系統,Qt的元物件系統提供了許多便捷的事件處理函式，如mousePressEvent、keyPressEvent等。可以使用這些函式來處理常見的事件。
    透過掌握事件處理流程和技巧，我們可以更好地控制應用程式的互動邏輯，為使用者提供更好的使用者體驗。在接下來的章節中，我們將詳細介紹Qt Widgets模組中常用的事件處理函式及其使用方法。

2.3 2_3_事件分發

2.3.1 2_3_事件分發

2_3_事件分發
2.3 事件分發
在Qt中，事件是使用者與應用程式互動的結果，比如滑鼠點選、鍵盤輸入、視窗調整等。Qt的 Widgets模組透過事件分發機制來處理這些事件。事件分發機制是Qt中一個相當重要的部分，因為它確保了應用程式能夠響應使用者的互動。
在Qt中，事件的分發過程大致如下,

  1. 事件產生,當使用者與應用程式互動時，比如移動滑鼠，作業系統會產生一個事件。
  2. 事件捕獲,這個事件首先會被傳遞給當前啟用的視窗，這個視窗可以捕獲這個事件，不將其傳遞給子控制元件。
  3. 事件傳遞,如果當前啟用的視窗沒有捕獲事件，那麼事件會按照樹形結構向下傳遞，從父控制元件傳遞給子控制元件。在傳遞過程中，如果某個控制元件實現了相應的事件處理函式，那麼這個控制元件就可以處理這個事件。
  4. 事件處理,當事件到達最終的目標控制元件後，控制元件會呼叫其事件處理函式來處理事件。這些處理函式通常是重寫的Q_OBJECT宣告的虛擬函式。
  5. 事件結束,如果控制元件處理了事件，那麼事件處理過程結束；如果沒有處理，事件會繼續向上傳遞給父控制元件，直到有控制元件處理它或者到達視窗根控制元件。
    在Qt中，有幾種事件型別，包括滑鼠事件、鍵盤事件、繪畫事件、輸入方法事件等。每個事件型別都有相應的事件類，例如QMouseEvent、QKeyEvent等。
    在編寫事件處理函式時，需要注意以下幾點,
  • 不要在事件處理函式中引發新的事件。
  • 考慮事件過濾器。如果某個控制元件不需要直接處理某些事件，可以使用事件過濾器將事件傳遞給祖先控制元件處理。
  • 事件處理函式不應該包含長時間執行的操作，以避免介面響應緩慢。
    Qt的訊號與槽機制和事件分發機制緊密相關。當一個事件發生時，可能會觸發一個或多個訊號，而連線到這些訊號的槽函式將會執行相應的操作。這種機制提高了程式碼的可維護性和可讀性。
    在深入研究Qt的事件分發機制時，理解事件型別、事件處理函式、訊號與槽機制以及事件過濾器是非常關鍵的。透過掌握這些知識，可以編寫出更加高效和使用者友好的Qt應用程式。

2.4 2_4_事件過濾

2.4.1 2_4_事件過濾

2_4_事件過濾
2.4 事件過濾
在Qt程式設計中，事件過濾是一種非常重要的機制，它允許一個物件（稱為過濾器）監聽另一個物件（稱為目標）的事件，並在事件發生前或發生後對其進行處理。這在某些情況下非常有用，比如當你想要在某個控制元件上新增一些特定的行為，但又不想或不能直接修改該控制元件的程式碼時。
在QT Widgets模組中，事件過濾主要透過QObject的installEventFilter()方法和事件處理函式來完成。首先，我們來看看如何設定一個事件過濾器。
設定事件過濾器
要設定一個事件過濾器，你需要在目標物件中呼叫installEventFilter()方法，並將過濾器物件作為引數傳遞。這個方法會在目標物件的事件系統中註冊過濾器物件。
cpp
MyWidget *target = new MyWidget();
MyFilter *filter = new MyFilter(target);
target->installEventFilter(filter);
在上面的程式碼中，MyWidget是目標物件，MyFilter是過濾器物件。透過呼叫installEventFilter()，我們讓MyFilter物件能夠攔截並處理MyWidget物件的事件。
事件過濾器類
事件過濾器類通常需要繼承自QObject，並且需要重寫兩個方法,eventFilter()和childEvent()。

  • eventFilter()方法是事件過濾的核心，當目標物件發生事件時，Qt會呼叫這個方法。在這個方法中，你可以透過判斷事件的型別來決定是否要處理這個事件，或者是否要傳遞給目標物件。
  • childEvent()方法用於處理目標物件發出的子物件事件，比如子控制元件的建立、刪除等。
    cpp
    class MyFilter : public QObject {
    Q_OBJECT
    public:
    explicit MyFilter(QObject *parent = nullptr);
    protected:
    bool eventFilter(QObject *obj, QEvent *event) override;
    void childEvent(QChildEvent *event) override;
    };
    在eventFilter()方法中，我們可以透過event引數來判斷事件的型別。Qt提供了多種事件型別，如QEvent::MouseButtonPress、QEvent::KeyPress等。我們可以根據事件型別來編寫相應的處理邏輯。
    事件處理
    在事件過濾器中處理事件時，我們可以透過呼叫event->ignore()來忽略事件，或者透過event->accept()來接受事件。如果我們要處理事件，可以呼叫目標物件的對應方法，或者編寫自己的處理邏輯。
    例如，如果我們想要在某個控制元件上新增滑鼠點選事件，可以在事件過濾器中這樣處理,
    cpp
    bool MyFilter::eventFilter(QObject *obj, QEvent *event) {
    if (event->type() == QEvent::MouseButtonPress) {
    QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
    if (mouseEvent->button() == Qt::LeftButton) {
    __ 處理滑鼠點選事件
    qDebug() << Left button clicked;
    return true; __ 處理了事件，不再傳遞給目標物件
    }
    }
    __ 其他事件處理或傳遞
    return QObject::eventFilter(obj, event);
    }
    在這個例子中，我們檢查了滑鼠點選事件，並在左鍵點選時新增了自己的處理邏輯。由於我們返回了true，表示已經處理了該事件，因此事件不會再傳遞給目標物件。如果我們要將事件傳遞給目標物件，只需要返回false即可。
    事件過濾是一種強大的機制，可以讓我們在不修改目標物件程式碼的情況下，為物件新增額外的行為。在QT Widgets模組中，熟練運用事件過濾，可以幫助我們建立更加靈活和可擴充套件的使用者介面。

2.5 2_5_實用技巧與經驗分享

2.5.1 2_5_實用技巧與經驗分享

2_5_實用技巧與經驗分享
2.5 實用技巧與經驗分享
2.5.1 利用元物件系統提高渲染效率
QT Widgets框架中，每個QWidget都繼承自QObject，這意味著每個QWidget都是一個擁有元物件的C++物件。元物件系統提供瞭如物件名稱、型別資訊和序列化等便捷功能。但在效能至關重要的應用中，元物件系統可能會帶來額外的開銷。
實用技巧,

  1. 禁用物件名稱, 如果你不使用物件名稱，可以在建立QWidget時將其設定為nullptr，以減少開銷。
    cpp
    QWidget *widget = new QWidget(parent);
    widget->setObjectName(nullptr);

  2. 禁用物件序列化, 如果你的應用程式不需要將物件儲存到XML或JSON檔案中，可以在QWidget的建構函式中設定Q_OBJECT宏為Q_GADGET，這樣就不會建立元物件了。
    cpp
    Q_OBJECT __ 預設
    __ 變成
    Q_GADGET __ 沒有元物件

2.5.2 高效繪製與渲染
在進行UI開發時，我們經常需要處理複雜的繪圖任務。為了提高渲染效率，可以採用以下方法,
實用技巧,

  1. 繪製快取, 對於頻繁重繪的控制元件，可以使用繪製快取。例如，QListView和QTableView使用繪製快取來提高列表和表格的渲染效率。
  2. 自定義繪製, 儘量在paintEvent中進行高效繪製。避免在非繪製事件中進行昂貴的繪圖操作，如複雜的圖形路徑、大量的小圖元等。
  3. 離屏繪製, 對於複雜的繪製任務，可以使用離屏繪製。先在臨時畫布上完成繪製，然後將繪製結果複製到螢幕上。這樣可以減少螢幕重新整理次數，提高繪製效能。
  4. 使用OpenGL, 對於需要高效能繪製的應用，可以考慮使用OpenGL代替QPainter。透過QOpenGLWidget可以在Qt應用中方便地使用OpenGL。
    2.5.3 最佳化事件處理
    QT Widgets框架中，事件是驅動使用者介面互動的核心。最佳化事件處理可以顯著提高應用程式的效能。
    實用技巧,
  5. 避免在事件處理函式中執行耗時操作, 事件處理函式（如mousePressEvent、keyPressEvent等）應該儘量快速執行。耗時操作應該在單獨的執行緒中執行。
  6. 使用事件過濾器, 透過事件過濾器，可以減少控制元件內部事件處理的複雜性。將通用的事件處理邏輯放在過濾器中，而不是每個控制元件的單獨事件處理函式中。
  7. 合理使用訊號與槽, 訊號與槽機制是Qt中實現事件驅動程式設計的關鍵。合理使用訊號與槽，可以避免不必要的記憶體複製和效能開銷。
  8. 減少事件傳遞, 在事件傳遞過程中，每個控制元件都會接收並處理事件。儘量減少事件傳遞的層級，可以提高事件處理的效率。
    2.5.4 記憶體管理
    在QT Widgets程式設計中，記憶體管理是一個重要的方面。記憶體洩漏和不必要的記憶體分配都會影響應用程式的效能。
    實用技巧,
  9. 使用智慧指標, 如QScopedPointer、QScopedArrayPointer等，可以幫助自動管理記憶體分配和釋放，避免記憶體洩漏。
  10. 動態建立和銷燬控制元件, 儘量減少在迴圈或頻繁呼叫的函式中動態建立和銷燬控制元件。可以使用QStackedWidget等控制元件來管理動態建立的控制元件。
  11. 使用堆疊分配, 對於短生命週期的物件，儘量使用堆疊分配，這樣可以避免記憶體分配和釋放的開銷。
  12. 及時釋放不再使用的資源, 例如，當一個影像檢視顯示的影像不再需要時，可以使用setPixmap方法設定為nullptr，這樣可以釋放影像資源。
    透過以上技巧和經驗的分享，可以有效地提高QT Widgets應用程式的效能。在實際開發過程中，需要根據具體情況進行最佳化，以達到最佳的效能表現。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

3 第三章_圖形與繪圖

3.1 3_1_繪圖裝置

3.1.1 3_1_繪圖裝置

3_1_繪圖裝置
3.1 繪圖裝置
在Qt中，繪圖裝置是進行圖形繪製的基礎。繪圖裝置提供了一個抽象層，使得在不同的圖形渲染場合下，能夠以統一的方式來繪製圖形。在Qt Widgets模組中，最常見的繪圖裝置是QPainter類。本節將詳細解析Qt中的繪圖裝置以及如何在Qt Widgets中使用QPainter進行繪圖。
3.1.1 繪圖裝置的概念
在Qt中，繪圖裝置提供了一種在螢幕上繪製圖形的方法。它是一個抽象的概念，實際的實現依賴於底層的圖形系統。在Qt中，繪圖裝置通常指的是一個可以繪製圖形的表面，這個表面可以是螢幕、印表機或者其他任何可以渲染圖形的內容。
Qt提供了多種繪圖裝置，比如QPainter、QImage、QPixmap等。其中，QPainter是最常用的繪圖裝置，它提供了一系列的繪圖API，可以在各種繪圖裝置上進行繪製。
3.1.2 QPainter的使用
QPainter是Qt中用於繪圖的主要類。它提供了一系列的繪圖功能，包括繪製線條、矩形、橢圓、文字等。要使用QPainter進行繪圖，需要先建立一個QPainter物件，然後將其與一個繪圖裝置關聯起來，最後呼叫繪圖函式進行繪製。
以下是一個使用QPainter繪製簡單圖形的基本步驟,

  1. 建立一個QPainter物件。
  2. 設定繪圖裝置的屬性，比如畫筆、畫刷、字型等。
  3. 呼叫繪圖函式進行繪製，比如drawLine()、drawRect()、drawText()等。
  4. 結束繪製，釋放資源。
    下面是一個簡單的例子，展示如何在Qt Widgets中使用QPainter繪製一個藍色的矩形,
    cpp
    include <QApplication>
    include <QWidget>
    include <QPainter>
    class PainterWidget : public QWidget {
    Q_OBJECT
    public:
    PainterWidget(QWidget *parent = nullptr) : QWidget(parent) {}
    protected:
    void paintEvent(QPaintEvent *event) override {
    QPainter painter(this); __ 建立QPainter物件，關聯到當前的繪製裝置，即這個Widget
    painter.setPen(QPen(Qt::blue, 2)); __ 設定畫筆顏色和寬度
    painter.drawRect(50, 50, 100, 100); __ 繪製一個藍色的矩形
    }
    };
    int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    PainterWidget widget;
    widget.show();
    return app.exec();
    }
    在這個例子中，我們建立了一個PainterWidget類，它繼承自QWidget。在paintEvent()函式中，我們建立了一個QPainter物件，並將其與當前的繪製裝置（即這個QWidget）關聯起來。然後，我們設定了畫筆的顏色和寬度，並使用drawRect()函式繪製了一個藍色的矩形。
    3.1.3 繪圖裝置的屬性
    在Qt中，繪圖裝置有一些基本的屬性，比如畫筆、畫刷、字型和變換等。這些屬性可以在繪製之前設定，以控制圖形的繪製效果。
  • 畫筆（Pen）,用於繪製線條和邊框。可以設定畫筆的顏色、寬度和樣式。
  • 畫刷（Brush）,用於填充圖形。可以設定畫刷的顏色和樣式，比如實心、空心等。
  • 字型（Font）,用於繪製文字。可以設定字型的名稱、大小和樣式。
  • 變換（Transform）,用於對繪製的圖形進行變換，比如旋轉、縮放和平移。
    在QPainter中，可以透過相應的API來設定這些屬性。比如，可以使用setPen()來設定畫筆，使用setBrush()來設定畫刷，使用setFont()來設定字型，使用setTransform()來設定變換等。
    3.1.4 繪圖裝置的選擇
    在Qt Widgets中，繪圖裝置通常選擇為當前的繪製裝置，即當前的QWidget。但是，在某些情況下，可能需要選擇其他的繪圖裝置，比如QImage或者QPixmap。這時，可以使用QPainter的begin()和end()函式來管理繪圖裝置的切換。
    例如，下面的程式碼將繪製到一個QImage物件上,
    cpp
    QImage image(300, 200, QImage::Format_RGB32); __ 建立一個300x200大小的QImage
    QPainter painter(&image); __ 建立QPainter物件，關聯到image
    painter.setPen(QPen(Qt::red, 2));
    painter.drawRect(50, 50, 100, 100);
    painter.end(); __ 結束繪製
    在這個例子中，我們首先建立了一個QImage物件，並設定了其格式為QImage::Format_RGB32。然後，我們建立了一個QPainter物件，並將其與QImage關聯起來。接著，我們設定了畫筆的顏色和寬度，並繪製了一個紅色的矩形。最後，我們呼叫end()函式結束繪製。
    繪圖裝置的正確選擇和操作對於實現高質量的圖形繪製是非常重要的。在Qt Widgets程式設計中，熟練掌握QPainter的使用和繪圖裝置的管理，可以讓我們更加自由地創造出豐富多樣的使用者介面。

3.2 3_2_繪圖上下文

3.2.1 3_2_繪圖上下文

3_2_繪圖上下文
3.2 繪圖上下文
在Qt中，繪圖上下文（QPainter）是一個非常重要的概念，它提供了在視窗、影像或其他繪圖裝置上進行繪製的全部資訊。繪圖上下文包含了諸如畫筆、畫刷、字型和轉換（如旋轉、縮放和平移）等屬性。本節將詳細介紹如何在Qt Widgets應用程式中使用繪圖上下文進行繪製。
3.2.1 繪圖上下文的基本使用
在Qt中，進行繪製操作前需要獲取繪圖上下文。對於QWidget的子類，可以透過重寫paintEvent(QPaintEvent *)函式來獲取繪圖上下文並進行繪製。以下是一個簡單的例子，展示瞭如何在QWidget的子類中使用繪圖上下文繪製一個矩形,
cpp
class MyWidget : public QWidget {
Q_OBJECT
public:
MyWidget(QWidget *parent = nullptr) : QWidget(parent) {}
protected:
void paintEvent(QPaintEvent *event) override {
QPainter painter(this); __ 獲取繪圖上下文
painter.setPen(QPen(Qt::red, 2)); __ 設定畫筆
painter.drawRect(10, 10, 100, 100); __ 使用畫筆繪製一個矩形
}
};
在上面的程式碼中，QPainter物件painter就是繪圖上下文，它提供了繪製的介面。透過setPen函式設定了繪製矩形的畫筆屬性，包括顏色和寬度。drawRect函式則是使用這個畫筆繪製了一個矩形。
3.2.2 繪圖上下文的轉換
在繪製複雜圖形時，可能需要對繪圖上下文進行各種轉換，如旋轉、縮放和平移。這些轉換可以透過繪圖上下文的相關函式來完成,
cpp
void paintEvent(QPaintEvent *event) override {
QPainter painter(this);
__ 設定畫筆
painter.setPen(QPen(Qt::red, 2));
__ 平移繪圖上下文
painter.translate(50, 50); __ 移動座標原點到(50,50)
__ 旋轉繪圖上下文
painter.rotate(45); __ 旋轉45度
__ 縮放繪圖上下文
painter.scale(0.5, 0.5); __ 縮放到原來的50%
__ 在轉換後的座標系中繪製矩形
painter.drawRect(0, 0, 100, 100);
}
上述程式碼首先進行了平移，將繪圖原點移動到視窗的(50,50)位置。接著進行了旋轉操作，旋轉了45度。最後，進行了縮放，將繪圖上下文的所有座標縮放到原來的50%。在這些轉換之後，繪製的矩形將根據這些轉換進行相應的變換。
3.2.3 自定義繪製操作
除了在預設的paintEvent中進行繪製，還可以透過自定義繪圖操作來更精細地控制繪製過程。例如，可以使用QPainterPath來繪製複雜路徑，或者使用繪圖上下文的矩陣來執行復雜的變換。
以下是一個使用QPainterPath繪製路徑的例子,
cpp
void paintEvent(QPaintEvent *event) override {
QPainter painter(this);
__ 建立一個路徑
QPainterPath path;
path.moveTo(10, 10); __ 移動到(10,10)
path.lineTo(100, 10); __ 繪製到(100,10)
path.lineTo(100, 100); __ 繪製到(100,100)
path.lineTo(10, 100); __ 繪製到(10,100)
path.closeSubpath(); __ 閉合路徑形成一個矩形
__ 設定畫筆和填充樣式
painter.setPen(QPen(Qt::blue, 2));
painter.setBrush(QBrush(Qt::green, Qt::SolidPattern));
__ 繪製路徑
painter.drawPath(path);
}
在這個例子中，QPainterPath物件path被用來定義一個複雜的路徑，它包括了移動、直線和閉合路徑的操作。然後使用setPen和setBrush設定了繪製路徑的畫筆和畫刷，最後使用drawPath函式繪製了路徑。
透過以上內容，讀者應該對繪圖上下文有了更深入的理解，能夠使用繪圖上下文進行復雜的繪製操作。在Qt Widgets程式設計中，繪圖上下文的使用是非常普遍的，掌握它對於進行專業的圖形繪製至關重要。

3.3 3_3_繪製基本圖形

3.3.1 3_3_繪製基本圖形

3_3_繪製基本圖形
3.3 繪製基本圖形
QtWidgets模組提供了豐富的圖形繪製功能，使得在應用程式中繪製各種圖形變得十分方便。在Qt中，繪製圖形主要依賴於QPainter類，本節將介紹如何使用QPainter繪製一些基本圖形。
3.3.1 繪製點
在Qt中，可以使用QPainter的drawPoint()函式繪製點。例如,
cpp
QPainter painter(this);
painter.drawPoint(10, 10);
如果要繪製多個點，可以使用drawPoints()函式，例如,
cpp
QPainter painter(this);
QPoint points[3] = {QPoint(10, 10), QPoint(30, 30), QPoint(50, 10)};
painter.drawPoints(points, 3);
3.3.2 繪製直線
使用QPainter的drawLine()函式可以繪製直線，例如,
cpp
QPainter painter(this);
painter.drawLine(10, 10, 50, 50);
3.3.3 繪製矩形
矩形是最常用的圖形之一，可以使用QPainter的drawRect()函式繪製矩形，例如,
cpp
QPainter painter(this);
painter.drawRect(10, 10, 40, 40);
如果要繪製一個填充矩形，可以使用fillRect()函式，例如,
cpp
QPainter painter(this);
painter.fillRect(10, 10, 40, 40, QBrush(Qt::red));
3.3.4 繪製橢圓
使用QPainter的drawEllipse()函式可以繪製橢圓，例如,
cpp
QPainter painter(this);
painter.drawEllipse(10, 10, 40, 40);
如果要繪製一個填充橢圓，可以使用fillEllipse()函式，例如,
cpp
QPainter painter(this);
painter.fillEllipse(10, 10, 40, 40, QBrush(Qt::blue));
3.3.5 繪製文字
使用QPainter的drawText()函式可以繪製文字，例如,
cpp
QPainter painter(this);
painter.drawText(10, 60, Qt);
以上介紹了Qt中一些基本圖形的繪製方法，透過這些方法，可以組合出各種複雜的圖形。在實際開發中，可以根據需要選擇合適的繪製函式，以實現所需的圖形效果。

3.4 3_4_繪製影像

3.4.1 3_4_繪製影像

3_4_繪製影像
3.4 繪製影像
在QT中，繪製影像是一個常見且重要的功能，它涉及到許多方面，如OpenGL、影像格式處理、2D_3D繪圖等。在QT Widgets模組中，我們主要關注的是如何在 Widgets應用程式中繪製影像。本節將詳細介紹如何在QT中繪製影像，以及一些相關的技巧和注意事項。
3.4.1 影像的基本概念
在QT中，影像通常使用QImage或QPixmap類來表示。這兩個類都提供了豐富的函式來處理影像，如載入、儲存、縮放、裁剪等。其中，QImage是一個無符號的8位或16點陣圖像，而QPixmap是對QImage的封裝，它還提供了與平臺相關的繪製函式。
3.4.2 繪製影像的基本方法
在QT中，有多種方法可以用於繪製影像。下面我們將介紹幾種常用方法,

  1. 使用QPainter繪製影像
    QPainter是QT中的繪圖引擎，它可以用於繪製各種圖形和影像。下面是一個使用QPainter繪製影像的簡單示例,
    cpp
    QPainter painter(this);
    painter.drawImage(QPoint(50, 50), QImage(:_image_example.png));
  2. 使用QWidget的paintEvent繪製影像
    在自定義QWidget子類時，我們可以重寫paintEvent函式來繪製影像。例如,
    cpp
    void MyWidget::paintEvent(QPaintEvent *event)
    {
    QPainter painter(this);
    painter.drawImage(QPoint(50, 50), QImage(:_image_example.png));
    }
  3. 使用QLabel顯示影像
    QLabel是一個用於顯示文字、影像和圖示的控制元件。要顯示影像，我們只需要將影像設定為QLabel的屬性即可。例如,
    cpp
    QLabel *label = new QLabel(this);
    label->setPixmap(QPixmap(:_image_example.png));
    3.4.3 繪製影像的技巧
  4. 影像的縮放和裁剪
    在繪製影像時，我們可能需要對影像進行縮放或裁剪。這時，可以使用QImage的scaled和scaledToWidth等函式來實現。例如,
    cpp
    QImage image = QImage(:_image_example.png).scaled(100, 100, Qt::KeepAspectRatio);
  5. 影像的混合和透明度處理
    在繪製影像時，我們可能需要對其進行混合或調整透明度。這可以透過QPainter的setCompositionMode和setOpacity函式來實現。例如,
    cpp
    QPainter painter(this);
    painter.setCompositionMode(QPainter::CompositionMode_Multiply);
    painter.setOpacity(0.5);
    painter.drawImage(QPoint(50, 50), QImage(:_image_example.png));
  6. 使用OpenGL繪製影像
    在QT中，我們還可以使用OpenGL來繪製影像。這通常需要使用QOpenGLWidget作為繪圖表面，並使用OpenGL的函式來繪製影像。例如,
    cpp
    QOpenGLWidget *oglWidget = new QOpenGLWidget(this);
    oglWidget->setGeometry(50, 50, 200, 200);
    在本節的示例程式碼中，我們只展示瞭如何在QT中繪製影像的基本方法和技巧。在實際開發中，根據具體的需求，我們可能需要使用更高階的影像處理技術。但掌握了本節內容後，你已經邁出了在QT中繪製影像的第一步。

3.5 3_5_實用技巧與經驗分享

3.5.1 3_5_實用技巧與經驗分享

3_5_實用技巧與經驗分享
在《QT Widgets模組原始碼解析與技巧》這本書中，我們專注於深入理解QT Widgets模組的工作原理，並透過實踐分享實用的技巧和經驗。在3_5_實用技巧與經驗分享這一部分，我們將討論一些在日常開發中非常有用的技巧，幫助讀者更好地掌握QT程式設計。
以下是一個示例正文,
3.5 實用技巧與經驗分享
在深入研究了QT Widgets模組的原理和用法之後，我們將分享一些實用的技巧和經驗，以幫助讀者在實際專案中更好地運用QT程式設計。
技巧1,最佳化列表檢視的效能
當我們的應用程式需要顯示大量的資料時，列表檢視（如QListView或QTableView）是一個很好的選擇。然而，當資料量非常大時，列表檢視的效能可能會受到影響。為了最佳化效能，我們可以採用以下策略,

  1. 只更新可見的項,透過設定適當的檢視邏輯，只更新當前在螢幕上可見的項，而不是每次資料更改都重新繪製整個列表。
  2. 使用虛擬化,列表檢視支援虛擬化，這意味著只有可見的項才會被渲染。確保正確配置虛擬化的引數，以提高效能。
  3. 適當的資料模型,選擇合適的資料模型，如使用QStandardItemModel或自定義模型，可以提高效能。
    技巧2,自定義組合框的樣式
    組合框（QComboBox）是QT中常用的控制元件之一。有時，我們可能希望自定義組合框的樣式以符合應用程式的整體風格。透過使用QSS（QT Style Sheets），我們可以輕鬆地自定義組合框的樣式。
    例如，要改變組合框中專案的顏色,
    css
    QComboBox {
    color: red;
    }
    QComboBox QListView {
    color: green;
    }
    透過這種方式，我們可以靈活地調整組合框的樣式，使其更符合我們的需求。
    技巧3,使用訊號和槽實現執行緒安全
    在QT中，訊號和槽機制是一種執行緒安全的方式來進行物件之間的通訊。在多執行緒環境中，確保正確使用訊號和槽機制非常重要。
  4. 在主執行緒中建立和更新UI,確保所有的UI操作都在主執行緒中進行，以避免潛在的執行緒問題。
  5. 使用訊號和槽傳遞資料,當需要在不同執行緒之間傳遞資料時，使用訊號和槽是一種安全的方式。
  6. 避免在槽中執行耗時操作,槽通常用於響應使用者操作，因此應避免在槽中執行耗時的操作，以免阻塞主執行緒。
    透過遵循這些技巧和經驗，我們可以在QT開發中更高效地工作，並創造出效能更好、更穩定的應用程式。希望這些分享能對讀者有所幫助！

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

4 第四章_佈局管理

4.1 4_1_佈局的概念

4.1.1 4_1_佈局的概念

4_1_佈局的概念
4.1 佈局的概念
在Qt中，佈局是用來管理控制元件在視窗中的位置和大小的一種機制。透過佈局，我們可以實現控制元件的自動排列和調整，使得介面更加美觀和易於管理。Qt提供了幾種佈局管理器，包括QHBoxLayout、QVBoxLayout、QGridLayout和QFormLayout等。
4.1.1 佈局的建立與使用
在Qt中，建立佈局非常簡單。首先需要知道佈局管理器是QWidget的子類，所以可以將它們作為普通控制元件一樣新增到視窗中。下面是建立一個水平佈局的例子,
cpp
QHBoxLayout *horizontalLayout = new QHBoxLayout(); __ 建立水平佈局
QWidget *widget1 = new QWidget(); __ 建立一個QWidget作為子控制元件
QWidget *widget2 = new QWidget();
horizontalLayout->addWidget(widget1); __ 將widget1新增到水平佈局中
horizontalLayout->addWidget(widget2); __ 將widget2新增到水平佈局中
__ 將水平佈局設定為某個視窗（例如一個QMainWindow或QWidget）的佈局
someWindow->setLayout(horizontalLayout);
在上面的程式碼中，我們首先透過new關鍵字建立了一個QHBoxLayout物件，這代表了水平佈局。然後，我們建立了兩個QWidget物件作為子控制元件，並將它們新增到水平佈局中。最後，我們將這個水平佈局設定為某個視窗的佈局。
4.1.2 佈局巢狀
佈局不僅可以作為頂級佈局管理器使用，還可以作為其他佈局的子佈局。這種巢狀佈局的使用方式可以讓控制元件的佈局更加靈活。例如，我們可以建立一個包含兩個垂直佈局的巢狀佈局,
cpp
QVBoxLayout *mainLayout = new QVBoxLayout(); __ 建立一個垂直佈局作為主佈局
QHBoxLayout *horizontalLayout1 = new QHBoxLayout(); __ 建立一個水平佈局
QHBoxLayout *horizontalLayout2 = new QHBoxLayout();
horizontalLayout1->addWidget(new QWidget()); __ 新增一些控制元件到horizontalLayout1
horizontalLayout2->addWidget(new QWidget()); __ 新增一些控制元件到horizontalLayout2
mainLayout->addLayout(horizontalLayout1); __ 將horizontalLayout1新增到主佈局中
mainLayout->addLayout(horizontalLayout2); __ 將horizontalLayout2新增到主佈局中
someWindow->setLayout(mainLayout); __ 將主佈局設定為視窗的佈局
在這個例子中，我們建立了一個垂直佈局mainLayout作為頂級佈局，然後在其中巢狀了兩個水平佈局horizontalLayout1和horizontalLayout2。每個水平佈局中又新增了一些控制元件。最後，我們將這個巢狀佈局設定為某個視窗的佈局。
4.1.3 佈局的優缺點
佈局在Qt中的應用非常廣泛，主要優點包括,

  1. 自動排列和調整,佈局會根據控制元件的大小和視窗的大小自動進行調整，使得介面更加美觀和易於管理。
  2. 靈活的佈局管理,透過佈局，可以輕鬆實現控制元件的新增、刪除和重新排列。
  3. 跨平臺一致性,佈局在Qt的各個平臺上表現一致，使得開發者可以更加專注於介面的設計，而不用擔心不同平臺之間的差異。
    但是，佈局也有其缺點,
  4. 效能問題,佈局的自動調整可能會導致效能問題，特別是在大量控制元件或者複雜的佈局中。
  5. 控制元件定位困難,使用佈局後，控制元件的精確位置和大小可能變得難以控制，因為佈局會自動進行調整。
    總的來說，佈局是Qt中管理控制元件位置和大小的一種強大和靈活的工具，但是也需要注意其效能和控制元件定位的問題。

4.2 4_2_常用的佈局類

4.2.1 4_2_常用的佈局類

4_2_常用的佈局類
4.2 常用的佈局類
在Qt中，佈局是管理控制元件位置和大小關係的重要部分。Qt提供了多種佈局類，以適應不同的介面設計需求。本節將介紹Qt中常用的幾種佈局類及其使用方法。
4.2.1 佈局管理器概述
Qt中的佈局管理器（Layout Manager）負責控制元件的佈局工作，使得控制元件可以自動適應容器的大小變化，或者按照一定的規則放置。佈局管理器可以很容易地實現控制元件之間的空間分配和大小調整。
4.2.2 常用的佈局類
1. QHBoxLayout（水平佈局）
QHBoxLayout是Qt中的一種水平佈局管理器，它將容器中的控制元件放置在水平方向上。當容器的大小變化時，QHBoxLayout會自動調整其中控制元件的位置和大小。
cpp
QHBoxLayout *horizontalLayout = new QHBoxLayout();
horizontalLayout->addWidget(new QPushButton(按鈕1));
horizontalLayout->addWidget(new QPushButton(按鈕2));
horizontalLayout->addWidget(new QPushButton(按鈕3));
2. QVBoxLayout（垂直佈局）
QVBoxLayout是Qt中的垂直佈局管理器，它將容器中的控制元件放置在垂直方向上。與QHBoxLayout類似，QVBoxLayout也會根據容器的大小自動調整控制元件的位置和大小。
cpp
QVBoxLayout *verticalLayout = new QVBoxLayout();
verticalLayout->addWidget(new QPushButton(按鈕1));
verticalLayout->addWidget(new QPushButton(按鈕2));
verticalLayout->addWidget(new QPushButton(按鈕3));
3. QGridLayout（網格佈局）
QGridLayout是Qt中的網格佈局管理器，它允許在容器中建立一個網格，然後將控制元件放置在這個網格中的指定位置。QGridLayout可以很方便地排列成行和列的控制元件。
cpp
QGridLayout *gridLayout = new QGridLayout();
gridLayout->addWidget(new QPushButton(按鈕1), 0, 0);
gridLayout->addWidget(new QPushButton(按鈕2), 0, 1);
gridLayout->addWidget(new QPushButton(按鈕3), 1, 0);
4. QFormLayout（表單佈局）
QFormLayout是Qt中的一種表單佈局管理器，它主要用於排列成對的控制元件，例如，標籤和編輯框。這種佈局管理器自動處理控制元件的對齊和間距。
cpp
QFormLayout *formLayout = new QFormLayout();
formLayout->addRow(new QLabel(標籤1), new QLineEdit());
formLayout->addRow(new QLabel(標籤2), new QLineEdit());
5. QStackedLayout（堆疊佈局）
QStackedLayout是Qt中的堆疊佈局管理器，它允許在容器中同時存在多個佈局，並且可以在它們之間進行切換。這在需要根據不同情況顯示不同佈局的場景中非常有用。
cpp
QStackedLayout *stackedLayout = new QStackedLayout();
stackedLayout->addLayout(new QVBoxLayout());
stackedLayout->addLayout(new QHBoxLayout());
透過以上介紹，我們可以看到Qt提供了多種佈局類，以滿足各種介面設計的需求。在實際開發過程中，我們可以根據具體情況選擇合適的佈局類來管理控制元件的佈局。

4.3 4_3_佈局的建立與使用

4.3.1 4_3_佈局的建立與使用

4_3_佈局的建立與使用
4.3 佈局的建立與使用
在Qt中，佈局管理器負責容器內控制元件的位置和大小調整。Qt提供了多種佈局管理器，如QHBoxLayout、QVBoxLayout、QGridLayout、QFormLayout和QStackedLayout等。使用佈局管理器可以很方便地實現控制元件的自動排列和尺寸調整，從而使介面更加靈活和易於維護。
4.3.1 佈局的建立
在Qt中建立佈局通常有以下幾個步驟,

  1. 建立佈局物件,首先需要根據需要選擇合適的佈局管理器類，例如QHBoxLayout或QVBoxLayout。
  2. 新增到容器,將佈局物件新增到容器控制元件中，例如QWidget或QMainWindow。
  3. 新增控制元件,將需要佈局的控制元件新增到佈局中。
  4. 設定控制元件屬性,可以設定控制元件的屬性，如間距和對齊方式等。
    下面是一個簡單的例子，演示如何建立一個水平佈局並新增兩個按鈕,
    cpp
    QHBoxLayout *horizontalLayout = new QHBoxLayout(this); __ this 指當前的 QWidget 物件
    horizontalLayout->addWidget(new QPushButton(按鈕1));
    horizontalLayout->addWidget(new QPushButton(按鈕2));
    4.3.2 佈局的使用
    一旦佈局被建立並新增到容器中，就可以透過以下方式使用佈局,
  5. 新增和移除控制元件,可以在執行時動態地向佈局中新增或移除控制元件。
  6. 調整控制元件佈局,可以調整控制元件在佈局中的位置和大小，例如透過設定QLayout::Spacing和QLayout::Margin屬性來調整間距和邊距。
  7. 佈局巢狀,可以將一個佈局作為另一個佈局的控制元件來使用，實現更復雜的佈局結構。
  8. 佈局轉換,可以轉換佈局，例如將水平佈局轉換為垂直佈局。
    下面是一個例子，演示如何將水平佈局轉換為垂直佈局，並新增一些控制元件,
    cpp
    __ 建立一個垂直佈局
    QVBoxLayout *verticalLayout = new QVBoxLayout();
    __ 將水平佈局作為垂直佈局的一個控制元件新增進去
    verticalLayout->addLayout(horizontalLayout);
    __ 新增其他控制元件
    verticalLayout->addWidget(new QPushButton(按鈕3));
    verticalLayout->addWidget(new QPushButton(按鈕4));
    4.3.3 佈局與控制元件的關係
    在Qt中，佈局與控制元件之間的關係是非常靈活的。佈局可以控制控制元件的尺寸和位置，而控制元件也可以影響佈局的行為。例如，當一個控制元件的尺寸發生變化時，佈局會相應地調整其他控制元件的位置和大小。此外，佈局還可以設定控制元件的間距和對齊方式，使介面更加美觀和一致。
    4.3.4 佈局的優缺點
    優點,
  • 自動調整,佈局可以自動適應容器的大小變化和控制元件的新增_移除。
  • 靈活性,佈局提供了多種佈局管理器，可以方便地實現各種佈局結構。
  • 易於維護,使用佈局可以使介面更加清晰和易於管理，減少了對絕對佈局的依賴。
    缺點,
  • 效能影響,相比於絕對佈局，佈局管理器在某些情況下可能會稍微影響效能。
  • 學習曲線,對於初學者來說，理解和熟練使用佈局可能需要一些時間。
    總的來說，佈局管理器是Qt中一個非常重要的功能，它可以大大簡化介面設計的複雜性，並使介面更加靈活和易於維護。

4.4 4_4_佈局的最佳化與調整

4.4.1 4_4_佈局的最佳化與調整

4_4_佈局的最佳化與調整
4.4 佈局的最佳化與調整
在QT中，佈局管理器負責自動調整控制元件的大小和位置，以適應容器的大小變化。然而，在實際開發中，我們往往需要對佈局進行一些最佳化和調整，以達到更好的顯示效果和使用者體驗。本節將介紹一些關於佈局最佳化和調整的方法和技巧。

  1. 使用佈局約束
    在QT中，佈局管理器使用佈局約束來控制控制元件的大小和位置。我們可以透過設定控制元件的佈局約束來最佳化佈局。例如，我們可以使用QWidget::setMaximumSize()和QWidget::setMinimumSize()方法來設定控制元件的最大和最小尺寸，從而控制控制元件的大小。另外，我們還可以使用佈局約束來控制控制元件之間的間距和對齊方式。
  2. 使用佈局巢狀
    在QT中，我們可以使用佈局巢狀來建立更復雜的佈局結構。佈局巢狀可以將多個佈局作為子控制元件新增到另一個佈局中，從而實現更靈活的佈局設計。例如，我們可以建立一個垂直佈局，其中包含一個水平佈局，用於顯示多個按鈕。這樣，我們可以透過調整巢狀佈局的間距和對齊方式來最佳化佈局。
  3. 使用彈性佈局
    在QT中，我們可以使用彈性佈局來適應不同尺寸的視窗。彈性佈局可以使控制元件根據視窗的大小變化自動調整大小和位置。例如，我們可以使用QHBoxLayout或QVBoxLayout作為主佈局，然後將其他佈局作為子佈局新增到主佈局中。透過設定子佈局的QBoxLayout::Alignment屬性，我們可以控制控制元件在視窗中的對齊方式。另外，我們還可以使用彈性佈局來建立響應式佈局，使控制元件在不同裝置上呈現出最佳狀態。
  4. 使用控制元件屬性
    在QT中，我們可以透過設定控制元件的屬性來最佳化佈局。例如，我們可以使用QWidget::setProperty()方法為控制元件設定自定義屬性，然後在佈局管理器中使用這些屬性來控制控制元件的大小和位置。另外，我們還可以使用控制元件的樣式表來設定控制元件的樣式和佈局屬性。透過設定控制元件的樣式表，我們可以控制控制元件的顏色、字型、邊距和間距等屬性，從而實現更美觀的佈局效果。
  5. 使用自定義佈局
    在QT中，我們可以建立自定義佈局來滿足特定的佈局需求。自定義佈局可以繼承QAbstractLayout或QLayout，並重新實現其方法來控制控制元件的大小和位置。例如，我們可以建立一個自定義水平佈局，該佈局在新增控制元件時自動調整控制元件的間距和對齊方式。透過使用自定義佈局，我們可以更靈活地控制佈局的屬性和行為，從而實現更好的佈局效果。
    總之，在QT中，佈局的最佳化與調整是一個重要的環節，可以透過使用佈局約束、佈局巢狀、彈性佈局、控制元件屬性和自定義佈局等方法和技巧來實現更美觀、更靈活的佈局效果。透過合理地最佳化和調整佈局，我們可以提高使用者體驗，使應用程式呈現出更好的視覺效果。

4.5 4_5_實用技巧與經驗分享

4.5.1 4_5_實用技巧與經驗分享

4_5_實用技巧與經驗分享
4.5 實用技巧與經驗分享

  1. 使用訊號和槽實現執行緒安全
    在QT中，訊號和槽機制是實現執行緒安全的一種常用方法。透過訊號和槽，可以實現物件之間的通訊，從而避免在多執行緒環境下直接操作共享資源導致的執行緒安全問題。
    示例程式碼,
    cpp
    class Communicate : public QObject
    {
    Q_OBJECT
    public:
    Communicate(QObject *parent = nullptr) : QObject(parent) {}
    signals:
    void sendData(const QString &data);
    public slots:
    void receiveData(const QString &data)
    {
    __ 處理接收到的資料
    }
    };
    __ 在其他地方使用
    Communicate comm;
    QThread thread;
    comm.moveToThread(&thread);
    connect(&thread, &QThread::started, &comm, &Communicate::sendData, Qt::DirectConnection);
    connect(&comm, &Communicate::sendData, &thread, &QThread::quit, Qt::DirectConnection);
    thread.start();
  2. 使用元物件實現程式碼重構
    QT提供了元物件功能，如元類、元物件運算子等。透過元物件，可以實現程式碼的重構和簡化。
    示例程式碼,
    cpp
    class Person
    {
    public:
    QString name;
    int age;
    Person(const QString &name, int age) : name(name), age(age) {}
    };
    Q_DECLARE_METATYPE(Person)
    __ 在其他地方使用
    QList<Person> people;
    people << Person(Alice, 30) << Person(Bob, 25);
    Q_ASSERT(people.size() == 2);
  3. 使用Q_INVOKABLE實現槽的遠端呼叫
    在QT中，透過Q_INVOKABLE宏可以將槽宣告為可以被遠端呼叫的函式。這種方式常用於實現客戶端和伺服器之間的通訊。
    示例程式碼,
    cpp
    class Server : public QObject
    {
    Q_OBJECT
    public:
    Server(QObject *parent = nullptr) : QObject(parent) {}
    signals:
    void dataReceived(const QString &data);
    public slots:
    Q_INVOKABLE void processData(const QString &data)
    {
    __ 處理資料
    emit dataReceived(data);
    }
    };
    __ 在其他地方使用
    Server server;
    QObject::connect(&server, &Server::dataReceived, [](const QString &data) {
    __ 處理接收到的資料
    });
    __ 遠端呼叫槽
    server.processData(Hello, world!);
  4. 使用Q_ASSERT進行除錯
    Q_ASSERT是QT中用於除錯的宏，可以在程式碼中插入斷言，以確保程式在執行過程中的一些條件得到滿足。如果條件不滿足，程式將丟擲異常並終止執行。
    示例程式碼,
    cpp
    void MyClass::myFunction()
    {
    Q_ASSERT(condition);
    __ 執行其他操作
    }
    在除錯過程中，使用Q_ASSERT可以幫助我們快速定位問題所在。釋出程式時，可以去掉或替換Q_ASSERT，以避免影響程式的穩定性。
  5. 使用Q_UNUSED避免 unused variable 警告
    在QT中，可以透過Q_UNUSED宏忽略不使用的變數或引數，以避免編譯器警告。
    示例程式碼,
    cpp
    void MyClass::myFunction(int unusedParam)
    {
    Q_UNUSED(unusedParam);
    __ 執行其他操作
    }
    使用Q_UNUSED可以讓我們更專注於實際需要關注的部分，減少編譯器警告帶來的干擾。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

5 第五章_視窗與控制元件

5.1 5_1_視窗的基本概念

5.1.1 5_1_視窗的基本概念

5_1_視窗的基本概念
5.1 視窗的基本概念
在QT中，視窗（Widget）是構成使用者介面的一切。無論是桌面應用程式還是移動應用程式，視窗都是使用者與程式互動的介面。QT提供了一套豐富的視窗小部件（Widgets），這些都是從QWidget類繼承而來的類，它們分別代表不同的控制元件，如按鈕、文字框、標籤等。
視窗的分類
在QT中，視窗可以分為以下幾類,

  1. 頂級視窗（Top-Level Widgets）,這些視窗位於其他視窗之上，可以獨立存在，例如QMainWindow、QDialog等。每個應用程式至少有一個頂級視窗。
  2. 子視窗（Child Widgets）,這些視窗是頂級視窗的子視窗，它們不能獨立存在，只能嵌入到頂級視窗中，例如QPushButton、QLabel等。
  3. 內嵌視窗（ Embeddable Widgets）,這些視窗可以被嵌入到其他視窗中，如QTextEdit、QSlider等。
    視窗的層次結構
    在QT中，視窗的層次結構是基於父子關係來組織的。每個視窗都可以有多個子視窗，但只能有一個父視窗。這種層次結構使得視窗的管理變得非常靈活。
    視窗的屬性
    QT視窗小部件有很多屬性，這些屬性決定了視窗的外觀和行為。常見的視窗屬性包括,
  • geometry,定義視窗的大小和位置。
  • title,視窗的標題。
  • visible,決定視窗是否可見。
  • enabled,決定視窗是否可以響應使用者操作。
  • cursor,定義視窗的滑鼠游標形狀。
    視窗的佈局
    在QT中，視窗的佈局是指視窗內小部件的排列方式。QT提供了多種佈局管理器，如QHBoxLayout、QVBoxLayout、QGridLayout等，幫助開發者輕鬆地管理視窗內小部件的佈局。
    總結起來，視窗是QT程式設計中的基礎元素，理解視窗的基本概念和屬性對於開發出功能豐富、使用者友好的應用程式至關重要。在下一節中，我們將詳細介紹QT中的各種視窗小部件。

5.2 5_2_控制元件的建立與使用

5.2.1 5_2_控制元件的建立與使用

5_2_控制元件的建立與使用
5_2_控制元件的建立與使用
控制元件是使用者介面設計的基礎，Qt Widgets模組提供了豐富的控制元件供我們使用。在Qt中，控制元件通常是指那些能夠響應使用者操作並能夠執行特定功能的圖形使用者介面元素，如按鈕、文字框、標籤等。
在本節中，我們將介紹如何建立自定義控制元件以及如何使用QtWidgets模組中提供的標準控制元件。
5.2.1 建立自定義控制元件
在Qt中，建立一個自定義控制元件通常需要以下幾個步驟,

  1. 繼承一個現有的控制元件類或基礎類，如QWidget或QPushButton。
  2. 重寫必要的虛擬函式，如paintEvent(QPaintEvent *)和mousePressEvent(QMouseEvent *)等，以實現控制元件的繪製和事件處理。
  3. 實現控制元件的自定義成員變數和成員函式。
  4. 使用Qt的訊號與槽機制來處理控制元件的事件和互動。
    例如，我們可以建立一個自定義的按鈕控制元件，它會在點選時發射一個訊號,
    cpp
    include <QPushButton>
    include <QMouseEvent>
    class CustomButton : public QPushButton
    {
    Q_OBJECT
    public:
    CustomButton(QWidget *parent = nullptr) : QPushButton(parent) {}
    protected:
    void mousePressEvent(QMouseEvent *event) override
    {
    __ 當使用者點選按鈕時發射訊號
    if (event->button() == Qt::LeftButton)
    {
    emit clicked();
    }
    __ 呼叫基類的mousePressEvent以處理其他事件
    QPushButton::mousePressEvent(event);
    }
    signals:
    void clicked(); __ 按鈕點選訊號
    };
    在上面的程式碼中，我們透過繼承QPushButton並重寫mousePressEvent函式來自定義按鈕的行為。當按鈕被點選時，會透過emit關鍵字發射一個名為clicked()的訊號。
    5.2.2 使用標準控制元件
    QtWidgets模組提供了一系列的標準控制元件，這些控制元件在Qt Designer中可以直接使用，也可以在程式碼中建立和配置。這些控制元件包括,
  • 基礎控制元件,如QWidget、QLabel、QPushButton、QCheckBox、QRadioButton等。
  • 佈局控制元件,如QHBoxLayout、QVBoxLayout、QGridLayout等。
  • 容器控制元件,如QGroupBox、QTabWidget、QTableWidget等。
  • 輸入控制元件,如QLineEdit、QTextEdit、QSpinBox、QComboBox等。
  • 資料顯示控制元件,如QListWidget、QTreeWidget、QGraphicsView等。
    使用標準控制元件的示例程式碼如下,
    cpp
    include <QLabel>
    include <QPushButton>
    include <QVBoxLayout>
    __ 建立一個應用程式視窗
    class MainWindow : public QMainWindow
    {
    public:
    MainWindow()
    {
    QWidget *centralWidget = new QWidget(this);
    setCentralWidget(centralWidget);
    QVBoxLayout *layout = new QVBoxLayout(centralWidget);
    QLabel *label = new QLabel(歡迎使用QtWidgets, this);
    QPushButton *button = new QPushButton(點選我, this);
    layout->addWidget(label);
    layout->addWidget(button);
    __ 設定佈局
    centralWidget->setLayout(layout);
    }
    };
    在上述程式碼中，我們建立了一個主視窗，並在其中使用QVBoxLayout佈局管理器來管理兩個控制元件,一個QLabel和一個QPushButton。這些控制元件被新增到佈局中，並按照垂直方向排列。
    控制元件的建立與使用是Qt應用程式開發的基礎，透過組合不同的控制元件，可以構建出豐富多樣的使用者介面。在下一節中，我們將學習如何使用Qt的佈局系統來管理控制元件的佈局。

5.3 5_3_視窗與控制元件的樣式

5.3.1 5_3_視窗與控制元件的樣式

5_3_視窗與控制元件的樣式
5.3 視窗與控制元件的樣式
在QT中，樣式是使用者介面控制元件外觀的重要組成部分。樣式不僅關係到介面的美觀，也影響著使用者的體驗。QT提供了豐富的樣式設定，允許開發者為視窗和控制元件自定義外觀。
5.3.1 樣式表（Style Sheets）
樣式表是QT中設定控制元件樣式的主要手段。透過樣式表，我們可以設定控制元件的顏色、字型、邊距、背景等屬性。樣式表使用CSS-like的語法，易於理解和使用。
下面是一個簡單的樣式表設定示例,
css
QPushButton {
background-color: 333;
border-style: outset;
border-width: 2px;
border-radius: 10px;
border-color: beige;
font: bold 14px;
min-width: 10em;
padding: 6px;
}
QPushButton:hover {
background-color: 555;
border-style: inset;
}
QPushButton:pressed {
background-color: 777;
border-style: inset;
}
在這個示例中，我們定義了一個按鈕的樣式，包括其背景顏色、邊框樣式、字型等。我們還定義了當滑鼠懸停在按鈕上以及按鈕被按下時的樣式。
5.3.2 視窗樣式（Window Styles）
QT視窗也支援樣式設定，這些樣式決定了視窗的邊框、標題欄、選單等的外觀。透過設定視窗樣式，我們可以建立不同的視窗效果，如標題欄、邊框、最大化按鈕等。
例如，我們可以透過如下方式設定一個視窗的樣式,
cpp
QWidget::setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
這會建立一個無邊框且始終保持在其他視窗之上的視窗。
5.3.3 自定義控制元件樣式
除了使用預定義的樣式和視窗樣式，我們還可以透過繼承QWidget或其子類來建立自定義控制元件，並完全重寫其繪製邏輯。透過重寫paintEvent(QPaintEvent *)方法，我們可以實現完全個性化的控制元件樣式。
cpp
void CustomWidget::paintEvent(QPaintEvent *) {
QPainter painter(this);
painter.setPen(Qt::blue);
painter.drawRect(rect()); __ 繪製一個藍色邊框
}
在這個例子中，我們建立了一個自定義控制元件，它在每次繪製時都會在邊界繪製一個藍色的矩形。
5.3.4 使用樣式類（Style Classes）
QT也支援使用樣式類來簡化樣式設定。樣式類是QT在樣式表中提供的一種快捷方式，可以直接應用到控制元件上，簡化樣式的設定過程。
例如，QT提供了一個QT_IS_STYLE_CLASS宏，可以用來檢查一個控制元件是否已經應用了一個特定的樣式類。
cpp
if (QT_IS_STYLE_CLASS(this, myStyleClass)) {
__ 執行與myStyleClass相關的樣式設定
}
使用樣式類，我們可以更方便地為多個控制元件應用統一的樣式，提高開發效率。
綜上所述，QT提供了多種方式來設定視窗和控制元件的樣式，無論是透過樣式表、視窗樣式、自定義控制元件繪製邏輯，還是透過樣式類，都能實現豐富的介面效果。在實際開發中，我們可以根據需要靈活運用這些技術，創造出既美觀又實用的使用者介面。

5.4 5_4_視窗與控制元件的動畫

5.4.1 5_4_視窗與控制元件的動畫

5_4_視窗與控制元件的動畫
5.4 視窗與控制元件的動畫
Qt提供了豐富的動畫效果，可以讓視窗與控制元件變得更加生動有趣。在本節中，我們將介紹如何在Qt中建立和應用視窗與控制元件的動畫。
5.4.1 動畫基礎
Qt中的動畫主要基於兩個類,QPropertyAnimation和QAbstractAnimation。其中，QPropertyAnimation用於對物件的屬性進行動畫處理，而QAbstractAnimation則是動畫的基礎類，提供了動畫的通用介面和功能。
要建立一個動畫，我們通常需要以下幾個步驟,

  1. 建立一個QAbstractAnimation的子類，並在其中實現動畫邏輯。
  2. 建立一個QPropertyAnimation物件，將其連線到目標物件的屬性上。
  3. 啟動動畫。
    5.4.2 視窗動畫
    在Qt中，視窗動畫通常指的是視窗的開啟、關閉、縮放等動畫效果。要實現這些效果，我們可以使用QPropertyAnimation對視窗的屬性進行動畫處理。
    以下是一個簡單的例子，展示瞭如何為一個QWidget視窗建立一個開啟和關閉的動畫,
    cpp
    class CustomWidgetAnimation : public QPropertyAnimation
    {
    public:
    CustomWidgetAnimation(QWidget *target, const QString &propertyName)
    : QPropertyAnimation(target, propertyName)
    {
    }
    void setDuration(int duration)
    {
    m_duration = duration;
    }
    protected:
    void updateCurrentValue(const QVariant &value) override
    {
    QWidget *target = object();
    if (target) {
    if (propertyName() == geometry) {
    target->setGeometry(value.toRect());
    } else if (propertyName() == windowOpacity) {
    target->setWindowOpacity(value.toReal());
    }
    }
    }
    private:
    int m_duration;
    };
    在上面的程式碼中，我們建立了一個名為CustomWidgetAnimation的QPropertyAnimation子類，它可以用於對QWidget視窗的geometry或windowOpacity屬性進行動畫處理。
    接下來，我們可以建立一個QWidget視窗，並使用CustomWidgetAnimation為其建立動畫,
    cpp
    class CustomWidget : public QWidget
    {
    public:
    CustomWidget(QWidget *parent = nullptr)
    : QWidget(parent)
    {
    __ 設定視窗初始位置和大小
    setGeometry(100, 100, 300, 200);
    setWindowOpacity(1.0);
    }
    private:
    void mousePressEvent(QMouseEvent *event) override
    {
    if (event->button() == Qt::LeftButton) {
    __ 建立動畫
    CustomWidgetAnimation *animation = new CustomWidgetAnimation(this, geometry);
    animation->setDuration(500);
    animation->setEndValue(QRect(500, 500, 300, 200));
    __ 啟動動畫
    animation->start();
    }
    }
    };
    在上面的程式碼中，我們建立了一個名為CustomWidget的QWidget視窗，並在其mousePressEvent事件中建立了一個CustomWidgetAnimation動畫。這個動畫將視窗的geometry屬性從初始位置和大小動畫到一個新的位置和大小。
    5.4.3 控制元件動畫
    在Qt中，控制元件動畫通常指的是對某個控制元件的屬性進行動畫處理，例如大小、位置、顏色等。要實現控制元件動畫，我們同樣可以使用QPropertyAnimation。
    以下是一個簡單的例子，展示瞭如何為一個QPushButton控制元件建立一個大小變化的動畫,
    cpp
    class CustomControlAnimation : public QPropertyAnimation
    {
    public:
    CustomControlAnimation(QWidget *target, const QString &propertyName)
    : QPropertyAnimation(target, propertyName)
    {
    }
    protected:
    void updateCurrentValue(const QVariant &value) override
    {
    QWidget *target = object();
    if (target) {
    if (propertyName() == size) {
    target->setSize(value.toSize());
    }
    }
    }
    };
    在上面的程式碼中，我們建立了一個名為CustomControlAnimation的QPropertyAnimation子類，它可以用於對控制元件的size屬性進行動畫處理。
    接下來，我們可以建立一個QPushButton控制元件，並使用CustomControlAnimation為其建立動畫,
    cpp
    class CustomWidget : public QWidget
    {
    public:
    CustomWidget(QWidget *parent = nullptr)
    : QWidget(parent)
    {
    __ 建立按鈕並新增到視窗中
    QPushButton *button = new QPushButton(點選我, this);
    button->setGeometry(50, 50, 100, 50);
    __ 建立動畫
    CustomControlAnimation *animation = new CustomControlAnimation(button, size);
    animation->setDuration(500);
    animation->setEndValue(QSize(200, 100));
    __ 啟動動畫
    animation->start();
    }
    };
    在上面的程式碼中，我們建立了一個名為CustomWidget的QWidget視窗，並在其中建立了一個QPushButton控制元件。我們在控制元件上建立了一個CustomControlAnimation動畫，這個動畫將控制元件的大小從初始大小動畫到一個新的大小。
    透過使用Qt的動畫功能，我們可以為視窗和控制元件建立豐富多樣的動畫效果，使應用程式更加生動有趣。在實際開發中，我們可以根據需要自定義動畫邏輯，為使用者提供更好的互動體驗。

5.5 5_5_實用技巧與經驗分享

5.5.1 5_5_實用技巧與經驗分享

5_5_實用技巧與經驗分享
5.5 實用技巧與經驗分享
在深入分析了QT Widgets模組的原始碼之後，作為QT高階工程師，我們總結了一些實用的技巧和開發經驗，希望對讀者在實際專案開發中有所幫助。

  1. 利用元物件系統提高效能
    QT框架內建了元物件系統(Meta-Object System)，它包括訊號與槽機制、執行時型別資訊、以及物件序列化等功能。在開發過程中，合理利用元物件系統的功能，可以有效提高程式的執行效率。
    例如，在設計UI介面時，使用Q_OBJECT宏定義元物件資訊，可以讓QT在執行時自動生成元物件資訊，這樣可以在物件之間進行通訊時減少訊息傳遞的開銷。
  2. 巧用事件過濾器
    在複雜的介面設計中，為了避免訊號與槽的濫用，可以使用事件過濾器(Event Filter)來處理一些通用的事件，如鍵盤事件、滑鼠事件等。透過設定事件過濾器，可以有效減少事件處理的複雜度。
  3. 繪製最佳化技巧
    繪製操作是介面效能的一個重要考量點。在開發過程中，應當注意以下幾點以最佳化繪製效能,
  • 儘可能使用QPainter進行繪製，避免頻繁地呼叫系統級的繪製操作。
  • 使用合適的繪圖策略，如離屏繪製、繪製快取等。
  • 合理使用檢視的大小調整機制，如resizeEvent中的最佳化。
  1. 記憶體管理
    QT提供了豐富的記憶體管理工具，如智慧指標QScopedPointer、物件生命週期管理器QObject::destroyed等。合理使用這些工具，可以有效避免記憶體洩漏問題。
  2. 自定義Widget的技巧
    自定義Widget是QT開發中的一個高階技能，下面提供一些實用的技巧,
  • 繼承QWidget或其子類來建立自定義Widget。
  • 使用paintEvent來繪製Widget的UI。
  • 使用mousePressEvent、mouseMoveEvent等來處理使用者互動。
  • 利用樣式表(QSS)來自定義Widget的外觀。
  1. 效能調優
    對於複雜的應用程式，效能調優是必不可少的步驟。QT提供了一些效能分析的工具，如QElapsedTimer、QLoggingCategory等，可以幫助我們定位效能瓶頸並進行最佳化。
  2. 多平臺開發注意事項
    QT框架支援多平臺開發，但在不同平臺上可能存在差異。在開發過程中，需要注意以下幾點,
  • 平臺的UI規範可能不同，需要根據不同的平臺進行適配。
  • 某些控制元件在不同平臺上的表現可能有所差異。
  • 注意檔案路徑格式、輸入法、字型渲染等平臺相關的細節問題。
    透過以上這些技巧和經驗的分享，可以在開發基於QT Widgets的應用程式時更加高效，同時也能提升程式的效能和使用者體驗。在實踐中不斷總結經驗，並積極探索新的技術，是成為一名優秀的QT開發者的必經之路。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

6 第六章_訊號與槽

6.1 6_1_訊號與槽的概念

6.1.1 6_1_訊號與槽的概念

6_1_訊號與槽的概念
6.1 訊號與槽的概念
在Qt中，訊號與槽是實現物件間通訊的基礎機制。這一機制是Qt框架的核心特性之一，它提供了一種優雅的解決方案來處理物件之間的互動和事件傳遞。
訊號（Signals）
訊號是Qt物件中宣告的一種特殊成員函式，它用於表示物件發出的某種事件或狀態變化。當物件的某個條件滿足時，就會發出一個訊號。訊號不需要任何引數，也不返回任何值。
在Qt中，訊號通常與槽（Slots）一起使用，以實現物件之間的相互作用。當一個物件發出一個訊號時，它會尋找與之關聯的槽，並將這個訊號傳遞給該槽。
槽（Slots）
槽是Qt物件中宣告的另一種特殊成員函式，它用於處理訊號。槽與訊號相對應，用於接收訊號並執行相應的操作。槽可以是任何返回型別為void的函式，也可以是帶有引數的函式。
在Qt中，槽可以透過兩種方式與訊號關聯,一種是使用connect函式手動關聯，另一種是在類中使用slot裝飾器自動關聯。
訊號與槽的連線
在Qt中，訊號與槽的連線是透過QObject類的connect函式實現的。這個函式接受兩個引數,第一個引數是發射訊號的物件，第二個引數是接收訊號的槽函式。
例如，我們可以連線一個按鈕的clicked訊號到一個標籤的updateText槽,
cpp
QPushButton *button = new QPushButton(點選我, this);
QLabel *label = new QLabel(未點選, this);
connect(button, SIGNAL(clicked()), label, SLOT(updateText()));
在這個例子中，當按鈕被點選時，它會發出一個clicked訊號。這個訊號會被連線到標籤的updateText槽上，當訊號被髮送時，標籤的updateText槽會被呼叫，並更新其顯示的文字。
訊號與槽的優勢
訊號與槽機制具有以下優勢,

  1. 物件導向,訊號與槽機制是一種物件導向的設計，它允許物件之間進行互動，而不需要了解彼此的內部實現。
  2. 解耦,訊號與槽機制可以將物件的傳送者和接收者解耦，使得它們可以獨立地改變和擴充套件。
  3. 動態,訊號與槽機制是動態的，可以在執行時進行連線和斷開，這為程式的靈活性和可擴充套件性提供了很大的便利。
  4. 安全,訊號與槽機制是一種型別安全的機制，它可以在編譯時檢查訊號和槽的連線是否正確。
    總之，訊號與槽是Qt框架中非常核心和重要的機制，它為Qt應用程式提供了強大的物件間通訊能力。在開發Qt應用程式時，熟練掌握訊號與槽的使用對於提高程式設計效率和程式質量至關重要。

6.2 6_2_訊號與槽的工作原理

6.2.1 6_2_訊號與槽的工作原理

6_2_訊號與槽的工作原理
6.2 訊號與槽的工作原理
Qt的訊號與槽（Signals and Slots）機制是其核心特性之一，它提供了一種物件間通訊的方式，是實現事件驅動程式設計的基礎。在Qt中，訊號（Signals）和槽（Slots）都是成員函式，訊號可以被多個物件接收，而槽通常用於執行特定的任務。這一機制使得Qt中的應用更加模組化，易於擴充套件和維護。
訊號（Signals）
訊號是當物件的一些特定事件發生時發出的。比如，在QPushButton點選時，就會發出一個點選訊號。訊號的宣告以signal關鍵字開始，並且通常不帶任何引數。在Qt中，訊號是觸發其他槽的源頭。
槽（Slots）
槽是當接收到訊號時被呼叫的函式。槽通常用來響應某些事件，比如使用者輸入、定時器事件或其他物件發出的訊號。槽的宣告以slot關鍵字開始，並且可以帶有一個或多個引數。
訊號與槽的連線
在Qt中，你可以在物件之間建立訊號與槽之間的連線。當一個物件的訊號被觸發時，它會導致與該訊號連線的所有槽被呼叫。這一機制使得物件可以自動執行其他物件的特定操作，而無需知道對方的存在，這大大提高了程式碼的模組化和可重用性。
工作原理

  1. 訊號發射（Signal Emission）,當一個物件需要通知其他物件發生了某些事情時，它會發射一個訊號。這個過程是自動的，基於事件的發生。
  2. 訊號連線（Signal Connection）,開發者可以在物件之間建立訊號與槽之間的連線。這意味著當發射者發出訊號時，連線的槽會被自動呼叫。
  3. 槽的執行（Slot Execution）,當訊號被連線的槽函式接收到時，它會執行相應的程式碼以響應這個事件。
    示例
    假設我們有一個按鈕（QPushButton），當使用者點選這個按鈕時，我們希望更新一個標籤（QLabel）上的文字。
    cpp
    class MainWindow : public QMainWindow
    {
    Q_OBJECT
    public:
    MainWindow(QWidget *parent = nullptr) : QMainWindow(parent)
    {
    QPushButton *button = new QPushButton(this);
    QLabel *label = new QLabel(this);
    button->clicked.connect(label, &QLabel::setText);
    __ 或者使用 lambda 表示式
    button->clicked.connect(={
    label->setText(按鈕被點選了);
    });
    }
    };
    在上面的程式碼中，button的clicked訊號被連線到了label的setText槽。當按鈕被點選時，label的文字將更新為按鈕被點選了。
    Qt的訊號與槽機制提供了一種優雅的解決方案來處理物件之間的通訊，無論這些物件的建立和銷燬是如何發生的，也不管它們的類層次結構如何。這種機制在Qt框架中被廣泛使用，是實現各種互動式使用者介面應用程式的關鍵。

6.3 6_3_訊號與槽的連線與斷開

6.3.1 6_3_訊號與槽的連線與斷開

6_3_訊號與槽的連線與斷開
6.3 訊號與槽的連線與斷開
在Qt中，訊號與槽的機制是實現物件間通訊的核心。訊號（Signal）與槽（Slot）的概念在Qt程式設計中非常重要，它們允許物件在某些事件發生時發出訊號，而其他物件可以監聽這些訊號並作出相應的響應。這種機制是Qt中實現事件驅動程式設計的關鍵。
在Qt Widgets模組中，大多數控制元件（Widget）都繼承自QObject，這意味著它們都能夠發出訊號。同時，控制元件的許多操作都伴隨著相應的訊號。例如，當一個按鈕被點選時，它會發出一個clicked訊號。
要使訊號與槽工作，必須將訊號連線到槽函式上。當訊號發出時，連線的槽就會被呼叫。這是一個典型的發出-接收模型。
6.3.1 訊號與槽的連線
在Qt中，使用connect()函式來連線訊號和槽。這個函式的原型如下,
cpp
void QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType connectionType = Qt::AutoConnection);

  • sender,訊號的傳送者。
  • signal,要連線的訊號的名稱。
  • receiver,訊號的接收者。
  • method,在接收者物件中要呼叫的槽函式的名稱。
  • connectionType,指定連線的型別，如Qt::AutoConnection、Qt::DirectConnection、Qt::QueuedConnection等。
    下面是一個簡單的例子，它連線了一個按鈕的clicked訊號到一個label的槽函式，當按鈕被點選時，label會更新其文字。
    cpp
    QPushButton *button = new QPushButton(點選我, this);
    QLabel *label = new QLabel(等待點選, this);
    __ 連線按鈕的clicked訊號到label的updateSlot槽函式
    connect(button, SIGNAL(clicked()), label, SLOT(updateSlot()));
    __ 也可以使用Lambda函式作為槽
    connect(button, SIGNAL(clicked()), ={
    label->setText(已點選);
    });
    在這個例子中，updateSlot()是QLabel類中的一個槽函式，它會在按鈕被點選時被呼叫，並更新標籤的文字。Lambda表示式也是一個現代C++中常用的做法，它提供了一種簡潔的方式來編寫臨時的、一次性的程式碼塊。
    6.3.2 訊號與槽的斷開
    當不再需要連線的訊號和槽時，可以使用disconnect()函式來斷開它們。這可以防止不必要的物件間通訊和潛在的記憶體洩漏。
    cpp
    disconnect(button, SIGNAL(clicked()), label, SLOT(updateSlot()));
    這行程式碼將斷開按鈕的clicked訊號和label的updateSlot()槽之間的連線。
    在Qt中，還可以使用訊號的槽連線模式（Qt::ConnectionType）來進行不同型別的連線。比如，Qt::DirectConnection要求傳送和接收物件在相同的執行緒中，而Qt::QueuedConnection則允許訊號在另一個執行緒中被處理。選擇適當的連線型別對於確保程式的正確性和效能是非常重要的。
    訊號與槽機制是Qt框架強大且靈活的特性之一，它支援複雜的應用程式架構，並能有效地促進物件之間的解耦。透過正確地使用這一機制，可以建立出響應迅速且易於維護的軟體系統。

6.4 6_4_訊號與槽的高階應用

6.4.1 6_4_訊號與槽的高階應用

6_4_訊號與槽的高階應用
6.4 訊號與槽的高階應用
在Qt中，訊號與槽機制是實現事件驅動程式設計的關鍵。它不僅保證了GUI的響應性，還在許多場合展現了它強大的功能。在本節中，我們將探討一些訊號與槽的高階應用，以充分發揮這一機制的優勢。
6.4.1 訊號的連線與斷開
在Qt中，我們可以使用connect()函式來連線兩個物件的訊號和槽。同樣，我們也可以使用disconnect()函式來斷開已經連線的訊號和槽。這兩個函式都是QObject類的一部分，因此所有Qt物件都可以使用它們。
以下是一個簡單的示例，演示瞭如何連線和斷開訊號與槽,
cpp
MyObject *obj1 = new MyObject();
MyObject *obj2 = new MyObject();
__ 連線訊號和槽
QObject::connect(obj1, &MyObject::signal1, obj2, &MyObject::slot1);
__ ...
__ 斷開訊號和槽
QObject::disconnect(obj1, &MyObject::signal1, obj2, &MyObject::slot1);
在這個示例中，我們建立了兩個MyObject型別的物件obj1和obj2。我們使用connect()函式將obj1的signal1訊號連線到obj2的slot1槽。然後，我們使用disconnect()函式斷開了這個連線。
注意,在連線和斷開訊號與槽時，我們傳遞的引數分別是訊號的指標和槽的指標。此外，為了避免潛在的錯誤，我們使用QObject::connect()和QObject::disconnect()函式，而不是直接使用connect()和disconnect()函式。
6.4.2 訊號與槽的傳遞物件
在Qt中，當我們連線訊號和槽時，可以傳遞一個或多個物件。這些物件可以在槽函式中透過Qt::Connection物件的sender()和receiver()函式訪問。
以下是一個示例，演示瞭如何在訊號和槽之間傳遞物件,
cpp
class MyObject : public QObject
{
Q_OBJECT
public:
MyObject(QObject *parent = nullptr) : QObject(parent)
{
}
signals:
void signal1(QObject *sender);
public slots:
void slot1(QObject *receiver)
{
Q_UNUSED(receiver)
qDebug() << Signal1 from << sender();
}
};
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MyObject obj1, obj2;
__ 連線訊號和槽，並傳遞物件
QObject::connect(&obj1, &MyObject::signal1, &obj2, &MyObject::slot1);
__ 觸發訊號
obj1.emitSignal1(&obj2);
return app.exec();
}
在這個示例中，我們建立了兩個MyObject型別的物件obj1和obj2。我們使用connect()函式將obj1的signal1訊號連線到obj2的slot1槽，並傳遞了obj2作為引數。在obj1的slot1槽中，我們可以透過sender()函式獲取發出訊號的物件，即obj1。
6.4.3 訊號與槽的巢狀使用
在Qt中，訊號和槽不僅可以連線到其他物件的槽上，還可以連線到自身的槽上。這種特性在某些場景中非常有用，例如在自定義物件中實現回撥函式。
以下是一個示例，演示瞭如何在訊號和槽中巢狀使用,
cpp
class MyObject : public QObject
{
Q_OBJECT
public:
MyObject(QObject *parent = nullptr) : QObject(parent)
{
}
signals:
void signal1();
void signal2();
public slots:
void slot1()
{
qDebug() << Slot1 called;
emit signal2(); __ 發出signal2訊號
}
void slot2()
{
qDebug() << Slot2 called;
emit signal1(); __ 發出signal1訊號
}
};
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MyObject obj;
__ 連線訊號和槽
QObject::connect(&obj, &MyObject::signal1, &obj, &MyObject::slot2);
__ 觸發訊號
obj.emitSignal1();
return app.exec();
}
在這個示例中，我們建立了一個MyObject型別的物件obj。我們定義了兩個訊號signal1和signal2，以及兩個槽slot1和slot2。在slot1槽中，我們首先輸出Slot1 called，然後發出signal2訊號。在slot2槽中，我們首先輸出Slot2 called，然後發出signal1訊號。
我們使用connect()函式將signal1訊號連線到slot2槽上。當signal1訊號被觸發時，將呼叫slot2槽，然後發出signal2訊號。signal2訊號再次被slot2槽處理，併發出signal1訊號。這個過程形成了一個巢狀的訊號和槽鏈。
6.4.4 訊號與槽的禁用和啟用
在某些情況下，我們可能希望禁用或啟用某個訊號與槽的連線。在Qt中，我們可以使用blockSignals(bool)函式來實現這一點。這個函式可以阻塞或恢復訊號的發射。
以下是一個示例，演示瞭如何禁用和啟用訊號與槽的連線,
cpp
class MyObject : public QObject
{
Q_OBJECT
public:
MyObject(QObject *parent = nullptr) : QObject(parent)
{
}
signals:
void signal1();
public slots:
void slot1()
{
qDebug() << Slot1 called;
}
};
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MyObject obj;
__ 連線訊號和槽
QObject::connect(&obj, &MyObject::signal1, &obj, &MyObject::slot1);
__ 禁用訊號的發射
obj.blockSignals(true);
__ 觸發訊號，但不會呼叫槽
obj.emitSignal1();
__ 啟用訊號的發射
obj.blockSignals(false);
return app.exec();
}
在這個示例中，我們建立了一個MyObject型別的物件obj。我們使用connect()函式將signal1訊號連線到slot1槽上。然後，我們呼叫blockSignals(true)函式禁用obj物件訊號的發射。在這種情況下，即使觸發signal1訊號，槽也不會被呼叫。之後，我們呼叫blockSignals(false)函式啟用訊號的發射。
注意,禁用訊號發射不會影響已經連線的槽。它只會阻止新的訊號發射。

6.5 6_5_實用技巧與經驗分享

6.5.1 6_5_實用技巧與經驗分享

6_5_實用技巧與經驗分享
6.5 實用技巧與經驗分享
在深入分析了QT Widgets模組的原始碼之後，作為QT高階工程師，我們累積了許多實用的技巧和經驗。在這一節中，我們將分享一些高階技巧，這些技巧可以幫助讀者更深入地理解QT的工作原理，以及如何在實際開發中發揮其最大潛力。
使用元物件系統最佳化效能
QT的元物件系統（Meta-Object System）為QT應用程式提供了許多強大的功能，如訊號與槽（signals and slots）機制、物件序列化、執行時型別資訊等。然而，這個系統也會帶來一定的效能開銷。在效能敏感的應用程式中，可以適當關閉不需要的功能，以減少不必要的開銷。
例如，如果你的應用程式不需要執行時型別資訊（RTTI），你可以在編譯時關閉它,
cpp
define QT_NO_RTTI
或者，如果你的應用程式不需要物件序列化，可以在編譯時禁用它,
cpp
define QT_NO_SERIALIZATION
高效使用事件處理
QT中的所有Widgets都是由事件驅動的。高效地處理事件是提升應用程式效能的關鍵。

  1. 事件過濾,使用事件過濾器（QObject::installEventFilter）來減少事件處理的重複工作，特別是對於那些處理相同型別事件的多層繼承體系。
  2. 合理使用事件忽略,在某些情況下，不是每個事件都需要被處理。在這種情況下，你可以選擇忽略事件，以減少處理的開銷。
  3. 最佳化事件處理程式碼,確保事件處理函式中的程式碼儘可能高效，避免在事件處理函式中執行耗時的操作。
    自定義繪圖技巧
    QT Widgets模組提供了豐富的繪圖功能，但有時標準的繪圖功能可能不足以滿足需求。這時，你可以透過自定義繪圖來完成更復雜的圖形渲染。
  4. 使用QPainter,透過QPainter類可以進行自定義繪圖。它提供了與OpenGL相容的繪圖API，可以用於繪製自定義控制元件。
  5. 繪圖上下文,利用繪圖上下文（QPainter的裝置）可以實現繪圖的快取和複用，減少繪圖的開銷。
  6. 離屏繪製,離屏繪製是一種將繪圖操作先在一個臨時畫布上完成，然後再將其繪製到目標控制元件上的技術。這樣可以減少直接在控制元件上繪製的次數，提高繪圖效能。
    記憶體管理
    QT Widgets應用程式的記憶體管理是保證程式穩定執行的關鍵。
  7. 智慧指標,QT提供了智慧指標QScopedPointer和QScopedArrayPointer，它們可以在物件生命週期結束時自動刪除指向的物件，避免記憶體洩漏。
  8. 物件池,對於頻繁建立和銷燬的物件，可以使用物件池技術來減少記憶體分配與釋放的開銷。
  9. 使用Q_UNUSED宏,對於那些不使用的變數，可以使用Q_UNUSED宏來避免編譯器警告，並告訴編譯器這個變數不會被使用，有助於最佳化程式碼。
    效能分析
    要最佳化應用程式的效能，首先需要知道哪些部分是效能瓶頸。QT提供了一些工具來幫助進行效能分析。
  10. QElapsedTimer,這個類可以用來測量程式碼塊執行所需的時間。
  11. QLoggingCategory,用於分類日誌資訊，可以幫助識別效能問題。
  12. QProfiler,這個工具可以幫助分析應用程式的執行時效能。
    透過上述技巧和經驗，QT開發者可以在實際的開發過程中，針對應用程式的需求進行最佳化，提高應用程式的效能和穩定性。這些高階技巧是在深入理解QT原始碼的基礎上積累的，對於提高QT開發水平具有重要意義。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

7 第七章_選單與工具欄

7.1 7_1_選單的建立與使用

7.1.1 7_1_選單的建立與使用

7_1_選單的建立與使用
7.1 選單的建立與使用
在QT中，選單是應用程式中常見的使用者介面元素，用於提供一系列的選項或命令。在QTWidgets模組中，可以透過QMenu類來建立和控制選單。本節將詳細介紹如何使用QTWidgets模組中的選單功能。
7.1.1 建立選單
要建立一個選單，首先需要一個選單欄（QMenuBar）或者選單按鈕（QMenuButton）。大多數情況下，我們會將選單欄新增到主視窗（QMainWindow）中。
cpp
__ 建立一個選單欄
QMenuBar *menuBar = new QMenuBar(this);
__ 建立一個選單
QMenu *fileMenu = new QMenu(檔案, this);
__ 將選單新增到選單欄中
menuBar->addMenu(fileMenu);
在建立了選單之後，可以透過新增動作（QAction）來填充選單項。每個選單項都是一個可執行的動作，可以關聯一個槽函式來響應使用者的點選事件。
cpp
__ 建立一個動作
QAction *openAction = new QAction(開啟, this);
__ 將動作新增到選單中
fileMenu->addAction(openAction);
在新增動作時，還可以設定動作的圖示，快捷鍵以及其他屬性。
7.1.2 使用選單
在建立了選單和選單項之後，當使用者點選這些選單項時，應當有一個相應的槽函式被呼叫。這通常是透過連線動作的訊號實現的。
cpp
__ 連線動作的觸發訊號到對應的槽函式
connect(openAction, &QAction::triggered, this, &MainWindow::openFile);
在槽函式中，可以編寫當使用者點選選單項時需要執行的程式碼。
cpp
void MainWindow::openFile()
{
__ 開啟檔案的程式碼
}
此外，QT還提供了一些特殊的選單項，如QMenu的addSeparator()方法用於在選單中新增分隔線，QMenu的addAction()方法可以用來新增更多的複雜動作，如子選單等。
7.1.3 動態建立選單
除了靜態建立選單外，還可以在程式執行時動態建立選單項。這可以透過繼承QMenu類並重寫其exec()方法來實現。
cpp
class DynamicMenu : public QMenu
{
public:
DynamicMenu(QWidget *parent = nullptr) : QMenu(parent) {}
void addItem(const QString &text)
{
__ 新增帶有指定文字的選單項
QAction *action = new QAction(text, this);
__ 連線動作的訊號到槽函式
connect(action, &QAction::triggered, this, &DynamicMenu::showMessage);
addAction(action);
}
protected:
void showMessage(bool checked)
{
__ 當選單項被點選時顯示訊息
QMessageBox::information(this, 資訊, 選單項被點選了！);
}
};
在主視窗中，可以像使用其他任何選單一樣使用這個動態建立的選單。
cpp
__ 建立動態選單物件
DynamicMenu *dynamicMenu = new DynamicMenu(this);
__ 動態新增選單項
dynamicMenu->addItem(動態選單項);
__ 在需要的地方顯示選單
dynamicMenu->popup(QCursor::pos());
使用以上程式碼，可以在執行時動態地建立選單項，並且透過點選這些選單項來執行特定的操作。
透過以上步驟，可以建立和使用了QTWidgets模組中的選單。在實際的應用程式中，根據需要可以建立複雜的多級選單，以及實現各種豐富的使用者互動功能。

7.2 7_2_工具欄的建立與使用

7.2.1 7_2_工具欄的建立與使用

7_2_工具欄的建立與使用
7.2 工具欄的建立與使用
工具欄（Toolbar）在QT應用程式中是非常常見的一個元件，它能夠以空間高效的方式提供一系列的按鈕，通常用於快速訪問常用的操作。在QT中，工具欄是基於QToolBar類實現的。
7.2.1 建立工具欄
要建立一個工具欄，首先需要包含必要的標頭檔案，並使用QToolBar類構造一個工具欄物件。建立工具欄的基本步驟如下,
cpp
include <QToolBar>
include <QPushButton>
__ ...
QToolBar *toolBar = new QToolBar(工具欄); __ 建立並設定工具欄的標題
在QT Creator中，還可以透過工具欄選單來快速建立工具欄。在選單欄中選擇工具 -> 建立工具欄，這將自動生成一個工具欄並插入到視窗中。
7.2.2 向工具欄新增工具按鈕
工具按鈕（Tool Button）是工具欄中最常見的控制元件，它通常用於觸發特定的命令。建立工具按鈕並向工具欄新增它們的過程如下,
cpp
__ 建立一個按鈕，並設定其圖示和文字
QPushButton *button = new QPushButton(QIcon(:_images_open.png), 開啟);
__ 將按鈕新增到工具欄中
toolBar->addWidget(button);
__ 如果按鈕需要連線一個槽函式，可以使用訊號槽機制連線
__ button->clicked().connect(this, &YourClass::openAction);
工具欄還支援新增其他型別的控制元件，如QAction、QLineEdit等。
7.2.3 工具欄的佈局與管理
工具欄提供了多種佈局選項，如Qt::Horizontal和Qt::Vertical，預設為水平佈局。可以透過設定工具欄的orientation屬性來更改其佈局方向,
cpp
toolBar->setOrientation(Qt::Vertical);
此外，工具欄可以被新增到任何父視窗或控制元件中，包括QMainWindow、QDockWidget等。例如，如果要將工具欄新增到主視窗中，可以這樣做,
cpp
QMainWindow *mainWindow = new QMainWindow();
QToolBar *toolBar = new QToolBar(工具欄);
mainWindow->addToolBar(toolBar);
7.2.4 工具欄的樣式定製
QT提供了豐富的樣式選項來定製工具欄的外觀。可以透過QSS（QT Style Sheets）來定義工具欄的樣式，或者使用工具欄的樣式列舉來設定。例如，要設定工具欄的字型大小和顏色，可以這樣做,
cpp
toolBar->setStyleSheet(QToolBar { font-size: 12px; color: green; });
7.2.5 工具欄的動效與動畫
QT工具欄支援多種動效和動畫，例如，可以透過設定工具欄的movable屬性為true，使工具欄可以移動到視窗的其他位置。此外，還可以透過animate()方法新增動畫效果。
7.2.6 實踐案例,建立一個帶有工具欄的文字編輯器
下面是一個簡單的例子，展示如何建立一個帶有工具欄的文字編輯器,
cpp
include <QApplication>
include <QMainWindow>
include <QTextEdit>
include <QToolBar>
include <QAction>
include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QMainWindow window;
QTextEdit *textEdit = new QTextEdit;
window.setCentralWidget(textEdit);
__ 建立並新增工具欄
QToolBar *toolBar = new QToolBar(工具欄);
window.addToolBar(toolBar);
__ 建立一個開啟檔案的按鈕，並新增到工具欄
QPushButton *openButton = new QPushButton(QIcon(:_images_open.png), 開啟);
toolBar->addWidget(openButton);
__ 設定工具欄的佈局方向
toolBar->setOrientation(Qt::Horizontal);
__ 設定工具欄的樣式
toolBar->setStyleSheet(QToolBar { font-size: 12px; color: green; });
window.show();
return app.exec();
}
在這個例子中，我們建立了一個主視窗和一個文字編輯器，並在其中新增了一個工具欄和一個按鈕，實現了開啟檔案的功能。
透過以上內容的學習，讀者應該能夠理解QT工具欄的基本概念、建立和使用方法，以及如何對工具欄進行樣式定製和動效設定。

7.3 7_3_選單與工具欄的整合

7.3.1 7_3_選單與工具欄的整合

7_3_選單與工具欄的整合
7.3 選單與工具欄的整合
在QT中，選單和工具欄是應用程式中常見的使用者介面元素，用於提供各種操作選項。QT Widgets模組提供了強大的API來方便地建立和整合選單與工具欄。
7.3.1 建立選單
在QT中，選單的建立通常是透過繼承QMenu類來實現的。你可以為不同的操作建立獨立的選單，也可以將它們組合成上下文選單（右鍵選單）。
cpp
__ 建立一個選單物件
QMenu *menu = new QMenu(this);
__ 新增選單項
QAction *action1 = new QAction(動作1, this);
QAction *action2 = new QAction(動作2, this);
__ 將動作新增到選單中
menu->addAction(action1);
menu->addAction(action2);
__ 設定選單的標題
menu->setTitle(我的選單);
在整合選單時，通常會將選單與某個控制元件的上下文選單關聯，例如，你可以為按鈕或表格檢視設定上下文選單。
cpp
__ 為按鈕設定上下文選單
QPushButton *button = new QPushButton(點選我, this);
button->setMenu(menu);
7.3.2 建立工具欄
QT提供了QToolBar類來建立工具欄。工具欄可以包含各種按鈕，這些按鈕通常用於快速訪問常用的操作。
cpp
__ 建立一個工具欄物件
QToolBar *toolBar = new QToolBar(this);
__ 新增工具欄按鈕
QAction *toolBarAction1 = new QAction(this);
QAction *toolBarAction2 = new QAction(this);
__ 將動作新增到工具欄中
toolBar->addAction(toolBarAction1);
toolBar->addAction(toolBarAction2);
__ 新增工具欄到主視窗
addToolBar(toolBar);
工具欄可以整合到應用程式的主視窗中，或者作為獨立的皮膚存在。你可以使用addToolBar方法將工具欄新增到QMainWindow或QWidget的主視窗區域。
7.3.3 選單與工具欄的整合
在QT中，選單和工具欄經常一起使用，以便在使用者介面中提供一致的操作選項。你可以將選單項與工具欄按鈕關聯起來，這樣使用者在點選按鈕或從選單中選擇項時，都會觸發相同的動作。
cpp
__ 建立一個動作並設定圖示和文字
QAction action = new QAction(QIcon(:_images_edit.png), 編輯, this);
__ 設定動作的快捷鍵
action->setShortcut(QKeySequence(Ctrl+E));
__ 新增動作到選單和工具欄
menu->addAction(action);
toolBar->addAction(action);
在上面的示例中，我們建立了一個動作（QAction）物件，並設定了圖示、文字和快捷鍵。然後，我們將這個動作新增到了選單和工具欄中。由於動作是訊號和槽機制的一部分，你可以連線動作的triggered訊號到相應的槽函式來執行操作。
7.3.4 自定義選單和工具欄
在QT中，你可以透過自定義選單和工具欄的樣式來改善使用者介面的外觀和感覺。使用QSS（QT Style Sheets）可以很容易地改變選單和工具欄的樣式。
qss
_ 自定義工具欄和選單的樣式 *_
QToolBar {
background-color: 333;
color: white;
}
QToolBar::handle {
background-color: 555;
}
QMenu {
background-color: 222;
color: white;
}
QMenu::item {
background-color: 111;
color: white;
}
QMenu::item:selected {
background-color: 444;
}
在上述QSS樣式中，我們改變了工具欄和選單的背景色、前景色以及選中項的背景色。這些樣式更改將增強應用程式的整體視覺效果。
總結起來，QT Widgets模組提供了豐富的API來建立和整合選單與工具欄。你可以建立獨立的選單和工具欄，將它們整合到主視窗中，並透過自定義樣式來改善使用者介面。透過整合選單和工具欄，你可以為應用程式提供一個一致和直觀的操作方式。

7.4 7_4_選單與工具欄的樣式與動畫

7.4.1 7_4_選單與工具欄的樣式與動畫

7_4_選單與工具欄的樣式與動畫
7.4 選單與工具欄的樣式與動畫
在Qt中，選單和工具欄是應用程式中常見的使用者介面元素，用於提供使用者與應用程式互動的方法。在《QT Widgets模組原始碼解析與技巧》這本書中，我們將深入探討如何使用Qt的選單和工具欄，並展示一些高階技巧。
7.4.1 選單的樣式
Qt提供了豐富的樣式來定製選單的外觀。你可以透過Qt的樣式系統來改變選單項的字型、顏色、圖示等。此外，你還可以使用QSS（Qt Style Sheets）來進一步自定義選單的樣式。
cpp
__ 設定選單項的字型和顏色
menu->setFont(QFont(Arial, 12));
menu->setStyleSheet(QMenu::item { color: blue; });
7.4.2 工具欄的樣式
與選單類似，工具欄的樣式也可以透過Qt的樣式系統進行定製。你可以改變工具欄的背景顏色、邊框樣式，甚至每個工具按鈕的圖示和文字樣式。
cpp
__ 設定工具欄的背景顏色和邊框樣式
toolBar->setStyleSheet(QToolBar { background-color: f0f0f0; border: 1px solid ccc; });
toolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
7.4.3 選單與工具欄的動畫
在Qt中，選單和工具欄的動畫可以透過QPropertyAnimation或QAbstractAnimation來實現。這些動畫可以用於建立平滑的彈出和關閉效果，或者在選單項之間進行切換。
cpp
__ 建立一個QPropertyAnimation物件
QPropertyAnimation *animation = new QPropertyAnimation(menu, windowOpacity);
animation->setDuration(500);
animation->setStartValue(1.0);
animation->setEndValue(0.0);
__ 播放動畫
animation->start();
在《QT Widgets模組原始碼解析與技巧》這本書中，我們將詳細介紹如何使用這些API來建立令人印象深刻的選單和工具欄效果。透過這些技巧，你將能夠為你的應用程式建立更加生動和使用者友好的介面。

7.5 7_5_實用技巧與經驗分享

7.5.1 7_5_實用技巧與經驗分享

7_5_實用技巧與經驗分享
7.5 實用技巧與經驗分享
在深入分析了QT Widgets模組的原始碼之後，作為QT高階工程師，我們積累了大量的實用技巧與經驗。在這一節中，我們將分享一些在實際專案開發中非常有用的技巧和方法。

  1. 使用元物件
    QT Widgets模組提供了豐富的元物件，如元物件系統（MOC），它可以幫助我們自動生成物件的元資訊。正確並高效地使用這些元物件，可以讓我們編寫出更加高效和易於維護的程式碼。
  • 元物件的好處,
    • 支援物件的內省（即在執行時獲取物件型別資訊）。
    • 增強物件的功能，如序列化和反射。
  • 如何高效使用,
    • 在設計類時，充分利用Q_OBJECT宏來宣告訊號和槽。
    • 利用物件序列化時，合理使用QDataStream。
  1. 自定義繪圖
    QT Widgets模組提供了豐富的繪圖能力，我們可以透過繼承QWidget或其子類來實現自定義的繪圖。
  • 自定義繪圖的優勢,
    • 可以建立出獨特的使用者介面效果。
    • 繪圖效能可以透過繪製策略進行最佳化。
  • 自定義繪圖的技巧,
    • 繼承正確的類,對於繪圖較為複雜的情況，可以繼承QGraphicsWidget。
    • 使用正確的繪圖上下文,瞭解QPainter的各種繪圖函式，以及如何正確地設定繪圖上下文。
  1. 效能最佳化
    在開發過程中，效能最佳化是一個永恆的話題。對於QT Widgets應用程式來說，效能最佳化尤為重要。
  • 效能最佳化的方向,
    • 減少繪製開銷,複用繪圖物件，合理使用快取。
    • 高效的事件處理,避免在主執行緒中處理耗時的操作。
  • 效能最佳化的技巧,
    • 對於列表檢視等頻繁更新的控制元件，使用虛擬化技術。
    • 使用QAbstractAnimation代替QPropertyAnimation，在某些情況下可以提高動畫效能。
  1. 訊號與槽機制的運用
    QT Widgets模組的訊號與槽機制是其核心特性之一，正確地使用這一機制可以使應用程式的互動更加靈活和高效。
  • 訊號與槽的優勢,
    • 提供了事件驅動的程式設計模型。
    • 支援物件之間的解耦。
  • 訊號與槽的技巧,
    • 避免在槽函式中執行耗時操作，保持UI的流暢。
    • 使用訊號連線來代替硬編碼的呼叫，提高程式碼的可維護性。
  1. 跨平臺開發的最佳實踐
    QT Widgets支援跨平臺開發，但是不同平臺間還是存在一些差異。在開發過程中，瞭解並遵循這些最佳實踐可以讓我們編寫出更加穩定和高效的程式碼。
  • 跨平臺開發的注意事項,
    • 平臺的GUI規範可能不同，需要適配。
    • 某些控制元件的繪製表現可能在不同平臺上有所不同。
  • 跨平臺開發的技巧,
    • 使用Q_PLATFORM_MACRO等宏來條件編譯不同平臺的程式碼。
    • 對於不確定的平臺行為，可以使用Q_UNLIKELY宏進行判斷。
      在本書的寫作過程中，我們不斷回顧和總結了這些實用的技巧與經驗。希望讀者在學習和實踐的過程中，能夠將這些技巧內化為自己的技能，從而在QT Widgets模組的開發中更加得心應手。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

免費QT影片課程 您可以看免費1000+個QT技術影片
免費QT影片課程 QT統計圖和QT資料視覺化影片免費看
免費QT影片課程 QT效能最佳化影片免費看
免費QT影片課程 QT介面美化影片免費看

8 第八章_對話方塊與狀態列

8.1 8_1_對話方塊的建立與使用

8.1.1 8_1_對話方塊的建立與使用

8_1_對話方塊的建立與使用
8.1 對話方塊的建立與使用
在QT應用程式開發中，對話方塊是一個非常重要的組成部分，它通常用於與使用者進行互動，比如提示資訊、獲取輸入或者選擇檔案等。QT提供了一系列預定義的對話方塊類，開發者可以直接使用或者基於這些類建立自定義對話方塊。

  1. 預定義對話方塊
    QT中的一些常用預定義對話方塊包括,
  • QMessageBox,用於顯示訊息對話方塊，可以用於警告、錯誤、資訊提示等。
  • QInputDialog,用於建立輸入對話方塊，可以讓使用者輸入文字或選擇列表項。
  • QColorDialog,用於選擇顏色。
  • QFileDialog,用於開啟檔案選擇對話方塊。
  • QFontDialog,用於選擇字型。
  1. 建立對話方塊
    在QT中建立對話方塊通常分為以下幾個步驟,
  2. 引入必要的標頭檔案。
  3. 建立對話方塊物件。
  4. 設定對話方塊的引數（如果需要）。
  5. 顯示對話方塊。
    下面以QMessageBox為例，展示如何建立和使用對話方塊。
    cpp
    include <QApplication>
    include <QMessageBox>
    include <QPushButton>
    int main(int argc, char *argv[])
    {
    QApplication a(argc, argv);
    QPushButton *button = new QPushButton(顯示訊息框);
    button->setGeometry(50, 50, 150, 30);
    __ 連線按鈕的點選訊號到顯示訊息框的槽函式
    QObject::connect(button, &QPushButton::clicked, & {
    QMessageBox::information(nullptr, 標題, 這是一個訊息框, QMessageBox::Ok);
    });
    button->show();
    return a.exec();
    }
    這段程式碼建立了一個簡單的應用程式，其中包含了一個按鈕和一段程式碼，當按鈕被點選時，會顯示一個包含資訊的對話方塊。
  6. 自定義對話方塊
    除了使用預定義的對話方塊外，QT也允許開發者建立自定義對話方塊。這通常涉及到建立一個繼承自QDialog的類，並在其中實現具體的使用者介面和邏輯。
    以下是一個自定義對話方塊的簡單示例,
    cpp
    include <QApplication>
    include <QDialog>
    include <QLabel>
    include <QPushButton>
    class CustomDialog : public QDialog
    {
    Q_OBJECT
    public:
    CustomDialog(QWidget *parent = nullptr) : QDialog(parent)
    {
    QLabel *label = new QLabel(這是一個自定義對話方塊, this);
    label->setGeometry(50, 50, 200, 20);
    QPushButton *okButton = new QPushButton(確定, this);
    okButton->setGeometry(100, 80, 75, 23);
    connect(okButton, &QPushButton::clicked, this, &CustomDialog::accept);
    }
    };
    int main(int argc, char *argv[])
    {
    QApplication a(argc, argv);
    CustomDialog d;
    if (d.exec() == QDialog::Accepted)
    {
    __ 使用者點選了確定按鈕
    }
    return a.exec();
    }
    在這個例子中，我們建立了一個簡單的自定義對話方塊，其中包含了一個標籤和一個確定按鈕。當使用者點選確定按鈕時，對話方塊會接受操作並關閉。
  7. 實踐技巧
  • 在設計對話方塊時，確保它們的功能清晰，不要讓使用者感到困惑。
  • 使用適當的對話方塊樣式和圖示，以提高使用者體驗。
  • 如果需要，可以透過繼承QDialog來自定義對話方塊的佈局和行為。
  • 在適當的時候使用模態對話方塊，以防止使用者在對話方塊顯示時進行其他操作。
    透過掌握對話方塊的建立與使用，開發者可以為應用程式提供更加直觀和友好的使用者介面。

8.2 8_2_狀態列的建立與使用

8.2.1 8_2_狀態列的建立與使用

8_2_狀態列的建立與使用
8.2 狀態列的建立與使用
在QT應用程式中，狀態列是一個非常重要的使用者介面元素，它通常位於視窗的底部，用於顯示程式的當前狀態或提供有關介面的附加資訊。在QT中，狀態列的實現是透過QStatusBar類來完成的。
8.2.1 狀態列的建立
要建立一個狀態列，首先需要包含必要的標頭檔案QStatusBar，然後透過呼叫QWidget的statusBar()方法或直接建立QStatusBar物件來獲取或建立狀態列。
cpp
include <QStatusBar>
__ ...
mainWindow->setStatusBar(new QStatusBar(mainWindow));
在上面的程式碼中，我們建立了一個QMainWindow物件mainWindow，並透過呼叫setStatusBar()方法為其新增了一個狀態列。
8.2.2 狀態列的使用
一旦狀態列被建立，我們就可以透過幾種不同的方式來使用它。最常見的方式是使用showMessage()方法來顯示一個簡短的訊息，這個方法會覆蓋狀態列中的任何現有訊息。
cpp
__ 顯示一個簡短的訊息
statusBar()->showMessage(這是一個狀態列訊息, timeout);
在這裡，timeout是一個整數，表示訊息持續顯示的時間（以毫秒為單位）。如果設定為QStatusBar::Infinite，則訊息將一直顯示，直到透過clearMessage()方法清除。
除了顯示文字訊息，我們還可以向狀態列新增自定義控制元件，比如進度條或標籤。這可以透過呼叫addPermanentWidget()或addWidget()方法來實現。
cpp
__ 新增一個永久性的控制元件到狀態列
statusBar()->addPermanentWidget(new QLabel(這是一個永久標籤), 1);
__ 新增一個臨時的控制元件到狀態列
QProgressBar *progressBar = new QProgressBar(mainWindow);
statusBar()->addWidget(progressBar);
在上面的程式碼中，我們建立了一個QLabel和一個QProgressBar，並將它們新增到了狀態列中。第一個引數是我們想要新增的控制元件，第二個引數是一個佈局引數，它決定了控制元件在狀態列中的位置。
8.2.3 狀態列與訊號槽
在QT中，狀態列也支援訊號和槽機制，這使得我們可以響應使用者的互動或其他事件，並更新狀態列的顯示。例如，我們可以連線一個按鈕的點選訊號到一個槽函式，該槽函式會更新狀態列的訊息。
cpp
connect(button, &QPushButton::clicked, this, &MainWindow::updateStatusBar);
void MainWindow::updateStatusBar()
{
statusBar()->showMessage(按鈕被點選了, 3000);
}
在這個例子中，我們使用connect()函式將按鈕的點選訊號連線到updateStatusBar()槽函式，當按鈕被點選時，狀態列會顯示一個訊息，持續時間為3000毫秒。
總結起來，狀態列是QT應用程式中一個非常重要的元件，它可以透過簡單的API進行建立和定製，同時支援訊號和槽機制，使得狀態列的更新和互動變得更加靈活和強大。在開發QT應用程式時，充分利用狀態列的功能可以大大提升使用者介面的友好性和資訊性。

8.3 8_3_對話方塊與狀態列的整合

8.3.1 8_3_對話方塊與狀態列的整合

8_3_對話方塊與狀態列的整合
8.3 對話方塊與狀態列的整合
在Qt應用程式中，對話方塊是使用者介面的重要組成部分，它們通常用於與使用者互動，獲取輸入或者顯示資訊。狀態列則用於顯示當前應用程式的狀態資訊。在許多應用程式中，狀態列與對話方塊緊密整合，以提供更好的使用者體驗。
在Qt中，對話方塊可以透過繼承QDialog或者QWidget來建立。狀態列可以透過呼叫setStatusBar方法來設定。在整合對話方塊與狀態列時，需要考慮以下幾個方面,

  1. 對話方塊的狀態列設定,建立對話方塊時，通常需要為其設定一個狀態列。這可以透過呼叫對話方塊的setStatusBar方法來完成。

  2. 狀態列資訊的更新,在對話方塊的操作中，可能需要根據使用者的操作更新狀態列的資訊。這可以透過狀態列的showMessage方法來實現。

  3. 對話方塊關閉時狀態列的處理,當對話方塊被關閉時，應該移除狀態列上顯示的訊息，以免使用者接收到過時的資訊。
    下面是一個簡單的示例，展示瞭如何在Qt中建立一個具有狀態列的對話方塊，並在其中更新狀態列資訊。
    cpp
    include <QDialog>
    include <QPushButton>
    include <QStatusBar>
    include <QVBoxLayout>
    class StatusDialog : public QDialog {
    Q_OBJECT
    public:
    StatusDialog(QWidget *parent = nullptr) : QDialog(parent) {
    __ 設定對話方塊的標題
    setWindowTitle(tr(狀態列對話方塊));
    __ 建立一個狀態列
    QStatusBar *statusBar = new QStatusBar(this);
    setStatusBar(statusBar); __ 設定對話方塊的狀態列
    __ 建立一個按鈕，用於更新狀態列資訊
    QPushButton *button = new QPushButton(tr(更新狀態列), this);

     __ 建立一個垂直佈局，將按鈕放入佈局中
 QVBoxLayout *layout = new QVBoxLayout(this);
 layout-&gt;addWidget(button);
 __ 連線按鈕的點選訊號到槽函式，用於更新狀態列資訊
 QObject::connect(button, &amp;QPushButton::clicked, [this]() {
     __ 更新狀態列資訊
     statusBar-&gt;showMessage(tr(狀態列資訊已更新));
 });
 __ 設定佈局
 setLayout(layout);

    }
    private slots:
    void onClose() {
    __ 關閉對話方塊時清除狀態列資訊
    statusBar->clearMessage();
    QDialog::onClose();
    }
    };
    在上面的程式碼中，我們建立了一個StatusDialog類，該類繼承自QDialog。在建構函式中，我們設定了對話方塊的標題，建立了一個狀態列，並將它設定給了對話方塊。然後，我們建立了一個按鈕，當使用者點選這個按鈕時，會觸發一個槽函式，該槽函式使用狀態列的showMessage方法來顯示一條訊息。最後，我們連線了對話方塊的關閉訊號到一個槽函式，當對話方塊關閉時，會清除狀態列上顯示的訊息。
    透過這樣的整合，我們可以確保使用者在操作對話方塊時能夠及時獲得反饋，同時當對話方塊關閉時，不會留下過時的狀態資訊。這是編寫高質量Qt應用程式時需要考慮的一個細節。

8.4 8_4_對話方塊與狀態列的樣式與動畫

8.4.1 8_4_對話方塊與狀態列的樣式與動畫

8_4_對話方塊與狀態列的樣式與動畫
8.4 對話方塊與狀態列的樣式與動畫
在QT中，對話方塊和狀態列是使用者介面的重要組成部分。它們不僅需要提供清晰的資訊展示，還需要在視覺上吸引使用者，從而提高使用者體驗。在這一節中，我們將深入探討如何透過樣式和動畫來定製對話方塊和狀態列，以實現更加豐富和動態的使用者介面。
8.4.1 對話方塊的樣式
對話方塊是QT中常見的視窗型別，用於與使用者進行互動。為了使對話方塊更具吸引力，我們可以透過自定義樣式來改變其外觀。

  1. 對話方塊的背景與邊框,
    對話方塊的背景可以使用樣式表中的background-color屬性進行更改。同時，透過CSS樣式，我們可以設定對話方塊的邊框樣式、顏色以及寬度。
  2. 對話方塊標題欄,
    標題欄通常包含對話方塊的標題和關閉按鈕。我們可以透過設定標題欄的背景色、文字顏色以及關閉按鈕的樣式來實現個性化設計。
  3. 對話方塊內容區域,
    內容區域是顯示對話方塊主要內容的地方。透過調整間距、字型樣式、顏色等，可以使內容區域更加清晰易讀。
  4. 對話方塊按鈕,
    對話方塊通常包含確定、取消等按鈕。我們可以自定義按鈕的字型、顏色、大小以及按下時的效果。
    8.4.2 狀態列的樣式
    狀態列用於顯示應用的當前狀態或提示資訊。透過自定義狀態列的樣式，我們可以使其更加直觀和吸引人。
  5. 狀態列背景與文字,
    狀態列的背景和文字顏色可以透過樣式表進行設定。通常，背景色會使用較淺的顏色，以便文字能夠清晰顯示。
  6. 狀態列圖示,
    狀態列中可能會用到圖示來表示狀態。我們可以透過改變圖示的顏色或者使用不同的圖示樣式來傳達不同的資訊。
  7. 狀態列分隔線,
    狀態列中如果有多個狀態資訊，通常會用分隔線進行分割。分隔線的樣式和顏色也是可以透過樣式表進行自定義的。
    8.4.3 對話方塊與狀態列的動畫
    動畫可以使對話方塊和狀態列更加生動有趣。在QT中，我們可以使用QPropertyAnimation或QAnimationGroup來實現動畫效果。
  8. 對話方塊彈出與消失動畫,
    當對話方塊出現或消失時，可以透過動畫來平滑地過渡。例如，我們可以讓對話方塊從頂部下滑進入，或者在關閉時漸隱出去。
  9. 狀態列提示動畫,
    當有新訊息提示時，狀態列可以透過彈跳或淡入的效果來吸引使用者注意。
  10. 按鈕點選動畫,
    對話方塊中的按鈕點選也可以新增動畫效果，比如按鈕按下時變形，或者有點選聲效等。
    在設計和實現這些樣式和動畫時，我們需要注意保持使用者介面的整體一致性和可用性。動畫效果過多或過於花哨可能會分散使用者的注意力，影響使用者體驗。因此，在實際應用中，應根據應用的特點和使用者需求來合理使用樣式和動畫。

8.5 8_5_實用技巧與經驗分享

8.5.1 8_5_實用技巧與經驗分享

8_5_實用技巧與經驗分享
8.5 實用技巧與經驗分享
在深入分析了QT Widgets模組的原始碼之後，作為QT高階工程師，我們將在本節分享一些實用的技巧和經驗，幫助讀者在開發過程中更加高效地使用QT Widgets，同時也會討論一些常見的陷阱和規避方法。

  1. 高效使用訊號與槽
    QT的核心特性之一是訊號與槽的機制，它是QT實現事件驅動程式設計的基礎。在開發過程中，我們應該充分利用這一機制來提高程式的響應性和靈活性。以下是一些經驗分享,
  • 避免不必要的槽函式,只在需要響應特定事件時設定槽函式，減少不必要的槽函式連線，這樣可以提高程式的效能。
  • 使用元物件系統,利用Q_OBJECT宏來宣告訊號和槽，這樣QT的元物件系統會自動為訊號和槽生成相應的元物件，便於管理和連線。
  • 訊號與槽的巢狀使用,在設計複雜的介面時，可以使用訊號巢狀來處理多個訊號的組合，增加程式的靈活性和可維護性。
  1. 最佳化繪圖效能
    在開發圖形使用者介面時，繪圖操作可能會成為效能的瓶頸。以下是一些最佳化繪圖效能的技巧,
  • 使用QPainter,對於複雜的繪圖操作，使用QPainter進行繪製可以顯著提高繪圖效能，因為它提供了更為底層的繪圖介面。
  • 繪圖上下文快取,對於頻繁變化的繪圖上下文（如畫刷、畫筆等），可以考慮使用物件快取來避免重複建立和銷燬。
  • 減少繪製次數,透過恰當的使用佈局策略和檢視重繪機制，減少不必要的繪製操作。
  1. 介面與邏輯分離
    為了保證程式碼的可維護性和可擴充套件性，我們應該遵循介面與邏輯分離的原則，將UI介面和業務邏輯程式碼分開。
  • 使用設計模式,如MVC（模型-檢視-控制器）模式，將介面與邏輯分離，這樣有助於程式碼的模組化和重用。
  • 利用元物件系統,透過繼承Q_OBJECT，可以自動為自定義的類生成元物件，便於在訊號與槽中使用。
  1. 常見陷阱與規避
    在QT開發過程中，有一些常見的陷阱需要我們注意，以下是一些典型的規避方法,
  • 避免在主執行緒中進行阻塞操作,如網路請求或者檔案操作，這些操作可能會導致主執行緒阻塞，影響介面響應。可以使用QThread等執行緒類來處理這些操作。
  • 正確使用定時器,QT提供了QTimer類來實現定時器功能，但是在使用時需要注意定時器的精確性和執行緒安全問題。
  • 管理記憶體洩漏,QT的元物件系統會自動管理物件的生命週期，但在使用自定義物件時，需要注意正確地釋放資源，避免記憶體洩漏。
    透過以上技巧和經驗的分享，相信讀者能夠在QT Widgets模組的開發中更加遊刃有餘，創造出效能卓越、使用者體驗良好的應用程式。在實踐中，經驗的積累是非常重要的，希望讀者能夠在實際專案中不斷嘗試、總結，最終成為QT領域的專家。

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

QT介面美化影片課程
QT效能最佳化影片課程
QT原理與原始碼分析影片課程
QT QML C++擴充套件開發影片課程

相關文章