[Scim-cvs] scim-bridge/trash scim-bridge-agent-messenger.h,NONE,1.1.2.1 scim-bridge-agent-imcontext.h,NONE,1.1.2.1 scim-bridge-agent-imcontext.cpp,NONE,1.1.2.1

[ryo-dairiki <ryo...@us...>]

Update of /cvsroot/scim/scim-bridge/trash
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv15704/trash

Added Files:
      Tag: plaintext
	scim-bridge-agent-messenger.h scim-bridge-agent-imcontext.h 
	scim-bridge-agent-imcontext.cpp 
Log Message:


--- NEW FILE: scim-bridge-agent-imcontext.cpp ---
#include <assert.h>

#include "scim-bridge-agent-imcontext.h"
#include "scim-bridge-agent-kernel.h"
#include "scim-bridge-imcontext-manager.h"

using namespace scim;

/* Class members */
bool ScimBridgeAgentIMContext::on_the_spot = true;
bool ScimBridgeAgentIMContext::imengine_shared = false;

IMEngineInstancePointer ScimBridgeAgentIMContext::shared_imengine = NULL;

bool ScimBridgeAgentIMContext::is_on_the_spot_enabled ()
{
    return on_the_spot;
}


void ScimBridgeAgentIMContext::set_on_the_spot_enabled (bool enabled)
{
    on_the_spot = enabled;
}


bool ScimBridgeAgentIMContext::is_imengine_shared ()
{
    return imengine_shared;
}


void ScimBridgeAgentIMContext::set_imengine_shared (bool shared)
{
    imengine_shared = shared;
}


IMEngineInstancePointer ScimBridgeAgentIMContext::get_shared_imengine ()
{
    return shared_imengine;
}


void ScimBridgeAgentIMContext::set_shared_imengine (IMEngineInstancePointer new_imengine)
{
    shared_imengine = new_imengine;
}


void ScimBridgeAgentIMContext::release_shared_imengine ()
{
    set_shared_imengine (NULL);
}


/* Object members */
ScimBridgeAgentIMContext::ScimBridgeAgentIMContext (): preedit_shown (false), client_peer (NULL)
{
    static bool static_initialized = false;
    if (!static_initialized) {
        static_initialized = true;
        scim_bridge_initialize_imcontext_manager ();
    }

    status = false;

    scim_bridge_add_imcontext (this);
}


ScimBridgeAgentIMContext::~ScimBridgeAgentIMContext ()
{
    free ();
}


void ScimBridgeAgentIMContext::free ()
{
    if (!imengine) {
        imengine->reset ();
        imengine = NULL;
    }

    client_peer = NULL;

    scim_bridge_remove_imcontext (this);
}


ScimBridgeAgentIMContext *ScimBridgeAgentIMContext::find (ScimBridgeIMContextID id)
{
    ScimBridgeAgentIMContext *imcontext = static_cast<ScimBridgeAgentIMContext*> (scim_bridge_find_imcontext (id));
    assert (imcontext != NULL && imcontext->get_id () == id);
    return imcontext;
}


void ScimBridgeAgentIMContext::reset_preedit ()
{
    preedit_string.clear ();
    preedit_caret = 0;
    preedit_shown = false;
    preedit_attribute_list.clear ();
}


void ScimBridgeAgentIMContext::set_preedit_caret (int caret_pos)
{
    preedit_caret = caret_pos;
}


const int ScimBridgeAgentIMContext::get_preedit_caret () const
{
    return preedit_caret;
}


const bool ScimBridgeAgentIMContext::is_on () const
{
    return status;
}


void ScimBridgeAgentIMContext::turn_on ()
{
    status = true;
}


void ScimBridgeAgentIMContext::turn_off ()
{
    status = false;
}


const ScimBridgeIMContextID ScimBridgeAgentIMContext::get_id () const
{
    return parent.id;
}


const ScimBridgeIMContextID ScimBridgeAgentIMContext::get_opponent_id () const
{
    return parent.opponent_id;
}


void ScimBridgeAgentIMContext::set_opponent_id (ScimBridgeIMContextID new_opponent_id)
{
    parent.opponent_id = new_opponent_id;
}


const IMEngineInstancePointer ScimBridgeAgentIMContext::get_imengine () const
{
    return imengine;
}


void ScimBridgeAgentIMContext::set_imengine (scim::IMEngineInstancePointer new_imengine)
{
    imengine = new_imengine;
    update_capabilities ();

    imengine->set_frontend_data (static_cast <void*> (this));

    if (imengine_shared) {
        set_shared_imengine (new_imengine);
    } else {
        set_shared_imengine (NULL);
    }
}


const WideString &ScimBridgeAgentIMContext::get_preedit_string ()
{
    return preedit_string;
}


void ScimBridgeAgentIMContext::set_preedit_string (const WideString &wstr)
{
    preedit_string = wstr;
}


const AttributeList &ScimBridgeAgentIMContext::get_preedit_attribute_list ()
{
    return preedit_attribute_list;
}


void ScimBridgeAgentIMContext::set_preedit_attribute_list (const AttributeList &attr_list)
{
    preedit_attribute_list = attr_list;
}


