web-dev-qa-db-fra.com

Comment configurer CLion IDE pour Qt Framework?

Comment configurer CLion IDE pour Qt Framework? Est-ce que IDE est compatible avec Qt ou existe-t-il d'autres IDE compatibles avec Qt?

Je veux juste essayer d'utiliser autre chose que Qt Creator.

c++qtclion
37
123qwe

J'étais aussi désespérée que toi, jusqu'à ce que je lise cette discussion sur Quora . Cela a parfaitement fonctionné pour moi!

En résumé, il y a 2 étapes principales:

Tout d'abord, CLion utilise CMake pour compiler votre code. Il est basé sur les fichiers de configuration CMake (par exemple "CMakeLists.txt"). Vous devez ajouter des commandes CMake basées sur Qt (les lignes avec 'find_package' et 'target_link_libraries'):

cmake_minimum_required(VERSION 3.5)
project(myqtproject)

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

set(SOURCE_FILES main.cpp)
find_package(Qt5Widgets REQUIRED)                 <-- this line

add_executable(myqtproject ${SOURCE_FILES})

target_link_libraries(myqtproject Qt5::Widgets)   <-- this line

Deuxièmement, CLion doit utiliser le binaire cmake installé par Qt. Pour cela, allez dans: . Par exemple, sur OSX:

-DCMAKE_PREFIX_PATH=/Users/edouard/Qt/5.7/clang_64/lib/cmake

Vous pouvez vérifier que tout fonctionne correctement, en effectuant un petit script de test dans main.cpp:

#include <QApplication>
#include <QDebug>

using namespace std;

int main() {
    qDebug() << QT_VERSION_STR;
    return 1;
}

Ce qui devrait afficher quelque chose comme:

/Users/edouard/Library/Caches/CLion2016.2/cmake/generated/myqtproject-89a4132/89a4132/Debug/untitled
5.7.0

Process finished with exit code 1

METTRE &AGRAVE; JOUR

J'étais coincé avec le problème de l'ajout de modules Qt5 (par exemple QSql). Vous pouvez le faire en ajoutant dans le fichier CMakeLists.txt:

find_package(Qt5Sql REQUIRED)

juste après l'autre find_package, et en ajoutant à la dernière ligne:

target_link_libraries(myqtproject Qt5::Widgets Qt5::Sql)

Vous pouvez le faire avec tous les autres modules Qt5.

31
Edouard Berthe

Cette approche est l’un des moyens les plus simples à utiliser pour la dernière version de Qt.

Qt:    5.10.1
CLion: 2018.1.2
GDB:   8.1

Configuration du projet

Dans CLion:

  1. Créer un projet exécutable C++/bibliothèque
  2. Utilisez cet exemple "CMakeLists.txt" pour les projets de console/interface graphique courants utilisant: QtCore, QtWidgets et QtQuick

CMakeLists.txt:

cmake_minimum_required(VERSION 3.10)
project(PROJECT_NAME)

set(CMAKE_CXX_STANDARD 14)

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)

set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_PREFIX_PATH "PATH_TO_QT/QT_VERSION/QT_Arch/lib/cmake")

find_package(Qt5Core REQUIRED)
find_package(Qt5Widgets REQUIRED)
find_package(Qt5Quick REQUIRED)

add_executable(PROJECT_NAME main.cpp MainWindow.cpp MainWindow.h qml.qrc)

target_link_libraries(PROJECT_NAME Qt5::Core)
target_link_libraries(PROJECT_NAME Qt5::Widgets)
target_link_libraries(PROJECT_NAME Qt5::Quick)

  • Les fichiers de ressources (.qrc) doivent être ajoutés à la liste add_executable, afin que moc puisse exécuter sa procédure sur la ressource et que le fichier interne , Tel que qmls, textes, ... soit accessible.

  • les fichiers qml doivent être inclus dans un fichier qrc et chargés avec QQmlApplicationEngine au moment de l'exécution

