QtCreator源码分析(三)——QtCreator源码结构分析

一、QtCreator源码目录简介

QtCreator-2.8.1包含5000多个文件,代码行数超过了110万行。

源码目录如下:

 bin: 生成Linux平台shell脚本。

dist: 安装文件配置信息和版本更新记录。

doc: 生成doxygen文档的配置文件。

lib:Qt组件相关的QML文件

qbs:QBS 配置文件。QBS,即 Qt Build Suite,是一种跨平台的编译工具,目的是将高层的项目描述(使用类似 QML 的语言)转换成底层的编译描述(供 make 等工具使用的信息)。它可以简化多平台的编译过程。QBS 与 qmake 类似,区别在于前者适用于任意项目,而后者一般仅供 Qt 项目使用。我们在阅读代码时将关注 qmake,不会深入研究 QBS 的使用。

scripts: QtCreator使用的perl以及python等脚本。

share: 源代码中所需要的一些非代码共享文件,例如代码模板等。

src: QtCreator源代码文件。

tests: QtCreator测试代码。

HACKING: QtCreator编码规范。

LICENSE.LGPL: LGPL协议。

qtcreator.pri: QtCreator项目需要使用的通用配置,一般会被include到大部分 pro文件。

qtcreator.pro: QtCreator的qmake项目文件。

qtcreator.qbs:  Qt Creator 的 QBS 项目文件。

README: 有关如何编译QtCreator等相关事宜的一些说明。

.gitignore: git忽略文件配置。

.gitmodules:git 子模块配置

二、QtCreator源码目录结构分析

Qt工程源码通常从qtcreator.pro文件开始阅读。

 1、qtcreator.pro 

include(qtcreator.pri)
#qtcreator.pri 中定义了很多函数和适用于各个模块的通用操作
#使用include操作符将其引入一个pro文件,qmake 会自动处理引用操作

#version check qt
!minQtVersion(4, 8, 0) {
    message("Cannot build Qt Creator with Qt version $${QT_VERSION}.")
    error("Use at least Qt 4.8.0.")
}

#判断Qt的版本。minQtVersion()是在qtcreator.pri中定义的函数,
#Qt版本低于4.8.0时执行块中语句
#message()是qmake预定义的函数,可以在控制台输出一段文本
#$${QT_VERSION}是占位符,会使用QT_VERSION变量的内容进行替换。
include(doc/doc.pri)

TEMPLATE  = subdirs
#TEMPLATE即代码模板,将告诉qmake要怎么生成最后的文件,可选值如下:
#app:创建用于构建可执行文件的Makefile。
#lib:创建用于构建库的 Makefile。
#subdirs:创建依次构建子目录中文件的Makefile。子目录使用SUBDIRS变量指定。
#aux:创建不构建任何东西的Makefile。如果构建目标不需要编译器,就可以使用
#例如,项目使用的是解释型语言。此时生成的Makefile仅适用于基Makefile的生成器
#不一定能供vcxproj或Xcode使用。
#vcapp:仅适用于Windows平台,用于生成VS应用程序项目。
#vclib:仅适用于Windows平台,用于生成VS库项目。
CONFIG   += ordered

#按照SUBDIRS书写顺序来编译
#虽然将源代码分为不同目录,但是目录之间是存在依赖关系的。
#比如,一个基础类库要被其它所有模块使用,在编译时,基础类库应该首先被编译。

SUBDIRS = src share lib/qtcreator/qtcomponents

