Hipe : The DOM on the desktop
How Hipe Works  |  Installation  |  Running hiped  |  Hipe API

Installing Hipe

Installing Hipe is easy once you have the required dependencies. However, exactly how you configure Hipe to run on your target system will differ depending on your requirements. (For example, if you are building an embedded device that uses Hipe for its entire user interface, you would configure Hipe to run your entire desktop environment. If you are installing Hipe on an Ubuntu desktop to develop software on, you might prefer to run Hipe within your existing desktop environmnent.)

The steps are as follows:

  1. Install the dependencies.
  2. Build and install the display server program, known as hiped.
  3. Configure hiped to start automatically.
  4. Install the API. This is not required for running applications built for Hipe, but is necessary for developing such applications. You will need the API to build the test applications. These will allow you to make sure that everything is working correctly.
  5. Build and install the test applications if desired.

These instructions assume you have downloaded the Hipe distribution into some directory called hipe. You will not need superuser privileges except for certain steps where stated.

A $ prompt in these instructions means you type the command as a normal user, while a # means you type the command with superuser privileges (or by prefixing it with sudo if your OS distribution allows it). Please don't literally type those prompt characters.

Install the dependencies

We assume you have a working X installation. You will also need the development files for Qt with QtWebkit. It has been tested to build successfully with either Qt4 or Qt5. Qt must be built with STL support as Hipe requires it. On a Debian-based system (e.g. Ubuntu), you can install the Webkit dependencies with the following command:

$ sudo apt install libqt5webkit5-dev

Such systems may also default to Qt4 even if you have only installed Qt5. (Hipe requires either Qt version 4 or 5.) If you are unable to run the qmake command in the following section below, the following may be helpful:

$ sudo apt install qt5-default

If in doubt, the following command will tell you which version of Qt is set up as the current default version:

$ qmake --version

You may also need to install other Qt development packages if you don't already have them. If the server refuses to compile in the following step, it means you're missing one or more Qt components.

Build hiped

hiped is the display server itself. If you have Qt Creator (a graphical IDE developed by the Qt people), you can open the hiped project file and build hiped in the graphical environment.

The following instructions don't require Qt Creator, and assume you will be building it from the terminal, the old-fashioned way.

First, from enter the server subdirectory of the hipe distribution.

$ cd hipe/server/

Now use qmake to configure and build the Makefile for your system:

$ qmake -makefile ./src/hiped.pro

Then run the following command to build the hiped executable from source:

$ make

An executable file, hiped should now be present in the current directory. The Hipe display server can now be run directly using the hiped executable if desired, however it is often more convenient to install it in a permanant location.

Install the compiled display server

Running make will produce the hiped executable but will not install it. The following describes a typical installation. In some cases your requirements may differ, and it is quite OK to modify your deployment accordingly. (Experiment as needed!)

First, it is recommended to copy the hiped executable file into your system's /usr/local/bin/ directory. It is recommended to check the file permissions to ensure that all users have permission to execute hiped.

Now you will need to configure your system to run hiped automatically so that applications that depend on Hipe can find the running display server.

Configure hiped

Running on an existing desktop environment

Unless you're preparing hiped to run in its own standalone display environment, hiped needs to be started within a graphical environment compatible with Qt applications (such as X11 or Wayland).

Configure the following command to run on user login, within the user's graphical desktop environment:

hiped &

For example, the command could be added to the appropriate session startup script (e.g. Xsession or .xprofile). The exact script to modify will differ depending on your OS distribution, or your OS distro may provide another way to configure applications to run on startup.

Now the Hipe display server is available from the moment the user logs in. The hiped background process is lightweight and consumes only minimal CPU and RAM resourses until it is actually required.

Deploying in an embedded environment

An easy way to deploy hiped is to start up a bare-bones X11 session (without a window manager or desktop environment), and then start hiped with the --fill option. Although other display backends are provided by Qt, running Hipe on X11 tends to outperform them due to driver availability issues on various devices.

The --fill option causes the first top-level application to take over the entire screen.

$ hiped --fill &

The server/start_hipe_standalone script (which must be run from a virtual console TTY in Linux) gives a rudimentary example of how to start Hipe as a standalone display environment by piggybacking off a bare-bones X11 session.

Note: If your system allows the user to run more than one application, then your top-level application should carry out framing management for other applications in order to provide a complete desktop shell. The quadrant sample program provides a very rudimentary example of how to do this. (You should also set up the appropriate environment variables to ensure applications run within your shell instead of attempting to spawn top-level frames.)

You can also try running

$ hiped --help

as well as browsing the Running hiped page for various other configuration options. In addition to the options listed, hiped supports standard Qt arguments for running on different graphics backends. You may be able to install additional backends as part of your Qt installation. Refer to the official Qt documentation for details. (Hipe has no affiliation with the Qt project or Qt developers.)

Compile and install the client API

So you've installed and configured the Hipe display server. Well, you won't be able to do anything interesting with Hipe without some Hipe client apps to run on it, so read on and install the API.

Leave the server directory and enter the api directory instead.

$ cd ..
$ cd api/

Build the Hipe API library, libhipe, by running make.

$ make

Now it's time to install the libhipe library so that hipe applications can be compiled and linked to it. To see what will happen, have a quick look at the Makefile, under the install: heading.

$ cat Makefile

By default, library files will be installed into your /usr/local/lib/ and /usr/local/include/ directories. This is sensible for most GNU/Linux distributions. For certain other system distributions or installation requirements, you may need to edit the Makefile to change these paths.

Now install libhipe with superuser priviledges:

# make install

And now you can build the test applications.

$ make testing

The test applications are now available inside the api/test/ subdirectory.