Configuración y primeros pasos
Instalación de Kirigami
Antes de empezar, necesitamos instalar Kirigami en nuestra máquina. Existen tres formas de hacerlo:
- Instalación de Kirigami desde los repositorios de su distribución Linux
- Compilación de Kirigami con kdesrc-build
- Instalación de Kirigami con Craft
Instalación de Kirigami desde los repositorios de su distribución Linux
Necesitamos un compilador de C++, los paquetes de desarrollo de Qt y Kirigami. Abra una aplicación de terminal y ejecute una de las siguientes líneas, dependiendo de la distribución Linux que esté usando:
sudo apt install build-essential cmake extra-cmake-modules qtbase5-dev qtdeclarative5-dev qtquickcontrols2-5-dev kirigami2-dev libkf5i18n-dev gettext libkf5coreaddons-dev qml-module-org-kde-qqc2desktopstyle | |
sudo pacman -S base-devel extra-cmake-modules cmake qt5-base qt5-declarative qt5-quickcontrols2 kirigami2 ki18n kcoreaddons breeze qqc2-desktop-style | |
sudo zypper install --type pattern devel_C_C++ sudo zypper install cmake extra-cmake-modules libQt5Core-devel libqt5-qtdeclarative-devel libQt5QuickControls2-devel kirigami2-devel ki18n-devel kcoreaddons-devel qqc2-desktop-style | |
sudo dnf groupinstall "Development Tools" "Development Libraries" sudo dnf install cmake extra-cmake-modules qt5-qtbase-devel qt5-qtdeclarative-devel qt5-qtquickcontrols2-devel kf5-kirigami2-devel kf5-ki18n-devel kf5-kcoreaddons-devel qqc2-desktop-style |
Puede encontrar más información para otras distribuciones aquí.
Si desea compilar Kirigami con Qt6, no es posible en la actualidad en Linux con solo los paquetes de la distribución. En lugar de ello, tendrá que echar mano de kdesrc-build.
Compilación de Kirigami con kdesrc-build
KDE dispone de una herramienta para compilar fácilmente todas sus bibliotecas y programas: kdesrc-build. Se puede usar para compilar Kirigami en Linux y FreeBSD.
For this tutorial, you will need to follow the setup instructions for kdesrc-build but using a ~/kde5
directory instead, then copy the sample KF5 file to your home:
cp ~/kde5/src/kdesrc-build/kdesrc-buildrc-kf5-sample ~/.config/kdesrc-buildrc
After that, you may simply run the following on a terminal:
kdesrc-build kirigami kcoreaddons ki18n breeze plasma-integration qqc2-desktop-style
source ~/kde5/build/kirigami/prefix.sh
And then you may compile your Kirigami projects on the same terminal shell you used to source the prefix file. If you close your terminal, you can simply source the file again to compile your app.
Instalación de Kirigami con Craft
KDE has a custom tool to easily install most of its libraries and programs: Craft. It can be used to install Kirigami on Linux, FreeBSD, Windows, Android and macOS.
You will need to follow the setup instructions for Craft. By the end of the setup, you should have run an environment setup file (craftenv.ps1
or craftenv.sh
), which will give you a terminal shell where you will be compiling your Kirigami application.
After that, you may simply run the following on a terminal:
craft kirigami kcoreaddons ki18n breeze kiconthemes qqc2-desktop-style
Theming on Windows
Pulse aquí para leer más
When building the application after installing dependencies with Craft, just installing KIconThemes and Breeze ensures the application will be able to use Breeze icons on platforms like Windows, linking is not necessary. qqc2-desktop-style on the other hand is responsible for the nice looking style we want to enforce on those platforms.
If you close your terminal, you can simply run the environment setup file again to compile your app.
Estructura del proyecto
Si bien existen herramientas que pueden configurar fácilmente nuestros archivos, los crearemos manualmente. Esto nos permitirá comprender mejor las piezas que compondrán nuestra nueva aplicación.
Primero creamos nuestra carpeta de proyecto. Vamos a llamar a la nuestra «holamundo».
helloworld/
├── CMakeLists.txt
└── src/
├── CMakeLists.txt
├── main.cpp
├── resources.qrc
└── contents/
└── ui/
└── main.qml
Dentro de esta carpeta vamos a crear la carpeta src/
y CMakeLists.txt
. Se suele considerar una buena práctica situar todos los archivos de código fuente principales en una carpeta src/
. Nuestra carpeta src/
, en cambio, va a contener otra carpeta llamada contents/
, que a su vez contiene una carpeta llamada ui/
. Ahí es donde vamos a crear nuestros archivos QML.
Consejo
Puede crear esta estructura rápidamente con:
mkdir -p helloworld/src/contents/ui
touch helloworld/CMakeLists.txt
touch helloworld/src/{CMakeLists.txt,main.cpp,resources.qrc}
touch helloworld/src/contents/ui/main.qml
Alternatively, you may want to use the standard Kirigami template provided by KDevelop, KDE's main IDE for coding in C++ and QML. KAppTemplate is also available if you only need a quick template to start coding in your favorite IDE or text editor.
Esta es una convención de KDE, pero no todos los proyectos de KDE usan esta estructura. Usted es libre de configurar las cosas de una manera diferente, pero deberá tener esto en cuenta al crear los archivos CMakeLists.txt
y resources.qrc
.
main.qml
|
|
Aquí es donde manejaremos la interfaz de nuestra aplicación.
Si sabe algo de JavaScript, gran parte de QML le será familiar (aunque tiene sus propias peculiaridades). La documentación de Qt dispone de gran cantidad de material sobre este lenguaje si tiene ganas de probar cosas por su cuenta. A lo largo del curso de estos tutoriales nos vamos a centrar en nuestro código QML, donde podemos usar Kirigami para sacar el máximo provecho del mismo.
Por ahora, centrémonos en main.qml
. Primero [importamos](https:// doc.qt.io/qt-6/qtqml-syntax-imports.html) cierto número de importantes módulos:
- QtQuick, la biblioteca estándar que usan las aplicaciones en QML.
- QtQuick Controls, que proporciona cierto número de controles estándares que podemos usar para hacer que nuestras aplicaciones sean interactivas.
- QtQuick Layouts, que proporciona herramientas para situar componentes dentro de la ventana de la aplicación.
- Kirigami , que proporciona cierto número de componentes adecuados para crear aplicaciones que funcionan en dispositivos de diferentes formas y tamaños.
Nota
Putting the QtQuick Controls and Kirigami imports into separate namespaces using theas
keyword is a best practice that ensures no components with the same name can conflict. You might see different names for QtQuick Controls in the wild, such as "QQC" or "QQC2". We will be using "Controls" in this tutorial for clarity.Luego llegamos a nuestro elemento base, Kirigami.ApplicationWindow , que proporciona algunas funcionalidades básicas que son necesarias para todas las aplicaciones de Kirigami. Esta es la ventana que contendrá todas nuestras páginas, las secciones principales de nuestra interfaz de usuario.
We then set the window's id
property to "root". IDs are useful because they let us uniquely reference a component, even if we have several of the same type.
We also set the window title
property to "Hello World". You'll notice that we have wrapped our "Hello World" string in a function called i18nc()
, where we detail the context of the string as well as the string itself.
Nota
i18n() functions make your app more easily translatable, as they return a version of the provided string in the user's language (as long as your app has been localised for that language). While an English user might see our window title as "Hello World", a Spanish user would see "Hola Mundo".
i18nc() builds on the i18n()
function by allowing developers to provide some context to translators working on the app. Here we clarify that the UI component is the title of the application window, so we have included the string "@title:window" before "Hello World". See the Ki18n Programmer's guide for more details.
We then set the first page of our page stack. Most Kirigami applications are organised as a stack of pages, each page containing related components suited to a specific task. For now, we are keeping it simple, and sticking to a single page.
pageStack
is an initially empty stack of pages provided by
Kirigami.ApplicationWindow
, and with pageStack.initialPage: Kirigami.Page {...}
we set the first page presented upon loading the application to a
Kirigami.Page
. This page will contain all our content.
Finally, we include in our page a
Controls.Label
that lets us place text on our page. We use anchors.centerIn: parent
to center our label horizontally and vertically within our parent element. In this case, the parent component of our label is
Kirigami.Page
. The last thing we need to do is set its text: text: i18n("Hello World!")
.
main.cpp
main.cpp
handles the "business logic" of our application. C++ is handy because it is flexible and fast, even if it is more involved than other programming languages.
main.cpp
también es el punto de entrada de nuestra aplicación. Las dos partes de nuestro proyecto, el motor y la interfaz del usuario, se configuran y se inician aquí.
|
|
For now, we don't need to go into too much detail regarding what our main.cpp
code does, but its role will grow significantly more important once we decide to add more complex functionality to our application in the future. If you want to get ahead, you can read more about how this main.cpp
works in this page.
resources.qrc
Our resources.qrc
is a Qt Resource file. It contains the list of all QML files as well as other files (like custom icons) that will be included in the binary.
|
|
Fíjese en la línea <file alias="main.qml">contents/ui/main.qml</file>
. En ella se detallan los archivos QML que se van a incluir en el proceso de compilación. En nuestro caso solo usamos main.qml
, pero si necesitamos añadir otro archivo QML a nuestro código, deberíamos asegurarnos de que lo incluimos en el archivo resources.qrc
añadiendo otra línea semejante a esta.
This resource file lets us use the "qrc:" + "/main.qml" path in our main.cpp
, instead of needing to specify the whole "contents/ui/main.qml" path.
CMakeLists.txt
CMakeLists.txt
files are needed to use KDE's build system of choice, CMake. The CMakeLists.txt
file in our top-level folder is going to specify some of our application's characteristics. It also includes some of the dependencies we need in order to compile our project.
|
|
The CMakeLists.txt
defines how to build your projects. Most of the content here is just to bootstrap your project. You can read a line-by-line, in-depth explanation of what this CMakeLists file does here.
The most important thing to keep in mind is that the Qt and KDE Frameworks dependencies are managed with find_package(). You will have to modify these lines and include any additional components that you decide to use during the development of your application.
The final line, add_subdirectory(src)
, points CMake to the helloworld/src/
directory, where our source code is located. Let's delve into the helloworld/src/CMakeLists.txt
file in there.
|
|
¡Este es mucho más corto! Repasemos lo que hace:
- add_executable() creates an executable from the given source files.
- target_link_libraries() links the libraries used in our code to our executable.
Nota
Note that these libraries should match the components that we included in our previousCMakeLists.txt
file—otherwise these components will not be included and our application won't compile.Ahora que nos hemos encargado de CMake, veamos los archivos a los que vamos a dedicar la mayor parte de nuestro tiempo de trabajo.
Compilar y ejecutar la aplicación
We are almost at the finish line. The last thing we need to do is build and run our application. Doing so will depend on which platform you are on.
If you are running your project on Linux, you will need to specify the place where the program will be installed. To do that, we need to change directories to our helloworld/
folder in our terminal application of choice and run the following commands:
cmake -B build/ -DCMAKE_INSTALL_PREFIX="~/kde5/usr"
cmake --build build/
cmake --install build/
The program will be installed to ~/kde5/usr/bin
.
If you are compiling your project with Craft on Windows, you might need to specify a CMake Generator for the first step, depending on whether you are using Visual Studio 2019 (msvc) or MinGW (make) to compile your projects.
Con Visual Studio:
cmake -B build/ -G "Visual Studio 16 2019"`
cmake --build build/
cmake --install build/
Con MinGW:
cmake -B build/ -G "MinGW Makefiles"
cmake --build build/
cmake --install build/
En ambos casos, el programa se instalará en C:\CraftRoot\bin
.
Podrá ejecutar el programa «helloworld» con:
helloworld # En Linux
helloworld.exe # En Windows
¡Ya está! Ahora verá su primera aplicación de Kirigami aparecer ante sus ojos.
Nota
La próxima vez que quiera crear los archivos y las carpetas necesarios, puede usar KAppTemplate o KDevelop para generar automáticamente un proyecto adecuado con el que empezar. Están disponibles en los repositorios de las principales distribuciones. Estas aplicaciones también generarán archivos que contienen metadatos de AppStream y un archivo .desktop
que contiene información sobre cómo se debe mostrar la aplicación en un lanzador de aplicaciones de Linux.
Gracias a la magia de CMakeLists, también puede usar un IDE, como KDevelop o QtCreator, para desarrollar esta aplicación dentro de un entorno confortable con el mínimo esfuerzo.