Qt on 夜云泊

Qt 编译后的程序放到指定目录，屏蔽 qDebug 输出

Fri, 18 Mar 2022 13:50:35 +0000

可执行程序放到指定目录

默认情况下 QtCreator 会将编译链接后的可执行程序与中间生成的文件防盗build-***-文件中，如何能将可执行文件生成在指定目录？

修改.pro:

CONFIG(debug ,debug|release){
    DESTDIR = ../debug
}else{
    DESTDIR = ../release
}

debug版本放在../debug目录中，release版本放在../release目录中。

屏蔽 qDebug 输出

CONFIG(debug ,debug|release){
    DEFINES -= QT_NO_DEBUG_OUTPUT
}else{
    DEFINES += QT_NO_DEBUG_OUTPUT
}

QT_NO_DEBUG_OUTPUT即为屏蔽 qDebug 输出的宏定义，可以在debug版本中不屏蔽 qDebug 输出，release版本中屏蔽 qDebug 输出。

参考

QT 屏蔽 qDebug()、qWarning() 打印信息_qq_35173114 的博客-CSDN 博客_qwarning QT 的 QDebug 无法输出日志_amwha 的专栏 - 程序员宅基地_qdebug 打印不出来 - 程序员宅基地 Qt Creator 中的.pro 文件的详解_hebbely 的博客-CSDN 博客_qt 的 pro 文件

解决 Qt-QObject::connect: Cannot queue arguments of type‘QTextCursor’错误

Sat, 04 Dec 2021 11:41:46 +0000

保留现场

我在线程中直接调用了 QTextEdit 的 append 函数时，候就会出现下面的错误：

QObject::connect: Cannot queue arguments of type 'QTextCursor'
 
(Make sure 'QTextCursor' is registered using qRegisterMetaType().)

探究原因

原因是我们不能通过线程来修改 UI，较为安全的修改用户界面的方式是向 UI 窗口发送信号 (signal)，较为简单的方式是使用 Qt threading 类。

解决方法

在窗口类中定义信号和槽，并声明和实现一个接口函数，这个接口函数由线程调用，在接口函数中 emit 一个信号，示例代码如下：

//mainwindow.h
signals:
    void AppendText(const QString &text);
private slots:
    void SlotAppendText(const QString &text);
public:
  void Append(const QString &text);
//mainwindow.cpp
connect(this,SIGNAL(AppendText(QString)),this,SLOT(SlotAppendText(QString)));
void ClassName::Append(const QString &text)
{
    emit AppendText("ok: string1");
}
//thread.cpp
void ThreadClassName::SlotAppendText(const QString &text)
{
    mText.append(text);
}

Qt 跨窗口，控件类传递数据

Thu, 02 Dec 2021 10:35:14 +0000

问题简介

本文基于【Qt】窗体间传递数据（跨控件跨类），三种情况与处理方法

已知三个窗体，A 为 B C 的父控件，B 与 C 互为兄弟控件那么参数传递分三种情况：

B 向 A（C 向 A）传递参数
B 向 C（C 向 B）传递参数
A 向 B（A 向 C）传递参数

三个空间关系模型参考如下，

Responsive Image

B 向 A（C 向 A）传递参数

//B.h
class B
{
signals:
    void toA([ParamList]);
}

//B.cpp
B::B()
{
    emit toA([ParamList]);
}

//A.h
class A
{
private:
   B *b;
private slots:
   void fromB([ParamList]);
}

//A.cpp
A::A()
{
    b = new B;
    connect(b, SIGNAL(toA([ParamList])), this, SLOT(fromB([ParamList])));
}

void A::fromB([ParamList])
{
//get[ParamList]
}

B 向 C（C 向 B）传递参数

//A.h
{
private:
  B *b;
  C *c;
}

//A.cpp
A::A()
{
  b = new B;
  c = new C;
  connect(b, SIGNAL(toC([ParamList]), c, SLOT(fromB([ParamList])));
}

//B.h
class B
{
signals:
 void toC([ParamList]);
}

//B.cpp
B::B()
{
  emit toC([ParamList]);
}

//C.h
class C
{
private slots:
  void fromB([ParamList]);
}

//C.cpp
void C::fromB([ParamList])
{
//get[ParamList]
}

A 向 B（A 向 C）传递参数

//B.h
class B
{
public:
   void fromA([ParamList]);
} 

//B.cpp
void B::fromA([ParamList])
{
//get[ParamList]
}

//A.h
class A
{
private:
   B *b;
}

//A.cpp
A:A()
{
    b = new B;
    b->fromA([ParamList]);
}

Clang-Format 格式化代码

Wed, 01 Dec 2021 17:42:45 +0000

安装

Linux

sudo apt-get install clang-format

windows

每每到这时候就越能感受到用 Linux 作为开发环境的优势，Windows 安装就稍显复杂了。

你可以选择安装完整的 LLVM，在bin目录可以看到clang-format.exe。安装完后，将 bin 目录添加到环境变量中。
你也可以只下载clang-format.exe，从LLVM Snapshot Builds下载安装包。在下载页面的底部。同样你需要将单独下载的文件加入到环境变量中。

Responsive Image

使用

入门使用

Linux 可以直接命令行，使用以 LLVM 代码风格格式化main.cpp, 结果直接写到main.cpp

clang g-format -i main.cpp -style=LLVM

进阶配置

如果每次编码都命令行执行一遍那也太麻烦了，而且每次修改也不止一个文件。最好的方式就是每次保存文件时自动格式化。比如 VSCode 已经内置了Clang-Format稍作配置即可实现，接下来介绍几种常见 IDE 如何配置Clang-Format。

VSCode

VSCode 最常用，因为内置了Clang-Format也最容易配置。

安装C/C++插件，Ctrl+Shift+X打开应用商店，搜索C/C++找到下图插件，安装后会自动安装Clang-Format程序，无需单独下载。默认安装路径为： C:\Users\(你的用户名)\.vscode\extensions\ms-vscode.cpptools-1.7.1\LLVM\bin\clang-format.exe。 Responsive Image
打开设置页面（左下角齿轮 - 设置），搜索format，勾选Format On Save，每次保存文件时自动格式化文档。下方的设置是决定每次格式化是整个文档，还是做过修改的内容。默认是file，对整个文档进行格式化。 Responsive Image
仍在设置页面搜索Clang，配置如下。.clang-format文件最后详解。 Responsive Image
效果图 Responsive Image

QtCreator

安装Beautifier插件：帮助（Help）-关于插件（About Plugins）- Beautifier勾选，重启 QtCreator。 Responsive Image
工具（Tool）- Beautifier，配置如图。该配置，保存文档时自动格式化，并选择Clang-Format作为格式化工具。 Responsive Image

配置Clang-Format程序路径，如果开头已经apt install安装过，这里会自动补全。 Responsive Image
Use predefined style可以选择内置的一些代码风格，如LLVM，Google等。
Use customized style使用自定义的一些代码风格。点击添加（Add）将配置文件粘贴进去即可，具体配置文件见最后。
别忘了点击OK保存。

Eclipse

安装cppstyle插件：Help - Eclipse Marketplace - 搜索cppstyle。
下载cpplint。可以去github上下载cpplint的源码，下载完之后解压放到某个目录下。
在Window - Preferences - C/C++ - CppStyle页面把clang-format的路径添加进去，然后把cpplint的目录指向刚才下载的styleguide目录下的cpplint/cpplint.py就可以了。勾选下面的Enable cpplint，Run clang-format on file save，然后点击Apply and Close保存修改并退出。如下图所示。 Responsive Image
此时再保存代码，将会出现如下错误，因为我们还未给当前项目编写配置文件.clang-format。将最后一章提到的配置文件放到当前项目的下即可，程序会自动搜索。
```
Cannot find .clang-format or _clang-format configuration file under any level parent directories of path.
Clang-format will default to Google style.
```

配置简介

上文多次提到了.clang-format配置文件，该文件决定了代码如何格式化，现在来介绍如何使用该文件。

导出`.clang-format`文件

如果重新编写一份配置文件，需要考虑的东西太多，clang-format内置了一些常见风格，我们可以根据已有的配置文件稍作修改，形成自己的代码风格。所以我们先导出一份内置的配置文件。

clang-format -style=可选格式名 -dump-config > .clang-format
# 可选格式最好写预设那那几个写最接近你想要的格式。比如我想要接近 Google C++ style 的。我就写-style=google

各个选项的含义

这里给出了配置的含义，感兴趣也可以查看官方文档，还提供了一些有案例，描述更清晰。

一些比较明显的代码分格区别

# 括号是分行，还是不分行，只有当 BreakBeforeBraces 设置为 Custom 时才有效
BraceWrapping:
  AfterCaseLabel:  true
  # class 定义后面
  AfterClass:      true
  # 控制语句后面
  AfterControlStatement: true
  AfterEnum:       true
  AfterFunction:   true
  AfterNamespace:  true
  AfterObjCDeclaration: true
  AfterStruct:     true
  AfterUnion:      true
  AfterExternBlock: true
  BeforeCatch:     true
  BeforeElse:      true
  # 缩进大括号，if else 语句后面的括号缩进
  IndentBraces:    false
  SplitEmptyFunction: true
  SplitEmptyRecord: true
  SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom

# tab 宽度
TabWidth: 4

# 换行缩进字符数
IndentWidth:     4

# 宏定义对齐
AlignConsecutiveMacros: AcrossEmptyLinesAndComments

基于LLVM代码风格修改的个人使用版本：

---
Language:        Cpp
# BasedOnStyle:  LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
# 宏定义对齐
AlignConsecutiveMacros: AcrossEmptyLinesAndComments
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignConsecutiveBitFields: true
AlignEscapedNewlines: Right
AlignOperands:   true
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
# 是否允许短方法单行，只有一行的函数将不会分行，直接写在函数名后
AllowShortFunctionsOnASingleLine: false
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
# 括号是分行，还是不分行，只有当 BreakBeforeBraces 设置为 Custom 时才有效
BraceWrapping:
  AfterCaseLabel:  true
  # class 定义后面
  AfterClass:      true
  # 控制语句后面
  AfterControlStatement: true
  AfterEnum:       true
  AfterFunction:   true
  AfterNamespace:  true
  AfterObjCDeclaration: true
  AfterStruct:     true
  AfterUnion:      true
  AfterExternBlock: false
  BeforeCatch:     true
  BeforeElse:      true
  # 缩进大括号
  IndentBraces:    false
  SplitEmptyFunction: true
  SplitEmptyRecord: true
  SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit:     100
CommentPragmas:  '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat:   false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
  - foreach
  - Q_FOREACH
  - BOOST_FOREACH
IncludeBlocks:   Preserve
IncludeCategories:
  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
    Priority:        2
    SortPriority:    0
  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
    Priority:        3
    SortPriority:    0
  - Regex:           '.*'
    Priority:        1
    SortPriority:    0
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: false
IndentGotoLabels: true
IndentPPDirectives: None
# 换行缩进字符数
IndentWidth:     4
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd:   ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 0
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments:  true
SortIncludes:    true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles:  false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard:        Latest
StatementMacros:
  - Q_UNUSED
  - QT_REQUIRE_VERSION
TabWidth:        8
UseCRLF:         false
UseTab:          Never
...

格式化最新的commit代码

clang-format还提供一个clang-format-diff.py脚本，用来格式化patch，code review提交代码前，跑一遍下面的代码。

// 格式化最新的 commit，并直接在原文件上修改
git diff -U0 HEAD^ | clang-format-diff.py -i -p1

常见问题

如何看懂官方文档并编写配置文件

官方文档里有各种设置的示例代码，即使不知道想要的格式化是哪个配置参数，翻一翻官方文档是示例大概率能找到。那么找到了想要的配置参数，如何在文件里配置呢？

以宏定义对齐为例。我们想要宏定义的值保持对齐的状态，如下一节图片所示。可以翻一遍官方文档，可以发现这个示例代码对应的参数可能是我们想要的，AlignConsecutiveMacros翻译为对齐连续的宏定义。那应该八九不离十了。

Responsive Image

找到了参数如何编写配置文件呢？可以继续看这个参数下面的更多示例，每一个示例都对应一个配置可能值Possible values。

ACS_None (in configuration: None) Do not align macro definitions on consecutive lines. ACS_None为这个配置的缩写，None表示在配置文件里的值。该配置表示不对宏定义进行对齐操作，在配置文件里可以添加如下：
```
AlignConsecutiveMacros: None
```
ACS_Consecutive (in configuration: Consecutive) Align macro definitions on consecutive lines. This will result in formattings like:
```
#define SHORT_NAME       42
#define LONGER_NAME      0x007f
#define EVEN_LONGER_NAME (2)

#define foo(x) (x * x)
/* some comment */
#define bar(y, z) (y + z)
```
ACS_Consecutive为这个配置的缩写，Consecutive表示在配置文件里的值。该配置表示对连续的宏定义进行对齐，在配置文件里可以添加如下：
```
AlignConsecutiveMacros: Consecutive
```

宏定义对齐失效

# 宏定义对齐
AlignConsecutiveMacros: AcrossEmptyLinesAndComments

使用宏定义对齐更详细的配置，可以参考官方文档。使用该配置一定要使用等宽的字体，否则配置生效但是显示不正确。比如我是用微软雅黑字体作为编码字体，因为该字体每个字符不等宽，导致格式化正确，但是显示不正确。

Responsive Image

如果将字体换位等宽字体如常用的Consolas，就可以正常显示。

Responsive Image

解决 QT 点击按钮无响应

Tue, 16 Nov 2021 17:42:47 +0000

保留现场

在运行中的界面上点击按钮没有效果，像是按钮上层有其他遮盖层。

探究原因

widget的父控件上又添加了其他Widget，覆盖在了按钮上，因此无法点击。通过new得到的控件，默认显示在比它new的早的控件上面。

解决方法

// 将有按钮的那一层widget置于上层
widget->raise();

解决 QT 在构造函数中写的控件不显示的问题

Tue, 16 Nov 2021 16:15:26 +0000

保留现场

在新窗口中的构造函数中添加控件运行后却没有显示

探究原因

新建的工程师 MainWindow 子类工程，没有设置父窗口。
没有将控件的父窗口设置成自己定义的 widget。

#include<QMainWindow>
 
QMainWindow::QMainWindow(QMainWindow*parent) :
    QMainWindow(parent),
    ui(new Ui::QMainWindow)
{
     ui->setupUi(this);
     QPushButton* button_1 = new QPushButton("add");
     QPushButton* button_1 = new QPushButton("del");
}

解决方法

方法 1：给按钮控件设置父窗口：QWidget，并且把按钮添加到父窗口中。

#include<QMainWindow>
#include<QPushButton>
#include<QHBoxLayout>
 
QMainWindow::QMainWindow(QMainWindow*parent) :
    QMainWindow(parent),
    ui(new Ui::QMainWindow)
{
     ui->setupUi(this);
     QWidget* w = new QWidget();
     this->setCentralWidget(w);
     QHBoxLayout* hLayout = new QHBoxLayout();
     QPushButton* button_1 = new QPushButton("add");
     QPushButton* button_1 = new QPushButton("del");
     hLayout->addWidget(button_1);
     hLayout->addWidget(button_2);
     w->setLayout(hLayout);
}

方法 2：手动指定父窗口

#include<QMainWindow>
#include<QPushButton>
#include<QHBoxLayout>
 
QMainWindow::QMainWindow(QMainWindow*parent) :
    QMainWindow(parent),
    ui(new Ui::QMainWindow)
{
     ui->setupUi(this);
    
    
     QPushButton* button_1 = new QPushButton("add");
     QPushButton* button_1 = new QPushButton("del");
     button_1->setParent(this);
     button_2->setParent(this);
     button_2->move(300,100);
    
}

QWidget 中 update 不执行 paintEvent

Mon, 15 Nov 2021 18:04:50 +0000

保留现场

手动执行update()或者repaint()都不能执行paintEvent函数。

探究原因

如果是代码new出来的控件，检查是否正确显示，比如有没有加入到layout中。或者有没有设置父窗口（可能被其他空间遮挡）。

检查控件width或者height大小是否不为 0。如果为 0，也不会出出发paintEvent。

解决方法

参考 QT 在构造函数中写的控件不显示

QtCreator 快速添加注释模板

Tue, 28 Sep 2021 19:26:03 +0000

需求

通常函数的注释一般都比较长，而且每个函数注释都格式一致，例如下面的函数注释模板。如果每次写注释都要复制一遍比较麻烦，复制完还要删除多余的字符。但是现有的编辑器一般都支持快捷输入。下面介绍在 QtCreator 中如何快捷输入注释模板。

/* 
 * Description:      // 函数功能、性能等的描述  
 * Input Parameter:  // 输入参数说明，包括每个参数的作 
 * Output Parameter: // 对输出参数的说明。 
 * Return:           // 函数返回值的说明 
 */

方法

QtCreator-菜单栏工具（Tool）- 选项（Options）- 文本编辑器（Text Editor）- 片段（Snippets）
组（Group）选择C++-添加（Add） Responsive Image
现在要为我们的触发（Trigger）起个名字，因为是函数注释，我起了个funcom，然后在下方空白框里填入注释模板。Apply 保存。如图 Responsive Image
在需要添加注释模板的地方输入funcom即可提示快捷输入，回车即可添加注释模板。 Responsive Image

我们可以看到片段里有很多熟悉的内容，比如if else，我们在写代码时输入if else自动补全花括号其实就是在这里设置的。同理，我们还可以设置一些其他需要的快捷输入内容。比如行注释，文件注释，经常使用的代码框架等等。

Qt 修改 UI 文件不生效

Sun, 26 Sep 2021 09:19:18 +0000

保留现场

修改了 UI 文件后，在代码中无法调用新增的内容。

探究原因

导致ui_*.h文件没有更新的原因是源代码中#include ui_*.h的位置和实际生成的位置不同，引用的是老的ui_*.h

解决方法

方法一：

项目设置文件.pro内增加 UI_DIR=./UI，同时删除掉源代码目录中ui_*.h，clear all,->qmake->rebuilt all 方法二：

Responsive Image

QtCreator 修改项目构建目录

Sat, 25 Sep 2021 19:17:46 +0000

保留现场

QtCreator 构建项目时，会在统计目录新建一个build-xxx-debug的目录，如果想要自己修改这个目录的位置，名称，该怎么办。

解决方法

仅修改工具（Tool）–>选项 (Options)–>构建和运行 (Build&Run) 中Default build directory：./%{CurrentBuild:Name}是不会生效的。

将工具–>选项–>构建和运行中Default build directory修改为./%{CurrentBuild:Name}（改为你想要的目标目录都行）；
把 QtCreator 关闭，把工程目录下后缀名为.pro.user的文件删掉；
用 QtCreator 打开工程，会提示你创建构建目录，此时提示的就是你修改后的Default build directory中填写的目录；

其中.pro.user文件记录了编译器、构建工具链、构建目录、版本…..等工程编译相关信息，想要更换项目的编译环境，得删除这个文件，由 QtCreator 自动重新创建。

Qt 命令行带参数启动 Qt 程序

Mon, 13 Sep 2021 12:03:44 +0000

简介

我们经常用到命令行参数，比如最常见的 Linux 命令，显示所有文件ls -a,ls其实就是一个程序，-a就是该程序需要解析的一个参数。那么如何能让 Qt 程序也能解析命令行参数，从命令行启动呢？

Qt 从 5.2 版开始提供了两个类QCommandLineOption和QCommandLineParser来解析应用的命令行参数。

添加程序属性信息，帮助，版本

一个程序启动后，我们会在命令行看到程序的一些简要信息，以及可以使用-v命令显示其版本信息，这些通用的参数以及被 Qt 分装好，可以直接使用。

#include "mainwindow.h"

#include <QApplication>
#include <QCommandLineParser>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QCommandLineParser parser;                        // 定义解析实例
    parser.setApplicationDescription("TestCommandLine");  // 描述可执行程序的属性
    parser.addHelpOption();                           // 添加帮助命令
    parser.addVersionOption();                        // 添加版本选择命令
    parser.process(a);                                // 把用户的命令行的放入解析实例
    MainWindow w;
    w.show();
    return a.exec();
}

