Comment créer des indicateurs Unity?

Je suis intéressé par les indicateurs Unity et je me demande s'il existe un tutoriel sur la façon de les programmer. Je peux utiliser les sources des sources existantes en dernier recours, mais je préférerais une approche plus conviviale car mes compétences en programmation sont assez limitées.

La documentation de l'indicateur d'application avec des exemples et des documents API est disponible ici:

• https://wiki.ubuntu.com/DesktopExperienceTeam/ApplicationIndicators , sa référence API est HTML dans le libappindicator-docpackage. (Merci @Sneetsher)
• http://developer.ubuntu.com/apps (cassé)

Il n'y a pas encore de didacticiels sur les indicateurs d'application, mais restez à l'écoute pour plus de contenu sur la section des didacticiels du site App Developer:

• http://developer.ubuntu.com/resources/app-developer-cookbook/all-recipes/ (cassé)

Voici un exemple d'indicateur d'application en C. Il s'agit d'une version "indicateur uniquement" (pas de fenêtre) de l'exemple fourni sur Ubuntu Wiki :

#include <libappindicator/app-indicator.h>

static void activate_action (GtkAction *action);

static GtkActionEntry entries[] = {
    {"New",  "document-new",     "_New",  "<control>N",
        "Create a new file",    G_CALLBACK(activate_action)},
    {"Open", "document-open",    "_Open", "<control>O",
        "Open a file",          G_CALLBACK(activate_action)},
    {"Save", "document-save",    "_Save", "<control>S",
        "Save file",            G_CALLBACK(activate_action)},
    {"Quit", "application-exit", "_Quit", "<control>Q",
        "Exit the application", G_CALLBACK(gtk_main_quit)},
};
static guint n_entries = G_N_ELEMENTS(entries);

static const gchar *ui_info =
"<ui>"
"  <popup name='IndicatorPopup'>"
"    <menuitem action='New' />"
"    <menuitem action='Open' />"
"    <menuitem action='Save' />"
"    <menuitem action='Quit' />"
"  </popup>"
"</ui>";

static void activate_action(GtkAction *action)
{
    const gchar *name = gtk_action_get_name (action);
    GtkWidget *dialog;

    dialog = gtk_message_dialog_new(NULL,
                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                    GTK_MESSAGE_INFO,
                                    GTK_BUTTONS_CLOSE,
                                    "You activated action: \"%s\"",
                                    name);

    g_signal_connect(dialog, "response", 
                     G_CALLBACK(gtk_widget_destroy), NULL);

    gtk_widget_show(dialog);
}

int main(int argc, char **argv)
{
    GtkWidget*      indicator_menu;
    GtkActionGroup* action_group;
    GtkUIManager*   uim;
    AppIndicator* indicator;
    GError* error = NULL;

    gtk_init(&argc, &argv);

    /* Menus */
    action_group = gtk_action_group_new("AppActions");
    gtk_action_group_add_actions(action_group, entries, n_entries,
                                 NULL);

    uim = gtk_ui_manager_new();
    gtk_ui_manager_insert_action_group(uim, action_group, 0);

    if (!gtk_ui_manager_add_ui_from_string(uim, ui_info, -1, &error)) {
        g_message("Failed to build menus: %s\n", error->message);
        g_error_free(error);
        error = NULL;
    }

    /* Indicator */
    indicator = app_indicator_new("example-simple-client",
                                  "go-jump",
                                  APP_INDICATOR_CATEGORY_APPLICATION_STATUS);

    indicator_menu = gtk_ui_manager_get_widget(uim, "/ui/IndicatorPopup");

    app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE);
    app_indicator_set_attention_icon(indicator, "indicator-messages-new");

    app_indicator_set_menu(indicator, GTK_MENU(indicator_menu));

    gtk_main();

    return 0;
}

J'ai fait un petit tutoriel ici pour créer un indicateur d'application chronomètre en python: http://www.steshadoku.com/blog/2017/elapses-creating-a-unity-stopwatch-indicator-w-python/

import gobject
import gtk
import appindicator
import os, sys
import time
from datetime import timedelta

if __name__ == "__main__":

    saveseconds = 0 #global variable to save how many seconds the clock has run
    dir_path = os.path.dirname(os.path.realpath(__file__))
    source_id = ""

    def on_timer(args=None):
      savetime = int(time.time() - timestart) + saveseconds
      ind.set_label(str(timedelta(seconds=savetime)))
      return True

    def finish(args=None):
        sys.exit()
        return True

    def stoptime(args=None):
        #print(source_id)
        global saveseconds
        saveseconds += int(time.time() - timestart)
        gtk.timeout_remove(source_id)
        return True

    def starttime(args=None):
        global timestart
        timestart = time.time()
        global source_id
        source_id = gtk.timeout_add(1000, on_timer)
            #sets timer to run every 1s
        return True

    def cleartime(args=None):
        global saveseconds
        saveseconds = 0
        ind.set_label(str(timedelta(seconds=0)))
        gtk.timeout_remove(source_id)
        return True

    #format below is category name, icon
    ind = appindicator.Indicator ("simple-clock-client", "hourglass", appindicator.CATEGORY_APPLICATION_STATUS, dir_path)
    ind.set_status (appindicator.STATUS_ACTIVE)
    ind.set_label("Elapses"); #name of program and initial display

    ##Setup Menu Items
    menu = gtk.Menu()

    stop = gtk.MenuItem("Stop")
    stop.connect("activate", stoptime)
    stop.show()
    menu.append(stop)

    start = gtk.MenuItem("Start")
    start.connect("activate", starttime)
    start.show()
    menu.append(start)

    clear = gtk.MenuItem("Clear")
    clear.connect("activate", cleartime)
    clear.show()
    menu.append(clear)

    exit = gtk.MenuItem("Exit")
    exit.connect("activate", finish)
    exit.show()
    menu.append(exit)

    ind.set_menu(menu) #set the menu with added items
    gtk.main()