const bool ScimBridgeAgentIMContext::is_preedit_shown () const
{
    return preedit_shown;
}


void ScimBridgeAgentIMContext::set_preedit_shown (bool shown)
{
    assert ((shown && on_the_spot) || !shown);
    preedit_shown = shown;

    update_capabilities ();
}


void ScimBridgeAgentIMContext::update_capabilities ()
{
    if (imengine) {
        unsigned int cap = SCIM_CLIENT_CAP_ALL_CAPABILITIES;

        if (!preedit_shown)
            cap -= SCIM_CLIENT_CAP_ONTHESPOT_PREEDIT;

        imengine->update_client_capabilities (cap);
    }
}


const ScimBridgeAgentClientPeer *ScimBridgeAgentIMContext::get_client_peer () const
{
    return client_peer;
}


ScimBridgeAgentClientPeer *ScimBridgeAgentIMContext::get_client_peer ()
{
    return client_peer;
}


void ScimBridgeAgentIMContext::set_client_peer (ScimBridgeAgentClientPeer *new_client_peer)
{
    client_peer = new_client_peer;
}


/* Calls for imengine instance */

const int ScimBridgeAgentIMContext::get_cursor_x () const
{
    return cursor_x;
}


const int ScimBridgeAgentIMContext::get_cursor_y () const
{
    return cursor_y;
}


void ScimBridgeAgentIMContext::set_cursor_x (int x)
{
    cursor_x = x;
}


void ScimBridgeAgentIMContext::set_cursor_y (int y)
{
    cursor_y = y;
}


void ScimBridgeAgentIMContext::set_cursor_location (int x, int y)
{
    cursor_x = x;
    cursor_y = y;
}


bool ScimBridgeAgentIMContext::process_key_event (const KeyEvent &keyevent)
{
    return imengine->process_key_event (keyevent);
}


void ScimBridgeAgentIMContext::update_lookup_table_page_size (int page_size)
{
    imengine->update_lookup_table_page_size (page_size);
}


void ScimBridgeAgentIMContext::lookup_table_page_up ()
{
    imengine->lookup_table_page_up ();
}


void  ScimBridgeAgentIMContext::lookup_table_page_down ()
{
    imengine->lookup_table_page_down ();
}


void ScimBridgeAgentIMContext::trigger_property (const String &property)
{
    imengine->trigger_property (property);
}


const String ScimBridgeAgentIMContext::get_factory_uuid () const
{
    return imengine->get_factory_uuid ();
}


void ScimBridgeAgentIMContext::process_helper_event (const String &helper_uuid, const Transaction &trans)
{
    imengine->process_helper_event (helper_uuid, trans);
}


void ScimBridgeAgentIMContext::move_preedit_caret (int caret_pos)
{
    imengine->move_preedit_caret (caret_pos);
}


void ScimBridgeAgentIMContext::select_candidate (int cand_index)
{
    imengine->select_candidate (cand_index);
}


void ScimBridgeAgentIMContext::focus_in ()
{
    imengine->focus_in ();
}


void ScimBridgeAgentIMContext::focus_out ()
{
    imengine->focus_out ();
}


void ScimBridgeAgentIMContext::reset ()
{
    reset_preedit ();
    imengine->reset ();
}


bool ScimBridgeAgentIMContext::process_keyevent (const scim::KeyEvent &keyevent)
{
    return imengine->process_key_event (keyevent);
}

--- NEW FILE: scim-bridge-agent-imcontext.h ---
#ifndef SCIMBRIDGEAGENTIMCONTEXT_H_
#define SCIMBRIDGEAGENTIMCONTEXT_H_

#define Uses_SCIM_ATTRIBUTE
#define Uses_SCIM_IMENGINE
#define Uses_SCIM_IMENGINE_MODULE

#include <scim.h>

#include "scim-bridge.h"
#include "scim-bridge-keyevent.h"
#include "scim-bridge-imcontext-common.h"

class ScimBridgeAgentClientPeer;

class ScimBridgeAgentIMContext: public ScimBridgeIMContext
{
    public:

        /* static functions */
        static void set_on_the_spot_enabled (bool enabled);
        static bool is_on_the_spot_enabled ();
        static bool is_imengine_shared ();
        static void set_imengine_shared (bool shared);
        static scim::IMEngineInstancePointer get_shared_imengine ();
        static void release_shared_imengine ();

        static ScimBridgeAgentIMContext *find (ScimBridgeIMContextID id);

        ScimBridgeAgentIMContext ();
        ~ScimBridgeAgentIMContext ();

        void free ();

        bool process_key_event (const scim::KeyEvent &keyevent);

        const scim::AttributeList &get_preedit_attribute_list ();
        void set_preedit_attribute_list (const scim::AttributeList &attr_list);
        const scim::WideString &get_preedit_string ();
        void set_preedit_string (const scim::WideString & wstr);
        void move_preedit_caret (int caret_pos);
        void set_preedit_caret (int caret_pos);
        const int get_preedit_caret () const;
        void set_preedit_shown (bool shown);
        const bool is_preedit_shown () const;
        void reset_preedit ();

