notepad_ipc.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_ipc.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad 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.
 *
 * notepad 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) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#include <cstdio>
#include <cstring>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <gconf/gconf-client.h>
#include <liberipc/eripc.h>
#include <liberipc/eripc_support.h>
#include <liberutils/er_error.h>
#include <liberscribble/scb.h>

#include "config.h"
#include "i18n.h"
#include "log.h" 

#include "notepad_window.h"
#include "notepad_utils.h"
#include "notepad_ipc.h"

namespace notepad
{

    //----------------------------------------------------------------------------
    // Static Variables
    //----------------------------------------------------------------------------
    static eripc_client_context_t  *eripcClient = 0;
    static int g_xid = 0;

    // reference to notepad window instance
    static notepad::CNotepadWindow* gInstance = 0;

    // reference to configuration
    static GConfClient* gClient = 0;
    static PenSize      gPensize = GCONF_DEFAULT_PEN_SIZE;
    static gchar        gMountpoint[88];


    //----------------------------------------------------------------------------
    // Constants
    //----------------------------------------------------------------------------

    // menu 
    static const char *MENU                     = "notepad_menu";
    static const char *ipc_menu                 = NULL;
    // |
    // |
    // |-- Pen type 
    static const char *GROUP_PEN_TYPE           = "notepad_pen_types";
    static const char *ITEM_PEN                 = "pen";
    static const char *ITEM_ERASER              = "eraser";
    // |-- 
    static const char *GROUP_PEN                = "notepad_pen";
    //     |
    static const char *GROUP_PEN2               = "notepad_pen2";
    //     |-- line sizes options
    static const char *GROUP_PEN_SIZE           = "notepad_pen_size";
    static const char *ITEM_PEN_FINE            = "pen_fine";
    static const char *ITEM_PEN_SMALL           = "pen_small";
    static const char *ITEM_PEN_MEDIUM          = "pen_medium";
    static const char *ITEM_PEN_LARGE           = "pen_large";
    static const char *ITEM_PEN_XLARGE          = "pen_xlarge";
    // |
    // |-- actions
    static const char *GROUP_ACTIONS            = "notepad_actions";
    static const char *ITEM_ACTION_GOTOPAGE     = "goto_page";
    static const char *ITEM_ACTION_INSERTPAGE   = "insert_page";
    static const char *ITEM_ACTION_DELETEPAGE   = "delete_page";
    static const char *ITEM_ACTION_CLEARPAGE    = "clear_page";
    static const char *ITEM_ACTION_RENAME       = "rename";
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
    static const char *ITEM_ACTION_CLOSE        = "close";
#endif

    // states of a menu item
    static const char *MENU_STATE_NORMAL        = "normal";
    static const char *MENU_STATE_SELECTED      = "selected";
    static const char *MENU_STATE_DISABLED      = "disabled"; 

    // stylus states
    static const char *STYLUS_PEN               = "pen";
    static const char *STYLUS_ERASER            = "eraser";


    //============================================================================
    // Local Function Declarations
    //============================================================================

    static void ipc_gconf_initialize(void);     // initalize gconf client
    static void ipc_gconf_read(void);           // read settings from gconf
    static void ipc_gconf_write(void);          // write settings to gconf 
    static void ipc_gconf_finalize(void);       // close gconf client

    static void ipc_menu_update_toolbar(void);  // upate toolbar
    static void menu_show(void);                // show selected menu items
    static void menu_set_text(void);            // fill in menu labels
    static gboolean ipc_status_set_stylus( const char *state ); // draw stylus on toolbar