运行结果：

➜ ./CommandLine -h
Usage: ./CommandLine [options]
TestCommandLine

Options:
  -h, --help     Displays help on commandline options.
  --help-all     Displays help including Qt specific options.
  -v, --version  Displays version information.

自定义参数

#include "mainwindow.h"
#include <QApplication>
#include <QCommandLineParser>
#include <QCommandLineOption>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QCommandLineParser parser;                        // 定义解析实例
    parser.setApplicationDescription("TestCommandLine");  // 描述可执行程序的属性
    parser.addHelpOption();                           // 添加帮助命令
    parser.addVersionOption();                        // 添加版本选择命令

    QCommandLineOption  CommandExe("c", QGuiApplication::translate("main","Take  the  first  argument  as a command to execute, "
                                                          "rather than reading commands from a script or standard input.  "
                                                          "If  any  fur‐\ther  arguments  are  given,  "
                                                          "the  first  one is assigned to $0,"
                                                          " rather than being used as a positional parameter."));

    parser.addOption(CommandExe);
    parser.process(a);                                // 把用户的命令行的放入解析实例
    MainWindow w;
    w.show();
    return a.exec();
}

运行结果：

➜ ./CommandLine -h
Usage: ./CommandLine [options]
TestCommandLine

Options:
  -h, --help     Displays help on commandline options.
  --help-all     Displays help including Qt specific options.
  -v, --version  Displays version information.
  -c             Take  the  first  argument  as a command to execute, rather
                 than reading commands from a script or standard input.  If  any
                 fur‐ her  arguments  are  given,  the  first  one is assigned
                 to $0, rather than being used as a positional parameter.

获取参数值

如果需要从命令行获取参数值，那么必须要给参数值，指定一个名字。如，参数接收的是路径，可以setValueName("path")，如，参数接收的是个数值，可以setValueName("value")。

如果不设置参数值名称，那么将无法获取其值。

Qt 文件系统

Tue, 31 Aug 2021 20:00:06 +0000

Qt 通过QIODevice提供了对 I/O 设备的抽象，这些设备具有读写字节块的能力。下面是 I/O 设备的类图：

Responsive Image

图中所涉及的类及其用途简要说明如下：

QIODevice：所有I/O设备类的父类，提供了字节块读写的通用操作以及基本接口； QFlie：访问本地文件或者嵌入资源； QTemporaryFile：创建和访问本地文件系统的临时文件； QBuffer：读写QByteArray； QProcess：运行外部程序，处理进程间通讯； QAbstractSocket：所有套接字类的父类； QTcpSocket：TCP协议网络数据传输； QUdpSocket：传输 UDP 报文； QSslSocket：使用 SSL/TLS 传输数据； QFileDevice：Qt5 新增加的类，提供了有关文件操作的通用实现。

QFile 及其相关类

我们通常会将文件路径作为参数传给QFile的构造函数。不过也可以在创建好对象最后，使用setFileName()来修改。QFile需要使用/作为文件分隔符，不过，它会自动将其转换成操作系统所需要的形式。例如C:/windows这样的路径在 Windows 平台下同样是可以的。

QFile主要提供了有关文件的各种操作，比如打开文件、关闭文件、刷新文件等。我们可以使用QDataStream或QTextStream类来读写文件，也可以使用QIODevice类提供的read()、readLine()、readAll()以及write()这样的函数。值得注意的是，有关文件本身的信息，比如文件名、文件所在目录的名字等，则是通过QFileInfo获取，而不是自己分析文件路径字符串。

在这段代码中，我们首先使用QFile创建了一个文件对象。这个文件名字是 test.txt。只要将这个文件放在同执行路径一致的目录下即可。可以使用QDir::currentPath()来获得应用程序执行时的当前路径。只要将这个文件放在与当前路径一致的目录下即可。然后，我们使用open()函数打开这个文件，打开形式是只读方式，文本格式。这个类似于fopen()的 r 这样的参数。open()函数返回一个 bool 类型，如果打开失败，我们在控制台输出一段提示然后程序退出。否则，我们利用 while 循环，将每一行读到的内容输出。

#include <QWidget>
#include <QApplication>
#include <QDebug>
#include <QFile>
#include <QFileInfo>
#include <QMainWindow>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QFile file("test.txt");
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        qDebug() << "Open file failed.";
        return -1;
    }
    else
    {
        while (!file.atEnd())
        {
            qDebug() << file.readLine();
        }
    }
    QFileInfo info(file);
    qDebug() << info.isDir();            //false
    qDebug() << info.isExecutable();     //false
    qDebug() << info.baseName();         //test
    qDebug() << info.completeBaseName(); //test.txt
    qDebug() << info.suffix();           //txt
    qDebug() << info.completeSuffix();   //txt

    QFileInfo fi("/tmp/archive.tar.gz");
    QString base = fi.baseName();          // base = "archive"
    QString cbase = fi.completeBaseName(); // base = "archive.tar"
    QString ext = fi.suffix();             // ext = "gz"
    QString ext = fi.completeSuffix();     // ext = "tar.gz"
    return app.exec();
}