        const int get_cursor_x () const;
        const int get_cursor_y () const;
        void set_cursor_x (int new_x);
        void set_cursor_y (int new_y);
        void set_cursor_location (int new_x, int new_y);

        const bool is_on () const;
        void turn_on ();
        void turn_off ();

        const ScimBridgeIMContextID get_id () const;
        const ScimBridgeIMContextID get_opponent_id () const;
        void set_opponent_id (ScimBridgeIMContextID new_opponent_id);

        void set_imengine (scim::IMEngineInstancePointer new_imengine);
        const scim::IMEngineInstancePointer get_imengine () const;

        void update_lookup_table_page_size (int page_size);
        void lookup_table_page_up ();
        void  lookup_table_page_down ();
        void trigger_property (const scim::String &property);
        const scim::String get_factory_uuid () const;
        void process_helper_event (const scim::String &helper_uuid, const scim::Transaction &trans);
        void select_candidate (int cand_index);

        void reset ();
        void focus_in ();
        void focus_out ();

        bool process_keyevent (const scim::KeyEvent &keyevent);

        const ScimBridgeAgentClientPeer *get_client_peer () const;
        ScimBridgeAgentClientPeer *get_client_peer ();
        void set_client_peer (ScimBridgeAgentClientPeer *new_client_peer);

    private:

        static scim::IMEngineInstancePointer shared_imengine;

        static bool on_the_spot;
        static bool imengine_shared;

        static void set_shared_imengine (scim::IMEngineInstancePointer new_imengine);

        scim::IMEngineInstancePointer imengine;
        scim::WideString preedit_string;
        scim::AttributeList preedit_attribute_list;

        bool preedit_shown;
        int preedit_caret;

        int cursor_x;
        int cursor_y;

        bool status;

        ScimBridgeAgentClientPeer *client_peer;

        void update_capabilities ();

};
#endif                                            /*SCIMBRIDGEAGENTIMCONTEXT_H_*/

--- NEW FILE: scim-bridge-agent-messenger.h ---
#ifndef SCIMBRIDGEAGENTMESSENGER_H_
#define SCIMBRIDGEAGENTMESSENGER_H_

#include "scim-bridge.h"
#include "scim-bridge-message.h"
#include "scim-bridge-agent-imcontext.h"

class ScimBridgeAgentClientPeerProtected;

class ScimBridgeAgentMessenger
{

    public:

        ScimBridgeAgentMessenger (ScimBridgeAgentClientPeerProtected &client_peer);
        ~ScimBridgeAgentMessenger ();

        bool is_thread_running ();

        void open_connection (int input_fd, int output_fd) throw (ScimBridgeAgentException);
        void close_connection ();

        void connection_closed ();

        ScimBridgeMessengerID get_id ();

        /* Calls from the client */
        void received_message_unknown (ScimBridgeMessageCode code) throw (ScimBridgeAgentException);
        void received_message_alloc_imcontext () throw (ScimBridgeAgentException);
        void received_message_free_imcontext () throw (ScimBridgeAgentException);
        void received_message_reset_imcontext () throw (ScimBridgeAgentException);
        void received_message_focus_changed () throw (ScimBridgeAgentException);
        void received_message_keyevent_occured () throw (ScimBridgeAgentException);
        void received_message_cursor_location_changed () throw (ScimBridgeAgentException);

        /* Remote function */
        void call_commit (const ScimBridgeAgentIMContext &ic) throw (ScimBridgeAgentException);

        void call_set_preedit_string (const ScimBridgeAgentIMContext &ic, const scim::WideString &string) throw (ScimBridgeAgentException);
        void call_set_preedit_attributes (const ScimBridgeAgentIMContext &ic, const scim::AttributeList &attributes) throw (ScimBridgeAgentException);
        void call_set_preedit_cursor_position (const ScimBridgeAgentIMContext &ic, int cursor_position) throw (ScimBridgeAgentException);
        void call_set_preedit_shown (const ScimBridgeAgentIMContext &ic, bool shown) throw (ScimBridgeAgentException);
        void call_update_preedit (const ScimBridgeAgentIMContext &ic) throw (ScimBridgeAgentException);

        void call_forward_keyevent (const ScimBridgeAgentIMContext &ic, const scim::KeyEvent &keyevent) throw (ScimBridgeAgentException);
        void call_beep (const ScimBridgeAgentIMContext &ic) throw (ScimBridgeAgentException);

        bool call_get_surrounding_string (const ScimBridgeAgentIMContext &ic, scim::WideString &surrounding, size_t max_length, int &cursor_pos) throw (ScimBridgeAgentException);
        bool call_delete_surrounding_string (const ScimBridgeAgentIMContext &ic, size_t offset, size_t len) throw (ScimBridgeAgentException);

    private:

        bool thread_running;

        pthread_t thread;

        ScimBridgeMessengerID id;

        ScimBridgeAgentClientPeerProtected &client_peer;

        int input_fd;
        int output_fd;

};
#endif                                            /*SCIMBRIDGEAGENTMESSENGER_H_*/