Kompreni CMakeLists

Ekkompreni kiel funkcias CMakeLists.txt dosieroj

CMake

En nia enkonduka lernilo, ni uzis CMake kiel la konstrusistemon por nia aplikaĵo, sed ni nur tre atentis unu el niaj CMakeLists.txt dosieroj. Ĉi tie, ni iom pli detale trarigardos kiel ĝi funkcias.

CMake estas utila ĉar ĝi permesas al ni aŭtomatigi grandan parton de la aĵoj kiuj devas esti faritaj antaŭ kompilo.

La radika CMakeLists.txt

Vi eble memoras ĉi tiun CMakeLists.txt dosieron de la unua lernilo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

cmake_minimum_required(VERSION 3.20)
project(kirigami-tutorial)

find_package(ECM 6.0.0 REQUIRED NO_MODULE)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)
include(ECMFindQmlModule)
include(ECMQmlModule)

find_package(Qt6 REQUIRED COMPONENTS
    Core
    Quick
    Test
    Gui
    QuickControls2
    Widgets
)

find_package(KF6 REQUIRED COMPONENTS
    Kirigami
    I18n
    CoreAddons
    QQC2DesktopStyle
    IconThemes
)

ecm_find_qmlmodule(org.kde.kirigami REQUIRED)

add_subdirectory(src)

install(PROGRAMS org.kde.tutorial.desktop DESTINATION ${KDE_INSTALL_APPDIR})

feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)

La unua linio, cmake_minimum_required() fiksas la version de CMake, kiun ni vokos.

Post tio, project(kirigami-tutorial) difinas la nomon de la projekto.

Poste ni atingas sekcion, kie ni inkluzivas kelkajn necesajn agordojn de CMake kaj KDE uzante extra-cmake-modules. Ili provizas aron de valoraj utilaĵoj:

  • KDEInstallDirs provizas oportunajn variablojn kiel ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}, ${KDE_INSTALL_QMLDIR}, ${KDE_INSTALL_INSTALL] kaj ${BIND_INS} ${KDE_INSTALL_LIBDIR}`.
  • KDECMakeSettings provizas aferojn kiel CMAKE_AUTORCC ON, celon malinstali kiu povas esti uzata kun cmake --build build/ - -target uninstall, kaj ENABLE_CLAZY.
  • KDECompilerSettings provizas minimuman C++-normon, kompililajn flagojn kiel -pedantic, kaj plej bonajn praktikajn makroojn kiel -DQT_NO_CAST_FROM_ASCII por postuli eksplicitaj konvertiĝoj kiel QStringLiteral().
  • ECMFindQmlModule provizas manieron certigi rultempan QML-dependecon trovigxas je kompiltempo.
  • ECMQmlModule provizas CMake-komandojn kiel ecm_add_qml_module() kaj ecm_target_qml_sources().

La sekva sekcio estas grava, ĉar ĝi specifas kiujn dependecojn ni alportos je kompilo. Ni rigardu la unuan:

13
14
15
16
17
18
19
20
21
22
23
24
25
26

find_package(Qt6 REQUIRED COMPONENTS
    Core
    Quick
    Test
    Gui
    QuickControls2
    Widgets
)

find_package(KF6 REQUIRED COMPONENTS
    Kirigami
    I18n
    CoreAddons
    QQC2DesktopStyle
  • find_package() trovas kaj ŝargas la eksteran bibliotekon kaj siajn komponantojn.
  • REQUIRED diras al CMake eliri kun eraro se la pakaĵo ne troveblas.
  • `COMPONENTS' estas parametro, kiu antaŭas la specifajn komponantojn de la kadro, kiun ni inkludos.
  • Ĉiu vorto post `COMPONENTS' rilatas al specifa komponanto de la biblioteko.

La installinio instrukcias CMake instali la labortablan dosieron en ${KDE_INSTALL_APPDIR}, kiu en Linukso tradukiĝas al $XDG_DATA_DIRS/applications, kutime /usr/share/applications, kaj en Vindozo tradukiĝas al C:/Program Dosieroj/${PROJECT_NAME}/bin/data/applications:

32

add_subdirectory(src)

La fina linio lasas CMake presi kiujn pakaĵojn ĝi trovis, kaj ĝi igas kompiladon tuj malsukesi se ĝi renkontas eraron:

34

install(PROGRAMS org.kde.tutorial.desktop DESTINATION ${KDE_INSTALL_APPDIR})

Kaj super tio, add_subdirectory(src)indikas CMake en la dosierujonsrc/, kie ĝi trovas alian CMakeLists.txt` dosieron.

src/CMakeLists.txt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

add_executable(kirigami-hello)

ecm_add_qml_module(kirigami-hello
    URI
    org.kde.tutorial
)

target_sources(kirigami-hello
    PRIVATE
    main.cpp
)

ecm_target_qml_sources(kirigami-hello
    SOURCES
    Main.qml
)

target_link_libraries(kirigami-hello
    PRIVATE
    Qt6::Quick
    Qt6::Qml
    Qt6::Gui
    Qt6::QuickControls2
    Qt6::Widgets
    KF6::I18n
    KF6::CoreAddons
    KF6::IconThemes
)

install(TARGETS kirigami-hello ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})

Dum la unua dosiero pritraktis metadatenojn kaj trovi bibliotekojn, ĉi tiu konsistos el pritraktado de dependecoj kaj instalo de la aplikaĵo. Ĝi havas la sekvajn CMake-vokojn:

  • add_executable() kreas la ruleblan celon kiun ni uzos por efektivigi nian projekton.
  • ecm_add_qml_module() kreas celon de QML-modulo kiu estos alirebla per la importo "org.kde.tutorial".
  • target_sources() aldonas C++ fontdosierojn al la rulebla celo.
  • ecm_target_qml_sources() aldonas QML-dosierojn al la modulo.
  • target_link_libraries() ligas la C++-bibliotekojn uzatajn en nia kodo al nia rulebla. Kirigami ne estas inkluzivita ĉi tie ĉar ni uzas nur ĝian QML-modulon.
  • install() instalas la plenumeblan al la sistemo.