    // Callbacks from popupmenu
    static void on_page_change( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_window_activated( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_window_deactivated( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_menu_item( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_changed_locale( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_changed_pen( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_prepare_unmount( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_volume_unmounted( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

    static void on_prepare_standby( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );

#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
    static void on_sys_changed_pageturn_inverted (eripc_context_t *context,
            const eripc_event_info_t *info,
            void                     *user_data);
#endif 

    static void on_changed_orientation( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data );



    // Exported DBUS API list
    static eripc_callback_function_t service_functions[] = {
        { on_menu_item,         "menuItemActivated",   NULL                        , 0 },
        { on_window_activated,  "activatedWindow",     NULL                        , 0 },
        { on_window_deactivated,"deactivatedWindow",   NULL                        , 0 },
        { on_page_change,       "pageChange",          NULL                        , 0 },
        { on_changed_pen,       "statusItemActivated", NULL                        , 0 },
        { on_changed_locale,    "sysChangedLocale",    DBUS_SERVICE_SYSTEM_CONTROL , 0 },
        { on_prepare_unmount,   "sysPrepareUnmount",   DBUS_SERVICE_SYSTEM_CONTROL , 0 },
        { on_volume_unmounted,  "sysVolumeUnmounted",  DBUS_SERVICE_SYSTEM_CONTROL , 0 },
        { on_prepare_standby,   "sysPrepareStandby",   DBUS_SERVICE_SYSTEM_CONTROL , 0 },
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
        { on_sys_changed_pageturn_inverted, "sysChangedPageturnInverted", DBUS_SERVICE_SYSTEM_CONTROL , 0},
#endif 
        { on_changed_orientation, "sysChangedOrientation",  DBUS_SERVICE_SYSTEM_CONTROL , 0 },
        { NULL, NULL, NULL, 0 }  // end of list
    };


    //============================================================================
    // Functions Implementation
    //============================================================================

    // initialise
    gboolean ipc_set_services(void)
    {

        pid_t pid = getpid();
        char name[128];
        sprintf(name, "%s_%05d", DBUS_APPL_NAME, pid);
        char service[128];
        sprintf(service, "%s_%05d", DBUS_SERVICE, pid);
        char path[128];
        sprintf(path, "%s_%05d", DBUS_PATH, pid);
        char interface[128];
        sprintf(interface, "%s_%05d", DBUS_INTERFACE, pid);

        eripcClient = eripc_client_context_new(
                name,
                "1.0",
                service,
                path,
                interface,
                service_functions);
        return (eripcClient != NULL);
    }


    void ipc_unset_services(void)
    {
        ipc_gconf_finalize(); // destruct gconf client
        eripc_client_context_free(eripcClient, service_functions);
        //menu_destroy();
    }

    gboolean ipc_sys_busy(gboolean busy)  //  Send message sysSetBusy to system daemon
    {
        LOGPRINTF("entry %d", busy);

        if (busy)
        {
            return eripc_sysd_set_busy(eripcClient, "delaydialog", NULL);
        }
        else
        {
            return eripc_sysd_reset_busy(eripcClient);
        }
    }

    gboolean ipc_sys_bg_busy(gboolean busy)  // set/unset busy state without dialog
    {
        LOGPRINTF("entry %d", busy);

        if (busy)
        {
            return eripc_sysd_set_bg_busy(eripcClient);
        }
        else
        {
            return eripc_sysd_reset_bg_busy(eripcClient);
        }
    }

    const char* ipc_get_mountpoint()
    {
        if (0 == g_strcmp0(gMountpoint, ""))
        {
            g_assert(eripcClient);
            eripc_event_info_t* reply = NULL;
            eripc_error_t result = eripc_send_varargs_and_wait( eripcClient->context,
                    &reply,                // reply handler
                    ERIPC_BUS_SESSION,
                    DBUS_SERVICE_SYSTEM_CONTROL,
                    "sysGetCardMountPoint",
                    ERIPC_TYPE_INVALID);
            if (result != ERIPC_ERROR_SUCCESS)
            {
                ERRORPRINTF("%s: eripc_send_varargs returns [%d]", __func__, result);
                return NULL;
            }
            g_assert(reply);
            g_assert(reply->args);
            g_assert(reply->args[0].type == ERIPC_TYPE_STRING);
            const char* valuestr = reply->args[0].value.s;
            if (valuestr[0] != 0) 
                strncpy(gMountpoint, valuestr, 88-1);
            LOGPRINTF("mountpoint %s", gMountpoint);
            eripc_event_info_free(eripcClient->context, reply);
        }
        return gMountpoint;
    }


    void ipc_sys_startup_complete(int xid)
    {
        // before sending startup_complete contruct default values;
        gMountpoint[0] = 0;
        gPensize = GCONF_DEFAULT_PEN_SIZE;

        ipc_gconf_initialize(); // initalize gconf client
        ipc_gconf_read();

        // send startup_complete
        g_xid = xid;
        eripc_sysd_startup_complete( eripcClient, getpid(), FALSE, xid);

        // re-read initialized items
        menu_show();
    }

    void ipc_change_filename(const gchar* filename, const gchar* label)
    {
        g_assert(g_xid);
        eripc_send_varargs(eripcClient->context, NULL, NULL, ERIPC_BUS_SESSION,
                DBUS_SERVICE_SYSTEM_CONTROL, "renameTask",
                ERIPC_TYPE_INT, g_xid,
                ERIPC_TYPE_STRING, filename,
                ERIPC_TYPE_STRING, label,
                ERIPC_TYPE_INVALID);
    }


    PenSize ipc_get_pensize(void)
    {
        PenSize size = gPensize;
        LOGPRINTF("get_pensize %d", size);
        if ((size < PEN_FINE) || (size > PEN_XLARGE) ) 
        {
            WARNPRINTF("invalid pensize setting, using default");
            size = GCONF_DEFAULT_PEN_SIZE;
        }
        return size;
    }


    void ipc_set_pensize(const PenSize new_pen_size)
    {
        if ((gPensize < PEN_FINE) || (gPensize > PEN_XLARGE) )
        {
            WARNPRINTF("invalid new pen size, using default");
        }
        else
        {
            gPensize = new_pen_size;
            ipc_gconf_write(); 
            // write here: 
            // because we can have multiple instances, and on window switch the 
            // on_window_activate of the selected comes before the on_window_deactivate 
            // of the current 
        }
        LOGPRINTF("set pensize %d", gPensize);
    }

    np_rotation ipc_get_rotation(void)
    {
        LOGPRINTF("entry");

        eripc_error_t retval;
        eripc_event_info_t *info = NULL;
        np_rotation rotation = NP_PORTRAIT;

        retval = eripc_send_varargs_and_wait(eripcClient->context,
                &info,
                ERIPC_BUS_SESSION,
                DBUS_SERVICE_SYSTEM_CONTROL,
                "sysGetOrientation",
                ERIPC_TYPE_INVALID);

        if (retval == ERIPC_ERROR_SUCCESS)
        {
            const eripc_arg_t *arg_array = info->args;
            if (arg_array[0].type == ERIPC_TYPE_STRING)
            {
                const char* orientation = arg_array[0].value.s;
                if (orientation)
                {
                    if ( 0 == strcasecmp( orientation, "landscape_anticlockwise") )
                    {
                        rotation = NP_ANTICLOCKWISE;
                    }
                    else if ( 0 == strcasecmp( orientation, "landscape_clockwise") )
                    {
                        rotation = NP_CLOCKWISE;
                    }
                    else
                    {
                        rotation = NP_PORTRAIT;
                    }
                }
            }
        }

        LOGPRINTF("exit %d", rotation);
        return rotation;
    }

    // popup menu and toolbar
    static void ipc_menu_update_toolbar(void)
    {
        eripc_send_varargs(eripcClient->context, NULL, NULL, ERIPC_BUS_SESSION,
                DBUS_SERVICE_POPUP_MENU, "updatesFinished", ERIPC_TYPE_INVALID);
    }

    void ipc_menu_set_pagecounter(int cur_page, int num_pages)
    {
        gboolean boundary_check = (num_pages != cur_page); // allow next to create new page
        eripc_menu_set_pagecounter(eripcClient, cur_page, num_pages, boundary_check);
        ipc_menu_update_toolbar();  

        if (num_pages == 1)
        {
            eripc_menu_set_item_state(eripcClient, ITEM_ACTION_GOTOPAGE, GROUP_ACTIONS, MENU_STATE_DISABLED );
        }
        else 
        {
            eripc_menu_set_item_state(eripcClient, ITEM_ACTION_GOTOPAGE, GROUP_ACTIONS, MENU_STATE_NORMAL );
        }
    }

    void menu_init(int pid, gpointer appwindow) 
    {
        LOGPRINTF("entry");
        g_assert( appwindow != 0 ); 
        if (appwindow == 0)
        {
            fprintf(stderr, "menu without window\n");
            return;
        }
        gInstance = static_cast <notepad::CNotepadWindow*> (appwindow);

        ipc_menu = g_strdup_printf("%s_%05d", MENU, pid);
        // MENU
        // |
        // |-- Pen type
        eripc_menu_add_group(eripcClient, GROUP_PEN_TYPE,       "",             "pen_type"          );
        eripc_menu_add_item(eripcClient, ITEM_PEN   ,           GROUP_PEN_TYPE, "pen"               ); 
        eripc_menu_add_item(eripcClient, ITEM_ERASER,           GROUP_PEN_TYPE, "eraser"            ); 
        // |
        // |-- PEN 
        eripc_menu_add_group(eripcClient, GROUP_PEN,            "",             "notepad_pen_menu"  ); 
        eripc_menu_add_group(eripcClient, GROUP_PEN2,           GROUP_PEN,      "tools_drawing"     ); 
        //     |
        //     |-- line sizes 
        eripc_menu_add_group(eripcClient, GROUP_PEN_SIZE,       GROUP_PEN2,     "notepad_pen_size"  ); 
        eripc_menu_add_item(eripcClient, ITEM_PEN_FINE,         GROUP_PEN_SIZE, "stylus_1"          ); 
        eripc_menu_add_item(eripcClient, ITEM_PEN_SMALL,        GROUP_PEN_SIZE, "stylus_2"          ); 
        eripc_menu_add_item(eripcClient, ITEM_PEN_MEDIUM,       GROUP_PEN_SIZE, "stylus_3"          ); 
        eripc_menu_add_item(eripcClient, ITEM_PEN_LARGE,        GROUP_PEN_SIZE, "stylus_4"          ); 
        eripc_menu_add_item(eripcClient, ITEM_PEN_XLARGE,       GROUP_PEN_SIZE, "stylus_5"          ); 
        // |
        // |-- actions
        eripc_menu_add_group(eripcClient, GROUP_ACTIONS,        "",             "notepad_actions"   );
        eripc_menu_add_item(eripcClient, ITEM_ACTION_GOTOPAGE,  GROUP_ACTIONS,  "goto_page"         );
        eripc_menu_add_item(eripcClient, ITEM_ACTION_INSERTPAGE,GROUP_ACTIONS,  "insert_page"       );
        eripc_menu_add_item(eripcClient, ITEM_ACTION_DELETEPAGE,GROUP_ACTIONS,  "delete_page"       );
        eripc_menu_add_item(eripcClient, ITEM_ACTION_CLEARPAGE, GROUP_ACTIONS,  "clear_page"        );
        eripc_menu_add_item(eripcClient, ITEM_ACTION_RENAME,    GROUP_ACTIONS,  "rename"            );
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        eripc_menu_add_item(eripcClient, ITEM_ACTION_CLOSE,     GROUP_ACTIONS,  "close"             );
#endif

        // add menus
        eripc_menu_add_menu(eripcClient, ipc_menu, GROUP_ACTIONS, GROUP_PEN, GROUP_PEN_TYPE, NULL);

        // localize text
        menu_set_text();

        menu_show();
        LOGPRINTF("exit");
    }


    void menu_destroy(void)
    {
        eripc_menu_remove_menu(eripcClient, ipc_menu);
    }



    //============================================================================
    // Local Function Definitions
    //============================================================================

    // gconf
    static void ipc_gconf_initialize(void) // initalize gconf client
    {
        LOGPRINTF("gconf_initialize");
        if (gClient == 0)
        {
            gClient = gconf_client_get_default();
        }
    }

    static void ipc_gconf_finalize(void) // destruct gconf client
    {
        LOGPRINTF("gconf_finalize");
        if (gClient != 0)
        {
            g_object_unref(G_OBJECT(gClient));
            gClient = 0;
        }
    }

    static void ipc_gconf_read(void) // read settings from gconf
    {
        LOGPRINTF("gconf_read");
        if (gClient)
        {
            gPensize = (PenSize) gconf_client_get_int(gClient, GCONF_PEN_SIZE, NULL);
            LOGPRINTF("getPenSize %d", gPensize);
            if ((gPensize < PEN_FINE) || (gPensize > PEN_XLARGE) )
            {
                WARNPRINTF("invalid pensize setting, using default");
                gPensize = GCONF_DEFAULT_PEN_SIZE;
            }
        }
    }

    static void ipc_gconf_write(void) // write settings to gconf 
    {
        LOGPRINTF("gconf_write pensize %d", gPensize);
        if (gClient)
        {
            (void) gconf_client_set_int(gClient, GCONF_PEN_SIZE, (gint) gPensize, NULL);
        }
    }

    // popupmenu and toolbar


    static gboolean ipc_status_set_stylus( const char *state )
    {
        g_return_val_if_fail( (state != NULL), FALSE);
        return eripc_menu_set_statusitem_state(eripcClient, "statusbar_stylus", state);
    }

    static void menu_set_text(void)
    {
        // MENU
        // |
        // |-- Pen type
        eripc_menu_set_item_label(eripcClient, ITEM_PEN,                GROUP_PEN_TYPE, _("Pen"         ));
        eripc_menu_set_item_label(eripcClient, ITEM_ERASER,             GROUP_PEN_TYPE, _("Eraser"      ));
        // |
        // |-- PEN 
        eripc_menu_set_group_label(eripcClient, GROUP_PEN2, _("Pen Size")); 
        //     |
        //     |-- line sizes options
        eripc_menu_set_item_label(eripcClient, ITEM_PEN_FINE,           GROUP_PEN_SIZE, _("Fine"        ));
        eripc_menu_set_item_label(eripcClient, ITEM_PEN_SMALL,          GROUP_PEN_SIZE, _("Small"       ));
        eripc_menu_set_item_label(eripcClient, ITEM_PEN_MEDIUM,         GROUP_PEN_SIZE, _("Medium"      ));
        eripc_menu_set_item_label(eripcClient, ITEM_PEN_LARGE,          GROUP_PEN_SIZE, _("Large"       ));
        eripc_menu_set_item_label(eripcClient, ITEM_PEN_XLARGE,         GROUP_PEN_SIZE, _("X-Large"     ));
        // |
        // |-- actions
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_GOTOPAGE,    GROUP_ACTIONS,  _("Go to Page..."));
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_INSERTPAGE,  GROUP_ACTIONS,  _("Insert Page" ));
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_CLEARPAGE,   GROUP_ACTIONS,  _("Clear Page..."  ));
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_DELETEPAGE,  GROUP_ACTIONS,  _("Delete Page..."  ));
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_RENAME,      GROUP_ACTIONS,  _("Rename..."   ));
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        eripc_menu_set_item_label(eripcClient, ITEM_ACTION_CLOSE,       GROUP_ACTIONS,  _("Close" ));
#endif    
    }


    static void menu_show(void)
    {
        LOGPRINTF("entry");
        // show selections
        gboolean scribblemode = gInstance->get_scribble_mode();
        if (scribblemode)
        {
            eripc_menu_set_item_state(eripcClient, ITEM_PEN, GROUP_PEN_TYPE, MENU_STATE_SELECTED );
            eripc_menu_set_item_state(eripcClient, ITEM_ERASER, GROUP_PEN_TYPE, MENU_STATE_NORMAL );
            ipc_status_set_stylus( STYLUS_PEN );
            eripc_send_varargs(eripcClient->context, NULL, NULL, ERIPC_BUS_SESSION,
                    DBUS_SERVICE_POPUP_MENU, "updatesFinished", ERIPC_TYPE_INVALID);
        }
        else
        {
            eripc_menu_set_item_state(eripcClient, ITEM_ERASER, GROUP_PEN_TYPE, MENU_STATE_SELECTED );
            eripc_menu_set_item_state(eripcClient, ITEM_PEN, GROUP_PEN_TYPE, MENU_STATE_NORMAL );
            ipc_status_set_stylus( STYLUS_ERASER );
            eripc_send_varargs(eripcClient->context, NULL, NULL, ERIPC_BUS_SESSION,
                    DBUS_SERVICE_POPUP_MENU, "updatesFinished", ERIPC_TYPE_INVALID);
        }

        PenSize ps = ipc_get_pensize();
        switch (ps)
        {
            case PEN_FINE:
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_FINE,   GROUP_PEN_SIZE, MENU_STATE_SELECTED );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_SMALL,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_MEDIUM, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_LARGE,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_XLARGE, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                break;
            case PEN_SMALL:
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_FINE,   GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_SMALL,  GROUP_PEN_SIZE, MENU_STATE_SELECTED );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_MEDIUM, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_LARGE,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_XLARGE, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                break;
            case PEN_MEDIUM:
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_FINE,   GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_SMALL,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_MEDIUM, GROUP_PEN_SIZE, MENU_STATE_SELECTED );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_LARGE,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_XLARGE, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                break;
            case PEN_LARGE:
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_FINE,   GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_SMALL,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_MEDIUM, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_LARGE,  GROUP_PEN_SIZE, MENU_STATE_SELECTED );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_XLARGE, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                break;
            case PEN_XLARGE:
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_FINE,   GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_SMALL,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_MEDIUM, GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_LARGE,  GROUP_PEN_SIZE, MENU_STATE_NORMAL );
                eripc_menu_set_item_state(eripcClient, ITEM_PEN_XLARGE, GROUP_PEN_SIZE, MENU_STATE_SELECTED );
                break;
            default:
                WARNPRINTF("unsupported pensize\n");
        }

        eripc_menu_show_menu(eripcClient, ipc_menu);
        gInstance->update_page_counter();
        ipc_menu_update_toolbar();  

        LOGPRINTF("exit");
    }

    void menu_block(gboolean block)
    {
        if (block)
        {
            eripc_sysd_set_menu_state(eripcClient, "block");
        }
        else
        {
            eripc_sysd_set_menu_state(eripcClient, "unblock");
        }
    }



    //----------------------------------------------------------------------------
    // Signal/message handlers
    //----------------------------------------------------------------------------

    static void on_page_change( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        const eripc_arg_t *arg_array = info->args;
        g_return_if_fail(arg_array[0].type == ERIPC_TYPE_STRING);
        gchar* direction = arg_array[0].value.s;

        if (strcmp(direction, "prev") == 0) 
        {   
            gInstance->pageflip_back();
        }
        if (strcmp(direction, "next") == 0) 
        {
            gInstance->pageflip_forward();
        }
    }


    static void on_window_activated( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");

        (void) gInstance->save();
        ipc_gconf_read();
        menu_show();
        gInstance->update_page_counter();
        ipc_menu_update_toolbar();  

        LOGPRINTF("exit");
    }


    static void on_window_deactivated( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");

        (void) gInstance->save();
        ipc_gconf_write();
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
        gInstance->quit();
#endif

        LOGPRINTF("exit");
    }


    static void on_menu_item( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        g_return_if_fail(info->args);
        g_return_if_fail(info->args[0].type == ERIPC_TYPE_STRING);
        g_return_if_fail(info->args[1].type == ERIPC_TYPE_STRING);
        g_return_if_fail(info->args[2].type == ERIPC_TYPE_STRING);
        g_return_if_fail(info->args[3].type == ERIPC_TYPE_STRING);

        g_return_if_fail(info->args[0].value.s != 0);
        g_return_if_fail(info->args[1].value.s != 0);
        g_return_if_fail(info->args[2].value.s != 0);
        g_return_if_fail(info->args[3].value.s != 0);

        const eripc_arg_t *arg_array = info->args;
        const char        *item      = arg_array[0].value.s;
        const char        *group     = arg_array[1].value.s;
        const char        *menu      = arg_array[2].value.s;
        const char        *state     = arg_array[3].value.s;

        LOGPRINTF("entry: on_menu_item: item [%s] group [%s] menu [%s] state [%s]", item, group, menu, state);

        if (item && group && menu && state)
        {
            if ( strcmp(group, GROUP_PEN_TYPE) == 0 )
            {
                if ( strcmp(state, MENU_STATE_NORMAL) == 0 )
                {
                    if ( strcmp(item, ITEM_PEN) == 0 )
                    {
                        LOGPRINTF("pen");
                        gInstance->set_scribble_mode(TRUE);
                    }
                    else if ( strcmp(item, ITEM_ERASER  ) == 0 )
                    {
                        LOGPRINTF("erase");
                        gInstance->set_scribble_mode(FALSE);
                    }
                }
                menu_show();
            }
            else if ( strcmp(group, GROUP_PEN_SIZE) == 0 )
            {

                if ( strcmp(state, MENU_STATE_NORMAL) == 0 )
                {
                    if ( strcmp(item, ITEM_PEN_FINE) == 0 )
                    {
                        LOGPRINTF("pen_fine");
                        ipc_set_pensize(PEN_FINE);
                    }
                    else if ( strcmp(item, ITEM_PEN_SMALL) == 0 )
                    {
                        LOGPRINTF("pen_small");
                        ipc_set_pensize(PEN_SMALL);
                    }
                    else if ( strcmp(item, ITEM_PEN_MEDIUM) == 0 )
                    {
                        LOGPRINTF("pen_medium");
                        ipc_set_pensize(PEN_MEDIUM);
                    }
                    else if ( strcmp(item, ITEM_PEN_LARGE) == 0 )
                    {
                        LOGPRINTF("pen_large");
                        ipc_set_pensize(PEN_LARGE);
                    }
                    else if ( strcmp(item, ITEM_PEN_XLARGE) == 0 )
                    {
                        LOGPRINTF("pen_xlarge");
                        ipc_set_pensize(PEN_XLARGE);
                    }
                }
                // Do not stay on eraser mode
                gInstance->set_scribble_mode(TRUE);
                menu_show();
            }
            else if ( strcmp(group, GROUP_ACTIONS) == 0 )
            {
                if ( strcmp(state, MENU_STATE_NORMAL) == 0 )
                {
                    if ( strcmp(item, ITEM_ACTION_RENAME ) == 0 )
                    {
                        LOGPRINTF("rename");
                        gInstance->rename();
                    }
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
                    else if ( strcmp(item, ITEM_ACTION_CLOSE ) == 0 )
                    {
                        LOGPRINTF("close");
                        (void) gInstance->save();
                        gInstance->quit();
                    }
#endif                
                    else if ( strcmp(item, ITEM_ACTION_GOTOPAGE ) == 0 )
                    {
                        LOGPRINTF("gotopage");
                        gInstance->goto_page();
                    }
                    else if ( strcmp(item, ITEM_ACTION_INSERTPAGE ) == 0 )
                    {
                        LOGPRINTF("insertpage");
                        gInstance->insert_page();
                    }
                    else if ( strcmp(item, ITEM_ACTION_CLEARPAGE ) == 0 )
                    {
                        LOGPRINTF("clearpage");
                        gInstance->clear_current_page();
                    }
                    else if ( strcmp(item, ITEM_ACTION_DELETEPAGE ) == 0 )
                    {
                        LOGPRINTF("deletepage");
                        gInstance->delete_current_page();
                    }
                    else
                    {
                        fprintf(stderr, "ignore state [%s] item [%s][%s]", state, item, group);
                    }
                }
                else
                {
                    fprintf(stderr, "unexpected menu group [%s]", group);
                }
            }
            ipc_menu_update_toolbar();  
        }
    }

    static void on_changed_locale( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        menu_set_text();
    }

    static void on_changed_pen( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        g_return_if_fail(info->args);
        g_return_if_fail(info->args[0].type == ERIPC_TYPE_STRING);

        const eripc_arg_t *arg_array = info->args;
        const char        *item      = arg_array[0].value.s;
        const char        *value     = arg_array[1].value.s;

        LOGPRINTF("entry: on_changed_pen: item [%s] value [%s]", item, value);
        if ( strcmp(item, "statusbar_stylus") == 0 )
        {
            if ( strcmp(value, STYLUS_PEN) == 0 )
            {
                LOGPRINTF("pen");
                gInstance->set_scribble_mode(FALSE); //toggle
                menu_show();
            }
            else if ( strcmp(value, STYLUS_ERASER  ) == 0 )
            {
                LOGPRINTF("erase");
                gInstance->set_scribble_mode(TRUE); //toggle
                menu_show();
            }
        }
    }

    static void on_prepare_unmount( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");
        (void) gInstance->save(true);
        gInstance->quit();
        LOGPRINTF("exit");
    }

    static void on_volume_unmounted( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");
        gInstance->quit();
        LOGPRINTF("exit");
    }

    static void on_prepare_standby( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");
        (void) gInstance->save();
        LOGPRINTF("exit");
    }

    // -- flipbar and orientation -- 

    /* @brief Called when the display's orientation has changed
     *
     * Application may need to adapt its screen size, coordinates and/or origin.
     * Possible values: "portrait", "landscape_clockwise", "landscape_anticlockwise"
     */
    static void on_changed_orientation( 
            eripc_context_t          *context,
            const eripc_event_info_t *info,
            void                     *user_data )
    {
        LOGPRINTF("entry");

        const eripc_arg_t *arg_array = info->args;
        if (arg_array[0].type == ERIPC_TYPE_STRING)
        {
            const char* orientation = arg_array[0].value.s;
            if (orientation)
            {
                if ( strcmp(orientation, "portrait") == 0)
                {
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
                    gboolean is_inverted = ipc_sys_is_pageturn_inverted();
                    (void) gInstance->set_pageturn_inverted(is_inverted);
#else
                    ;
#endif 
                }
                else
                {
                    // landscapee
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
                    (void) gInstance->set_pageturn_inverted(FALSE);
#else           
                    ;
#endif 
                }
                // Note: dont call set_rotation from here, window gets configure event.
                // Note: timing of this on_changed_orientation depends on rotation direction.
            }
        }
        LOGPRINTF("exit");
    }


