1.0
Getting Started

There are various ways to get started with EGT depending on your requirements. If you are building EGT on a PC, you can start by just fetching the source of the EGT project. If you are developing for and deploying to a target board, the easiest way to work with EGT is part of a buildroot or Yocto Project SDK which already includes a cross compiler and all of the necessary dependencies and tools.

See Eclipse Development Environment Setup for how to setup the Eclipse IDE for host or cross compiling.

If you are planning to work on EGT itself, see the CONTRIBUTING.md file in the root of the EGT repository.

Fetching Source

Fetch the source:

git clone --recursive https://github.com/linux4sam/egt.git
Note
Note the --recursive option. This option is necessary to initialize any git submodules in the project. If you forget to do this, autogen.sh will do it for you.

Building

EGT is tested on Ubuntu 18.04, but is also known to work on Ubuntu 16.04 as well as other distributions like Debian and Fedora. These instructions should be adjusted accordingly.

EGT uses the GNU Autotools, like automake, for building on Linux platforms.

To build for a PC, first install the required dependencies for building EGT:

sudo apt install build-essential automake autoconf libtool pkg-config \
libdrm-dev libinput-dev libcairo-dev libjpeg-dev libmagic-dev gettext

Optional, but recommended, EGT Dependencies include:

sudo apt install librsvg2-dev liblua5.3-dev libcurl4-openssl-dev \
libxkbcommon-dev xkb-data
sudo apt install libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev
sudo apt install libplplot-dev plplot-driver-cairo
sudo apt install libasound2-dev libsndfile1-dev
Note
On Ubuntu 16.04 the package plplot12-driver-cairo should be used instead of plplot-driver-cairo.

Then, clone the source and initialize Autotools. Typically Autotools only needs to be initialized once and it will automatically pick up most changes. However, when making changes to the configure scripts, the environment, or makefiles re-running autogen.txt, or more simply autoreconf -fvi, is necessary.

git clone --recursive https://github.com/linux4sam/egt.git
cd egt
./autogen.txt

Then, configure and build.

./configure
make

You can also build out of the source tree. This is useful, for example, to use the same code tree with different parameters and environments to configure the build in as many different build directories as you wish. It also avoids polluting the source tree with build artifacts.

mkdir -p build/host
cd build/host
../../configure
make

Then, run an example.

cd examples/basic
./basic

EGT also supports cross compilation for target systems. If you already have a cross compiler available with dependent libraries available, add it to your PATH and follow the standard instructions.

Note
When adding cross compilation paths to the PATH environment variable, it should come before any existing system paths.
./autogen.txt
./configure --prefix=/nfsroot/root/egt/ --host=arm-buildroot-linux-gnueabi
make

Configure Options

You can run "./configure --help" to see more options. Some non-standard options are listed here, but not all.

--enable-code-coverage
Whether to enable code coverage support
--enable-sanitize
turn on sanitize analysis tools
--enable-debug
enable debugging support [default=yes]
--enable-gcov
turn on code coverage analysis tools
--enable-profile
turn on profiling tools
--disable-icons
do not install icons [default=no]
--enable-examples
build examples [default=yes]
--disable-virtualkeyboard
include support for virtualkeyboard [default=yes]
--enable-lto
enable gcc's LTO [default=no]
--enable-lua-bindings
enable lua bindings (default: no)
--enable-simd
build with simd support [default=no]
--enable-snippets
build snippets examples [default=no]

Cross Compiling With Buildroot

EGT is included as a package as part of the buildroot-external-microchip project. To build a complete SDK and target filesystem for a board, follow the instructions found in that project's README.

See the configs directory in the buildroot-external-microchip project for a graphics defconfig for your processor and board.

Cross Compiling With Yocto

EGT is included as a package as part of the meta-atmel Yocto layer project. To build a complete SDK and target filesystem for a board, follow the instructions found in that project's README.

First Application

The examples folder of the EGT project contains various examples. This is the basic example which shows the minimum necessary to create a window with a button on it.

The include file <egt/ui> contains most basic functionality needed.

#include <egt/ui>
int main()
{
egt::Application app;
egt::TopWindow window;
egt::Button button(window, "Press Me");
egt::center(button);
window.show();
return app.run();
}

Basic Example

If you want to use a UI file instead.

#include <egt/ui>
#include <egt/uiloader.h>
int main(int argc, char** argv)
{
egt::Application app(argc, argv);
#ifdef EXAMPLEDATA
egt::add_search_path(EXAMPLEDATA);
#endif
egt::experimental::UiLoader loader;
auto window = loader.load("file:ui.xml");
window->show();
return app.run();
}

Using this Documentation Offline or With Other Development Tools

This documentation is also available in the form of a docset that can be read and searched using a tool like Dash (macOS) and Zeal (macOS/Windows/Linux). In turn, the documentation can be integrated into an IDE or tools like Atom/VSCode for an indexed and easily searchable API reference. These tools also provide a method for automatically or manually updating to the latest EGT documentation.

Once you have one of these tools installed, the docset feed URL is located at:

https://linux4sam.github.io/egt-docs/docset/EGT.xml

Note
To install Zeal, see the official documentation to download and installing. Specifically, on Ubuntu, it is recommended to get the latest version with their PPA.
sudo add-apt-repository ppa:zeal-developers/ppa
sudo apt update
sudo apt install zeal