La dokumentaro por la du ECM-komandoj troviĝas en la extra-cmake-modules API for ECMQmlModule.

La alvoko al ecm_add_qml_module() estis uzata ĉi tie por modifi la tradician C++-fontkodon plenumeblan celon kaj igi ĝin io kiu povas akcepti QML-dosierojn kaj C++-fontkodon kiu estas alirebla de QML en kio estas nomita uzante la ruleblan kiel subtenan celon. por QML-modulo. Ĉi tio signifas, ke la QML-dosieroj estas rulitaj rekte kiel parto de la aplikaĵo, kio ofte okazas por aplikoj.

Vi ankaŭ povas krei apartan QML-modulon, kiu ne uzas la plenumeblan kiel subtenan celon uzante ecm_add_qml_module(). En ĉi tiu kazo, vi kreus bibliotekan celon uzante add_library(), ligus ĝin al ekzistanta plenumebla celo uzante target_link_libraries( ), kaj krom instali la bibliotekon per install() vi devos fini la QML-modulon per ecm_finalize_qml_module() do ĝi povas generi du dosierojn: qmldir kaj qmltypes. Ĉi tiuj dosieroj estas uzataj de QtQuick-aplikoj por trovi apartajn QML-modulojn.

La metodo por krei apartan QML-modulon estas pli bone ekzempligita en Uzante apartajn dosierojn.

Ĉi tiuj estas aldonoj provizitaj de ekstra-cmake-moduloj por uzi Qt-deklara registrado (la anstataŭaĵo al Qt-resursaj dosieroj) pli facile.

La dokumentaro por ĉiuj tri komandoj troviĝas en la extra-cmake-modules API for ECMQmlModule.

src/components/CMakeLists.txt

En la lernilo pri kiel dividi vian kodon en apartajn dosierojn, nova CMake-dosiero estis lanĉita por permesi apartaj QML-moduloj:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

add_library(kirigami-hello-components)

ecm_add_qml_module(kirigami-hello-components
    URI "org.kde.tutorial.components"
    GENERATE_PLUGIN_SOURCE
)

ecm_target_qml_sources(kirigami-hello-components
    SOURCES
    AddDialog.qml
    KountdownDelegate.qml
)

ecm_finalize_qml_module(kirigami-hello-components)

install(TARGETS kirigami-hello-components ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})

La postulo por ke ĉi tiu dosiero estu legita de CMake estas aldoni alvokon al add_subdirectory() en la src/CMakeLists.txt indikanta ĝin.

Ni kreas novan celon nomitan kirigami-hello-components kaj poste turnas ĝin en QML-modulon uzante ecm_add_qml_module() sub la importnomo. org.kde.tutorial.components kaj aldonu la koncernajn QML-dosierojn.

La voko al add_library() generas novan celon nomitan kirigami-hello-components. Ĉi tiu celo havos sian propran aron de fontkodaj dosieroj, QML-dosieroj, ligos siajn proprajn bibliotekojn kaj tiel plu, sed ĝi devas esti ligita al la plenumebla, sed post kiam ĝi estas kompilita ĝi devas esti ligita al la plenumebla kreita en la src/CMakeLists.txt. Ĉi tio estas farita aldonante la celnomon al la listo de bibliotekoj kiuj estos ligitaj al la plenumebla en target_link_libraries().

La alvoko al ecm_add_qml_module() ŝanĝas la bibliotekon por permesi al ĝi akcepti QML-dosierojn kiel antaŭe, sed ĉi-foje ni devas uzi GENERATE_PLUGIN_SOURCE . Kiam la plenumebla estas uzata kiel subtena celo (kiel kun kirigami-hello) ĝi ne bezonas generi kromprogramon ĉar ĝi estas enkonstruita en la rulebla; kun apartaj QML-moduloj kiel kirigami-hello-components la aldonkodo estas necesa.

La [qt_add_qml_module()] de Qt kontraŭflue (https://doc.qt.io/qt-6/qt-add-qml-module.html#targets-and-plugin-targets) defaŭlte generas kromprogramon kune kun la QML-modulo , sed ecm_add_qml_module() de KDE defaŭlte ne por malantaŭen kongruo.

Alia afero necesa por apartaj QML-moduloj estas fini la celon. Ĉi tio ĉefe signifas ke CMake generas du dosierojn, qmldir kaj qmltypes, kiuj priskribas la QML-modulojn kiujn ni havas kaj eksportas iliajn simbolojn por uzo. en la biblioteko. Ili estas gravaj kiam vi instalas vian aplikaĵon, por ke la rulebla programo povu trovi kie estas la QML-dosieroj por ĉiu modulo, do ili estas aŭtomate aldonitaj al la celo.

Vi povas tiam simple instali la celon kiel antaŭe.

Venontfoje vi bezonos aldoni pliajn QML-dosierojn, memoru inkluzivi ilin en ĉi tiu dosiero. C++-dosieroj, kiuj uzas la ŝlosilvorton QML_ELEMENT, kiun ni vidos multe pli poste en la lernilo, ankaŭ povas esti aldonitaj ĉi tie uzante target_sources( ). Vi povas logike apartigi vian kodon kreante pli da QML-moduloj kun malsamaj enportoj laŭbezone.

Ĉi tiu aranĝo estos utila dum disvolvado de plej multaj Kirigami-aplikoj.

Previous
Listo vidoj
Next
Eltrovante main.cpp