#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
    static void on_sys_changed_pageturn_inverted(  eripc_context_t *context,
            const eripc_event_info_t *info,
            void *user_data)
    {
        LOGPRINTF("entry");

        const eripc_arg_t *arg_array = info->args;

        if (arg_array[0].type == ERIPC_TYPE_BOOL)
        {
            gboolean is_inverted = arg_array[0].value.b;
            if ( ipc_sys_is_in_portrait_mode() )
            {
                (void) gInstance->set_pageturn_inverted(is_inverted);
            }
        }
    }
#endif 


    // the following functions queries sysd about the
    // custom setting of the flipbar.

    // Function: ipc_sys_is_pageturn_inverted()
    //
    // Return value: False -> pageturning is not inverted i.e. left to right gives next page
    //               True  -> pageturning is     inverted i.e. left to right gives previous page
    // Intended use: during application initialisation and only useful in portrait reading mode

    gboolean ipc_sys_is_pageturn_inverted()
    {
        gboolean result = FALSE;
#if MACHINE_IS_DR800S || MACHINE_IS_DR800SG || MACHINE_IS_DR800SW
        eripc_error_t retval;
        eripc_event_info_t* info = NULL;

        LOGPRINTF("entry");

        retval = eripc_send_varargs_and_wait(eripcClient->context,
                &info,
                ERIPC_BUS_SESSION,
                DBUS_SERVICE_SYSTEM_CONTROL,
                "sysGetPageturnInverted",
                ERIPC_TYPE_INVALID);

        if (retval != ERIPC_ERROR_SUCCESS)
        {
            ERRORPRINTF("Error launching eripc handler");
        }
        else if (info == NULL || info->args == NULL)
        {
            ERRORPRINTF("sysd returns OK but no reply structure");
        }
        else
        {
            const eripc_arg_t *arg_array = info->args;

            if (arg_array[0].type == ERIPC_TYPE_BOOL)
            {
                result = (gboolean) arg_array[0].value.b;
            }
            else
            {
                result = FALSE ;
            }
        }

        eripc_event_info_free(eripcClient->context, info);
#endif 
        return result;
    }

    // Function: ipc_sys_is_in_portrait_mode()
    //
    // Return value: False -> the device is in landscape mode i.e. flipbar up should be interpreted as previous page.
    //               True  ->  the device is in portrait mode i.e. flipbar interpretation should depend on sys_is_pageturn_inverted result.
    // Intended use: during application initialisation
    gboolean ipc_sys_is_in_portrait_mode(void)
    {

        gboolean result = TRUE;

        eripc_error_t retval;
        eripc_event_info_t* info = NULL;

        LOGPRINTF("entry");

        retval = eripc_send_varargs_and_wait(eripcClient->context,
                &info,
                ERIPC_BUS_SESSION,
                DBUS_SERVICE_SYSTEM_CONTROL,
                "sysGetOrientation",
                ERIPC_TYPE_INVALID);

        if (retval != ERIPC_ERROR_SUCCESS)
        {
            ERRORPRINTF("Error launching eripc handler");
        }
        else if (info == NULL || info->args == NULL)
        {
            ERRORPRINTF("sysd returns OK but no reply structure");
        }
        else
        {
            const eripc_arg_t *arg_array = info->args;

            if (arg_array[0].type == ERIPC_TYPE_STRING)
            {
                if ( strcmp("portrait", arg_array[0].value.s) == 0 )
                {
                    result = TRUE;
                }
                else
                {
                    result = FALSE;
                }
            }
            else
            {
                result = FALSE ;
            }
        }
        eripc_event_info_free(eripcClient->context, info);
        return result;
    }

} //namespace