二进制文件读写

本节，我们将学习QDataStream的使用以及一些技巧。

QDataStream提供了基于QIODevice的二进制数据的序列化。数据流是一种二进制流，这种流完全不依赖于底层操作系统、CPU 或者字节顺序（大端或小端）。例如，在安装了 Windows 平台的 PC 上面写入的一个数据流，可以不经过任何处理，直接拿到运行了 Solaris 的 SPARC 机器上读取。由于数据流就是二进制流，因此我们也可以直接读写没有编码的二进制数据，例如图像、视频、音频等。

QDataStream既能够存取 C++ 基本类型，如 int、char、short 等，也可以存取复杂的数据类型，例如自定义的类。实际上，QDataStream对于类的存储，是将复杂的类分割为很多基本单元实现的。

结合QIODevice，QDataStream可以很方便地对文件、网络套接字等进行读写操作。

QFile file("file.dat");
file.open(QIODevice::WriteOnly);
QDataStream out(&file);
out << QString("the answer is");
out << (qint32)42;

在这段代码中，我们首先打开一个名为 file.dat 的文件（注意，我们为简单起见，并没有检查文件打开是否成功，这在正式程序中是不允许的）。然后，我们将刚刚创建的file对象的指针传递给一个QDataStream实例out。类似于std::cout标准输出流，QDataStream也重载了输出重定向«运算符。后面的代码就很简单了：将“the answer is”和数字42输出到数据流（如果你不明白这句话的意思，这可是宇宙终极问题的答案，请自行搜索《银河系漫游指南》）。由于我们的 out 对象建立在file之上，因此相当于将宇宙终极问题的答案写入file。

需要指出一点：最好使用Qt整型来进行读写，比如程序中的qint32。这保证了在任意平台和任意编译器都能够有相同的行为。

我们通过一个例子来看看 Qt 是如何存储数据的。例如char *字符串，在存储时，会首先存储该字符串包括\0结束符的长度（32位整型），然后是字符串的内容以及结束符\0。在读取时，先以32位整型读出整个的长度，然后按照这个长度取出整个字符串的内容。

但是，如果你直接运行这段代码，你会得到一个空白的 file.dat，并没有写入任何数据。这是因为我们的file没有正常关闭。为性能起见，数据只有在文件关闭时才会真正写入。因此，我们必须在最后添加一行代码：

file.close(); // 如果不想关闭文件，可以使用 file.flush();

重新运行一下程序，你就得到宇宙终极问题的答案了。

我们已经获得宇宙终极问题的答案了，下面，我们要将这个答案读取出来：

QFile file("file.dat");
file.open(QIODevice::ReadOnly);
QDataStream in(&file);
QString str;
qint32 a;
in >> str >> a;

这段代码没什么好说的。唯一需要注意的是，你必须按照写入的顺序，将数据读取出来。也就是说，程序数据写入的顺序必须预先定义好。在这个例子中，我们首先写入字符串，然后写入数字，那么就首先读出来的就是字符串，然后才是数字。顺序颠倒的话，程序行为是不确定的，严重时会直接造成程序崩溃。

由于二进制流是纯粹的字节数据，带来的问题是，如果程序不同版本之间按照不同的方式读取（前面说过，Qt 保证读写内容的一致，但是并不能保证不同 Qt 版本之间的一致），数据就会出现错误。因此，我们必须提供一种机制来确保不同版本之间的一致性。通常，我们会使用如下的代码写入：

QFile file("file.dat");
file.open(QIODevice::WriteOnly);
QDataStream out(&file);

// 写入魔术数字和版本
out << (quint32)0xA0B0C0D0;
out << (qint32)123;

out.setVersion(QDataStream::Qt_4_0);

// 写入数据
out << lots_of_interesting_data;

所谓魔术数字，是二进制输出中经常使用的一种技术。二进制格式是人不可读的，并且通常具有相同的后缀名（比如 dat 之类），因此我们没有办法区分两个二进制文件哪个是合法的。所以，我们定义的二进制格式通常具有一个魔术数字，用于标识文件的合法性。在本例中，我们在文件最开始写入 0xA0B0C0D0，在读取的时候首先检查这个数字是不是 0xA0B0C0D0。如果不是的话，说明这个文件不是可识别格式，因此根本不需要去继续读取。一般二进制文件都会有这么一个魔术数字，例如 Java 的 class 文件的魔术数字就是 0xCAFEBABE，使用二进制查看器就可以查看。魔术数字是一个 32 位的无符号整型，因此我们使用quint32来得到一个平台无关的 32 位无符号整型。

out << (qint32)123是标识文件的版本。我们用魔术数字标识文件的类型，从而判断文件是不是合法的。但是，文件的不同版本之间也可能存在差异：我们可能在第一版保存整型，第二版可能保存字符串。为了标识不同的版本，我们只能将版本写入文件。比如，现在我们的版本是 123。

out.setVersion(QDataStream::Qt_4_0)上面一句是文件的版本号，但是，Qt不同版本之间的读取方式可能也不一样。这样，我们就得指定Qt 按照哪个版本去读。这里，我们指定以Qt 4.0 格式去读取内容。

当我们这样写入文件之后，我们在读取的时候就需要增加一系列的判断：

QFile file("file.dat");
file.open(QIODevice::ReadOnly);
QDataStream in(&file);

// 检查魔术数字
quint32 magic;
in >> magic;
if (magic != 0xA0B0C0D0) 
{
    return BAD_FILE_FORMAT;
}

// 检查版本
qint32 version;
in >> version;
if (version < 100) {
    return BAD_FILE_TOO_OLD;
}
if (version > 123) {
    return BAD_FILE_TOO_NEW;
}

if (version <= 110) {
    in.setVersion(QDataStream::Qt_3_2);
} else {
    in.setVersion(QDataStream::Qt_4_0);
}

// 读取数据
in >> lots_of_interesting_data;
if (version >= 120) {
    in >> data_new_in_version_1_2;
}
in >> other_interesting_data;

我们通过下面一段代码看看什么是流的形式：

QFile file("file.dat");
file.open(QIODevice::ReadWrite);

QDataStream stream(&file);
QString str = "the answer is 42";
QString strout;

stream << str;
file.flush();
stream >> strout;

在这段代码中，我们首先向文件中写入数据，紧接着把数据读出来。有什么问题吗？运行之后你会发现，strout实际是空的。为什么没有读取出来？我们不是已经添加了file.flush();语句吗？原因并不在于文件有没有写入，而是在于我们使用的是“流”。所谓流，就像水流一样，它的游标会随着输出向后移动。当使用<<操作符输出之后，流的游标已经到了最后，此时你再去读，当然什么也读不到了。所以你需要在输出之后重新把游标设置为0的位置才能够继续读取。具体代码片段如下：

stream << str;
stream.device()->seek(0);
stream >> strout;

文本文件读写

Qt 绘制系统

Fri, 27 Aug 2021 14:39:12 +0000

本篇文章所涉及代码可在此处查看。

绘制系统简介

Qt 的绘图系统允许使用相同的 API 在屏幕和其它打印设备上进行绘制。整个绘图系统基于QPainter,QPainterDevice和QPaintEngine三个类。

QPainter用来执行绘制的操作；QPaintDevice是一个二维空间的抽象，这个二维空间允许QPainter在其上面进行绘制，也就是QPainter工作的空间；QPaintEngine提供了画笔（QPainter）在不同的设备上进行绘制的统一的接口。QPaintEngine类应用于QPainter和QPaintDevice之间，通常对开发人员是透明的。

三个类的关系：QPainter->QPaintEngine->QPaintDevice。通过这个关系我们也可以知道，QPainter通过QPaintEngine翻译指令在QPaintDevice上绘制。

通过一个实例来了解一下绘制系统的，

//main.h
#include <QPainter>
#include <QWidget>
#include <QPaintEvent>
#include <QApplication>
#include <QMainWindow>

class PaintedWidget : public QWidget
{
    Q_OBJECT
public:
    PaintedWidget(QWidget *parent = 0);

protected:
    void paintEvent(QPaintEvent *);
};

//main.cpp
#include "paintwidget.h"

PaintedWidget::PaintedWidget(QWidget *parent) : QWidget(parent)
{
    resize(800, 600);
    setWindowTitle(tr("Paint Demo"));
}

void PaintedWidget::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.drawLine(20, 20, 700, 20);
    painter.setPen(Qt::red);
    painter.drawRect(10, 10, 100, 400);
    painter.setPen(QPen(Qt::green, 5));
    painter.setBrush(Qt::blue);
    painter.drawEllipse(0, 0, 300, 40);
    // painter.drawRect(120, 50, 50, 400);

}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    PaintedWidget paintMap;
    paintMap.show();
    return app.exec();
}

Responsive Image

在构造函数中，我们仅仅设置了窗口的大小和标题。而paintEvent()函数则是绘制的代码。

首先，我们在栈上创建了一个QPainter对象，也就是说，每次运行paintEvent()函数的时候，都会重建这个QPainter对象。注意，这一点可能会引发某些细节问题：由于我们每次重建QPainter，因此第一次运行时所设置的画笔颜色、状态等，第二次再进入这个函数时就会全部丢失。有时候我们希望保存画笔状态，就必须自己保存数据，否则的话则需要将QPainter作为类的成员变量。

paintEvent()作为重绘函数，会在需要重绘时由 Qt 自动调用。“需要重绘”可能发生在很多地方，比如组件刚刚创建出来的时候就需要重绘；组件最大化、最小化的时候也需要重新绘制；组件由遮挡变成完全显示的时候也需要等等。

QPainter接收一个QPaintDevice指针作为参数。QPaintDevice有很多子类，比如QImage，以及QWidget。注意回忆一下，QPaintDevice可以理解成要在哪里去绘制，而现在我们希望画在这个组件，因此传入的是 this 指针。

我们还需要注意绘制的顺序，直线-矩形 - 椭圆，所以直线位于最下方，以此类推。

如果了解 OpenGL，肯定听说过这么一句话：OpenGL 是一个状态机。所谓状态机，就是说，OpenGL 保存的只是各种状态。比如，将画笔颜色设置成红色，那么，除非你重新设置另外的颜色，它的颜色会一直是红色。QPainter也是这样，它的状态不会自己恢复，除非你使用了各种设置函数。因此，如果在上面的代码中，我们在椭圆绘制之后再画一个矩形，它的样式还会是绿色5像素的轮廓线以及蓝色的填充，除非你显式地调用了设置函数进行状态的更新。

Responsive Image

这是大多数绘图系统的实现方式，包括 OpenGL、QPainter以及 Java2D。正因为QPainter是一个状态机，才会引出我们前面曾经介绍过的一个细节问题：由于paintEvent()是需要重复进入的，因此，需要注意第二次进入时，QPainter的状态是不是和第一次一致，否则的话可能会造成闪烁的现象。这个闪烁并不是由于双缓冲的问题，而是由于绘制状态的快速切换。

画刷和画笔

画刷和画笔。前者使用QBrush描述，大多用于填充；后者使用QPen描述，大多用于绘制轮廓线。

//main.cpp
void PaintedWidget::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.drawLine(20, 20, 700, 20);
    painter.setPen(Qt::red);
    painter.drawRect(10, 10, 100, 400);
    painter.setPen(QPen(Qt::green, 5));
    painter.setBrush(Qt::blue);
    painter.drawEllipse(0, 0, 300, 40);
    painter.drawRect(120, 50, 50, 400);
    ///////////////////画笔与笔刷
    QLinearGradient gradient(QPointF(180, 50), QPointF(230, 400));
    gradient.setColorAt(0, Qt::black);
    gradient.setColorAt(1, Qt::red);
    gradient.setSpread(QGradient::PadSpread);

    QBrush brush(gradient);

    QPen pen(Qt::green, 3, Qt::DashDotLine, Qt::RoundCap, Qt::RoundJoin);
    // painter.setPen(pen);
    painter.setBrush(brush);
    painter.drawRect(180, 50, 50, 400);
}

Responsive Image

画刷的style()定义了填充的样式，使用Qt::BrushStyle枚举，默认值是Qt::NoBrush，也就是不进行任何填充。我们可以从下面的图示中看到各种填充样式的区别：

Responsive Image