Debuger:

Afin d'avoir une vue lisible par l'homme dans les sessions de débogage à partir de types Qt, une nouvelle GDB doit être installée sur le système et de jolies imprimantes doivent être disponibles:

Jolies imprimantes pour Qt5:

1- Lekensteyn _ {Qt5 Pretty Printers} (en cours d'exécution):

Adresse: https://github.com/Lekensteyn/qt5printers

Configuration: ~/.gdbinit

python
import sys, os.path
sys.path.insert(0, os.path.expanduser('~/.gdb'))
import qt5printers
qt5printers.register_printers(gdb.current_objfile())
end

2- Officiel (ne fonctionne pas !!!):

"PATH_TO_QT/QT_VERSION/QT_Arch/Tools/QtCreator/share/qtcreator/debugger/"

Configuration: ~/.gdbinit

Comme indiqué dans le fichier lisez-moi inclus (mais ne fonctionne pas!):

python sys.path.insert(1, '<path/to/qtcreator>/share/qtcreator/debugger/')
python from gdbbridge import *

Outils externes

Dans "Fichier -> Paramètres -> Outils -> Outils externes", ajoutez 4 outils externes:

Qt Créateur:

Program:   "PATH_TO_QT/QT_VERSION/QT_Arch/Tools/QtCreator/bin/qtcreator"
Arguments: $FilePath$

Concepteur d'interface utilisateur:

Program:   "PATH_TO_QT/QT_VERSION/QT_Arch/lib/bin/designer")
Arguments: $FilePath$

LUpdate:

Program:   "PATH_TO_QT/QT_VERSION/QT_Arch/lib/bin/lupdate")
Arguments: $FilePath$ -ts $FileNameWithoutExtension$.ts

Linguiste:

Program:   "PATH_TO_QT/QT_VERSION/QT_Arch/lib/bin/linguist")
Arguments: $FilePath$

Maintenant, vous pouvez faire un clic droit sur ces types de fichiers et sous l'outil externe:

  1. Pour .ui, sélectionnez Qt Creator/Designer _ et démarrez la conception de l'interface utilisateur.
  2. Pour .qml, sélectionnez Qt Creator et créez l'interface utilisateur dans l'éditeur QML.
  3. Pour .qrc, sélectionnez Qt Creator et utilisez l'éditeur de ressources.
  4. Pour .cpp/.ui, sélectionnez LUpdate _ pour créer son fichier de traduction.
  5. Pour .ts, sélectionnez Linguist et lancez la traduction.

Embellisseur automatique

Si vous utilisez Qt Creator un esthétiseur comme "Uncrustify" pour embellir automatiquement le code lors de la sauvegarde d'un fichier source, alors:

  1. Installez le plugin "Actions de sauvegarde"
  2. Sous "Fichier -> Paramètres -> Actions de sauvegarde"
  3. Vérifier:
    1. Actions de sauvegarde actives lors de la sauvegarde
    2. Reformater le fichier
  4. Pour des performances optimales, décochez:
    1. Organiser les importations
11
AshkanVZ

Vous pouvez créer des applications QT dans CLion. QT Fournit des modules CMake qui s’occupent de tous les détails. 

Le script CMake suivant construit l'exemple d'application ' Exemple de disposition dynamique '

cmake_minimum_required(VERSION 3.7)
project(qtlayoutexample)
set(CMAKE_CXX_STANDARD 14)

# Find QT packages
find_package(Qt5Widgets)

# Add the include directories for the Qt 5 Widgets module to
# the compile lines.
include_directories(${Qt5Widgets_INCLUDE_DIRS})

# Find includes in corresponding build directories
set(CMAKE_INCLUDE_CURRENT_DIR ON)
# Instruct CMake to run moc automatically when needed.
set(CMAKE_AUTOMOC ON)

# Add compiler flags for building executables (-fPIE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}")

qt5_generate_moc(main.cpp main.moc)