#按照顺序,应该是先编译src,然后编译share,最后lib/qtcreator/qtcomponents
unix:!macx:!isEmpty(copydata):SUBDIRS += bin
#对于Unix平台(unix),如果不是Mac OS(!macx),
#并且copydata不为空(!isEmpty(copydata)),则需要再增加一个bin目录
!isEmpty(BUILD_TESTS):SUBDIRS += tests
#如果BUILD_TESTS不为空(!isEmpty(BUILD_TESTS)),则增加一个tests目录
OTHER_FILES += dist/copyright_template.txt \
    $$files(dist/changes-*) \
    qtcreator.qbs \
    qbs/pluginspec/pluginspec.qbs \
    $$files(dist/installer/ifw/config/config-*) \
    dist/installer/ifw/packages/org.qtproject.qtcreator/meta/package.xml.in \
    dist/installer/ifw/packages/org.qtproject.qtcreator.application/meta/installscript.qs \
    dist/installer/ifw/packages/org.qtproject.qtcreator.application/meta/package.xml.in \
    dist/installer/ifw/packages/org.qtproject.qtcreator.application/meta/license.txt \
    $$files(scripts/*.py) \
    $$files(scripts/*.sh) \
    $$files(scripts/*.pl)
#需要在最终的目标包括的文件

qmake_cache = $$targetPath($$IDE_BUILD_TREE/.qmake.cache)
!equals(QMAKE_HOST.os, Windows) {
    maybe_quote = "\""
    maybe_backslash = "\\"
}

#如果操作系统时Windows,双引号为",反斜线为\

system("echo $${maybe_quote}$${LITERAL_HASH} config for qmake$${maybe_quote} > $$qmake_cache")
# Make sure the qbs dll ends up alongside the Creator executable.
exists(src/shared/qbs/qbs.pro) {
    system("echo QBS_DLLDESTDIR = $${IDE_BUILD_TREE}/bin >> $$qmake_cache")
    system("echo QBS_DESTDIR = $${maybe_backslash}\"$${IDE_LIBRARY_PATH}$${maybe_backslash}\" >> $$qmake_cache")
    system("echo QBSLIBDIR = $${maybe_backslash}\"$${IDE_LIBRARY_PATH}$${maybe_backslash}\" >> $$qmake_cache")
    system("echo QBS_INSTALL_PREFIX = $${QTC_PREFIX} >> $$qmake_cache")
    system("echo QBS_LIB_INSTALL_DIR = $${QTC_PREFIX}/$${IDE_LIBRARY_BASENAME}/qtcreator >> $$qmake_cache")
    system("echo QBS_RESOURCES_BUILD_DIR = $${maybe_backslash}\"$${IDE_DATA_PATH}/qbs$${maybe_backslash}\" >> $$qmake_cache")
    system("echo QBS_RESOURCES_INSTALL_DIR = $${QTC_PREFIX}/share/qtcreator/qbs >> $$qmake_cache")
    system("echo CONFIG += qbs_no_dev_install >> $$qmake_cache")
}
_QMAKE_CACHE_ = $$qmake_cache # Qt 4 support prevents us from using cache(), so tell Qt 5 about the cache

contains(QT_ARCH, i386): ARCHITECTURE = x86
else: ARCHITECTURE = $$QT_ARCH
#如果QT_ARCH中有i386,则将ARCHITECTURE赋值为x86,否则就是$$QT_ARCH
macx: PLATFORM = "mac"
else:win32: PLATFORM = "windows"
else:linux-*: PLATFORM = "linux-$${ARCHITECTURE}"
else: PLATFORM = "unknown"
#根据操作系统定义了一个新的宏PLATFORM

PATTERN = $${PLATFORM}$(INSTALL_EDITION)-$${QTCREATOR_VERSION}$(INSTALL_POSTFIX)

macx:INSTALLER_NAME = "qt-creator-$${QTCREATOR_VERSION}"
else:INSTALLER_NAME = "qt-creator-$${PATTERN}"
#根据操作系统平台,定义新的宏INSTALLER_NAME
macx {
    APPBUNDLE = "$$OUT_PWD/bin/Qt Creator.app"
    BINDIST_SOURCE = "$$OUT_PWD/bin/Qt Creator.app"
    BINDIST_INSTALLER_SOURCE = $$BINDIST_SOURCE
    deployqt.commands = $$PWD/scripts/deployqtHelper_mac.sh \"$${APPBUNDLE}\" \"$$[QT_INSTALL_TRANSLATIONS]\" \"$$[QT_INSTALL_PLUGINS]\" \"$$[QT_INSTALL_IMPORTS]\" \"$$[QT_INSTALL_QML]\"

    codesign.commands = codesign -s \"$(SIGNING_IDENTITY)\" $(SIGNING_FLAGS) \"$${APPBUNDLE}\"
    dmg.commands = $$PWD/scripts/makedmg.sh $$OUT_PWD/bin qt-creator-$${PATTERN}.dmg
    dmg.depends = deployqt
    QMAKE_EXTRA_TARGETS += codesign dmg
#$$OUT_PWD是qmake生成的Makefile所在的文件夹
} else {
    BINDIST_SOURCE = "$(INSTALL_ROOT)$$QTC_PREFIX"
    BINDIST_INSTALLER_SOURCE = "$$BINDIST_SOURCE/*"
    deployqt.commands = $$PWD/scripts/deployqt.py -i \"$(INSTALL_ROOT)$$QTC_PREFIX\"
    deployqt.depends = install
    win32 {
        deployartifacts.depends = install
        deployartifacts.commands = git clone "git://gitorious.org/qt-creator/binary-artifacts.git" -b $$BINARY_ARTIFACTS_BRANCH&& xcopy /s /q /y /i "binary-artifacts\\win32" \"$(INSTALL_ROOT)$$QTC_PREFIX\"&& rmdir /s /q binary-artifacts

        QMAKE_EXTRA_TARGETS += deployartifacts
    }
}

INSTALLER_ARCHIVE_FROM_ENV = $$(INSTALLER_ARCHIVE)
isEmpty(INSTALLER_ARCHIVE_FROM_ENV) {
    INSTALLER_ARCHIVE = $$OUT_PWD/qt-creator-$${PATTERN}-installer-archive.7z
} else {
    INSTALLER_ARCHIVE = $$OUT_PWD/$$(INSTALLER_ARCHIVE)
}


bindist.depends = deployqt
bindist.commands = 7z a -mx9 $$OUT_PWD/qt-creator-$${PATTERN}.7z \"$$BINDIST_SOURCE\"
bindist_installer.depends = deployqt
bindist_installer.commands = 7z a -mx9 $${INSTALLER_ARCHIVE} \"$$BINDIST_INSTALLER_SOURCE\"
installer.depends = bindist_installer
installer.commands = $$PWD/scripts/packageIfw.py -i \"$(IFW_PATH)\" -v $${QTCREATOR_VERSION} -a \"$${INSTALLER_ARCHIVE}\" "$$INSTALLER_NAME"

macx {
    # this should be very temporary:
    MENU_NIB = $$(MENU_NIB_FILE)
    isEmpty(MENU_NIB): MENU_NIB = "FATAT_SET_MENU_NIB_FILE_ENV"
    copy_menu_nib_installer.commands = cp -R \"$$MENU_NIB\" \"$${INSTALLER_NAME}.app/Contents/Resources\"

    codesign_installer.commands = codesign -s \"$(SIGNING_IDENTITY)\" $(SIGNING_FLAGS) \"$${INSTALLER_NAME}.app\"
    dmg_installer.commands = hdiutil create -srcfolder "$${INSTALLER_NAME}.app" -volname \"Qt Creator\" -format UDBZ "qt-creator-$${PATTERN}-installer.dmg" -ov -scrub -stretch 2g
    QMAKE_EXTRA_TARGETS += codesign_installer dmg_installer copy_menu_nib_installer
}


win32 {
    deployqt.commands ~= s,/,\\\\,g
    bindist.commands ~= s,/,\\\\,g
    bindist_installer.commands ~= s,/,\\\\,g
    installer.commands ~= s,/,\\\\,g
#~=运算符将符合正则表达式的内容替换为后面的部分

#s,/,\\\\,g表示将输入字符串中的/全部替换为\

}


QMAKE_EXTRA_TARGETS += deployqt bindist bindist_installer installer
#将目标都添加到QMAKE_EXTRA_TARGETS

2、qtcreator.pri 

!isEmpty(QTCREATOR_PRI_INCLUDED):error("qtcreator.pri already included")
QTCREATOR_PRI_INCLUDED = 1
#如果存在QTCREATOR_PRI_INCLUDED,抛出错误,防止QTCREATOR_PRI_INCLUDED被多次引入
QTCREATOR_VERSION = 2.8.1
# Qt Creator的版本
BINARY_ARTIFACTS_BRANCH = 2.8
#指定git的分支
isEqual(QT_MAJOR_VERSION, 5) {
#Qt版本高于5时,定义替换函数cleanPath
defineReplace(cleanPath) {
    return($$clean_path($$1))
}

#定义替换函数使用的语句是defineReplace,其参数是函数名字
defineReplace(targetPath) {
    return($$shell_path($$1))
}

} else { # qt5
#Qt版本低于5时,定义替换函数cleanPath
defineReplace(cleanPath) {
    win32:1 ~= s|\\\\|/|g
    contains(1, ^/.*):pfx = /
    else:pfx =
    segs = $$split(1, /)
    out =
    for(seg, segs) {
        equals(seg, ..):out = $$member(out, 0, -2)
        else:!equals(seg, .):out += $$seg
    }
    return($$join(out, /, $$pfx))
}

defineReplace(targetPath) {
    return($$replace(1, /, $$QMAKE_DIR_SEP))
}

} # qt5

defineReplace(qtLibraryName) {
   unset(LIBRARY_NAME)
#取消LIBRARY_NAME定义
   LIBRARY_NAME = $$1
#定义LIBRARY_NAME并使用qtLibraryName函数第一个参数赋值
   CONFIG(debug, debug|release) {
      !debug_and_release|build_pass {
          mac:RET = $$member(LIBRARY_NAME, 0)_debug
              else:win32:RET = $$member(LIBRARY_NAME, 0)d
      }
   }
   isEmpty(RET):RET = $$LIBRARY_NAME
   return($$RET)
}

defineTest(minQtVersion) {
#定义测试函数使用的语句是defineTest,其参数是函数名字minQtVersion
    maj = $$1
    min = $$2
    patch = $$3
    isEqual(QT_MAJOR_VERSION, $$maj) {
        isEqual(QT_MINOR_VERSION, $$min) {
            isEqual(QT_PATCH_VERSION, $$patch) {
                return(true)
            }
            greaterThan(QT_PATCH_VERSION, $$patch) {
                return(true)
            }
        }
        greaterThan(QT_MINOR_VERSION, $$min) {
            return(true)
        }
    }
    greaterThan(QT_MAJOR_VERSION, $$maj) {
        return(true)
    }

    return(false)
}

isEqual(QT_MAJOR_VERSION, 5) {

# For use in custom compilers which just copy files
defineReplace(stripSrcDir) {
    return($$relative_path($$absolute_path($$1, $$OUT_PWD), $$_PRO_FILE_PWD_)
}

} else { # qt5

# For use in custom compilers which just copy files
win32:i_flag = i
defineReplace(stripSrcDir) {
    win32 {
        !contains(1, ^.:.*):1 = $$OUT_PWD/$$1
    } else {
        !contains(1, ^/.*):1 = $$OUT_PWD/$$1
    }
    out = $$cleanPath($$1)
    out ~= s|^$$re_escape($$_PRO_FILE_PWD_/)||$$i_flag
    return($$out)
}

#OUT_PWD表示生成的makefile所在目录
#_PRO_FILE_PWD_表示.pro文件所在目录
} # qt5

!isEmpty(BUILD_TESTS):TEST = 1

isEmpty(TEST):CONFIG(debug, debug|release) {
    !debug_and_release|build_pass {
        TEST = 1
    }
}

isEmpty(IDE_LIBRARY_BASENAME) {
    IDE_LIBRARY_BASENAME = lib
}

equals(TEST, 1) {
    QT +=testlib
    DEFINES += WITH_TESTS
}

IDE_SOURCE_TREE = $$PWD
#源码代码所在目录,根据.pro文件或.pri文件的不同位置而有所不同
isEmpty(IDE_BUILD_TREE) {
    sub_dir = $$_PRO_FILE_PWD_
    sub_dir ~= s,^$$re_escape($$PWD),,
#参数string中出现的所有正则表达式中的保留字进行转义
    IDE_BUILD_TREE = $$cleanPath($$OUT_PWD)
    IDE_BUILD_TREE ~= s,$$re_escape($$sub_dir)$,,
#IDE_BUILD_TREE输出根目录

}

#构建路径
IDE_APP_PATH = $$IDE_BUILD_TREE/bin
#最终输出的二进制文件的位置
macx {
    IDE_APP_TARGET   = "Qt Creator"
    IDE_LIBRARY_PATH = $$IDE_APP_PATH/$${IDE_APP_TARGET}.app/Contents/PlugIns
    IDE_PLUGIN_PATH  = $$IDE_LIBRARY_PATH
    IDE_LIBEXEC_PATH = $$IDE_APP_PATH/$${IDE_APP_TARGET}.app/Contents/Resources
    IDE_DATA_PATH    = $$IDE_APP_PATH/$${IDE_APP_TARGET}.app/Contents/Resources
    IDE_DOC_PATH     = $$IDE_DATA_PATH/doc
    IDE_BIN_PATH     = $$IDE_APP_PATH/$${IDE_APP_TARGET}.app/Contents/MacOS
    copydata = 1
    isEmpty(TIGER_COMPAT_MODE):TIGER_COMPAT_MODE=$$(QTC_TIGER_COMPAT)
    !isEqual(QT_MAJOR_VERSION, 5) {
        # Qt5 doesn't support 10.5, and will set the minimum version correctly to 10.6 or 10.7.
        isEmpty(TIGER_COMPAT_MODE) {
            QMAKE_CXXFLAGS *= -mmacosx-version-min=10.5
            QMAKE_LFLAGS *= -mmacosx-version-min=10.5
        }
    }
} else {
    contains(TEMPLATE, vc.*):vcproj = 1
    IDE_APP_TARGET   = qtcreator
    IDE_LIBRARY_PATH = $$IDE_BUILD_TREE/$$IDE_LIBRARY_BASENAME/qtcreator
    IDE_PLUGIN_PATH  = $$IDE_LIBRARY_PATH/plugins
    IDE_LIBEXEC_PATH = $$IDE_APP_PATH # FIXME
    IDE_DATA_PATH    = $$IDE_BUILD_TREE/share/qtcreator
    IDE_DOC_PATH     = $$IDE_BUILD_TREE/share/doc/qtcreator
    IDE_BIN_PATH     = $$IDE_APP_PATH
    !isEqual(IDE_SOURCE_TREE, $$IDE_BUILD_TREE):copydata = 1
}

INCLUDEPATH += \
    $$IDE_BUILD_TREE/src \ # for <app/app_version.h>
    $$IDE_SOURCE_TREE/src/libs \
    $$IDE_SOURCE_TREE/tools \
    $$IDE_SOURCE_TREE/src/plugins
#INCLUDEPATH给出了头文件检索目录,在头文件包含中不必写全路径
CONFIG += depend_includepath

LIBS += -L$$IDE_LIBRARY_PATH
#LIBS是qmake连接第三方库的配置。-L指定了第三方库所在的目录;
#-l指定了第三方库的名字。如果没有-l,则会连接-L指定的目录中所有的库。
!isEmpty(vcproj) {
    DEFINES += IDE_LIBRARY_BASENAME=\"$$IDE_LIBRARY_BASENAME\"
} else {
    DEFINES += IDE_LIBRARY_BASENAME=\\\"$$IDE_LIBRARY_BASENAME\\\"
}

DEFINES += QT_CREATOR QT_NO_CAST_TO_ASCII QT_NO_CAST_FROM_ASCII
!macx:DEFINES += QT_USE_FAST_OPERATOR_PLUS QT_USE_FAST_CONCATENATION

unix {
    CONFIG(debug, debug|release):OBJECTS_DIR = $${OUT_PWD}/.obj/debug-shared
    CONFIG(release, debug|release):OBJECTS_DIR = $${OUT_PWD}/.obj/release-shared

    CONFIG(debug, debug|release):MOC_DIR = $${OUT_PWD}/.moc/debug-shared
    CONFIG(release, debug|release):MOC_DIR = $${OUT_PWD}/.moc/release-shared

    RCC_DIR = $${OUT_PWD}/.rcc
    UI_DIR = $${OUT_PWD}/.uic
}

win32-msvc* { 
    #Don't warn about sprintf, fopen etc being 'unsafe'
    DEFINES += _CRT_SECURE_NO_WARNINGS
}

qt:greaterThan(QT_MAJOR_VERSION, 4) {
    contains(QT, core): QT += concurrent
    contains(QT, gui): QT += widgets
    DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x040900
}

QBSFILE = $$replace(_PRO_FILE_, \\.pro$, .qbs)
exists($$QBSFILE):OTHER_FILES += $$QBSFILE

# recursively resolve plugin deps
done_plugins =
for(ever) {
    isEmpty(QTC_PLUGIN_DEPENDS): \
        break()
#默认QTC_PLUGIN_DEPENDS没有设置,跳出循环
    done_plugins += $$QTC_PLUGIN_DEPENDS
    for(dep, QTC_PLUGIN_DEPENDS) {
        include($$PWD/src/plugins/$$dep/$${dep}_dependencies.pri)
        LIBS += -l$$qtLibraryName($$QTC_PLUGIN_NAME)
    }

    QTC_PLUGIN_DEPENDS = $$unique(QTC_PLUGIN_DEPENDS)
    QTC_PLUGIN_DEPENDS -= $$unique(done_plugins)
}

#遍历处理插件依赖,允许用户在编译时直接通过QTC_PLUGIN_DEPENDS指定插件依赖。
#如果没有,则根据每个插件自己的依赖处理。

# recursively resolve library deps
done_libs =
for(ever) {
    isEmpty(QTC_LIB_DEPENDS): \
        break()
    done_libs += $$QTC_LIB_DEPENDS
    for(dep, QTC_LIB_DEPENDS) {
        include($$PWD/src/libs/$$dep/$${dep}_dependencies.pri)
        LIBS += -l$$qtLibraryName($$QTC_LIB_NAME)
    }

    QTC_LIB_DEPENDS = $$unique(QTC_LIB_DEPENDS)
    QTC_LIB_DEPENDS -= $$unique(done_libs)
}
#遍历处理库依赖

3、src.pro

Qtcreator.pro文件中SUBDIRS定义了编译的顺序,因此先看src目录。

SUBDIRS = src share lib/qtcreator/qtcomponents

   src.pro内容如下:

TEMPLATE  = subdirs
CONFIG   += ordered

SUBDIRS = \
    libs \
    app \
    plugins \
    tools

4、libs.pro

libs.pro内容如下:

TEMPLATE  = subdirs

SUBDIRS   = \
    aggregation \
    extensionsystem \
    utils \
    languageutils \
    cplusplus \
    qmljs \
    qmldebug \
    qmleditorwidgets \
    glsl \
    ssh \
    zeroconf

for(l, SUBDIRS) {
    QTC_LIB_DEPENDS =
    include($$l/$${l}_dependencies.pri)
    lv = $${l}.depends
    $$lv = $$QTC_LIB_DEPENDS
}

#遍历SUBDIRS中的目录项,QTC_LIB_DEPENDS赋值为$$l/$${l}_dependencies.pri输出值
#l为aggregation,QTC_LIB_DEPENDS是include(aggregation/aggregation_dependencies.pri)输出值
SUBDIRS += \
    utils/process_stub.pro \
    qtcomponents/styleitem

exists(../shared/qbs/qbs.pro):SUBDIRS += \
    ../shared/qbs/src/lib \
    ../shared/qbs/src/plugins \
    ../shared/qbs/static.pro

win32:SUBDIRS += utils/process_ctrlc_stub.pro

# Windows: Compile Qt Creator CDB extension if Debugging tools can be detected.    
win32 {
    include(qtcreatorcdbext/cdb_detect.pri)
    exists($$CDB_PATH):SUBDIRS += qtcreatorcdbext
}

5、aggregation.pro

aggregation.pro内容如下:

include(../../qtcreatorlibrary.pri)


DEFINES += AGGREGATION_LIBRARY

HEADERS = aggregate.h \
    aggregation_global.h

SOURCES = aggregate.cpp

qtcreatorlibrary.pri内容如下:

include($$replace(_PRO_FILE_PWD_, ([^/]+$), \\1/\\1_dependencies.pri))
#qt-creator/src/libs/aggregation/aggregation_dependencies.pri
TARGET = $$QTC_LIB_NAME
#QTC_LIB_NAME在aggregation_dependencies.pri中定义,值为Aggregation
include(../qtcreator.pri)
#qtcreator.pri
# use precompiled header for libraries by default
isEmpty(PRECOMPILED_HEADER):PRECOMPILED_HEADER = $$PWD/shared/qtcreator_pch.h
win32 {
    DLLDESTDIR = $$IDE_APP_PATH
}

DESTDIR = $$IDE_LIBRARY_PATH
include(rpath.pri)
TARGET = $$qtLibraryName($$TARGET)
TEMPLATE = lib
CONFIG += shared dll
contains(QT_CONFIG, reduce_exports):CONFIG += hide_symbols
!macx {
    win32 {
        dlltarget.path = $$QTC_PREFIX/bin
        INSTALLS += dlltarget
    } else {
        target.path = $$QTC_PREFIX/$$IDE_LIBRARY_BASENAME/qtcreator
        INSTALLS += target
    }
}

Aggregation类分析:

Aggregation::Aggregate将多个相关组件定义为一个聚合体,从而使外界可以将多个组件视为一个整体。类似于一个类通过C++多继承实现多个接口。

class Aggregation : public Interface1, public Interface2, public Interface3
{

}

虽然C++支持多继承,但多继承通常会带来一些问题,所以一般会避免使用。Aggregate仅限于接口,从而规避了多继承的问题。Aggregate内部的组件可以是任意QObject的子类。Aggregate可以实现:

Aggregate内部的每个组件都可以相互“转换”

Aggregate内部的每个组件的生命周期都被绑定在一起,例如,其中任意一个被析构,那么,剩余的所有组件也就会被析构

Aggregate的使用示例如下:

class Interface1 : public QObject
{

};

class Interface2 : public QObject
{  

};

Interface1* objetct1 = new Interface1;
Interface2* objetct2 = new Interface2;
Aggregate* aggregate = new Aggregate;
//Aggregate将objetct1、objetct2捆绑为一个聚合体
aggregate->add(objetct1);
aggregate->add(objetct2);
//删除任意一个都会销毁聚合体
delete objetct1;//同时析构objetct2

   聚合实例aggregate现在有两个接口的实现。如果需要转换成相应接口

Interface1* iface1Ptr = Aggregation::query<Interface1>(&aggregate);
Interface2* iface2Ptr = Aggregation::query<Interface2>(&aggregate);

Aggregate实现如下:

Aggregation.h文件:

#ifndef AGGREGATE_H
#define AGGREGATE_H

#include "aggregation_global.h"

#include <QObject>
#include <QList>
#include <QHash>
#include <QReadWriteLock>
#include <QReadLocker>

namespace Aggregation {

class AGGREGATION_EXPORT Aggregate : public QObject
{
    Q_OBJECT
public:
    Aggregate(QObject *parent = 0);
    virtual ~Aggregate();
    void add(QObject *component);
    void remove(QObject *component);
    //将组件转化为一个聚合体对象
    template <typename T> T *component() {
        QReadLocker(&lock());
        //遍历属性中的组件连表
        foreach (QObject *component, m_components) {
            //如果属性连表中存在可以转换为本聚合体的组件
            if (T *result = qobject_cast<T *>(component))
                return result;
        }

        return (T *)0;
    }

    //将多个组件转换为聚合体连表
    template <typename T> QList<T *> components() {
        QReadLocker(&lock());
        QList<T *> results;
        foreach (QObject *component, m_components) {
            if (T *result = qobject_cast<T *>(component)) {
                results << result;
            }
        }
        return results;
    }

    static Aggregate *parentAggregate(QObject *obj);
    static QReadWriteLock &lock();
signals:
    void changed();
private slots:
    void deleteSelf(QObject *obj);
private:
    //聚合体注册管理器函数
    static QHash<QObject *, Aggregate *> &aggregateMap();
    //聚合体属性连表,存储聚合体包含的组件
    QList<QObject *> m_components;
};

// get a component via global template function
template <typename T> T *query(Aggregate *obj)
{
    if (!obj)
        return (T *)0;
    return obj->template component<T>();
}

template <typename T> T *query(QObject *obj)
{
    if (!obj)
        return (T *)0;
    T *result = qobject_cast<T *>(obj);
    if (!result) {
        QReadLocker(&lock());
        Aggregate *parentAggregation = Aggregate::parentAggregate(obj);
        result = (parentAggregation ? query<T>(parentAggregation) : 0);
    }

    return result;
}

// get all components of a specific type via template function
template <typename T> QList<T *> query_all(Aggregate *obj)
{
    if (!obj)
        return QList<T *>();
    return obj->template components<T>();
}

template <typename T> QList<T *> query_all(QObject *obj)
{
    if (!obj)
        return QList<T *>();
    QReadLocker(&lock());
    Aggregate *parentAggregation = Aggregate::parentAggregate(obj);
    QList<T *> results;
    if (parentAggregation)
        results = query_all<T>(parentAggregation);
    else if (T *result = qobject_cast<T *>(obj))
        results.append(result);
    return results;
}

} // namespace Aggregation

#endif // AGGREGATE_H

Aggregation.cpp文件:

#include "aggregate.h"


#include <QWriteLocker>
#include <QDebug>
using namespace Aggregation;

Aggregate *Aggregate::parentAggregate(QObject *obj)
{
    QReadLocker locker(&lock());
    return aggregateMap().value(obj);
}

QHash<QObject *, Aggregate *> &Aggregate::aggregateMap()
{
    static QHash<QObject *, Aggregate *> map;
    return map;
}

QReadWriteLock &Aggregate::lock()
{
    static QReadWriteLock lock;
    return lock;
}

Aggregate::Aggregate(QObject *parent)
    : QObject(parent)
{
    QWriteLocker locker(&lock());
    //Aggregate本身向Aggregate聚合体中注册
    aggregateMap().insert(this, this);
}

Aggregate::~Aggregate()
{
    QList<QObject *> components;
    {
        QWriteLocker locker(&lock());
        //遍历m_components包含的组件
        foreach (QObject *component, m_components) {
            //断开destroyed与槽函数deleteSelf的关联
            disconnect(component, SIGNAL(destroyed(QObject*)), this, SLOT(deleteSelf(QObject*)));
            //将组件注销
            aggregateMap().remove(component);
        }
        components = m_components;
        //删除属性中所以组件对象
        m_components.clear();
        //将聚合体自身注销
        aggregateMap().remove(this);
    }

    //析构所有组件
    qDeleteAll(components);
}

//destroyed信号发出时会被调用
void Aggregate::deleteSelf(QObject *obj)
{
    {
        QWriteLocker locker(&lock());
        //注销obj
        aggregateMap().remove(obj);
        //从属性中删除
        m_components.removeAll(obj);
    }

    //析构聚合体本身
    delete this;
}

//add()函数用于向Aggregate中添加组件
void Aggregate::add(QObject *component)
{
    if (!component)
        return;
    {
        QWriteLocker locker(&lock());
        //查阅component是否已经向Aggregate聚合体注册
        Aggregate *parentAggregation = aggregateMap().value(component);
        if (parentAggregation == this)
            return;//如果component已经注册,并且在Aggregate聚合体自身注册,返回

        //如果component已经在其他Aggregate聚合体注册
        if (parentAggregation) {
            qWarning() << "Cannot add a component that belongs to a different aggregate" << component;
            return;
        }

        //如果component没有被注册添加到任何聚合体,添加到m_components属性中
        m_components.append(component);
        //连接destroyed信号到deleteSelf槽函数
        connect(component, SIGNAL(destroyed(QObject*)), this, SLOT(deleteSelf(QObject*)));
        //将component注册到本聚合体中
        aggregateMap().insert(component, this);
    }
    emit changed();
}



void Aggregate::remove(QObject *component)
{
    if (!component)
        return;
    {
        QWriteLocker locker(&lock());
        //将组件注销
        aggregateMap().remove(component);
        //从属性中删除组件
        m_components.removeAll(component);
        //断开destroyed信号与槽deleteSelf连接
        disconnect(component, SIGNAL(destroyed(QObject*)), this, SLOT(deleteSelf(QObject*)));
    }

    emit changed();
}

6、extensionsystem.pro

Qt Creator 的核心是一个插件系统,插件系统由extensionsystem模块实现。

   extensionsystem.pro内容如下:

DEFINES += EXTENSIONSYSTEM_LIBRARY
include(../../qtcreatorlibrary.pri)

unix:!macx:!freebsd*:LIBS += -ldl

!isEmpty(vcproj) {
    DEFINES += IDE_TEST_DIR=\"$$IDE_SOURCE_TREE\"
} else {
    DEFINES += IDE_TEST_DIR=\\\"$$IDE_SOURCE_TREE\\\"
}

HEADERS += pluginerrorview.h \
    plugindetailsview.h \
    invoker.h \
    iplugin.h \
    iplugin_p.h \
    extensionsystem_global.h \
    pluginmanager.h \
    pluginmanager_p.h \
    pluginspec.h \
    pluginspec_p.h \
    pluginview.h \
    optionsparser.h \
    plugincollection.h \
    pluginerroroverview.h

SOURCES += pluginerrorview.cpp \
    plugindetailsview.cpp \
    invoker.cpp \
    iplugin.cpp \
    pluginmanager.cpp \
    pluginspec.cpp \
    pluginview.cpp \
    optionsparser.cpp \
    plugincollection.cpp \
    pluginerroroverview.cpp

FORMS += pluginview.ui \
    pluginerrorview.ui \
    plugindetailsview.ui \
    pluginerroroverview.ui

RESOURCES += pluginview.qrc

extensionsystem模块中有四个带有图形界面的类,分别是PluginView、PluginErrorView、PluginDetailsView和PluginErrorOverview,分贝表示有关插件的信息、错误信息、详细列表以及错误概览。

QtCreator在源代码中使用了大量D-Pointer设计,为了解决解决二进制兼容的问题。

要使一个库能够实现二进制兼容,就要求每一个结构以及每一个对象的数据模型保持不变。所谓“数据模型保持不变”,就是不能在类中增加、删除数据成员。这是C++编译器要求的,其根本是保持数据成员在数据模型中的位移保持不变。

ExtensionSystem::PluginSpec类

PluginSpec类是最基础的类,代表QtCreator的一个插件。

QtCreator中每一个插件都是一个动态链接库,QtCreator可以指定插件是否启用,即是否允许在QtCreator启动时加载插件以及更多的操作。QtCreator将插件动态链接库对应的物理文件抽象为ExtensionSystem::PluginSpec类。PluginSpec类更多的是提供给整个插件系统关于插件的信息,包括插件的名字、当前状态等。其中,名字作为静态数据是嵌入到插件文件中的,作为插件的“元数据”;当前状态则是标记插件当前是出于加载中,还是已经加载完毕,是保存在内存中的动态数据。同时,如果插件出现了任务错误,其详细的错误信息都是在PluginSpec类中。

在QtCreator中,每一个插件会对应着一个XML文件,用于描述插件的元信息、插件的依赖等。

PluginSpec类采用了D-Pointer设计,有三个文件:pluginspec.h、pluginspec_p.h 和 pluginspec.cpp。

pluginspec.h文件:

#ifndef PLUGINSPEC_H
#define PLUGINSPEC_H

#include "extensionsystem_global.h"
//定义向外暴露的宏
#include <QString>
#include <QList>
#include <QHash>

QT_BEGIN_NAMESPACE
class QStringList;
QT_END_NAMESPACE

namespace ExtensionSystem {
//扩展系统的命名空间
namespace Internal {
//扩展系统内部实现的命名空间,不能在自定义插件中使用
    class PluginSpecPrivate;
    class PluginManagerPrivate;
}

class IPlugin;
//可以被外部使用的类
//PluginDependency定义了有关被依赖插件的信息,包括被依赖插件的名字以及版本号等
//开发人员使用PluginDependency定义所需要的依赖,QtCreator则根据定义的依赖,
//利用Qt的反射机制,通过名字和版本号获取到插件对应的状态,
//从而获知被依赖插件是否加载之类的信息。
//QtCreator在匹配版本号时,并不会直接按照给出的version值完全匹配,
//而是按照一定的算法,选择一段区间内兼容的版本。
//这样做的目的是,有些插件升级了版本号之后,另外的插件可以按照版本号兼容,不需要一同升级。
struct EXTENSIONSYSTEM_EXPORT PluginDependency
{
    enum Type { //依赖类型枚举
        Required,   //必须的依赖
        Optional    //可选依赖
    };

    PluginDependency() : type(Required) {}
    QString name;   //被依赖插件名字
    QString version;    //被依赖插件版本号
    Type type;  //依赖类型
    bool operator==(const PluginDependency &other) const;
};

uint qHash(const ExtensionSystem::PluginDependency &value);

//用于描述插件参数。QtCreator的插件可以在启动时提供额外的参数
struct EXTENSIONSYSTEM_EXPORT PluginArgumentDescription
{
    QString name;
    QString parameter;
    QString description;
};


class EXTENSIONSYSTEM_EXPORT PluginSpec
{
public:
    //指示插件加载时的状态的枚举
    enum State { Invalid, Read, Resolved, Loaded, Initialized, Running, Stopped, Deleted};
    //Invalid:起始点:任何信息都没有读取,甚至连插件元数据都没有读到
    //Read:成功读取插件元数据,并且元数据是合法的;此时,插件的相关信息已经可用
    //Resolved:插件描述文件中给出的各个依赖已经被成功找到,这些依赖可以通过dependencySpecs()函数获取
    //Loaded:插件的库已经加载,插件实例成功创建;此时插件实例可以通过plugin()函数获取
    //Initialized:调用插件实例的IPlugin::initialize()函数,并且该函数返回成功
    //Running:插件的依赖成功初始化,并且调用了extensionsInitialized()函数;此时,加载过程完毕
    //Stopped:插件已经停止,插件的IPlugin::aboutToShutdown()函数被调用
    //Deleted:插件实例被删除销毁
    ~PluginSpec();

    // information from the xml file, valid after 'Read' state is reached
    QString name() const;//插件名字
    QString version() const;//插件版本
    QString compatVersion() const;//插件兼容版本
    QString vendor() const;//插件提供者
    QString copyright() const;//插件版权
    QString license() const;//插件协议
    QString description() const;//插件描述
    QString url() const;//插件主页

    QString category() const;//插件类别,用于在界面分组显示插件信息
    bool isExperimental() const;//是否实验性质的插件
    bool isDisabledByDefault() const;//是否默认禁用
    bool isEnabledInSettings() const;//因配置信息启动
    bool isEffectivelyEnabled() const;//是否在启动时已经加载
    bool isDisabledIndirectly() const;
    bool isForceEnabled() const;//是否通过命令行参数 -load 加载
    bool isForceDisabled() const;//是否通过命令行参数 -noload 禁用
    QList<PluginDependency> dependencies() const;//插件依赖列表,状态Read可用

    typedef QList<PluginArgumentDescription> PluginArgumentDescriptions;
    PluginArgumentDescriptions argumentDescriptions() const;//插件处理的命令行参数描述符列表

    // other information, valid after 'Read' state is reached
    QString location() const;// PluginSpec实例对应的插件XML描述文件所在目录的绝对位置
    QString filePath() const;//PluginSpec实例对应的插件XML描述文件的绝对路径

    void setEnabled(bool value);
    void setDisabledByDefault(bool value);
    void setDisabledIndirectly(bool value);
    void setForceEnabled(bool value);
    void setForceDisabled(bool value);

    QStringList arguments() const;//插件命令行参数。启动时设置
    //设置插件命令行参数为 arguments
    void setArguments(const QStringList &arguments);
    //将 argument 添加到插件的命令行参数
    void addArgument(const QString &argument);
    //当一个依赖需要插件名为pluginName、版本为version时,返回该插件是否满足
    bool provides(const QString &pluginName, const QString &version) const;

    // dependency specs, valid after 'Resolved' state is reached
    //插件的依赖。当状态达到 PluginSpec::Resolved 时才可用
    QHash<PluginDependency, PluginSpec *> dependencySpecs() const;

    // linked plugin instance, valid after 'Loaded' state is reached
    //PluginSpec实例对应的IPlugin实例。当状态达到PluginSpec::Loaded时才可用
    IPlugin *plugin() const;
    // state
    State state() const;//当前状态
    bool hasError() const;//是否发生错误
    QString errorString() const;//错误信息
private:
    PluginSpec();//构造函数私有,只能在友元类中创建对象
    Internal::PluginSpecPrivate *d;//d指针,指向私类对象
    friend class Internal::PluginManagerPrivate;
    friend class Internal::PluginSpecPrivate;
};

} // namespace ExtensionSystem

#endif // PLUGINSPEC_H

pluginspec_p.h文件:

#ifndef PLUGINSPEC_P_H
#define PLUGINSPEC_P_H

#include "pluginspec.h"
#include "iplugin.h"

#include <QObject>
#include <QStringList>
#include <QXmlStreamReader>

namespace ExtensionSystem {
class IPlugin;
class PluginManager;

namespace Internal {

class EXTENSIONSYSTEM_EXPORT PluginSpecPrivate : public QObject
{
    Q_OBJECT
public:
    PluginSpecPrivate(PluginSpec *spec);
    bool read(const QString &fileName);
    bool provides(const QString &pluginName, const QString &version) const;
    bool resolveDependencies(const QList<PluginSpec *> &specs);
    bool loadLibrary();
    bool initializePlugin();
    bool initializeExtensions();
    bool delayedInitialize();
    IPlugin::ShutdownFlag stop();
    void kill();
    QString name;
    QString version;
    QString compatVersion;
    bool experimental;
    bool disabledByDefault;
    QString vendor;
    QString copyright;
    QString license;
    QString description;
    QString url;
    QString category;
    QList<PluginDependency> dependencies;
    bool enabledInSettings;
    bool disabledIndirectly;
    bool forceEnabled;
    bool forceDisabled;

    QString location;
    QString filePath;
    QStringList arguments;

    QHash<PluginDependency, PluginSpec *> dependencySpecs;
    PluginSpec::PluginArgumentDescriptions argumentDescriptions;
    IPlugin *plugin;
    PluginSpec::State state;
    bool hasError;
    QString errorString;

    static bool isValidVersion(const QString &version);
    static int versionCompare(const QString &version1, const QString &version2);
    void disableIndirectlyIfDependencyDisabled();
private:

    PluginSpec *q;//q指针,指向公类对象
    bool reportError(const QString &err);
    void readPluginSpec(QXmlStreamReader &reader);
    void readDependencies(QXmlStreamReader &reader);
    void readDependencyEntry(QXmlStreamReader &reader);
    void readArgumentDescriptions(QXmlStreamReader &reader);
    void readArgumentDescription(QXmlStreamReader &reader);
    bool readBooleanValue(QXmlStreamReader &reader, const char *key);
    static QRegExp &versionRegExp();
};

} // namespace Internal

} // namespace ExtensionSystem

#endif // PLUGINSPEC_P_H

IPlugin类

IPlugin类是所有插件的基类,每个插件都必须继承IPlugin抽象类,并实现其中的纯虚函数。QtCreator的插件包含两部分:一个描述文件和一个至少包含了IPlugin实现的库文件。在库文件中,插件实现的IPlugin类需要与描述文件中的name属性相匹配。对于IPlugin抽象接口的实现需要使用标准的Qt插件系统暴露给外界,使用Q_PLUGIN_METADATA宏,并且给定 IID 为org.qt-project.Qt.QtCreatorPlugin。

Q_PLUGIN_METADATA宏是 Qt 5.0 新引入的,用于声明插件的元数据。当实例化插件对象时,插件的元数据会作为插件对象的一部分。Q_PLUGIN_METADATA宏需要声明一个 IID 属性,用于标识对象实现的接口;还需要一个文件的引用,文件包含了插件的元数据。任何一个 Qt 插件都需要在源代码中添加这么一个宏,并且只允许添加一个。

class CorePlugin : public ExtensionSystem::IPlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QtCreatorPlugin" FILE "Core.json")
};

class GitPlugin : public VcsBase::VcsBasePlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QtCreatorPlugin" FILE "Git.json")
};

使用Q_PLUGIN_METADATA宏的类必须有无参数的构造函数。FILE是可选的,指向一个 JSON 文件,必须能够被构建系统找到。

Qt Creator 规定其插件的 IID 必须是 org.qt-project.Qt.QtCreatorPlugin。而IID 所代表的,就是IPlugin。FILE根据每个插件而定。

IPlugin提供了一系列回调函数,用于插件加载到一定阶段时进行回调。

当插件描述文件读取、并且所有依赖都满足后,插件将开始进行加载。插件加载分为三个阶段:

A、所有插件的库文件按照依赖树从根到叶子的顺序进行加载。

B、按照依赖树从根到叶子的顺序依次调用每个插件的IPlugin::initialize()函数。

virtual bool initialize(const QStringList &arguments, QString *errorString) = 0;

每个插件都必须实现initialize函数。initialize函数会在插件加载完成,并且创建了插件对应的IPlugin对象之后调用。initialize函数返回值是bool类型,当插件初始化成功,返回true;否则,需要在errorString参数中设置人可读的错误信息。initialize函数的调用顺序是依赖树从根到叶子,因此,所有依赖本插件的插件的initialize()函数,都会在本插件自己的initialize()函数之后被调用。如果插件需要共享一些对象,就应该将共享对象放在initialize函数中。

C、按照依赖树从叶子到根的顺序依次调用每个插件的IPlugin::extensionsInitialized()函数

virtual void extensionsInitialized() = 0;

extensionsInitialized函数会在IPlugin::initialize()调用完毕、并且自己所依赖插件的IPlugin::initialize()和IPlugin::extensionsInitialized()调用完毕之后被调用。在extensionsInitialized函数中,插件可以假设自己所依赖的插件已经成功加载并且正常运行。插件所依赖的各个插件提供的可被共享的对象都已经创建完毕(在IPlugin::initialize()函数中完成的),可以正常使用。

如果插件的库文件加载失败,或者插件初始化失败,所有依赖该插件的插件都会失败。

virtual bool delayedInitialize() { return false; }

delayedInitialize函数会在所有插件的IPlugin::extensionsInitialized()函数调用完成、同时所依赖插件的IPlugin::delayedInitialize()函数也调用完成后才被调用,即延迟初始化。插件的IPlugin::delayedInitialize()函数会在程序运行之后才被调用,并且距离程序启动有几个毫秒的间隔。为避免不必要的延迟,插件对delayedInitialize函数的实现应该尽快返回。delayedInitialize函数的意义在于,有些插件可能需要进行一些重要的启动工作,虽然不必在启动时直接完成,但也应该在程序启动后的较短时间内完成。delayedInitialize函数默认返回false,即不需要延迟初始化。如果插件有这类需求,就可以重写delayedInitialize函数。

virtual ShutdownFlag aboutToShutdown() { return SynchronousShutdown; }

aboutToShutdown()函数会以插件初始化的相反顺序调用。aboutToShutdown函数应该用于与其它插件断开连接、隐藏所有 UI、优化关闭操作。如果插件需要延迟真正的关闭,例如,需要等待外部进程执行完毕,以便自己完全关闭,则应该返回IPlugin::AsynchronousShutdown。这么做的话会进入主事件循环,等待所有返回了IPlugin::AsynchronousShutdown的插件都发出了asynchronousShutdownFinished()信号之后,再执行相关操作。aboutToShutdown函数默认实现是不作任何操作,直接返回IPlugin::SynchronousShutdown,即不等待其它插件关闭.

可被共享的对象。插件之间的依赖容易解决。比如,插件 B 依赖于插件 A,那么,如果 B 成功加载,可以肯定,A一定是存在的。那么,就可以在 B中使用 A 提供的各个函数。但是,还有另外一种情况:插件B扩展插件 A 的功能。例如,不同的插件提供了打开不同文件的功能:插件 A 提供打开文本文件的功能;插件 B 提供打开二进制文件的功能。那么,当程序启动时,程序怎么知道自己能打开哪些文件呢?因为在程序启动时,并不知道哪些插件是可用的。QtCreator提供了一个对象池。A 可以打开文本,B 可以打开二进制文件,那么,把能打开文件的类实例放到对象池里面。程序启动之后,自己去对象池找,看有哪些关于打开文件的对象,就知道自己能打开什么文件了。

对象池可以理解为一个全局变量,里面会有很多不同插件提供的对象,其它插件只需要从这里面找到自己需要的对象即可使用。这种设计避免了插件要暴露很多接口的情况。如果没有对象池,那么,插件 A 和 B 就需要主动注册自己能够打开哪些文件,就要求主程序提供类似的注册接口——进一步说,程序需要将所有可能被扩展的功能都提供注册接口,这无疑会引起接口“爆炸”。

IPlugin将对象池操作委托给PluginManager类。

IPlugin.h文件:

#ifndef IPLUGIN_H
#define IPLUGIN_H

#include "extensionsystem_global.h"

#include <QObject>
#if QT_VERSION >= 0x050000
#    include <QtPlugin>
#endif

namespace ExtensionSystem {

namespace Internal {
    class IPluginPrivate;
    class PluginSpecPrivate;
}

class PluginManager;
class PluginSpec;

class EXTENSIONSYSTEM_EXPORT IPlugin : public QObject
{
    Q_OBJECT
public:
    enum ShutdownFlag {
        SynchronousShutdown,//异步
        AsynchronousShutdown//同步
    };

    IPlugin();
    virtual ~IPlugin();
    //每个子插件都必须实现,initialize函数会在插件加载完成,并且创建了插件对应的IPlugin对象之后调用

    virtual bool initialize(const QStringList &arguments, QString *errorString) = 0;
    virtual void extensionsInitialized() = 0;
    virtual bool delayedInitialize() { return false; }
    virtual ShutdownFlag aboutToShutdown() { return SynchronousShutdown; }
    virtual QObject *remoteCommand(const QStringList & /* options */, const QStringList & /* arguments */) { return 0; }
    //相关联的PluginSpec实例的访问
    PluginSpec *pluginSpec() const;
    //添加对象到对象池
    void addObject(QObject *obj);
    //自动析构对象池中的对象
    void addAutoReleasedObject(QObject *obj);
    //删除对象池中对象
    void removeObject(QObject *obj);