画刷的gradient()定义了渐变填充。这个属性只有在样式是Qt::LinearGradientPattern、Qt::RadialGradientPattern或者Qt::ConicalGradientPattern之一时才有效。渐变可以由QGradient对象表示。Qt 提供了三种渐变：QLinearGradient、QConicalGradient和QRadialGradient，它们都是QGradient的子类。

本文以QLinearGradient为例，两个坐标分别为起点与重点坐标。setColorAt设置渐变颜色，0表示开始，1表示结束。意思就是从黑色渐变到红色。setSpread设置显示方式为平铺。

QLinearGradient gradient(QPointF(180, 50), QPointF(230, 400));
gradient.setColorAt(0, Qt::black);
gradient.setColorAt(1, Qt::red);
gradient.setSpread(QGradient::PadSpread);

默认的画笔属性是纯黑色，0 像素，方形笔帽（Qt::SquareCap），斜面型连接（Qt::BevelJoin）。

画笔样式有一下几种， Responsive Image

你也可以使用setDashPattern()函数自定义样式，例如如下代码片段：

QVector<qreal> dashes;
qreal space = 4;

dashes << 1 << space << 3 << space << 9 << space
        << 27 << space << 9 << space;
pen.setColor(Qt::black);
pen.setDashPattern(dashes);
painter.setPen(pen);
painter.drawLine(30, 300, 600, 30);

Responsive Image

pen.setCapStyle(Qt::RoundCap)笔帽定义了画笔末端的样式，例如：

Responsive Image

pen.setJoinStyle(Qt::RoundJoin)连接样式定义了两条线连接时的样式，例如：

Responsive Image

反走样

我们在光栅图形显示器上绘制非水平、非垂直的直线或多边形边界时，或多或少会呈现锯齿状外观。这是因为直线和多边形的边界是连续的，而光栅则是由离散的点组成。在光栅显示设备上表现直线、多边形等，必须在离散位置采样。由于采样不充分重建后造成的信息失真，就叫走样；用于减少或消除这种效果的技术，就称为反走样。也就是常说的防锯齿现象。因为性能方面的考虑，Qt 默认关闭反走样。

void paintEvent(QPaintEvent *)
{
    ///////////////////对比反走样效果
    QPainter painter(this);
    painter.setPen(QPen(Qt::black, 5, Qt::DashDotLine, Qt::RoundCap));
    painter.setBrush(Qt::yellow);
    painter.drawEllipse(550, 150, 200, 150);

    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setPen(QPen(Qt::black, 5, Qt::DashDotLine, Qt::RoundCap));
    painter.setBrush(Qt::yellow);
    painter.drawEllipse(300, 150, 200, 150);
}

Responsive Image

我们可以明显观察到右边的椭圆轮廓是有锯齿现象的，这两个椭圆除了位置位置不同，唯一的区别就是右边的开启了反锯齿。

painter.setRenderHint(QPainter::Antialiasing, true);

虽然反走样比不反走样的图像质量高很多，但是，没有反走样的图形绘制还是有很大用处的。首先，就像前面说的一样，在一些对图像质量要求不高的环境下，或者说性能受限的环境下，比如嵌入式和手机环境，一般是不进行反走样的。另外，在一些必须精确操作像素的应用中，也是不能进行反走样的。

坐标系统

在 Qt 的坐标系统中，每个像素占据 1x1 的空间。你可以把它想象成一张方格纸，每个小格都是 1 个像素。方格的焦点定义了坐标，也就是说，像素 (x, y) 的中心位置其实是在(x + 0.5, y + 0.5)的位置上。这个坐标系统实际上是一个“半像素坐标系”。我们可以通过下面的示意图来理解这种坐标系：

Responsive Image

我们使用一个像素的画笔进行绘制，可以看到，每一个绘制像素都是以坐标点为中心的矩形。注意，这是坐标的逻辑表示，实际绘制则与此不同。因为在实际设备上，像素是最小单位，我们不能像上面一样，在两个像素之间进行绘制。所以在实际绘制时，Qt 的定义是，绘制点所在像素是逻辑定义点的右下方的像素。

接下来，我们探究 Qt 绘制图像的坐标情况，对于画笔大小为一个像素的情况比较容易理解，当我们绘制矩形左上角 (1, 2) 时，实际绘制的像素是在右下方。

Responsive Image

当画笔大小超过 1 个像素时，就略显复杂了。如果绘制像素是偶数，则实际绘制会包裹住逻辑坐标值；如果是奇数，则是包裹住逻辑坐标值，再加上右下角一个像素的偏移。具体请看下面的图示：

Responsive Image

从上图可以看出，如果实际绘制是偶数像素，则会将逻辑坐标值夹在相等的两部分像素之间；如果是奇数，则会在右下方多出一个像素。

Qt 的这种处理，带来的一个问题是，我们可能获取不到真实的坐标值。由于历史原因，QRect::right()和QRect::bottom()的返回值并不是矩形右下角点的真实坐标值：QRect::right()返回的是left() + width() - 1；QRect::bottom()则返回 top() + height() - 1，上图的绿色点指出了这两个函数的返回点的坐标。

为避免这个问题，我们建议是使用QRectF。QRectF使用浮点值，而不是整数值，来描述坐标。这个类的两个函数QRectF::right()和QRectF::bottom()是正确的。如果你不得不使用QRect，那么可以利用 x() + width() 和 y() + height()来替代 right()和bottom()函数。

对于反走样，实际绘制会包裹住逻辑坐标值：

Responsive Image

前面说过，QPainter是一个状态机。那么，有时我想保存下当前的状态：当我临时绘制某些图像时，就可能想这么做。当然，我们有最原始的办法：将可能改变的状态，比如画笔颜色、粗细等，在临时绘制结束之后再全部恢复。对此，QPainter提供了内置的函数：save()和restore()。save()就是保存下当前状态；restore()则恢复上一次保存的结果。这两个函数必须成对出现：QPainter使用栈来保存数据，每一次save()，将当前状态压入栈顶，restore()则弹出栈顶进行恢复。

在了解了这两个函数之后，我们就可以进行示例代码了：

//绘制一个网格背景
void CoordinateWidget::paintGrid()
{
    size_t win_width = this->geometry().width();
    size_t win_height = this->geometry().height();
    QPainter painter(this);
    for (size_t x = 0; x < win_width; x += 25)
    {
        painter.drawLine(QPoint(x, 1), QPoint(x, win_height));
    }
    for (size_t y = 0; y < win_height; y += 25)
    {
        painter.drawLine(QPoint(1, y), QPoint(win_width, y));
    }
}
void CoordinateWidget::paintEvent(QPaintEvent *)
{
    paintGrid();
    QPainter painter(this);
    painter.fillRect(10, 10, 50, 100, Qt::red);
    painter.save();
    painter.translate(100, 0); // 向右平移 100px
    painter.fillRect(10, 10, 50, 100, Qt::yellow);
    painter.restore();
    painter.save();
    painter.translate(300, 0); // 向右平移 300px
    painter.rotate(30);        // 顺时针旋转 30 度
    painter.fillRect(10, 10, 50, 100, Qt::green);
    painter.restore();
    painter.save();
    painter.translate(400, 0); // 向右平移 400px
    painter.scale(2, 3);       // 横坐标单位放大 2 倍，纵坐标放大 3 倍
    painter.fillRect(10, 10, 50, 100, Qt::blue);
    painter.restore();
    painter.save();
    painter.translate(600, 0); // 向右平移 600px
    painter.shear(0, 1);       // 横向不变，纵向扭曲 1 倍
    painter.fillRect(10, 10, 50, 100, Qt::cyan);
    painter.restore();
}

Qt 提供了四种坐标变换：平移 translate，旋转 rotate，缩放 scale 和扭曲 shear。在这段代码中，我们首先在 (10, 10) 点绘制一个红色的 50x100 矩形。保存当前状态，将坐标系平移到 (100, 0)，绘制一个黄色的矩形。注意，translate()操作平移的是坐标系，不是矩形。因此，我们还是在(10, 10) 点绘制一个 50x100 矩形，现在，它跑到了右侧的位置。然后恢复先前状态，也就是把坐标系重新设为默认坐标系（相当于进行translate(-100, 0)），再进行下面的操作。之后也是类似的。由于我们只是保存了默认坐标系的状态，因此我们之后的translate()横坐标值必须增加，否则就会覆盖掉前面的图形。所有这些操作都是针对坐标系的，因此在绘制时，我们提供的矩形的坐标参数都是不变的。

为了更直观的查看绘制坐标，先在背景画了一个网格。

运行结果如下：

Responsive Image

Qt 模仿登录界面-页面反转效果

Tue, 24 Aug 2021 13:55:37 +0000

设置一个旋转效果，将登录界面旋转翻个面，设置一些网络参数。

效果

Responsive Image

网络参数设置界面布局

Responsive Image

网络参数设置界面

//loginnetsetwindow.cpp
//初始化标题
void LoginNetSetWindow::initMyTitle()
{
 m_titleBar->move(0, 0);
 m_titleBar->raise();
 m_titleBar->setBackgroundColor(0, 0, 0, true);
 m_titleBar->setButtonType(MIN_BUTTON);
 m_titleBar->setTitleWidth(this->width());
 m_titleBar->setMoveParentWindowFlag(false);
}

void LoginNetSetWindow::initWindow()
{
 QLabel* pBack = new QLabel(this);
 QMovie *movie = new QMovie();
 movie->setFileName(":/Resources/NetSetWindow/headBack.gif");
 pBack->setMovie(movie);
 movie->start();
 pBack->move(0, 0);

 connect(ui.pButtonOk, SIGNAL(clicked()), this, SIGNAL(rotateWindow()));
 connect(ui.pButtonCancel, SIGNAL(clicked()), this, SIGNAL(rotateWindow()));
 
    ui.comboBoxNetType->addItem(QStringLiteral("不使用代理"));
 ui.comboBoxServerType->addItem(QStringLiteral("不使用高级选项"));
}

void LoginNetSetWindow::paintEvent(QPaintEvent *event)
{
 // 绘制背景图;
 QPainter painter(this);
 QPainterPath pathBack;
 pathBack.setFillRule(Qt::WindingFill);
 pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
 painter.setRenderHint(QPainter::Antialiasing, true);
 painter.fillPath(pathBack, QBrush(QColor(235, 242, 249)));
 
 QPainterPath pathBottom;
 pathBottom.setFillRule(Qt::WindingFill);
 pathBottom.addRoundedRect(QRect(0, 300, this->width(), this->height() - 300), 3, 3);
 painter.setRenderHint(QPainter::Antialiasing, true);
 painter.fillPath(pathBottom, QBrush(QColor(205, 226, 242)));

 painter.setPen(QPen(QColor(160 , 175 , 189)));
 painter.drawRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
}

initMyTitle()就不多说了，和正面登录界面差不多。

`QPainterPath`类

它是由一些图形如曲线、矩形、椭圆组成的对象。主要的用途是，能保存已经绘制好的图形。实现图形元素的构造和复用；图形状只需创建一次，然后调用QPainter::drawPath() 函数多次绘制。painterpath可以加入闭合或不闭合的图形 ( 如：矩形、椭圆和曲线) 。QPainterPath 可用于填充，描边，clipping。

`setFillRule()`设置填充模式

不是很理解 https://doc.qt.io/qt-5/qt.html#FillRule-enum

`addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3)`圆角矩形

QRect(0, 300, this->width(), this->height() - 300)设置了矩形的位置及大小
(3,3)表示倒圆角的大小

`setRenderHint()`开启反走样

QPainter::Antialiasing 告诉绘图引擎应该在可能的情况下进行边的反锯齿绘制
QPainter::TextAntialiasing 尽可能的情况下文字的反锯齿绘制
QPainter::SmoothPixmapTransform 使用平滑的 pixmap 变换算法 (双线性插值算法),而不是近邻插值算

初始化旋转窗口

// 初始化旋转的窗口;
void RotateWidget::initRotateWindow()
{
 m_loginWindow = new LoginWindow(this);
 // 这里定义了两个信号，需要自己去发送信号;
 connect(m_loginWindow, SIGNAL(rotateWindow()), this, SLOT(onRotateWindow()));
 connect(m_loginWindow, SIGNAL(closeWindow()), this, SLOT(close()));
 connect(m_loginWindow, SIGNAL(hideWindow()), this, SLOT(onHideWindow()));

 m_loginNetSetWindow = new LoginNetSetWindow(this);
 connect(m_loginNetSetWindow, SIGNAL(rotateWindow()), this, SLOT(onRotateWindow()));
 connect(m_loginNetSetWindow, SIGNAL(closeWindow()), this, SLOT(close()));
 connect(m_loginNetSetWindow, SIGNAL(hideWindow()), this, SLOT(onHideWindow()));

 this->addWidget(m_loginWindow);
 this->addWidget(m_loginNetSetWindow);

 // 这里宽和高都增加，是因为在旋转过程中窗口宽和高都会变化;
 this->setFixedSize(QSize(m_loginWindow->width() + 20, m_loginWindow->height() + 100));
}

