menutest.c

Go to the documentation of this file.

/*
 * File Name: menutest.c
 */

/*
 * This file is part of popupmenu.
 *
 * popupmenu is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * popupmenu is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

#include "config.h"

#include <glib.h>
#include <stdlib.h> 
#include <signal.h>
#include <unistd.h>

#include <liberipc/eripc.h>

#include "i18n.h"

#define DBUS_SERVICE            "com.irexnet.popupmenu"
#define DBUS_SERVICE_MENUTEST   "com.irexnet.popupmenutest"

int activated_handler = -1;
eripc_context_t *ctx = NULL;

/**
 * Utility to return a pointer to a statically allocated string giving
 * the textural representation of Muali errors. 
 */
static const gchar* eripcErrorStr(eripc_error_t errorcode) 
{
    switch (errorcode) 
    {
    case ERIPC_ERROR_SUCCESS:
        return "No error (ERIPC_ERROR_SUCCESS)";
    case ERIPC_ERROR:
        return "Some kind of error occurred (ERIPC_ERROR)";
    case ERIPC_ERROR_INVALID:
        return "At least one parameter is invalid (ERIPC_ERROR_INVALID)";
    case ERIPC_ERROR_OOM:
        return "Out of memory error (ERIPC_ERROR_OOM)";
    case ERIPC_ERROR_TIMEOUT:
        return "Timeout error (ERIPC_ERROR_TIMEOUT)";
    default:
        return "Unknown/Undefined";
    }
}

/**
 * Utility to print out the type and content of given eripc_rpc_t.
 * It also demonstrates the types available when using Muali for
 * the RPC. Most simple types are available, but arrays are not
 * (unfortunately).
 */
static void printEventInfo(const eripc_event_info_t *event) 
{
    int i=0;
    const eripc_arg_t *arg_array = event->args;

    for (i=0; arg_array[i].type != ERIPC_TYPE_INVALID; i++)
    {
        switch (arg_array[i].type) 
        {
        case ERIPC_TYPE_BOOL:
          g_print("boolean:%s", (arg_array[i].value.b == TRUE) ? "TRUE":"FALSE");
          break;
        case ERIPC_TYPE_DOUBLE:
          g_print("double:%.3f", arg_array[i].value.d);
          break;
        case ERIPC_TYPE_BYTE:
          g_print("byte:%d", arg_array[i].value.by);
          break;
        case ERIPC_TYPE_INT:
          g_print("int32:%d", arg_array[i].value.i);
          break;
        case ERIPC_TYPE_UINT:
          g_print("uint32:%u", arg_array[i].value.u);
          break;
        case ERIPC_TYPE_STRING:
          g_print("string:'%s'", arg_array[i].value.s);
          break;
        case ERIPC_TYPE_DATA:
          g_print("dataptr:'%p'", arg_array[i].value.data);
          break;
        default:
          g_print("unknown(type=%d)", arg_array[i].type);
          break;
        }
      g_print("\n");
    }
}
 

static void replyFunction_rh(eripc_context_t *context, 
        const eripc_event_info_t *info, 
        void *user_data)
{
//    g_print("replyFunction_rh reply!\n");
//    printEventInfo(info);
    return;
}


static void menuActivated_rh(eripc_context_t *context, 
        const eripc_event_info_t *info, 
        void *user_data)
{
    g_print("menuActivated_rh reply!\n");
    printEventInfo(info);
    
    eripc_reply_bool(context, info->message_id, TRUE);    
    return;
}