signals:
    void asynchronousShutdownFinished();
private:
    Internal::IPluginPrivate *d;
    friend class Internal::PluginSpecPrivate;
};

} // namespace ExtensionSystem

// The macros Q_EXPORT_PLUGIN, Q_EXPORT_PLUGIN2 become obsolete in Qt 5.
#if QT_VERSION >= 0x050000
#    if defined(Q_EXPORT_PLUGIN)
#        undef Q_EXPORT_PLUGIN
#        undef Q_EXPORT_PLUGIN2
#    endif
#    define Q_EXPORT_PLUGIN(plugin)
#    define Q_EXPORT_PLUGIN2(function, plugin)
#else
#    define Q_PLUGIN_METADATA(x)
#endif


#endif // IPLUGIN_H

IPlugin.cpp文件:

#include "iplugin.h"
#include "iplugin_p.h"
#include "pluginmanager.h"
#include "pluginspec.h"

using namespace ExtensionSystem;

IPlugin::IPlugin()
    : d(new Internal::IPluginPrivate())
{

}

IPlugin::~IPlugin()
{
    foreach (QObject *obj, d->addedObjectsInReverseOrder)
        PluginManager::removeObject(obj);
    qDeleteAll(d->addedObjectsInReverseOrder);
    d->addedObjectsInReverseOrder.clear();
    delete d;
    d = 0;
}