对正面和反面分别定义了信号槽，当对应的面接收到信号时，执行对应的动作。因为是旋转一百八十度，所以选择函数可以公用。

旋转窗口

Responsive Image


// 开始旋转窗口;
void RotateWidget::onRotateWindow()
{
 // 如果窗口正在旋转，直接返回;
 if (m_isRoratingWindow)
 {
  return;
 }
 m_isRoratingWindow = true;
 m_nextPageIndex = (currentIndex() + 1) >= count() ? 0 : (currentIndex() + 1);
 QPropertyAnimation *rotateAnimation = new QPropertyAnimation(this, "rotateValue");
 // 设置旋转持续时间;
 rotateAnimation->setDuration(1500);
 // 设置旋转角度变化趋势;
 rotateAnimation->setEasingCurve(QEasingCurve::InCubic);
 // 设置旋转角度范围;
 rotateAnimation->setStartValue(0);
 rotateAnimation->setEndValue(180);
 connect(rotateAnimation, SIGNAL(valueChanged(QVariant)), this, SLOT(repaint()));
 connect(rotateAnimation, SIGNAL(finished()), this, SLOT(onRotateFinished()));
 // 隐藏当前窗口，通过不同角度的绘制来达到旋转的效果;
 currentWidget()->hide();
 rotateAnimation->start();
}

// 旋转结束;
void RotateWidget::onRotateFinished()
{
 m_isRoratingWindow = false;
 setCurrentWidget(widget(m_nextPageIndex));
 repaint();
}
/ 绘制旋转效果;
void RotateWidget::paintEvent(QPaintEvent *event)
{
    if (m_isRoratingWindow)
    {
        // 小于 90 度时;
        int rotateValue = this->property("rotateValue").toInt();
        if (rotateValue <= 90)
        {
            QPixmap rotatePixmap(currentWidget()->size());
            currentWidget()->render(&rotatePixmap);
            QPainter painter(this);
            painter.setRenderHint(QPainter::Antialiasing);
            QTransform transform;
            transform.translate(width() / 2, 0);
            transform.rotate(rotateValue, Qt::YAxis);
            painter.setTransform(transform);
            painter.drawPixmap(-1 * width() / 2, 0, rotatePixmap);
        }
        // 大于 90 度时
        else
        {
            QPixmap rotatePixmap(widget(m_nextPageIndex)->size());
            widget(m_nextPageIndex)->render(&rotatePixmap);
            QPainter painter(this);
            painter.setRenderHint(QPainter::Antialiasing);
            QTransform transform;
            transform.translate(width() / 2, 0);
            transform.rotate(rotateValue + 180, Qt::YAxis);
            painter.setTransform(transform);
            painter.drawPixmap(-1 * width() / 2, 0, rotatePixmap);
        }
    }
    else
    {
        return QStackedWidget::paintEvent(event);
    }
}

`QPropertyAnimation`动画类

QPropertyAnimation *rotateAnimation = new QPropertyAnimation(this, "rotateValue")

rotateValue就是这个动画的属性，我们这个动画中变化的就是旋转值，也就是旋转角度。这个属性名完全自己起，也可以改成rotateAngle等等，或者说想做一个平移的动画，也可以取一个moveDist等名字。

下面这一串就是标准的一套动画流程

    // 设置旋转持续时间;
    rotateAnimation->setDuration(1000);
    // 设置旋转角度变化趋势;
    rotateAnimation->setEasingCurve(QEasingCurve::InCubic);
    // 设置旋转角度范围;
    rotateAnimation->setStartValue(0);
    rotateAnimation->setEndValue(180);
    //开始动画
    rotateAnimation->start();

`paintEvent`绘图事件

#include <QtWidgets/QApplication>
#include "rotatewidget.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    RotateWidget w;
    w.show();
    return a.exec();
}

我们main函数得知，最开始显示的窗口就是RotateWidget。在实例化一个RotateWidget类后，进行了标题栏的初始化工作，然后开始执行w.show()显示，但是此时窗口是不显示的。这是因为我们在RotateWidget的构造函数中进行了设置不显示窗口。

    this->setWindowFlags(Qt::FramelessWindowHint | 
    Qt::WindowStaysOnTopHint | 
    Qt::WindowMinimizeButtonHint);

当运行到return a.exec()时，Qt 会自动调用void RotateWidget::paintEvent()。此时开始正式绘制窗口，但是因为我们还没哟点击登录页面的网络设置按钮，所以m_isRoratingWindow=0。会调用父类的绘图事件，QStackedWidget::paintEvent()，最后也就是BaseWindow::paintEvent()。会将登录页面先绘制出来。

当我们点击网络设置按钮时，m_isRoratingWindow=1开始绘制旋转画面。

Qt 模仿登录界面-交互响应

Wed, 18 Aug 2021 13:07:01 +0000

效果预览

Responsive Image

设置窗口拖动

因为这个项目中没有将登录界面直接继承MainWindow，而是继承的Dialog类，所以它是不能直接移动的，需要我们自己添加相应的方法。这里实现了三种方法，点击，拖动，释放。

//mytitlebar.cpp
// 以下通过 mousePressEvent、mouseMoveEvent、mouseReleaseEvent 三个事件实现了鼠标拖动标题栏移动窗口的效果;
void MyTitleBar::mousePressEvent(QMouseEvent *event)
{
 if (m_buttonType == MIN_MAX_BUTTON)
 {
  // 在窗口最大化时禁止拖动窗口;
  if (m_pButtonMax->isVisible())
  {
   m_isPressed = true;
   m_startMovePos = event->globalPos();
  }
 }
 else
 {
  m_isPressed = true;
  m_startMovePos = event->globalPos();
 }
 
 return QWidget::mousePressEvent(event);
}

void MyTitleBar::mouseMoveEvent(QMouseEvent *event)
{
 if (m_isPressed && m_isMoveParentWindow)
 {
  QPoint movePoint = event->globalPos() - m_startMovePos;
  QPoint widgetPos = this->parentWidget()->pos() + movePoint;
  m_startMovePos = event->globalPos();
  this->parentWidget()->move(widgetPos.x(), widgetPos.y());
 }
 return QWidget::mouseMoveEvent(event);
}

void MyTitleBar::mouseReleaseEvent(QMouseEvent *event)
{
 m_isPressed = false;
 return QWidget::mouseReleaseEvent(event);
}

`globalPos()`获取全局的坐标

event->globalPos()是获取全局的坐标，全局是相对于整个屏幕而言的。还有一个函数pos()获取的是局部坐标，相对于一个widget窗口而言。

`move()`移动窗口

void move(int x, int y);
void move(const QPoint &);

其中move的原点是父窗口的左上角，如果没有父窗口，则桌面即为父窗口。x 往右递增，y 往下递增

mouseMoveEvent()这个函数里有一点需要注意的是，m_startMovePos = event->globalPos()这条语句。每次移动窗口之前，先把鼠标移动后的位置记录下来，作为下一次移动的起点。

设置最小化，关闭

//mytitlebar.cpp
// 信号槽的绑定;
void MyTitleBar::initConnections()
{
 connect(m_pButtonMin, SIGNAL(clicked()), this, SLOT(onButtonMinClicked()));
 connect(m_pButtonClose, SIGNAL(clicked()), this, SLOT(onButtonCloseClicked()));
}

void MyTitleBar::onButtonMinClicked()
{
 emit signalButtonMinClicked();
}

void MyTitleBar::onButtonCloseClicked()
{
 emit signalButtonCloseClicked();
}

标题栏是在basewindow中 new 出来的，mytitlebar类只负责发送信号，真正处理信号的是在basewindow类中。

//basewindow.cpp
void BaseWindow::initTitleBar()
{
 createMyTitle(this);
 m_titleBar->move(0, 0);
 
 connect(m_titleBar, SIGNAL(signalButtonMinClicked()), this, SLOT(onButtonMinClicked()));
 connect(m_titleBar, SIGNAL(signalButtonCloseClicked()), this, SLOT(onButtonCloseClicked()));
}


void BaseWindow::onButtonMinClicked()
{
 if (Qt::Tool == (windowFlags() & Qt::Tool))
 {
  hide();
 }
 else
 {
  showMinimized();
 }
}

void BaseWindow::onButtonCloseClicked()
{
 close();
}

在初始化标题栏时，就把点击信号与相关的槽函数绑定。当有最小化点击信号发生时，就会调用最小化操作。

和窗口相关的几个函数

showMinimized()     //最小化
showNormal()        //从最小化或者最大化窗口恢复到正常窗口
showMaximized()     //最大化
show()              //显示窗口，可以显示模态窗口也可以显示非模态
hide()              //隐藏窗口
isVisible()         //判断是否可见
isMinimized()       //判断是否处于最小化状态
close()             //关闭窗口

切换用户及删除用户

//loginwindow.cpp
// 初始化用户登录信息;
void LoginWindow::initAccountList()
{
    // 设置代理;
    m_Accountlist = new QListWidget(this);
    ui->accountComboBox->setModel(m_Accountlist->model());
    ui->accountComboBox->setView(m_Accountlist);

    for (int i = 0; i < 3; i++)
    {
        AccountItem *account_item = new AccountItem();
        account_item->setAccountInfo(i, QStringLiteral("Dominic%1号").arg(i), QString(":/Resources/LoginWindow/headImage/head_%1.png").arg(i));
        connect(account_item, SIGNAL(signalShowAccountInfo(int, QString)), this, SLOT(onShowAccountInfo(int, QString)));
        connect(account_item, SIGNAL(signalRemoveAccount(int)), this, SLOT(onRemoveAccount(int)));
        QListWidgetItem *list_item = new QListWidgetItem(m_Accountlist);
        m_Accountlist->setItemWidget(list_item, account_item);
    }
}
//将选项文本显示在 QComboBox 当中
void LoginWindow::onShowAccountInfo(int index, QString accountName)
{
    ui->accountComboBox->setEditText(accountName);
    ui->accountComboBox->hidePopup();

    // 更换用户头像;
    QString fileName = QString(":/Resources/LoginWindow/headImage/head_%1.png").arg(index);
    ui->userHead->setPixmap(QPixmap(fileName).scaled(ui->userHead->width(), ui->userHead->height()));
}

// 移除当前登录列表中某一项;
void LoginWindow::onRemoveAccount(int index)
{
    for (int row = 0; row < m_Accountlist->count(); row++)
    {
        AccountItem* itemWidget = (AccountItem*)m_Accountlist->itemWidget(m_Accountlist->item(row));
        if (itemWidget != NULL && itemWidget->getItemWidgetIndex() == index)
        {
            m_Accountlist->takeItem(row);
            itemWidget->deleteLater();
        }
    }
}

在initAccountList()中，初始化好了三个账户信息，当接收到显示用户信息的信号signalShowAccountInfo后，就会调用onShowAccountInfo槽函数显示用户信息。在这个函数中，将下拉框的内容设置成切换后的用户名，然后隐藏下拉框hidPopup。更改头像。

当接收到删除信号时，调用onRemoveAccount槽函数，删除指定的用户信息。

`hidPopup()`隐藏下拉框

文章开头的效果图是隐藏下拉框的效果，每次切换用户下拉框隐藏，我们再来看一下不隐藏什么效果就容易理解了。 Responsive Image

`takeItem()`删除部件

QListWidgetItem *QListWidget::takeItem(int row)

从下拉菜单中选择一行部件删除。

`deleteLater()`稍后删除对象

deletelater的原理是 QObject::deleteLater()并没有将对象立即销毁，而是向主消息循环发送了一个event，下一次主消息循环收到这个event之后才会销毁对象。

切换登录状态