static void add_group(const char *name, const char *parent, const char *label, const char *icon) 
{
    eripc_error_t result;

//    g_print("menutest: add group `%s`\n",name);

    result = eripc_send_varargs(ctx,
                                NULL, 
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "addGroup",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, parent,
                                ERIPC_TYPE_STRING, label,
                                ERIPC_TYPE_STRING, icon,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void add_item(const char *name, const char *parent, const char *label) 
{
    eripc_error_t result;
    
//    g_print("menutest: add item `%s.%s`\n",parent,name);
    
    result = eripc_send_varargs(ctx,
                                NULL, 
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "addItem",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, parent,
                                ERIPC_TYPE_STRING, label,
                                ERIPC_TYPE_STRING, name,     /* icon name is same as iten name */
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    } 
}


static void add_menu(const char *name, const char *label, const char *service,
                     const char *group1, const char *group2, const char *group3, const char *group4) 
{
    eripc_error_t result;

    result = eripc_send_varargs(ctx,
                                replyFunction_rh,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "addMenu",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_STRING, label,
                                ERIPC_TYPE_STRING, service,
                                ERIPC_TYPE_STRING, group1,
                                ERIPC_TYPE_STRING, group2,
                                ERIPC_TYPE_STRING, group3,
                                ERIPC_TYPE_STRING, group4,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    } 
}


static void remove_group(const char *name) 
{
    eripc_error_t result;
    
    result = eripc_send_varargs(ctx,
                                replyFunction_rh,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "removeGroup",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void remove_menu(const char *name) 
{
    eripc_error_t result;
    
    result = eripc_send_varargs(ctx,
                                replyFunction_rh,
                                NULL,
                                ERIPC_BUS_SESSION,
                                DBUS_SERVICE,
                                "removeMenu",
                                ERIPC_TYPE_STRING, name,
                                ERIPC_TYPE_INVALID);

    if (result != ERIPC_ERROR_SUCCESS) 
   {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}


static void install_activation_handler()
{
    eripc_error_t result;
    
    result = eripc_set_message_handler(ctx,
                                      menuActivated_rh,
                                      NULL,
                                      ERIPC_BUS_SESSION,
                                      DBUS_SERVICE_MENUTEST,
                                      "menuItemActivated",
                                      &activated_handler);
    
    if (result != ERIPC_ERROR_SUCCESS) 
    {
        g_error("Error launching the RPC (%s)\n", eripcErrorStr(result));
    }
}

void term_handler(int sig)
{
    g_warning("menutest got SIGTERM, cleaning up\n");
    
    if (activated_handler != -1)
    {
      eripc_unset_handler(ctx, activated_handler);
    }
    
    remove_group("ctb_view");
    remove_group("ctb_sort");
    remove_group("ctb_content_tools");
    remove_group("ctb_trashcan_tools");
    remove_group("ctb_settings_tools");
    remove_group("uds_view");
    remove_group("uds_tools");
    remove_group("uds_navigation");
    remove_group("uds_actions");
    remove_group("uds_bookmark_actions");
    
    remove_menu("ctb_menu_content");
    remove_menu("ctb_menu_trashcan");
    remove_menu("ctb_menu_settings");
    remove_menu("uds_menu_reading");
    remove_menu("uds_menu_thumbnail"); 
    remove_menu("uds_menu_toc"); 
    remove_menu("uds_menu_bookmark");
    remove_menu("uds_menu_dictionary");
    remove_menu("uds_menu_search");
    remove_menu("uds_menu_info");
    
    g_warning("menutest exists\n");
   
    exit(0);
}

int main(int argc, char **argv) 
{
    GMainLoop *gloop = NULL;
    const char *group = NULL;
   
    signal(SIGTERM, term_handler);
    signal(SIGINT, term_handler);
    
    gloop = g_main_loop_new(NULL, FALSE);

    ctx = eripc_init("menutest", "1.0", NULL);
    if (ctx == NULL) 
    {
        g_error("Failed to initialize IPC API\n");
    }

    eripc_set_timeout(ctx, 2000);
    
    
    g_print("-- Adding menu items...\n");

    // content browser groups
    //
    
    // content browser view 
    group = "ctb_view";
    add_group(group, NULL, _("View"), NULL);
        add_item("view_small",  group, _("Thumbnails"));
        add_item("view_detail", group, _("Details"));
        add_item("view_large",  group, _("Covers"));

    // content browser sort
    group = "ctb_sort";
    add_group(group, NULL, _("Sort by"), NULL);
        add_item("sort_name",   group, _("Name"));
        add_item("sort_type",   group, _("Type"));
        add_item("sort_date",   group, _("Date"));
        add_item("sort_size",   group, _("Size"));
        add_item("sort_author", group, _("Author"));
    
    // content browser tools
    group = "ctb_content_tools";
    add_group("ctb_content_tools",  NULL, _("Actions"), NULL);
        add_item("open",            group, _("Open"));
        add_item("search_library",  group, _("Search Documents"));
        add_item("create_shortcut", group, _("Add Shortcut"));
        add_item("delete",          group, _("Delete"));
        add_item("select_all",      group, _("Select All"));
        add_item("copy",            group, _("Copy"));
        add_item("cut",             group, _("Cut"));
        add_item("paste",           group, _("Paste"));
    
    // trashcan toools
    group = "ctb_trashcan_tools";
    add_group(group,                NULL,  _("Actions"), NULL);
        add_item("empty_trash",     group, _("Empty Recycle Bin"));
        add_item("delete",          group, _("Delete"));
        add_item("copy",            group, _("Copy"));
        add_item("cut",             group, _("Cut"));
        add_item("paste",           group, _("Paste"));
    
    // settings tools
    group = "ctb_settings_tools";
    add_group(group,               NULL,  _("Actions"), NULL);
        add_item("open",            group, _("Open"));

    // uds groups
    //
    
    // uds view 
    group = "uds_view";
    add_group("uds_view",           NULL,  _("View"), NULL);
        add_item("view_reading",    group, _("Normal Reading"));
        add_item("view_thumbnail",  group, _("Page Thumbnails"));
        add_item("view_bookmark",   group, _("All Bookmarks"));
        add_item("view_toc",        group, _("Table of Contents"));
        add_item("view_info",       group, _("Details"));

    // uds toolboxes
    add_group("uds_tools",          NULL, _("Tools"), NULL);
        add_group("tools_bookmark", "uds_tools", _("Bookmarking"), "tools_bookmark");
            group = "tools_bookmark_tools";
            add_group(group, "tools_bookmark", _("Actions"), NULL);
                add_item("bookmark_add",      group, _("Add Bookmark"));
                add_item("bookmark_toc",      group, _("Add Contents Bookmark"));
                add_item("bookmark_delete",   group, _("Delete Bookmark"));
        add_group("tools_drawing", "uds_tools", _("Writing"), "tools_drawing");
            group = "pen_functions";
            add_group(group, "tools_drawing", _("Pen Types"), NULL);
                add_item("pen",               group, _("Pen"));
                add_item("eraser",            group, _("Eraser"));
            group = "pen_size";
            add_group(group, "tools_drawing", _("Shapes"), NULL);
                add_item("stylus_1",          group, _("Size 1"));
                add_item("stylus_2",          group, _("Size 2"));
                add_item("stylus_3",          group, _("Size 3"));
                add_item("stylus_4",          group, _("Size 4"));
                add_item("stylus_5",          group, _("Size 5"));
            group = "pen_color";
            add_group(group, "tools_drawing", _("Colours"), NULL);
                add_item("stylus_black",      group, _("Black"));
                add_item("stylus_dark_grey",  group, _("Dark Grey"));
                add_item("stylus_light_grey", group, _("Light Grey"));
                add_item("stylus_white",      group, _("White"));
        add_group("tools_character", "uds_tools", _("Fonts"), "tools_character");
            group = "font_sizes_1";
            add_group(group, "tools_character", _("Font Sizes"), NULL);
                add_item("font_size_6",       group, _("6pt"));
                add_item("font_size_8",       group, _("8pt"));
                add_item("font_size_10",      group, _("10pt"));
                add_item("font_size_11",      group, _("11pt"));
            group = "font_sizes_2";
            add_group(group, "tools_character", _("Font Sizes"), NULL);
                add_item("font_size_12",      group, _("12pt"));
                add_item("font_size_14",      group, _("14pt"));
                add_item("font_size_16",      group, _("16pt"));
                add_item("font_size_18",      group, _("18pt"));
                add_item("font_size_20",      group, _("20pt"));
            group = "font_sizes_3";
            add_group(group, "tools_character", _("Font Sizes"), NULL);
                add_item("font_size_22",      group, _("22pt"));
                add_item("font_size_24",      group, _("24pt"));
                add_item("font_size_28",      group, _("28pt"));
                add_item("font_size_30",      group, _("30pt"));
                add_item("font_size_34",      group, _("34pt"));
        add_group("tools_zoom", "uds_tools", _("Zooming"), "tools_zoom");
            group = "zoom_page";
            add_group(group, "tools_zoom", _("Screen Mode"), "zoom_page");
                add_item("mode_full_screen",  group, _("Full Screen"));
                add_item("zoom_auto",         group, _("Hide Margins"));
                add_item("zoom_fit",          group, _("Fit on Screen"));
                add_item("mode_continuous",   group, _("Page Flow"));
            group = "zoom_factor";
            add_group(group, "tools_zoom", _("Zoom Factors"), NULL);
                add_item("zoom_75",           group, _("75%"));
                add_item("zoom_100",          group, _("100%"));
                add_item("zoom_150",          group, _("150%"));
                add_item("zoom_200",          group, _("200%"));
                add_item("zoom_selection",    group, _("Selection Zoom"));
            group = "zoom_shift";
            add_group(group, "tools_zoom", _("Other"), NULL);
                add_item("mode_pan",          group, _("Pan"));

    // navigation
    group = "uds_navigation";
    add_group(group,                   NULL,  _("Actions"), NULL);
        add_item("history_back",       group, _("Jump to Previous"));
        add_item("history_forward",    group, _("Jump to Next"));
        add_item("dictionary_lookup",  group, _("Look Up in Dictionary"));
        add_item("search_text",        group, _("Find Word"));
        add_item("close",              group, _("Close Document"));
    
    // actions
    group = "uds_actions";
    add_group(group,     NULL,  _("Actions"), NULL);
        add_item("open", group, _("Open"));

    // bookmark actions
    group = "uds_bookmark_actions";
    add_group(group,                   NULL,  _("Actions"), NULL);
        add_item("open",               group, _("Open"));
        add_item("bookmark_delete",    group, _("Delete Bookmark"));
        add_item("select_all",         group, _("Select All"));

    // add menus
    //
    // content browser
    add_menu("ctb_menu_content",       _("Menu"), DBUS_SERVICE_MENUTEST, "ctb_view", "ctb_sort", "ctb_content_tools", NULL);
    add_menu("ctb_menu_trashcan",      _("Menu"), DBUS_SERVICE_MENUTEST, "ctb_view", "ctb_sort", "ctb_trashcan_tools", NULL);
    add_menu("ctb_menu_settings",      _("Menu"), DBUS_SERVICE_MENUTEST, "ctb_view", "ctb_settings_tools", NULL, NULL);
    
    // universal document shell
    add_menu("uds_menu_reading",       _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", "uds_tools", "uds_navigation", NULL);
    add_menu("uds_menu_thumbnail",     _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", "uds_actions", NULL, NULL);
    add_menu("uds_menu_toc",           _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", "uds_actions", NULL, NULL);
    add_menu("uds_menu_bookmark",      _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", "uds_bookmark_actions", NULL, NULL);
    add_menu("uds_menu_dictionary",    _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", "uds_actions", NULL, NULL);
    add_menu("uds_menu_search",        _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", NULL, NULL, NULL);
    add_menu("uds_menu_info",          _("Menu"), DBUS_SERVICE_MENUTEST, "uds_view", NULL, NULL, NULL);

    // install callback handler on activation
    install_activation_handler(ctx);

    g_print("-- Enter main loop\n");
    g_main_loop_run(gloop);
    
    // normally we should not come here as we stay in the GMainloop

    g_print("-- Exit main loop\n");
    ctx = NULL;

    g_print("Quitting\n");
    return EXIT_SUCCESS;
}