Development/Tutorials/First program/pt-br
| Tutorial Series | Tutorial para Iniciantes |
| Previous | C++, Qt, Building KDE |
| What's Next | Tutorial 2 - KXmlGuiWindow |
| Further Reading | CMake |
Resumo
Seu primeiro programa deve cumprimentar o mundo com um amigável "Hello World", e o que mais? Para isso, usaremos uma classe KMessageBox e personalizaremos um dos botões.
O Código
Todo o código que precisamos estará em um arquivo, main.cpp. Crie esse arquivo com o código abaixo:
#include <QApplication>
#include <QCommandLineParser>
#include <KAboutData>
#include <KLocalizedString>
#include <KMessageBox>
int main (int argc, char *argv[])
{
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("tutorial1");
KAboutData aboutData(
// The program name used internally. (componentName)
QStringLiteral("tutorial1"),
// A displayable program name string. (displayName)
i18n("Tutorial 1"),
// The program version string. (version)
QStringLiteral("1.0"),
// Short description of what the app does. (shortDescription)
i18n("Displays a KMessageBox popup"),
// The license this code is released under
KAboutLicense::GPL,
// Copyright Statement (copyrightStatement = QString())
i18n("(c) 2015"),
// Optional text shown in the About box.
// Can contain any information desired. (otherText)
i18n("Some text..."),
// The program homepage string. (homePageAddress = QString())
QStringLiteral("http://example.com/"),
// The bug report email address
// (bugsEmailAddress = QLatin1String("[email protected]")
QStringLiteral("[email protected]"));
aboutData.addAuthor(i18n("Name"), i18n("Task"), QStringLiteral("[email protected]"),
QStringLiteral("http://your.website.com"), QStringLiteral("OSC Username"));
KAboutData::setApplicationData(aboutData);
QCommandLineParser parser;
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
KGuiItem yesButton( i18n( "Hello" ), QString(),
i18n( "This is a tooltip" ),
i18n( "This is a WhatsThis help text." ) );
return
KMessageBox::questionYesNo
(0, i18n( "Hello World" ), i18n( "Hello" ), yesButton )
== KMessageBox::Yes? EXIT_SUCCESS: EXIT_FAILURE;
}Primeiro, precisamos criar um objeto QApplication. Isso precisa ser feito exatamente uma vez em cada programa, pois é necessário para coisas como i18n. Também deve ser criado antes de qualquer outro KDE Framework ou Qt object. Uma chamada para KLocalizedString::setApplicationDomain() é necessária para configurar corretamente o catálogo de traduções e deve ser feita antes que a próxima etapa aconteça.
O primeiro objeto específico do KDE Framework que criamos neste programa é o KAboutData. Essa é a classe usada para armazenar informações sobre o programa, como uma breve descrição, autores ou informações de licença. Praticamente todos os aplicativos do KDE devem usar esta classe. Em seguida, chamamos KAboutData::setApplicationData() para inicializar as propriedades do objeto QApplication.
Então chegamos ao QCommandLineParser. Essa é a classe que você usaria para especificar opções de linha de comando para, por exemplo, abrir o programa com um arquivo específico. No entanto, neste tutorial, simplesmente o inicializamos com o objeto KAboutData que criamos para que possamos usar as opções --version or --author.
Agora que fizemos toda a configuração necessária, podemos passar a fazer coisas interessantes com nosso aplicativo. Vamos criar uma pop-up box, mas vamos personalizar um dos botões. Para fazer essa personalização, precisamos usar um objeto KGuiItem. O primeiro argumento no construtor KGuiItem é o texto que aparecerá no item (no nosso caso, um botão). Então temos a opção de definir um ícone para o botão, mas não queremos um, apenas fornecemos QString(). Em seguida, definimos a tooltip (é o que aparece quando você passa o mouse sobre um item) e, finalmente, o "What's This?"(acessado com o botão direito do mouse ou Shift-F1).
Agora que temos o nosso item, podemos criar nosso pop-up. Chamamos a função KMessageBox::questionYesNo() que, por padrão, cria uma message box com os botões "Yes" e "No". O segundo argumento é o texto que aparecerá na message box acima dos botões. A terceira é a legenda que a janela terá e, finalmente, definimos o KGuiItem para (o que normalmente seria) o botão "Yes" para o KGuiItem yesButton que criamos.
Observe que todo o texto visível ao usuário é passado através da função i18n(); isso é necessário para que a UI seja traduzível. Mais informações sobre localização podem ser encontradas em localization tutorial.
Tudo foi feito no que diz respeito ao código. Agora, compile e experimente.
Compilação
Você deve usar o CMake para o seu ambiente de compilação. Forneça um arquivo CMakeLists.txt, o CMake usa esse arquivo para gerar todos os Makefiles a partir dele.
CMakeLists.txt
Crie um arquivo chamado CMakeLists.txt no mesmo diretório que o main.cpp com este conteúdo:
cmake_minimum_required(VERSION 3.0)
project (tutorial1)
set(QT_MIN_VERSION "5.3.0")
set(KF5_MIN_VERSION "5.2.0")
find_package(ECM 1.0.0 REQUIRED NO_MODULE)
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDECompilerSettings NO_POLICY_SCOPE)
include(FeatureSummary)
# Find Qt modules
find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
Core # QCommandLineParser, QStringLiteral
Widgets # QApplication
)
# Find KDE modules
find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
CoreAddons # KAboutData
I18n # KLocalizedString
WidgetsAddons # KMessageBox
)
feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
set(tutorial1_SRCS main.cpp)
add_executable(tutorial1 ${tutorial1_SRCS})
target_link_libraries(tutorial1
Qt5::Widgets
KF5::CoreAddons
KF5::I18n
KF5::WidgetsAddons
)
install(TARGETS tutorial1 ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
A função find_package() localiza o pacote solicitado(neste caso, ECM, Qt5 ou KF5) e define algumas variáveis que descrevem a localização dos cabeçalhos do pacote e bibliotecas. O ECM, ou Extra CMake Modules, é necessário para importar arquivos e funções especiais do CMake para criar aplicativos KDE.
Aqui tentamos encontrar os módulos para o Qt 5 e o KDE Frameworks 5 necessários para compilar nosso tutorial. Os arquivos necessários são incluídos pelo CMake para que o compilador possa vê-los no momento da criação. Os números mínimos de versão são definidos na parte superior do arquivo CMakeLists.txt para facilitar a referência
Em seguida, criamos uma variável chamada tutorial1_SRCS usando a função set(). Nesse caso, simplesmente a definimos como o nome do nosso único arquivo de origem.
Então usamos add_executable() para criar um executável chamado tutorial1 a partir dos arquivos fontes listados em nossa variável tutorial1_SRCS. Depois, linkar nosso executável às bibliotecas necessárias usando a função target_link_libraries(). A linha que começa com install grava um destino "install" padrão no Makefile.
Make And Run
Para compilar, linkar e instalar seu programa, você deve ter vários softwares instalados, por exemplo cmake, make e gcc-c ++ e Qt 5 e os arquivos de desenvolvimento KDE Frameworks. Para ter certeza de que você tem tudo, é melhor seguir paraesse guia de instalação.
Embora você possa executar o CMake diretamente dentro do diretório do código-fonte em si, é uma boa prática e altamente recomendável em alguns softwares do KDE usar um diretório de compilação separado e executar CMake a partir daí:
mkdir build && cd build
You can invoke CMake and make manually:
cmake .. && make
E executar com:
./tutorial1
Adiante
Now you can move on to using KXmlGuiWindow.