# Tell CMake to create the qtlayoutexample executable
add_executable(qtlayoutexample main.cpp dialog.cpp main.moc)

#Link the qtlayoutexample executable to the Qt 5 widgets library.
target_link_libraries(qtlayoutexample Qt5::Widgets)

Plus d'informations concernant la construction d'applications Qt avec CMake .

2
Tom

Ce lien a un projet quickstart, il vous suffit de changer votre CMAKE_PREFIX_PATH dans CMakeLists pour qu’il trouve l’emplacement du compilateur empaqueté Qt que vous voulez utiliser (le mien est gcc_64, son par défaut est clang_64). réponses déjà définies:

https://github.com/ArneGockeln/qtstarter

De plus, (sous Linux basé sur Ubuntu), je devais installer les bibliothèques OpenGL comme décrit ici ( https://askubuntu.com/questions/11378/how-do-i-set-up-an-opengl-programming -environnement ).

2
Halcyon

Comme le mentionne Tom Lank, les projets Qt peuvent maintenant être gérés et construits sous CMake, ce qui rend CLion heureux.

Le manuel CMake de Qt5 décrit comment. Qt fournit ici beaucoup de magie, et il est expliqué beaucoup mieux dans la documentation CMake .

Une chose qui n’est pas mentionnée dans le manuel de Qt CMake ou au-dessus est que vous aurez également besoin des lignes:

set(CMAKE_AUTOUIC ON) # if you have any .ui files
set(CMAKE_AUTORCC ON) # if you have any .qrc files

Tous ces appels à set() devraient probablement précéder la ligne find_package(Qt5Widgets REQUIRED). Incluez également tous les fichiers .ui ou .qrc en tant que dépendances dans l'appel à add_executable() avec vos fichiers .cpp.

Au début, c'était très déroutant pour moi de naviguer sur le Web, mais vous ne devriez pas avoir besoin d'appels vers qt_*() ou qt5_*(). Ceux-ci ont été remplacés pour autant que je sache.

Pour vérifier que votre CMakeLists.txt fonctionne réellement correctement, vous pouvez essayer de construire dans Qt Creator en chargeant CMakeLists.txt en tant que projet et construction.

Une fois confirmé, vous pouvez charger le fichier CMakeLists.txt en tant que projet dans CLion . Vous devrez probablement indiquer à CMake où trouver vos paquets Qt avec une ligne comme celle-ci avant votre find_package:

set(CMAKE_PREFIX_PATH "C:/Qt/5.9/msvc2015_64")

Enfin, si vous exécutez/construisez pour Windows, Qt n'est plus fourni avec les bibliothèques GCC/Mingw32. Vous devez construire avec Visual Studio. Heureusement, CLion prend maintenant en charge Visual Studio à titre expérimental et je l’ai trouvé efficace pour les projets Qt; Veillez simplement à définir l’architecture (sous Paramètres-> Construire, Exécution, Développement-> CMake) sur x86_AMD64, afin de pouvoir créer en mode 64 bits et d’être compatible avec les bibliothèques de pré-construction de Qt.

Tout cela est testé avec CLion 2017.1, Qt 5.9 et le compilateur Visual Studio 2015.

2
jtbr

La seule chose dont vous avez besoin est d’ajouter QT install ..Qt\5.10.1\mingw53_32\bin; à votre PATH. N'oubliez pas de redémarrer l'ordinateur par la suite, car CLion ne peut pas actualiser le chemin pour une raison quelconque, seul le redémarrage complet de PC peut vous aider. 

0
brgs

Vous pouvez facilement développer Qt avec VC, Eclipse, CLion etc. lorsque vous utilisez CMake comme outil de construction. CMake générera les fichiers de projet pour chaque IDE. J'utilisais plusieurs IDE de cette façon. Après ce voyage, je suis un utilisateur encore plus heureux de Qt Creator. 

0
Roland Wolf