/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */

/* vim:set et sts=4: */

/* bus - The Input Bus

 * Copyright (C) 2010 Google Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301

 * USA

 */

#include <ibus.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include "test-client.h"

#ifdef DEBUG

#  define IDEBUG g_debug

#else

#  define IDEBUG(a...)

#endif

/* functions prototype */

static void          bus_test_client_class_init      (BusTestClientClass *class);

static void          bus_test_client_destroy         (IBusObject         *object);

/* static methods*/

static void          _store_modifier_state          (BusTestClient      *client,

                                                     guint               modifier);

static gboolean      _is_shift_set                  (BusTestClient      *client);

static gboolean      _is_modifier_set               (BusTestClient      *client,

                                                     guint               modifier);

static gboolean      _is_modifier_key               (guint               modifier);

static guint         _get_modifiers_to_mask         (BusTestClient      *client);

static gint16        _get_keysym_to_keycode         (guint               keysym);

static void          _bus_disconnected_cb           (IBusBus            *ibusbus,

                                                     BusTestClient      *client);

static void          _bus_disabled_cb               (IBusInputContext   *ibuscontext,

                                                     BusTestClient      *client);

static IBusBus      *_bus = NULL;

static Display      *_xdisplay = NULL;

G_DEFINE_TYPE (BusTestClient, bus_test_client, IBUS_TYPE_OBJECT)

static void

bus_test_client_class_init (BusTestClientClass *class)

{

    IDEBUG ("%s", __FUNCTION__);

    IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (class);

    ibus_object_class->destroy = bus_test_client_destroy;

    /* init display object */

    if (_xdisplay == NULL) {

        _xdisplay = XOpenDisplay (NULL);

    }

    /* init bus object */

    if (_bus == NULL) {

        ibus_set_display (XDisplayString (_xdisplay));

        _bus = ibus_bus_new();

    }

    g_signal_connect (_bus, "disconnected", G_CALLBACK (_bus_disconnected_cb), NULL);

}

static void

bus_test_client_init (BusTestClient *client)

{

    IDEBUG ("%s", __FUNCTION__);

    client->connected = FALSE;

    client->enabled = FALSE;

    g_return_if_fail (ibus_bus_is_connected (_bus));

    client->connected = TRUE;

    client->ibuscontext = ibus_bus_create_input_context (_bus, "test-client");

    g_return_if_fail (client->ibuscontext != NULL);

    g_signal_connect (client->ibuscontext,

                      "disabled",

                      G_CALLBACK (_bus_disabled_cb),

                      client);

    bus_test_client_clear_modifier (client);

    client->caps = IBUS_CAP_FOCUS;

    ibus_input_context_set_capabilities (client->ibuscontext, client->caps);

    ibus_bus_set_global_engine (_bus, "xkb:us::eng");

    client->enabled = TRUE;

}

static void

bus_test_client_destroy (IBusObject *object)

{

    IDEBUG ("%s", __FUNCTION__);

    BusTestClient *client = BUS_TEST_CLIENT (object);

    g_object_unref (client->ibuscontext);

}

BusTestClient *

bus_test_client_new (void)

{

    IDEBUG ("%s", __FUNCTION__);

    BusTestClient *client = BUS_TEST_CLIENT (g_object_new (BUS_TYPE_TEST_CLIENT, NULL));

    if (client->connected && client->enabled) {

        return client;

    } else {

        return NULL;

    }

}

gboolean

bus_test_client_is_enabled (BusTestClient *client)

{

    IDEBUG ("%s", __FUNCTION__);

    return client->enabled;

}

gboolean

bus_test_client_is_connected (BusTestClient *client)

{

    IDEBUG ("%s", __FUNCTION__);

    return client->connected;

}

gboolean

bus_test_client_send_key (BusTestClient *client,

                     guint      keysym)

{

    gboolean is_modifier = _is_modifier_key (keysym);

    gint16 keycode;

    guint state;

    if (is_modifier) {

        IDEBUG ("key: %d is modifier.", keysym);

        gboolean is_modifier_set = _is_modifier_set (client, keysym);

        keycode = _get_keysym_to_keycode (keysym);

        state = _get_modifiers_to_mask (client);

        if (is_modifier_set) {

            state |= IBUS_RELEASE_MASK;

        }

        ibus_input_context_process_key_event (client->ibuscontext,

                                              keysym,

                                              keycode,

                                              state);

        _store_modifier_state (client, keysym);

    } else {

        IDEBUG ("key: %d is not modifier.", keysym);

        /* This is an example code. If you use the keysym >= 0x01000000,

         * gdk_keyval_is_upper may be useful since 

         * XConvertCase supports implementation-independent conversions.

         */

        KeySym xlower = 0;

        KeySym xupper = 0;

        gboolean is_upper = FALSE;

        if (keysym) {

            XConvertCase (keysym, &xlower, &xupper);

            is_upper = ((guint) xupper == keysym);

        }

        gboolean is_shift_set = _is_shift_set (client);

        if (is_upper && !is_shift_set) {

            _store_modifier_state (client, IBUS_KEY_Shift_L);

        }

        keycode = _get_keysym_to_keycode (keysym);

        state = _get_modifiers_to_mask (client);

        ibus_input_context_process_key_event (client->ibuscontext,

                                              keysym,

                                              keycode,

                                              state);

        state |= IBUS_RELEASE_MASK;

        ibus_input_context_process_key_event (client->ibuscontext,

                                              keysym,

                                              keycode,

                                              state);

        if (is_upper && !is_shift_set) {

            _store_modifier_state (client, IBUS_KEY_Shift_L);

        }

    }

    return TRUE;

}