PluginSpec *IPlugin::pluginSpec() const
{
    return d->pluginSpec;
}

void IPlugin::addObject(QObject *obj)
{
    PluginManager::addObject(obj);
}


void IPlugin::addAutoReleasedObject(QObject *obj)
{
    d->addedObjectsInReverseOrder.prepend(obj);
    PluginManager::addObject(obj);
}

void IPlugin::removeObject(QObject *obj)
{
    PluginManager::removeObject(obj);
}

   iplugin_p.h文件:

#include "iplugin.h"

#include <QString>

namespace ExtensionSystem {

class PluginManager;
class PluginSpec;

namespace Internal {

class IPluginPrivate
{
public:
    PluginSpec *pluginSpec;
    QList<QObject *> addedObjectsInReverseOrder;
};

} // namespace Internal

} // namespace ExtensionSystem

#endif // IPLUGIN_P_H

  • 3
    点赞
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
管理系统,作为一种高效的企业运营管理工具,旨在通过集成化、系统化的手段,对组织内部的各类资源进行规划、协调、控制和优化,以实现企业战略目标,提升运营效率,增强核心竞争力。以下是对管理系统的详细介绍: 一、定义与构成 管理系统是指由硬件设备、软件应用、数据资源、人员以及相关管理制度共同构建的,用于处理、监控、分析和决策各类业务活动的综合信息系统。它通常包括以下几个核心组成部分: 数据采集模块:负责从各类业务环节中实时、准确地收集信息,形成企业的基础数据资源。 数据分析模块:运用统计学、人工智能等技术对数据进行深度挖掘和智能分析,提供决策支持。 业务流程管理模块:设计、执行、监控和优化业务流程,确保各项任务按照预定规则高效运转。 决策支持模块:基于数据分析结果,为管理者提供直观的可视化报告,辅助其进行科学决策。 用户界面与交互模块:提供友好的人机交互界面,方便用户操作使用。 二、主要类型与功能 管理系统根据所针对的管理对象和领域,可分为多种类型,如: 人力资源管理系统(HRM):涵盖招聘、培训、绩效考核、薪酬福利等人力资源全流程管理,提升人才效能。 客户关系管理系统(CRM):集中管理客户信息,优化销售、营销和服务流程,提升客户满意度和忠诚度。 供应链管理系统(SCM):整合供应商、制造商、分销商、零售商等供应链各环节,实现物流、资金流、信息流的协同运作。 企业资源计划系统(ERP):对企业内部财务、生产、采购、库存、销售等各项资源进行全面集成管理,提高整体运营效率。 项目管理系统(PM):对项目全生命周期进行规划、跟踪、控制,确保项目按时、按质、按预算完成。 、价值与优势 提高效率:自动化工作流程、标准化业务操作,显著减少人工干预,提升工作效率。 优化决策:实时数据分析与预测,提供精准的决策依据,助力管理层做出明智选择。 资源整合:打破部门壁垒,实现信息共享,优化资源配置,降低运营成本。 合规风控:内置法规遵循机制,强化内部控制,降低经营风险。 持续改进:通过对系统数据的持续监控与分析,驱动业务流程持续优化,促进企业创新与发展。 总的来说,管理系统作为现代企业管理的重要工具,以其强大的数据处理能力、智能化的决策支持和高效的业务流程管理,有力推动了企业的数字化转型,助力企业在日益激烈的市场竞争中保持竞争优势。
Qt Creator源码解析可以帮助你深入了解Qt Creator的内部实现和工作原理。在进行源码解析之前,建议你熟悉C++语言和Qt框架的基础知识。 Qt Creator源码托管在Git上,你可以通过以下步骤获取源码: 1. 克隆Qt Creator的Git仓库: ``` git clone https://code.qt.io/qt-creator/qt-creator.git ``` 2. 进入源码目录: ``` cd qt-creator ``` 3. 安装构建依赖: ``` qmake -r make ``` 一旦你成功地获取了Qt Creator源码,你可以使用任何你喜欢的编辑器或IDE来浏览和分析源代码。这里有一些你可以开始探索的关键部分: 1. Qt Creator的主要入口点是`src/qtcreator.pro`文件,它定义了项目的结构和构建配置。 2. `src/app/main.cpp`文件包含了Qt Creator的主要入口函数,在这里进行了一些初始化操作,然后启动了Qt Creator的应用程序。 3. `src/plugins`目录包含了Qt Creator的插件,这些插件提供了丰富的功能和工具。你可以深入研究这些插件的源码,了解它们是如何实现的。 4. `src/libs`目录包含了Qt Creator使用的一些核心库,如代码编辑器、调试器、可视化设计工具等。你可以深入研究这些库的源码,了解它们的内部实现和交互方式。 5. `src/shared`目录包含了一些共享的代码和工具类,它们被多个部分使用。你可以查看这些代码,了解它们是如何被重用和共享的。 在进行源码解析时,你可能会遇到一些挑战,因为Qt Creator是一个复杂的项目。阅读官方文档、参考示例代码以及与社区进行讨论都是非常有帮助的。同时,使用调试器来跟踪代码执行流程也是一个很好的学习方法。 希望这些信息对你进行Qt Creator源码解析有所帮助!

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值