Comment configurer L'IDE de CLion pour le Framework Qt?
8 réponses
CLion n'est pas (encore) compatible .
Visual Studio a un plugin Qt disponible .
Eclipse a ont un Qt plugin mais le travail a été arrêté il y a quelque temps .
CLion fait support Qt dans le sens où comme il utilise CMake, il peut gérer invoquer les moc , rcc , et uic assez indolore. Cependant, il ne comprend pas QML, et surtout, il ne comprend pas les fichiers de projets QMake - ce qui rend évidemment l'utilisation des projets Qt existants dans CLion difficile car vous devez d'abord les porter sur CMake.
j'étais aussi désespéré que vous, jusqu'à ce que je lise cette discussion de Quora . Ça 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 de CMake (E. G-listes de classement.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
d'autre part, CLion doit utiliser le binaire cmake installé par Qt. Pour cela, aller dans:
'Preferences' - > 'Build, Execution, Deployment' - > ' CMake 'et dans' CMake options ' ajoutent le chemin CMake que Qt utilise, qui doit être dans le répertoire où Qt est installé. Par exemple, sur OSX:
-DCMAKE_PREFIX_PATH=/Users/edouard/Qt/5.7/clang_64/lib/cmake
vous pouvez tester que tout fonctionne bien, en faisant un petit script de test dans main.cpp :
#include <QApplication>
#include <QDebug>
using namespace std;
int main() {
qDebug() << QT_VERSION_STR;
return 1;
}
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
mise à JOUR
j'étais coincé avec le problème d'ajouter des modules Qt5 (par exemple QSql). Vous pouvez le faire en ajoutant les CMakeLists.txt:
find_package(Qt5Sql REQUIRED)
juste après l'autre find_package , et ajouter à la dernière ligne:
target_link_libraries(myqtproject Qt5::Widgets Qt5::Sql)
vous pouvez le faire avec tous les autres modules Qt5.
cette approche est l'une des plus simples à utiliser pour la plus récente version Qt .
Qt: 5.10.1
CLion: 2018.1.2
GDB: 8.1
configuration de Projet
In CLion :
- Créer un C++ Exécutable / Bibliothèque projet
- utiliser cet échantillon " CMakeLists.txt "pour console/gui projets qui utilise: 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)
-
fichiers de Ressources (.qrc) doit être ajouté à la liste add_executable, en afin que le moc puisse exécuter sa procédure sur la ressource et le fichier interne comme qmls, textes,... être accessible.
-
les fichiers qml doivent être inclus dans un fichier qrc et chargés en utilisant QQmlApplicationEngine à l'exécution
Debuger:
pour avoir une vue lisible par l'homme dans les sessions de débogage des types Qt, un nouveau GDB doit être installé sur le système et de jolies imprimantes doivent être disponibles:
très imprimantes pour Qt5:
1 - Lekensteyn" 1519110920 Qt5 Pretty Printers (Working):
adresse: https://github.com/Lekensteyn/qt5printers
le programme d'Installation: ~/.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/"
le programme d'Installation: ~/.gdbinit
comme indiqué dans le fichier readme 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", ajouter 4 outils externes:
Qt Creator:
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:
- For .de l'interface utilisateur, sélectionnez Qt Creator / Designer et de commencer la conception de l'INTERFACE utilisateur
- For .qml sélectionnez Qt Creator et de la conception de l'INTERFACE utilisateur dans QML éditeur
- For .qrc sélectionnez Qt Creator et utiliser l'éditeur de ressources
- For .rpc/.ui sélectionner LUpdate pour créer son fichier de traduction
- For .ts sélectionner linguiste et commencer la traduction
Automatique Formatage Automatique De La Requête
si dans Qt Creator vous avez utilisé un embellisseur comme "Uncrustify" pour embellir automatiquement le code lors de la sauvegarde d'un fichier source, alors:
- Installer le plugin " Enregistrer les Actions "
- Sous la rubrique "Fichier -> Paramètres -> enregistrer les Actions"
- Check:
- Active d'enregistrer les actions sur " enregistrer
- dossier Reformat
- pour la meilleure performance un-check:
- organiser les importations
vous pouvez construire des applications QT en CLion. QT fournit des modules CMake qui prennent soin de tous les détails.
le script CMake suivant construit l'application d'exemple " "Dynamic Layouts Example "
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 création d'applications Qt avec CMake .
comme le mentionne Tom Lank, les projets Qt peuvent désormais être gérés et construits sous CMake, ce qui rend CLion heureux.
le manuel de Qt5 décrit comment. Qt fournit beaucoup de magie sous le capot ici, et il est expliqué beaucoup mieux dans la CMake documentation .
une chose qui n'est pas mentionnée dans le manuel Qt CMake ou ci-dessus est que vous aurez aussi 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) . Également inclure .ou de l'interface utilisateur .qrc des fichiers comme des dépendances dans l'appel à add_executable() le long de avec votre .fichiers cpp.
cela a été initialement très déroutant pour moi en parcourant le web, mais vous ne devriez pas avoir besoin d'appels à qt_*() ou qt5_*() . Ceux-ci ont été remplacées autant que je peux dire.
pour tester que votre CMakeLists.txt en fait fonctionne correctement, vous pouvez essayer de construire au sein de Qt Creator, en chargeant CMakeLists.txt comme un projet et un bâtiment.
une fois confirmé, vous pouvez charger le fichier CMakeLists.txt comme un projet en CLion.
Très probablement, vous devrez dire à CMake où trouver vos paquets Qt avec une ligne comme celle-ci avant votre find_package 's:
set(CMAKE_PREFIX_PATH "C:/Qt/5.9/msvc2015_64")
enfin, si vous utilisez / construisez pour windows, Qt n'est plus pré-construit avec les bibliothèques GCC/Mingw32. Vous devez construire avec visual studio. Heureusement, CLion supporte maintenant Visual Studio expérimentalement et je l'ai trouvé pour travailler pour les projets Qt; juste être sûr de mettre l'architecture (sous Paramètres->construction, exécution, Développement->CMake) à x86_amd64, afin de construire en mode 64 bits et être compatible avec les libs pré-construction de Qt.
tout cela est testé avec le compilateur CLion 2017.1, Qt 5.9, et le compilateur Visual Studio 2015.
ce lien a un projet quickstart, vous avez juste à changer votre CMAKE_PREFIX_PATH dans les listes CMakeLists à l'emplacement du compilateur QT empaqueté que vous voulez utiliser (le mien est gcc_64, son par défaut est clang_64)-- il a certains des paramètres mentionnés par d'autres réponses déjà définies:
https://github.com/ArneGockeln/qtstarter
en outre, (sur Linux Ubuntu) j'ai dû installer les bibliothèques OpenGL comme décrit ici ( https://askubuntu.com/questions/11378/how-do-i-set-up-an-opengl-programming-environment ).
vous pouvez facilement développer Qt avec VC, Eclipse, CLion etc. lorsque vous utilisez CMake comme outil de construction. CMake va générer les fichiers de projet pour chaque IDE. J'utilisais plusieurs IDEs de cette façon. Après ce voyage, je suis un utilisateur encore plus heureux de Qt Creator.
la seule chose dont vous avez besoin est D'ajouter QT install ..Qt.10.1\mingw53_32\bin; à votre chemin. N'oubliez pas de redémarrer PC après, car pour une raison ou une autre, CLion n'est pas capable de rafraîchir le chemin, seul le redémarrage complet du pc aide.