//loginwindow.cpp
// 选择了新的用户登录状态;
void LoginWindow::onLoginStateClicked()
{
    m_loginStateMemu = new QMenu();
    QAction *pActionOnline = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_online.png"), QStringLiteral("我在线上"));
    QAction *pActionActive = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_Qme.png"), QStringLiteral("Q 我吧"));
    m_loginStateMemu->addSeparator();
    QAction *pActionAway = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_away.png"), QStringLiteral("离开"));
    QAction *pActionBusy = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_busy.png"), QStringLiteral("忙碌"));
    QAction *pActionNoDisturb = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_notdisturb.png"), QStringLiteral("请勿打扰"));
    m_loginStateMemu->addSeparator();
    QAction *pActionHide = m_loginStateMemu->addAction(QIcon(":/Resources/LoginWindow/LoginState/state_hide.png"), QStringLiteral("隐身"));
    // 设置状态值;
    pActionOnline->setData(ONLINE);
    pActionActive->setData(ACTIVE);
    pActionAway->setData(AWAY);
    pActionBusy->setData(BUSY);
    pActionNoDisturb->setData(NOT_DISTURB);
    pActionHide->setData(HIDE);


    connect(m_loginStateMemu, SIGNAL(triggered(QAction *)), this, SLOT(onMenuClicked(QAction*)));

    QPoint pos = ui->loginState->mapToGlobal(QPoint(0, 0)) + QPoint(0, 20);
    m_loginStateMemu->exec(pos);
}

// 用户状态菜单点击;
void LoginWindow::onMenuClicked(QAction * action)
{
    ui->loginState->setIcon(action->icon());
    // 获取状态值;
    m_loginState = (LoginState)action->data().toInt();
    qDebug() << "onMenuClicked" << m_loginState;
}

在接收到点击状态按钮信号时，调用onLoginStateClicked槽函数，改变用户登录状态。切换的下拉菜单用的是QMenu。

`addSeparator()`添加分割线

Q 我吧和离开状态之间的分割线。 Responsive Image

`mapToGlobal()`映射成全局坐标

弹出登录状态菜单m_loginStateMemu是我们自己 new 出来的，默认显示是从左上角开始显示，这样当然不行。

Responsive Image

mapToGlobal()的作用就是将控件的坐标映射成全局坐标。代码里的意思就是将loginState控件里面的坐标用全局坐标表示。然后再向下偏移20个单位。再把得到的全局坐标作为m_loginStateMemu显示起始坐标。

下图是未偏移的结果， Responsive Image

向下偏移20个单位的效果，因为我们mapToGlobal(QPoint(0, 0))的参数是(0,0)为起点。如果我们mapToGlobal(QPoint(0, 20))的参数是(0,20)，就不用再加上偏移了。 Responsive Image

Qt 模仿登录界面-窗口布局及样式

Tue, 17 Aug 2021 11:30:06 +0000

框架类图

Responsive Image

效果预览

Responsive Image

完整项目及资源文件请在Github查看。

页面布局

Responsive Image

初始化标题栏

// 初始化标题栏;
void LoginWindow::initMyTitle()
{
    // 因为这里有控件层叠了，所以要注意控件 raise() 方法的调用顺序;
    m_titleBar->move(0, 0);
    m_titleBar->raise();
    m_titleBar->setBackgroundColor(100, 0, 0, true);
    m_titleBar->setButtonType(MIN_BUTTON);
    m_titleBar->setTitleWidth(this->width());
    // 这里需要设置成 false，不允许通过标题栏拖动来移动窗口位置，否则会造成窗口位置错误;
    m_titleBar->setMoveParentWindowFlag(false);
    ui->pButtonArrow->raise();
}

`raise()`将控件置于顶层

程序在打开后一般都在所有窗体的顶层，打开其他程序后之前的程序就会被放到下一层，在这里，当设置完my_titleBar后对其他控件操作就会把my_titleBar控件覆盖。所有要用raise()方法将其置于顶层。

初始化窗口

// 初始化窗口;
void LoginWindow::initWindow()
{
    //背景 GIG 图;
    QLabel* pBack = new QLabel(this);
    QMovie *movie = new QMovie();
    movie->setFileName(":/Resources/LoginWindow/back.gif");
    pBack->setMovie(movie);
    movie->start();
    pBack->move(0, 0);

    //文本框内提示
    ui->accountComboBox->setEditable(true);
    QLineEdit* lineEdit = ui->accountComboBox->lineEdit();
    lineEdit->setPlaceholderText(QStringLiteral("QQ 号码/手机/邮箱"));
    QRegExp regExp("[A-Za-z0-9_]{6,30}"); //正则表达式限制用户名输入不能输入汉字
    lineEdit->setValidator(new QRegExpValidator(regExp,this));
    ui->passwordEdit->setPlaceholderText(QStringLiteral("密码"));

    //密码框中的小键盘按钮;
    m_keyboardButton = new QPushButton();
    m_keyboardButton->setObjectName("pButtonKeyboard");
    m_keyboardButton->setFixedSize(QSize(16, 16));
    m_keyboardButton->setCursor(QCursor(Qt::PointingHandCursor));//鼠标放上去变成手形

    QHBoxLayout* passwordEditLayout = new QHBoxLayout();
    passwordEditLayout->addStretch();
    passwordEditLayout->addWidget(m_keyboardButton);
    passwordEditLayout->setSpacing(0);
    passwordEditLayout->setContentsMargins(0, 0, 8, 0);

    ui->passwordEdit->setLayout(passwordEditLayout);
    //设置密码达到最长时最后一个字符离小键盘图标的距离（12）
    ui->passwordEdit->setTextMargins(0, 0, m_keyboardButton->width() + 12, 0);

    //设置头像以及状态图标
    ui->userHead->setPixmap(QPixmap(":/Resources/LoginWindow/HeadImage.png"));
    ui->loginState->setIcon(QIcon(":/Resources/LoginWindow/LoginState/state_online.png"));
    ui->loginState->setIconSize(QSize(13, 13));
}

lineEdit->setPlaceholderText QStringLiteral:如果该 QString 不会修改的话，那使用 QStringLiteral

`setPlaceholderText()`设置文本提示

该方法可以设置文本框中的默认文字提示，如图片中的 QQ 号码/手机/邮箱。

`setCursor()`设置鼠标形态

共有以下 19 种鼠标形态：

Responsive Image

图片来自这里

`addStretch()`布局加入弹簧

QHBoxLayout* passwordEditLayout = new QHBoxLayout();
passwordEditLayout->addStretch();
passwordEditLayout->addWidget(m_keyboardButton);

addStretch()用来在布局中平分布局，他就是个弹簧的作用。如果不加参数，就是等于加个弹簧，会把小键盘图标挤到边上。如图：

Responsive Image

如果将代码改一下：

QHBoxLayout* passwordEditLayout = new QHBoxLayout();
passwordEditLayout->addStretch(1);
passwordEditLayout->addWidget(m_keyboardButton);
passwordEditLayout->addStretch(1);

意思就是将除了小键盘图标以外的空间分成两份，那么刚好小键盘图标就是在中间位置，就像两遍各防止了一个弹簧。效果如下：

Responsive Image

setSpacing()设置空间之间上下距离，还有一个容易混淆的设置setMargin()表示设置空间与窗口边缘的左右距离。

setContentsMargins设置左侧、顶部、右侧和底部边距，以便在布局周围使用。

Responsive Image

现在我们设置的是setContentsMargins(0, 0, 8, 0)，现在我们设置大一点看看效果。

Responsive Image

QLineEdit.setTextMargins(left=,top=,right=,bottom=)设置文本边距，这里主要为了设置密码输入过长时，最后一个字符距离小键盘图标有一定间隙。

初始化用户登录信息

//accountitem.cpp
void LoginWindow::initAccountList()
{
 for (int i = 0; i < 3; i++)
 {
  AccountItem *account_item = new AccountItem();
  account_item->setAccountInfo(i, QStringLiteral("Dominic_%1号").arg(i), QString(":/Resources/LoginWindow/headImage/head_%1.png").arg(i));
  QListWidgetItem *list_item = new QListWidgetItem(m_Accountlist);
  m_Accountlist->setItemWidget(list_item, account_item);
 }
}

Qt 添加资源文件（QtCreator）

Thu, 12 Aug 2021 10:23:58 +0000

QtCreator➜新建文件或项目➜Qt➜Qt Resource File

Responsive Image

点击Choose，设置资源文件名和路径。资源文件是一系列文件的集合，比如我要建立一个图片的资源文件，我可以设置img为资源文件名，将来所有图片类资源，都放到这个资源文件里，加入还有音频类的文件，我可以新建一个audio的资源文件，以后所有音频类的文件都放到这个资源文件下。

而不是我想要添加的文件名。

Responsive Image

右侧编辑器下方有个Add Prefix(添加前缀)，我们首先要添加文件前缀，前缀就是存放文件的文件夹名，然后添加需要的文件。添加完以后看效果就知道啥意思了。

Responsive Image

这么做带来的一个问题是，如果以后我们要更改文件名，比如将 xbl.png 改成 xiabanle.png，那么，所有使用了这个名字的路径都需要修改。所以，更好的办法是，我们给这个文件去一个“别名”，以后就以这个别名来引用这个文件。具体做法是，选中这个文件，添加别名信息：

这样，我们可以直接使用:/images/avatar用到这个资源，无需关心图片的真实文件名。

Qt 事件

Mon, 09 Aug 2021 09:55:07 +0000

本篇文章所涉及代码可在此处查看

事件以及与信号的区别

事件（event）是由系统或者 Qt 本身在不同的时刻发出的。当用户按下鼠标、敲下键盘，或者是窗口需要重新绘制的时候，都会发出一个相应的事件。一些事件在对用户操作做出响应时发出，如键盘事件等；另一些事件则是由系统自动发出，如计时器事件。

事件和信号槽的区别

信号是由具体对象发出，然后马上交给connect函数连接的槽进行处理，如果处理过程中产生了新的信号，将会继续执行新的信号，一直这样递归进行下去。而事件使用一个事件队列对发出的所有事件进行维护，当新的事件产生时会被加到事件队列的尾部。

在运行过程中发现，刚启动时并不会显示任何内容，只有在点击一次后，平面才会显示信息。这是因为QWidget中有一个mouseTracking属性，该属性用于设置是否追踪鼠标。只有鼠标被追踪时，mouseMoveEvent()才会发出。如果mouseTracking是 false（默认即是），组件在至少一次鼠标点击之后，才能够被追踪，也就是能够发出mouseMoveEvent()事件。如果mouseTracking为 true，则mouseMoveEvent()直接可以被发出。知道了这一点，我们就可以在main()函数中直接设置下：

EventLabel *label = new EventLabel;
label->setWindowTitle("MouseEvent Demo");
label->resize(300, 200);
label->setMouseTracking(true);
label->show();

显示效果

Responsive Image

事件的接受与忽略

//custombutton.h
#include <QDebug>
#include <QMouseEvent>
#include <QApplication>
#include <QPushButton>

class CustomButton : public QPushButton
{
    Q_OBJECT
private:
    void onButtonClicked();

public:
    CustomButton(QWidget *parent = 0);

};

//custombutton.cpp
#include "custombutton.h"

CustomButton::CustomButton(QWidget *parent) : QPushButton(parent)
{
    connect(this, &CustomButton::clicked, this, &CustomButton::onButtonClicked);
}

void CustomButton::onButtonClicked()
{
    qDebug() << "You clicked this!";
}

//main02.cpp
#include "custombutton.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    CustomButton btn;
    btn.setText("This is a Button!");
    btn.show();

    return a.exec();
}

以上代码运行结果就是点击按钮会在控制台输出：“You clicked this!"。

现在，我们在CustomButton类中再添加一个事件函数：

//custombutton.h
protected:
    void mousePressEvent(QMouseEvent *event);

//custombutton.cpp
void CustomButton::mousePressEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton)
    {
        qDebug() << "Left";
    }
    else
    {
        QPushButton::mousePressEvent(event);
    }
}

这时运行结果为点击按键输出"Left”。而没有再输出"You clicked this!"。说明我们把父类的实现覆盖了。当重写事件回调函数时，时刻注意是否需要通过调用父类的同名函数来确保原有实现仍能进行！。这一定程度上说，我们的组件忽略了父类的事件。

通过调用父类的同名函数，我们可以把 Qt 的事件传递看成链状：如果子类没有处理这个事件，就会继续向其父类传递。Qt 的事件对象有两个函数：accept()和ignore()。正如它们的名字一样，前者用来告诉 Qt，这个类的事件处理函数想要处理这个事件；后者则告诉 Qt，这个类的事件处理函数不想要处理这个事件。在事件处理函数中，可以使用isAccepted()来查询这个事件是不是已经被接收了。具体来说：如果一个事件处理函数调用了一个事件对象的accept()函数，这个事件就不会被继续传播给其父组件；如果它调用了事件的ignore()函数，Qt 会从其父组件中寻找另外的接受者。