void bus_test_client_clear_modifier (BusTestClient *client)

{

    int i;

    for (i = 0; i < MODIFIER_KEY_NUM; i++) {

        (client->modifier)[i] = FALSE;

    }

}

static void

_store_modifier_state (BusTestClient    *client,

                       guint         modifier)

{

    switch(modifier) {

    case IBUS_KEY_Shift_L:

    case IBUS_KEY_Shift_R:

        /* ShiftMask */

        client->modifier[0] = !client->modifier[0];

        break;

    case IBUS_KEY_Shift_Lock:

    case IBUS_KEY_Caps_Lock:

        /* LockMask */

        client->modifier[1] = !client->modifier[1];

        break;

    case IBUS_KEY_Control_L:

    case IBUS_KEY_Control_R:

        /* ControlMask */

        client->modifier[2] = !client->modifier[2];

        break;

    case IBUS_KEY_Alt_L:

    case IBUS_KEY_Alt_R:

    case IBUS_KEY_Meta_L:

        /* Mod1Mask */

        client->modifier[3] = !client->modifier[3];

        break;

    case IBUS_KEY_Num_Lock:

        /* Mod2Mask */

        client->modifier[4] = !client->modifier[4];

        break;

    case IBUS_KEY_Super_L:

    case IBUS_KEY_Hyper_L:

        /* Mod4Mask */

        client->modifier[5] = !client->modifier[5];

        break;

    case IBUS_KEY_ISO_Level3_Shift:

    case IBUS_KEY_Mode_switch:

        /* Mod5Mask */

        client->modifier[6] = !client->modifier[6];

        break;

    default:

        break;

    }

}

static gint16

_get_keysym_to_keycode (guint keysym)

{

    return XKeysymToKeycode (_xdisplay, keysym);

}

static gboolean

_is_shift_set (BusTestClient *client)

{

    return client->modifier[0];

}

static gboolean

_is_modifier_set (BusTestClient *client,

                  guint      modifier)

{

    switch(modifier) {

    case IBUS_KEY_Shift_L:

    case IBUS_KEY_Shift_R:

        /* ShiftMask */

        return client->modifier[0];

    case IBUS_KEY_Shift_Lock:

    case IBUS_KEY_Caps_Lock:

        /* LockMask */

        return client->modifier[1];

    case IBUS_KEY_Control_L:

    case IBUS_KEY_Control_R:

        /* ControlMask */

        return client->modifier[2];

    case IBUS_KEY_Alt_L:

    case IBUS_KEY_Alt_R:

    case IBUS_KEY_Meta_L:

        /* Mod1Mask */

        return client->modifier[3];

    case IBUS_KEY_Num_Lock:

        /* Mod2Mask */

        return client->modifier[4];

    case IBUS_KEY_Super_L:

    case IBUS_KEY_Hyper_L:

        /* Mod4Mask */

        return client->modifier[5];

    case IBUS_KEY_ISO_Level3_Shift:

    case IBUS_KEY_Mode_switch:

        /* Mod5Mask */

        return client->modifier[6];

    default:

        return FALSE;

    }

}

static gboolean

_is_modifier_key (guint modifier)

{

    switch(modifier) {

    case IBUS_KEY_Shift_L:

    case IBUS_KEY_Shift_R:

    case IBUS_KEY_Shift_Lock:

    case IBUS_KEY_Caps_Lock:

    case IBUS_KEY_Control_L:

    case IBUS_KEY_Control_R:

    case IBUS_KEY_Alt_L:

    case IBUS_KEY_Alt_R:

    case IBUS_KEY_Meta_L:

    case IBUS_KEY_Num_Lock:

    case IBUS_KEY_Super_L:

    case IBUS_KEY_Hyper_L:

    case IBUS_KEY_ISO_Level3_Shift:

    case IBUS_KEY_Mode_switch:

        return TRUE;

    default:

        return FALSE;

    }

}

static guint

_get_modifiers_to_mask (BusTestClient *client)

{

    guint retval = 0;

    if(client->modifier[0])

        retval |= IBUS_SHIFT_MASK;

    if(client->modifier[1])

        retval |= IBUS_LOCK_MASK;

    if(client->modifier[2])

        retval |= IBUS_CONTROL_MASK;

    if(client->modifier[3])

        retval |= IBUS_MOD1_MASK;

    if(client->modifier[4])

        retval |= IBUS_MOD2_MASK;

    if(client->modifier[5])

        retval |= IBUS_MOD4_MASK;

    if(client->modifier[6])

        retval |= IBUS_MOD5_MASK;

    return retval;

}

static void

_bus_disconnected_cb (IBusBus   *ibusbus,

                      BusTestClient *client)

{

    g_assert (IBUS_IS_BUS (ibusbus));

    g_assert (BUS_IS_TEST_CLIENT (client));

    IDEBUG ("%s", __FUNCTION__);

    client->connected = FALSE;

    IDEBUG ("Disconnected ibus daemon");

}

static void

_bus_disabled_cb (IBusInputContext  *ibuscontext,

                  BusTestClient         *client)

{

    g_assert (IBUS_IS_INPUT_CONTEXT (ibuscontext));

    g_assert (BUS_IS_TEST_CLIENT (client));

    IDEBUG ("%s", __FUNCTION__);

    client->enabled = FALSE;

    IDEBUG ("Disabled ibus engine");

}