//custombutton01.h
#include <QDebug>
#include <QVBoxLayout>
#include <QMainWindow>
#include <QMouseEvent>
#include <QPushButton>
#include <QApplication>

class CustomButton : public QPushButton
{
    Q_OBJECT

public:
    CustomButton(QWidget *parent) : QPushButton(parent)
    {
    }

protected:
    void mousePressEvent(QMouseEvent *event)
    {
        qDebug() << "CustomButton";
    }
};

class CustomButtonEx : public CustomButton
{
    Q_OBJECT
public:
    CustomButtonEx(QWidget *parent) : CustomButton(parent)
    {
    }

protected:
    void mousePressEvent(QMouseEvent *event)
    {
        qDebug() << "CustomButtonEx";
    }
};

class CustomWidget : public QWidget
{
    Q_OBJECT
public:
    CustomWidget(QWidget *parent) : QWidget(parent)
    {
    }

protected:
    void mousePressEvent(QMouseEvent *event)
    {
        qDebug() << "CustomWidget";
    }
};

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = 0) : QMainWindow(parent)
    {
        CustomWidget *widget = new CustomWidget(this);
        CustomButton *cbex = new CustomButton(widget);
        cbex->setText(tr("CustomButton"));
        CustomButtonEx *cb = new CustomButtonEx(widget);
        cb->setText(tr("CustomButtonEx"));
        QVBoxLayout *widgetLayout = new QVBoxLayout(widget);
        widgetLayout->addWidget(cbex);
        widgetLayout->addWidget(cb);
        this->setCentralWidget(widget);
    }

protected:
    void mousePressEvent(QMouseEvent *event)
    {
        qDebug() << "MainWindow";
    }
};

//mai03.cpp
#include "custombutton01.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MainWindow win;
    win.show();
    return app.exec();
}

这段代码在一个MainWindow中添加了一个CustomWidget，里面有两个按钮对象：CustomButton和CustomButtonEx。每一个类都重写了mousePressEvent()函数。

Responsive Image

运行程序点击 CustomButtonEx，结果是

CustomButtonEx

因为我们重写了mousePressEvent()，所以调用子类自己的函数，如果在CustomButtonEx的mousePressEvent()第一行增加一句event->accept()，重新运行，发现结果不变。正如我们前面所说，QEvent 默认是accept的，调用这个函数并没有什么区别。然后我们将CustomButtonEx的event->accept()改成event->ignore()。这次运行结果是

CustomButtonEx
CustomWidget

ignore()说明我们想让事件继续传播，于是CustomButtonEx的父组件CustomWidget也收到了这个事件，所以输出了自己的结果。

同理，CustomWidget又没有调用父类函数或者显式设置accept()或ignore()，所以事件传播就此打住。

这里值得注意的是，CustomButtonEx的事件传播给了父组件CustomWidget，而不是它的父类CustomButton。事件的传播是在组件层次上面的，而不是依靠类继承机制。

在一个特殊的情形下，我们必须使用accept()和ignore()函数，那就是窗口关闭的事件。对于窗口关闭QCloseEvent事件，调用accept()意味着 Qt 会停止事件的传播，窗口关闭；调用ignore()则意味着事件继续传播，即阻止窗口关闭。回到我们前面写的简单的文本编辑器。

event() 函数

事件对象创建完毕后，Qt 将这个事件对象传递给QObject的event()函数。event()函数并不直接处理事件，而是将这些事件对象按照它们不同的类型，分发给不同的事件处理器（event handler）。

如上所述，event()函数主要用于事件的分发。所以，如果你希望在事件分发之前做一些操作，就可以重写这个event()函数了。例如，我们希望在一个 QWidget 组件中监听 tab 键的按下，那么就可以继承 QWidget，并重写它的event()函数，来达到这个目的：

bool CustomWidget::event(QEvent *e)
{
    if (e->type() == QEvent::KeyPress) 
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) 
        {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return QWidget::event(e);
}

CustomWidget是一个普通的QWidget子类。我们重写了它的event()函数，这个函数有一个QEvent对象作为参数，也就是需要转发的事件对象。函数返回值是 bool 类型。如果传入的事件已被识别并且处理，则需要返回 true，否则返回 false。如果返回值是 true，并且，该事件对象设置了accept()，那么 Qt 会认为这个事件已经处理完毕，不会再将这个事件发送给其它对象，而是会继续处理事件队列中的下一事件。注意，在event()函数中，调用事件对象的accept()和ignore()函数是没有作用的，不会影响到事件的传播。

我们可以通过使用QEvent::type()函数可以检查事件的实际类型，其返回值是QEvent::Type类型的枚举。我们处理过自己感兴趣的事件之后，可以直接返回 true，表示我们已经对此事件进行了处理；对于其它我们不关心的事件，则需要调用父类的event()函数继续转发，否则这个组件就只能处理我们定义的事件了。为了测试这一种情况，我们可以尝试下面的代码：

bool CustomTextEdit::event(QEvent *e)
{
    if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return false;
}

CustomTextEdit是QTextEdit的一个子类。我们重写了其event()函数，却没有调用父类的同名函数。这样，我们的组件就只能处理 Tab 键，再也无法输入任何文本，也不能响应其它事件，比如鼠标点击之后也不会有光标出现。这是因为我们只处理的KeyPress类型的事件，并且如果不是KeyPress事件，则直接返回 false，鼠标事件根本不会被转发，也就没有了鼠标事件。

事件过滤器

有时候，对象需要查看、甚至要拦截发送到另外对象的事件。例如，对话框可能想要拦截按键事件，不让别的组件接收到；或者要修改回车键的默认处理。

通过前面的章节，我们已经知道，Qt 创建了QEvent事件对象之后，会调用QObject的event()函数处理事件的分发。显然，我们可以在event()函数中实现拦截的操作。由于event()函数是 protected 的，因此，需要继承已有类。如果组件很多，就需要重写很多个event()函数。这当然相当麻烦，更不用说重写event()函数还得小心一堆问题。好在 Qt 提供了另外一种机制来达到这一目的：事件过滤器。

QObject有一个eventFilter()函数，用于建立事件过滤器。这个函数的签名如下：

这个函数正如其名字显示的那样，是一个“事件过滤器”。所谓事件过滤器，可以理解成一种过滤代码。想想做化学实验时用到的过滤器，可以将杂质留到滤纸上，让过滤后的液体溜走。事件过滤器也是如此：它会检查接收到的事件。如果这个事件是我们感兴趣的类型，就进行我们自己的处理；如果不是，就继续转发。这个函数返回一个 bool 类型，如果你想将参数 event 过滤出来，比如，不想让它继续转发，就返回 true，否则返回 false。事件过滤器的调用时间是目标对象（也就是参数里面的watched对象）接收到事件对象之前。也就是说，如果你在事件过滤器中停止了某个事件，那么，watched对象以及以后所有的事件过滤器根本不会知道这么一个事件。

class MainWindow : public QMainWindow
 {
 public:
     MainWindow();
 protected:
     bool eventFilter(QObject *obj, QEvent *event);
 private:
     QTextEdit *textEdit;
 };

 MainWindow::MainWindow()
 {
     textEdit = new QTextEdit;
     setCentralWidget(textEdit);
     textEdit->installEventFilter(this);
 }

 bool MainWindow::eventFilter(QObject *obj, QEvent *event)
 {
     if (obj == textEdit) {
         if (event->type() == QEvent::KeyPress) {
             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
             qDebug() << "Ate key press" << keyEvent->key();
             return true;
         } else {
             return false;
         }
     } else {
         // pass the event on to the parent class
         return QMainWindow::eventFilter(obj, event);
     }
 }

MainWindow是我们定义的一个类。我们重写了它的eventFilter()函数。为了过滤特定组件上的事件，首先需要判断这个对象是不是我们感兴趣的组件，然后判断这个事件的类型。在上面的代码中，我们不想让textEdit组件处理键盘按下的事件。所以，首先我们找到这个组件，如果这个事件是键盘事件，则直接返回 true，也就是过滤掉了这个事件，其他事件还是要继续处理，所以返回 false。对于其它的组件，我们并不保证是不是还有过滤器，于是最保险的办法是调用父类的函数。

eventFilter()函数相当于创建了过滤器，然后我们需要安装这个过滤器。安装过滤器需要调用QObject::installEventFilter()函数。这个函数的签名如下：

void QObject::installEventFilter ( QObject * filterObj )

这个函数接受一个QObject *类型的参数。记得刚刚我们说的，eventFilter()函数是QObject的一个成员函数，因此，任意QObject都可以作为事件过滤器（问题在于，如果你没有重写eventFilter()函数，这个事件过滤器是没有任何作用的，因为默认什么都不会过滤）。已经存在的过滤器则可以通过QObject::removeEventFilter()函数移除。

我们可以向一个对象上面安装多个事件处理器，只要调用多次installEventFilter()函数。如果一个对象存在多个事件过滤器，那么，最后一个安装的会第一个执行，也就是后进先执行的顺序。

还记得我们前面的那个例子吗？我们使用event()函数处理了 Tab 键：

bool CustomWidget::event(QEvent *e)
{
    if (e->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        }
    }
    return QWidget::event(e);
}

bool FilterObject::eventFilter(QObject *object, QEvent *event)
{
    if (object == target && event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        if (keyEvent->key() == Qt::Key_Tab) {
            qDebug() << "You press tab.";
            return true;
        } else {
            return false;
        }
    }
    return false;
}

事件过滤器的强大之处在于，我们可以为整个应用程序添加一个事件过滤器。记得，installEventFilter()函数是QObject的函数，QApplication或者QCoreApplication对象都是QObject的子类，因此，我们可以向QApplication或者QCoreApplication添加事件过滤器。这种全局的事件过滤器将会在所有其它特性对象的事件过滤器之前调用。尽管很强大，但这种行为会严重降低整个应用程序的事件分发效率。因此，除非是不得不使用的情况，否则的话我们不应该这么做。

注意，如果你在事件过滤器中 delete 了某个接收组件，务必将函数返回值设为 true。否则，Qt 还是会将事件分发给这个接收组件，从而导致程序崩溃。

事件过滤器和被安装过滤器的组件必须在同一线程，否则，过滤器将不起作用。另外，如果在安装过滤器之后，这两个组件到了不同的线程，那么，只有等到二者重新回到同一线程的时候过滤器才会有效。

事件过滤器和安装过滤器的组件必须在同一线程。Qt 里面，对象创建之后，可以使用 moveToThread() 函数将一个对象移动到另外的线程。在这种情形下（当然，事件过滤器必须在同一线程时才能被正确安装，这是第一句话说明的），在它们分属在不同线程时，事件过滤器也是不起作用的，只用当它们重新回到同一线程（使用 moveToThread() 或者是线程自然结束）时，过滤器才能重新工作

Qt 对话框

Thu, 05 Aug 2021 10:11:33 +0000

本篇文章所涉及代码，可在此处查看

Qt 中使用 QDialog 类实现对话框。就像主窗口一样，我们通常会设计一个类继承 QDialog。QDialog（及其子类，以及所有 Qt::Dialog 类型的类）的对于其 parent 指针都有额外的解释：

如果 parent 为 NULL，则该对话框会作为一个顶层窗口，否则则作为其父组件的子对话框（此时，其默认出现的位置是 parent 的中心）。

顶层窗口与非顶层窗口的区别在于，顶层窗口在任务栏会有自己的位置，而非顶层窗口则会共享其父组件的位置。

对话框分为模态对话框和非模态对话框。所谓模态对话框，就是会阻塞同一应用程序中其它窗口的输入。模态对话框很常见，比如“打开文件”功能。你可以尝试一下记事本的打开文件，当打开文件对话框出现时，我们是不能对除此对话框之外的窗口部分进行操作的。

与此相反的是非模态对话框，例如查找对话框，我们可以在显示着查找对话框的同时，继续对记事本的内容进行编辑。

Qt 支持模态对话框和非模态对话框。其中，Qt 有两种级别的模态对话框：应用程序级别的模态和窗口级别的模态，默认是应用程序级别的模态。应用程序级别的模态是指，当该种模态的对话框出现时，用户必须首先对对话框进行交互，直到关闭对话框，然后才能访问程序中其他的窗口。窗口级别的模态是指，该模态仅仅阻塞与对话框关联的窗口，但是依然允许用户与程序中其它窗口交互。

消息对话框 QMessageBox

文件对话框 QFileDialog

‘QTextEdit’ Does not name a type

需要包含头文件

#include <QTextEdit>

Qt 需要包含的头文件实在太多了。

可能添加了头文件仍然报同样的错，没有搜索到相关的解答。

我的做法是：

确保在.pro文件中加入QT += widgets和CONFIG += c++11
将包含库文件语句都放到头文件.h中

Git 中添加 gitignore 并更新远程仓库

Wed, 04 Aug 2021 14:09:20 +0000

gitignore 的作用

在使用Git版本控制时，必须要用.gitignore这个文件来告诉Git那些文件或目录不需要添加到版本控制中。通俗点说，就是不需要git push到远程仓库。

在平时开发过程中，开发目录下会有各种格式的文件，比如 C 语言除了.c源码，还会有.o目标文件，没有后缀的可执行程序等等，假如你要进行深度学习类的开发，如图像识别，需要训练大量数据，如果这些训练数据也到跟踪管理，那push一次就可以下班回家了。

但是我们怎么让Git知道哪些文件需要跟踪，哪些文件不需要呢，这时候.gitignore文件就起作用了。

常用规则

简单介绍一下常用的规则，虽然后面有现成的模板，但是我们还是了解一下常用规则，能看得懂.gitignore里写了啥。也方便自己编写一些规则适应自己的工作。

/test/              # 过滤整个test文件夹
*.o                 # 过滤所有.o文件
/test/hello.o       # 过滤test文件夹下hello.o这个文件
!src/               # 不过滤src这个文件夹
!*.c                # 不过滤.c文件

通过 gitignore 文件更新远程仓库

上面说到我们在不同环境下需要制定不同的规则，但是每次都要重新写一遍，又或者不知道制定什么样的规则，还是挺麻烦的。

首先推荐一个.gitignore模板仓库，在平时工作学习中遇到的各种语言环境下的模板都能找到。这是广大开发人员总结的一些规则。

最近在学习Qt，在所有模板中搜索关键字，找到了Qt.gitignore这个模板打开并复制，在自己本地仓库里新建一个.gitignore文件，将复制的内容粘贴进去。

现在就要解决如何更新远程仓库的内容，因为我在使用.gitignore文件之前已经向远程push过了，现在需要删除不需要的文件。

git rm -r --cached .

rm就是Linux下常用的删除命令，-r表示递归删除，--cached表示需要在本地端（工作区）保留文件，.表示所有文件。

git add .   # 重新添加所有文件到暂存区，然后提交，推送
git commit -m "update"
git push

Qt 添加资源文件

Wed, 04 Aug 2021 11:34:10 +0000

本文是学习【Qt 学习之路】的学习笔记，源码非原创。Github同步本文更改的代码。

在建立 Qt 学习代码仓时，推送到远程的代码比较乱，所以用gitignore文件屏蔽了一些。相关方法在这里。

资源文件

Qt 资源系统是一个跨平台的资源机制，用于将程序运行时所需要的资源以二进制的形式存储于可执行文件内部。如果你的程序需要加载特定的资源（图标、文本翻译等），那么，将其放置在资源文件中，就再也不需要担心这些文件的丢失。也就是说，如果你将资源以资源文件形式存储，它是会编译到可执行文件内部。

使用 QtCreator 的相关方法，讲得也很清楚了，就不赘述了。

不使用 QtCreator 添加资源文件

在使用命令行编译运行时，并不能像在 QtCreator 中一样，可以自动的生成一个.qrc文件，这就需要我们自己去编写。从原文的讲解中我们也知道，它就是一个XML描述文件，里面定义了文件位置等信息。如原文中的.qrc文件：

<RCC>
    <qresource prefix="/images">
        <file alias="doc-open">document-open.png</file>
    </qresource>
</RCC>

其中

<RCC>
    <qresource>

    </qresource>
</RCC>

是固定的标记，再往中间加东西。如果学过html语言就很容易理解。其中prefix="/images"就是自动加上前缀/images，因为图片在images目录下，每次都加这个路径太麻烦，太长。

alias="doc-open"意思是将document-open.png这个文件起个别名，原来的太长了。下次再用document-open.png就只需要用doc-open就行了。

我们知道了这些，就可以编写一个自己的.qrc文件了。我也自己下载了一个打开文件的图标open.png，文件比较少，就和代码放在同一个目录下了。我们将其命名为ico.qrc，这个文件中以后都存放有关图标的资源，我们开始编写：

<RCC>
    <qresource>
        <file>open.png</file>
    </qresource>
</RCC>

因为添加资源后需要更新.pro文件才能正常编译，所以需要在.pro中加入RESOURCES 信息，就在.pro文件最后一行加入：

RESOURCES += ico.qrc

然后输入命令

qmake MainWindow.pro
make clean #因为之前可能make过，先清理一遍
make
./MainWindow

如果一切顺利，将会得到下面的窗口： Responsive Image

Responsive Image

Reference

https://www.devbean.net/2012/08/qt-study-road-2-action/

Linux(Ubuntu) 环境下安装 Qt

Tue, 27 Jul 2021 16:34:50 +0000

真蠢，之前费那么大劲，只要一句命令就完事了

下载安装

sudo apt install qtcreator

但是在用命令行构建 project 时可能会报错

qmake -project
could not find a Qt installation of ''

这时候需要

sudo apt-get install qt5-default

好了可以愉快玩耍了。

瞎折腾

下载 Qt

从 Qt5.15.0 起，对于开源用户，Qt 官方不再提供独立安装文件，且不再有 bug 修复版本（比如 Qt5.15.1），如果从官网下载，需要自己编译。虽然想试试编译，但是虚拟机刚开始开的空间太小了，还是另寻他法吧。以后有机会再来编译试试新功能。若读者有兴趣可以从官网下载源码并编译。或者参考官方的编译教程，从 GitHub 上下载。

国内有一些镜像站，提供 qt 镜像下载：清华大学：https://mirrors.tuna.tsinghua.edu.cn/qt/archive/qt/ 中国科学技术大学：http://mirrors.ustc.edu.cn/qtproject/ 北京理工大学：https://mirrors.cnnic.cn/qt/

以清华大学的镜像为例，找到archive/qt/5.14/5.14.0/qt-opensource-linux-x64-5.14.0.run，点击即可开始下载。

qt 5.15 已经不提供安装包，想要最新版本，只能下 5.14，但是 5.14.2 下载没资源，下不动，如果遇到下不动的情况换一个版本吧

安装 Qt

下载的.run文件双击是无法安装的，因为它还没有可执行的权限，需要我们赋给它执行权限，打开终端进入安装包的目录。

chmod +x filename.run

chmod命令是控制用户对文件的权限修改的命令，x是可执行权限的参数。执行以上命令后就可以直接双击安装了。

网上一些教程可以跳过登录，我没找到跳过按钮，需要注册一个账号才能继续安装。 Responsive Image

安装目录一般选择在/opt目录下 Responsive Image

安装的附加组件最好都选择，以免后期使用再安装麻烦。Qt Creator 肯定要装的。 Responsive Image

安装依赖库

apt-get install g++
apt-get install libgl1-mesa-dev
apt-get install libqt4-dev
apt-get install build-essential # Build Essential，它是一个元软件包，可让您在Ubuntu中安装和使用c ++工具。
sudo apt install qt5-default # 如果要将Qt 5用作默认的Qt Creator版本需要安装，否则会报 qmake: could not find a Qt installation of ''的错误

使用 Qt Creator 创建第一个程序

使用 Qt Creator 创建

首先我们先创建一个不带窗口的 HelloWorld 程序，测试安装是否成功，打开 Qt Creator-文件 - 新建文件或项目，选择 Non-Qt Project-Plain C++ Application。 Responsive Image

接下来就设置项目名等，一直下一步。完成后就可以在编辑器看到如下 Responsive Image

点击左下角运行按钮就可以得到如下： Responsive Image

再创建一个带窗口的 HelloWorld，在选择模板时选择 Application-Qt Widgets Application。一路点下一步就可以完成创建，运行后就可得到一个灰白的 HelloWorld 窗口。

命令行编译第一个 Qt 程序

首先创建工作目录HelloWorldQt

mkdir HelloWorld

进入项目目录下，新建一个main.cpp文件

cd HelloWorldQt
vim main.cpp

编辑以下内容：

#include <QApplication>
#include <QLabel>
#include <QWidget>

int main(int argc, char *argv[ ])
{
    QApplication app(argc, argv);
    QLabel hello("<center>Welcome to my first Qt program</center>");
    hello.setWindowTitle("My First Qt Program");
    hello.resize(400, 400);
    hello.show();
    return app.exec();
}

建立 QtProject 文件

qmake -project

用vim打开HelloWorldQt.pro文件，添加以下内容

QT += gui widgets

Responsive Image

运行qmake，使项目 platform-specific，会得到一个Makefile文件

qmake HelloWorldQt.pro

使用make命令将Makefile编译为可执行程序

➜  HelloWorldQt make
g++ -c -pipe -O2 -Wall -W -D_REENTRANT -fPIC -DQT_DEPRECATED_WARNINGS / 
-DQT_NO_DEBUG -DQT_WIDGETS_LIB /
-DQT_GUI_LIB -DQT_CORE_LIB -I. / 
-I. -isystem / 
/usr/include/x86_64-linux-gnu/qt5 -isystem / 
/usr/include/x86_64-linux-gnu/qt5/QtWidgets /
-isystem /usr/include/x86_64-linux-gnu/qt5/QtGui /
-isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -I. /
-I/usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -o main.o main.cpp
g++ -Wl,-O1 -o HelloWorldQt main.o  /
/usr/lib/x86_64-linux-gnu/libQt5Widgets.so /
/usr/lib/x86_64-linux-gnu/libQt5Gui.so / 
/usr/lib/x86_64-linux-gnu/libQt5Core.so /
/usr/lib/x86_64-linux-gnu/libGL.so -lpthread

如果一切顺利，执行可以得到如下

./HelloWorldQt

Responsive Image

Qt on 夜云泊

Qt 编译后的程序放到指定目录，屏蔽 qDebug 输出

可执行程序放到指定目录

屏蔽 qDebug 输出

参考

解决 Qt-QObject::connect: Cannot queue arguments of type‘QTextCursor’错误

保留现场

探究原因

解决方法

Qt 跨窗口，控件类传递数据

问题简介

B 向 A（C 向 A）传递参数

B 向 C（C 向 B）传递参数

A 向 B（A 向 C）传递参数

Clang-Format 格式化代码

安装

Linux

windows

使用

入门使用

进阶配置

VSCode

QtCreator

Eclipse

配置简介

导出.clang-format文件

各个选项的含义

格式化最新的commit代码

常见问题

如何看懂官方文档并编写配置文件

宏定义对齐失效

解决 QT 点击按钮无响应

保留现场

探究原因

解决方法

解决 QT 在构造函数中写的控件不显示的问题

保留现场

探究原因

解决方法

QWidget 中 update 不执行 paintEvent

保留现场

探究原因

解决方法

QtCreator 快速添加注释模板

需求

方法

Qt 修改 UI 文件不生效

保留现场

探究原因

解决方法

QtCreator 修改项目构建目录

保留现场

解决方法

Qt 命令行带参数启动 Qt 程序

简介

添加程序属性信息，帮助，版本

自定义参数

获取参数值

Qt 文件系统

QFile 及其相关类

二进制文件读写

文本文件读写

Qt 绘制系统

绘制系统简介

画刷和画笔

反走样

坐标系统

Qt 模仿登录界面-页面反转效果

效果

网络参数设置界面布局

网络参数设置界面

QPainterPath类

setFillRule()设置填充模式

addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3)圆角矩形

setRenderHint()开启反走样

初始化旋转窗口

旋转窗口

QPropertyAnimation动画类

paintEvent绘图事件

Qt 模仿登录界面-交互响应

导出`.clang-format`文件

`QPainterPath`类

`setFillRule()`设置填充模式

`addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3)`圆角矩形

`setRenderHint()`开启反走样

`QPropertyAnimation`动画类

`paintEvent`绘图事件

`globalPos()`获取全局的坐标

`move()`移动窗口

`hidPopup()`隐藏下拉框

`takeItem()`删除部件

`deleteLater()`稍后删除对象

`addSeparator()`添加分割线

`mapToGlobal()`映射成全局坐标

`raise()`将控件置于顶层

`setPlaceholderText()`设置文本提示

`setCursor()`设置鼠标形态

`addStretch()`布局加入弹簧