wrapper/cle/imi_cle.cpp

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2007 Sun Microsystems, Inc. All Rights Reserved.
 *
 * The contents of this file are subject to the terms of either the GNU Lesser
 * General Public License Version 2.1 only ("LGPL") or the Common Development and
 * Distribution License ("CDDL")(collectively, the "License"). You may not use this
 * file except in compliance with the License. You can obtain a copy of the CDDL at
 * http://www.opensource.org/licenses/cddl1.php and a copy of the LGPLv2.1 at
 * http://www.opensource.org/licenses/lgpl-license.php. See the License for the
 * specific language governing permissions and limitations under the License. When
 * distributing the software, include this License Header Notice in each file and
 * include the full text of the License in the License file as well as the
 * following notice:
 *
 * NOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION LICENSE
 * (CDDL)
 * For Covered Software in this distribution, this License shall be governed by the
 * laws of the State of California (excluding conflict-of-law provisions).
 * Any litigation relating to this License shall be subject to the jurisdiction of
 * the Federal Courts of the Northern District of California and the state courts
 * of the State of California, with venue lying in Santa Clara County, California.
 *
 * Contributor(s):
 *
 * If you wish your version of this file to be governed by only the CDDL or only
 * the LGPL Version 2.1, indicate your decision by adding "[Contributor]" elects to
 * include this software in this distribution under the [CDDL or LGPL Version 2.1]
 * license." If you don't indicate a single choice of license, a recipient has the
 * option to distribute your version of this file under either the CDDL or the LGPL
 * Version 2.1, or to extend the choice of license to its licensees as provided
 * above. However, if you add LGPL Version 2.1 code and therefore, elected the LGPL
 * Version 2 license, then the option applies only if the new code is made subject
 * to such option by the copyright holder.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <cstdio>
#include <cstdlib>

#include "ime.h"

#include "imi_data.h"
#include "imi_view.h"
#include "imi_clewin.h"
#include "imi_options.h"
#include "ic_history.h"

#ifndef CLE_SUNPINYIN_DATADIR
    #define CLE_SUNPINYIN_DATADIR "/usr/lib/iiim/le/cle/input_methods/data"
#endif

static ImeResult sunpinyin_Initialize(ImeInfo ime_info);
static ImeResult sunpinyin_Destroy(ImeInfo ime_info);
static ImeResult sunpinyin_Process_Key_Event(ImeInputContext ic, ImeKey key_event);
static ImeResult sunpinyin_Process_Aux_Event(ImeInputContext ic, ImeEvent pEvent);
static ImeResult sunpinyin_Create_Session(ImeInputContext ic);
static ImeResult sunpinyin_Destroy_Session(ImeInputContext ic);
static ImeResult sunpinyin_focus_in(ImeInputContext ic);
static ImeResult sunpinyin_Attach_User(ImeInputContext ic);
static ImeResult sunpinyin_Dettach_User(ImeInputContext ic);
static ImeResult sunpinyin_Attach_Desktop(ImeInputContext ic);
static ImeResult sunpinyin_Dettach_Desktop(ImeInputContext ic);

ImeMethodsRec sunpinyin_methods = {
    100,                              /* version */
    sunpinyin_Initialize,             /* ImeInitialize */
    sunpinyin_Destroy,                /* ImeDestroy  */
    sunpinyin_Process_Key_Event,      /* ImeProcessKeyEvent */
    sunpinyin_Process_Aux_Event,      /* ImeProcessAuxEvent  */
    sunpinyin_Create_Session,         /* ImeAttachSession */
    sunpinyin_Destroy_Session,        /* ImeDetachSession */
    sunpinyin_focus_in,               /* ImeFocusIn  */
    NULL,                             /* ImeFocusOut */
    sunpinyin_Attach_User,            /* ImeAttachUser */
    sunpinyin_Dettach_User,           /* ImeDetachUser */
    sunpinyin_Attach_Desktop,         /* ImeAttachDesktop */
    sunpinyin_Dettach_Desktop,        /* ImeDetachDesktop */
    NULL,                             /* ImeGetErrorMessage */
};

const char* InputStyleOptions[] = {
    "",
    "",
    NULL
};

const char* CharSetOptions[] = {
    "GB2312",
    "GBK",
    NULL
};

const char* LayoutOptions[] = {
    "",
    "",
    NULL
};


ImePropertyRec sunpinyin_options[] = {
    { 1, ENCODE_UTF8, "/input_style",    "", NULL, ImeProperty_Selection, {0, 0}, 0},
    { 2, ENCODE_UTF8, "/charset",        "",   NULL, ImeProperty_Selection, {0, 0}, 1},

    {30, ENCODE_UTF8, "/PageKey/Minus",   "-/=", NULL, ImeProperty_Toggle, {0, 0}, 1},
    {31, ENCODE_UTF8, "/PageKey/Braket",  "[/]", NULL, ImeProperty_Toggle, {0, 0}, 1},
    {32, ENCODE_UTF8, "/PageKey/Comma",   ",/.", NULL, ImeProperty_Toggle, {0, 0}, 0}

#if 0
    ,
    { 3, ENCODE_UTF8, "/history_memory", "(0,10)", NULL, ImeProperty_Int, {0, 10}, 5},
    { 4, ENCODE_UTF8, "/ranking_method", "", NULL, ImeProperty_Toggle, {0, 0}, 1},
    { 5, ENCODE_UTF8, "/layout",         "", NULL, ImeProperty_Selection, {0, 0}, 0},

    { 7, ENCODE_UTF8, "/Fuzzy",          "", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 8, ENCODE_UTF8, "/Fuzzy/zh",       "zh = z", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 9, ENCODE_UTF8, "/Fuzzy/ch",       "ch = c", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 10,ENCODE_UTF8, "/Fuzzy/sh",       "sh = s", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 11,ENCODE_UTF8, "/Fuzzy/ln",       "l  = n", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 12,ENCODE_UTF8, "/Fuzzy/fh",       "f  = h", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 13,ENCODE_UTF8, "/Fuzzy/ang",      "an = ang",  NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 14,ENCODE_UTF8, "/Fuzzy/eng",      "en = eng",  NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 15,ENCODE_UTF8, "/Fuzzy/ing",      "in = ing", NULL, ImeProperty_Toggle, {0, 0}, 0},
    { 50,ENCODE_UTF8, "/owner_aux",      "", NULL, ImeProperty_Toggle, {0, 0}, 0},
#endif
};

ImePropertyListRec sunpinyin_optionlist = {
    sizeof(sunpinyin_options)/sizeof(ImePropertyRec),
    sunpinyin_options
};

static void setOptionsFromPL(int count, ImePropertyRec* pl, CSunpinyinOptions* dst)
{
    for (int i=0; i < count; ++i) {
        switch (pl[i].id) {
        case 1:
            dst->m_ViewType = pl[i].value.int_value; break;
        case 2:
            dst->m_GBK = pl[i].value.int_value; break;

        case 30:
            dst->m_MinusAsPageUp = pl[i].value.int_value; break;
        case 31:
            dst->m_BracketAsPageUp = pl[i].value.int_value; break;
        case 32:
            dst->m_CommaAsPageUp = pl[i].value.int_value; break;

#if 0
        case 3:
            dst->m_MemoryPower = pl[i].value.int_value; break;
        case 4:
            dst->m_ContextRanking = pl[i].value.int_value; break;
        case 5:
            dst->m_LayoutVeritcal = pl[i].value.int_value; break;
        case 7:
            dst->m_Fuzzy = pl[i].value.int_value; break;
        case 8:
            dst->m_Fuzzy_zh = pl[i].value.int_value; break;
        case 9:
            dst->m_Fuzzy_ch = pl[i].value.int_value; break;
        case 10:
            dst->m_Fuzzy_sh = pl[i].value.int_value; break;
        case 11:
            dst->m_Fuzzy_ln = pl[i].value.int_value; break;
        case 12:
            dst->m_Fuzzy_fh = pl[i].value.int_value; break;
        case 13:
            dst->m_Fuzzy_ang = pl[i].value.int_value; break;
        case 14:
            dst->m_Fuzzy_eng = pl[i].value.int_value; break;
        case 15:
            dst->m_Fuzzy_ing = pl[i].value.int_value; break;

        case 50:
#endif

        default:
            break;
        }
    }
}

static ImeInfoRec sunpinyin_inforec = {
    100,                                                   //version
    0,
    ENCODE_UTF8,
    "SunPinyin-ef1a0a92-9f0e-410b-b8a8-e6f296c1801c",      //uuid
    "Sun",                                             //name
    " <Phill.Zhang (at) sun.com>",
    "Sun's intelligent Pinyin IM",
    "Copyright (c) 2005 Sun Microsystems",
    "sunpinyin_logo.xpm",
    "zh_CN.GB18030,zh_CN.UTF-8,zh_CN.GBK,zh_CN.GB2312,zh",
    &sunpinyin_optionlist,
    NULL
};

ImmServices imm_services;

class CSunpinyinUserData {
public:
    CSunpinyinUserData() : m_pPref(NULL), m_pHistory(NULL) { }

    CSunpinyinOptions*      m_pPref;
    CBigramHistory*         m_pHistory;
};

extern "C" {

ImeResult RegisterIME(ImmServices srvs, ImeInfo* ppinfo, ImeMethods* pmthds, int argc, char **argv)
{
    #ifdef DEBUG
        printf("Register Sun Pinyin IM...\n");
        fflush(stdout);
    #endif
    sunpinyin_options[0].range.multiString_range = InputStyleOptions;
    sunpinyin_options[1].range.multiString_range = CharSetOptions;
    sunpinyin_options[4].range.multiString_range = LayoutOptions;

    CCLEWinHandler::sm_imm_srvs = imm_services = srvs;

    *ppinfo = &sunpinyin_inforec;
    *pmthds = &sunpinyin_methods;

    return (IME_OK);
}

}

static const char* getLMPath(void)
{
    return CLE_SUNPINYIN_DATADIR"/lm_sc.t3g";
}

static const char* getPYTriePath(void)
{
    return CLE_SUNPINYIN_DATADIR"/pydict_sc.bin";
}

static CIMIData* s_pSunPinyinData = NULL;

static ImeResult sunpinyin_Initialize(ImeInfo sunpinyin_info)
{
    bool suc=false;

    #ifdef DEBUG
        printf("sunpinyin_Initialize...\n");
        fflush(stdout);
    #endif

    s_pSunPinyinData = new CIMIData();
    if (s_pSunPinyinData && s_pSunPinyinData->loadResource(getLMPath(), getPYTriePath())) {
        suc = true;
    }

    if (!suc) {
        delete s_pSunPinyinData;
        s_pSunPinyinData = NULL;
        return IME_FAIL;
    }

    return IME_OK;
}

static ImeResult sunpinyin_Attach_User(ImeInputContext ic)
{
    CSunpinyinUserData* pud = NULL;
    if ((pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER)) == NULL) {
        pud = new CSunpinyinUserData();
        pud->m_pPref = new CSunpinyinOptions();
        ImePropertyListRec* pl = imm_services->ImmGetPropertyList(ic);
        if (pl != NULL) { // It must be non-zero
            setOptionsFromPL(pl->count, pl->properties, pud->m_pPref);
        }
        pud->m_pHistory = new CBigramHistory();
        int sz = 0;
        unsigned *psaved = (unsigned*)imm_services->ImmLoadUserProfile(ic, "history", &sz);
        if (psaved != NULL) {
            pud->m_pHistory->loadFromBuffer(psaved, sz);
            imm_services->ImmFreeUserProfile(psaved);
        }
        imm_services->ImmSetData(ic, IME_SCOPE_USER, pud);
    }
    return IME_OK;
}

static ImeResult sunpinyin_Dettach_User(ImeInputContext ic)
{
    CSunpinyinUserData* pud = NULL;
    if ((pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER)) != NULL) {
        size_t sz = 0;
        void* pbuf = NULL;
        if (pud->m_pHistory) {
            pud->m_pHistory->bufferize(&pbuf, &sz);
            if (pbuf) {
                imm_services->ImmSaveUserProfile(ic, "history", pbuf, int(sz));
                free(pbuf);
            }
        }
        delete pud;
    }
    imm_services->ImmSetData(ic, IME_SCOPE_USER, NULL);
    return IME_OK;
}

static ImeResult sunpinyin_Attach_Desktop(ImeInputContext ic)
{
    return IME_OK;
}

static ImeResult sunpinyin_Dettach_Desktop(ImeInputContext ic)
{
    return IME_OK;
}

static ImeResult sunpinyin_Destroy(ImeInfo sunpinyin_info)
{
    delete s_pSunPinyinData;
    s_pSunPinyinData = NULL;
    CCLEWinHandler::sm_imm_srvs = NULL;

    return (IME_OK);
}

static ImeResult
_sunpinyin_Create_Session(ImeInputContext ic, int viewType)
{
    #ifdef DEBUG
        printf(">>>>>>>> SunPinyin alloc private session data...\n");
        fflush(stdout);
    #endif

    CSunpinyinUserData* pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER);
    if (pud == NULL) { //should not happen, but now, CLE make it happen
        sunpinyin_Attach_User(ic);
        pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER);
    }

    CIMIData* pdata = s_pSunPinyinData;

    CIMIContext *pic = NULL;
    CIMIView *pv = NULL;
    CCLEWinHandler *pwh = NULL;

    #ifdef DEBUG
        printf("    -------->>>>Creating searching related core structure...\n");
        fflush(stdout);
    #endif
    pic = new CIMIContext();
    pic->setCoreData(pdata);
    pic->setHistoryMemory(pud->m_pHistory);
    pic->setNonCompleteSyllable(true);
    pic->clear();

    #ifdef DEBUG
        printf("    -------->>>>Creating view...\n");
        fflush(stdout);
    #endif
    pv = CIMIViewFactory::createView(viewType);
    #ifdef DEBUG
        printf("    -------->>>>Setting view options...\n");
        fflush(stdout);
    #endif

    bool enable_gbk = pud->m_pPref->m_GBK;
    if (imm_services->ImmGetSessionEncoding(ic) == ENCODE_GB2312)
        pud->m_pPref->m_GBK = false;
    pv->setPreference(pud->m_pPref);
    pud->m_pPref->m_GBK = enable_gbk;

    /* FIXME: we should add the candidate window size to preferences */
    pv->s_CandiWindowSize = 10;

    #ifdef DEBUG
        printf("    -------->>>>Bundle searching structure with view...\n");
        fflush(stdout);
    #endif
    pv->attachIC(pic);

    #ifdef DEBUG
        printf("    -------->>>>Creating GUI_Handler...\n");
        fflush(stdout);
    #endif
    pwh = new CCLEWinHandler();
    pwh->setOptions(pv->getPreference());
    pv->attachWinHandler(pwh);
    pwh->setMainWindow(ic);

    imm_services->ImmSetData(ic, IME_SCOPE_SESSION, pv);
    #ifdef DEBUG
        printf("    -------->>>>Done\n");
        fflush(stdout);
    #endif
    return (IME_OK);
}

static ImeResult
sunpinyin_Create_Session(ImeInputContext ic)
{
    CSunpinyinUserData* pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER);
    if (pud == NULL) { //should not happen, but now, CLE make it happen
        sunpinyin_Attach_User(ic);
        pud = (CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER);
    }

    int viewType = (pud->m_pPref->m_ViewType==0)?(CIMIViewFactory::SVT_CLASSIC):(CIMIViewFactory::SVT_MODERN);
    return _sunpinyin_Create_Session(ic, viewType);
}

static ImeResult sunpinyin_Destroy_Session(ImeInputContext ic)
{
    CIMIView *pv = (CIMIView*)imm_services->ImmGetData(ic, IME_SCOPE_SESSION);
    imm_services->ImmSetData(ic, IME_SCOPE_SESSION, NULL);

    if (pv) {
        CIMIContext *pic = pv->getIC();
        CIMIWinHandler *pwh = pv->getWinHandler();

        delete pic;
        delete pwh;
        delete pv;
    }

    return (IME_OK);
}

static ImeResult sunpinyin_Process_Aux_Event(ImeInputContext ic, ImeEvent pEvent)
{
    CIMIView *pv = (CIMIView*)imm_services->ImmGetData(ic, IME_SCOPE_SESSION);

    int pgno;
    bool relative;

    if (pv && pEvent) {
        switch (pEvent->type) {
        case IME_EVENT_IMM_NOTIFY:
            switch (pEvent->notify_event.trigger) {
            case IMM_TRIGGER_FULL_HALF_PUNC:
                pv->setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLPUNC, pEvent->notify_event.value);
                break;
            case IMM_TRIGGER_FULL_HALF_SIMBOL:
                pv->setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLSIMBOL, pEvent->notify_event.value);
                break;
            }
            return IME_OK;

        case IME_EVENT_PROPERTY:
            return sunpinyin_focus_in(ic);

        case IME_EVENT_CANDI_SELECT:
            pv->onCandidateSelectRequest(pEvent->candidate_select_event.param);
            return IME_OK;

        case IME_EVENT_CANDI_PAGE:
            switch (pEvent->candidate_page_event.param) {
            case ImeCandidatesPageFirst:
                pgno = 0; relative = false; break;
            case ImeCandidatesPagePrevious:
                pgno = -1; relative = true; break;
            case ImeCandidatesPageNext:
                pgno = 1; relative = true; break;
            case ImeCandidatesPageLast:
                pgno = -1; relative = false; break;
            default:
                return IME_UNPROCESSED_EVENT;
            }
            pv->onCandidatePageRequest(pgno, relative);
            return IME_OK;
        }
    }

    return IME_UNPROCESSED_EVENT;
}

ImeResult  sunpinyin_focus_in(ImeInputContext ic)
{
    CIMIView *pv = (CIMIView*)imm_services->ImmGetData(ic, IME_SCOPE_SESSION);
    if (pv) {
        CSunpinyinOptions* pup = ((CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER))->m_pPref;
        ImePropertyListRec* pl = imm_services->ImmGetPropertyList(ic);
        setOptionsFromPL(pl->count, pl->properties, pup);

        CSunpinyinOptions* pvp = (CSunpinyinOptions*)pv->getPreference();

        if ((pup->m_GBK != pvp->m_GBK &&  imm_services->ImmGetSessionEncoding(ic) != ENCODE_GB2312) ||
                                                (pup->m_ViewType != pvp->m_ViewType)) {
            sunpinyin_Destroy_Session(ic);
            imm_services->ImmHidePreedit(ic);
            imm_services->ImmHideCandidates(ic);
            sunpinyin_Create_Session(ic);
        } else {
            pvp->m_MinusAsPageUp   = pup->m_MinusAsPageUp;
            pvp->m_CommaAsPageUp   = pup->m_CommaAsPageUp;
            pvp->m_BracketAsPageUp = pup->m_BracketAsPageUp;
        }
    }
    return IME_OK;
}

static ImeResult sunpinyin_Process_Key_Event(ImeInputContext ic, ImeKey key_event)
{
    int ret = IME_UNUSED_KEY;

    /* sunpinyin_focus_in(ic); */

    CIMIView *pv = (CIMIView*)imm_services->ImmGetData(ic, IME_SCOPE_SESSION);

    #ifdef DEBUG
        printf(">>>>>>>>SunPinyin Process a key [0x%X, 0x%X, 0x%X] on view @%X",
                    key_event->keycode, key_event->keychar, key_event->modifier,pv);
        fflush(stdout);
    #endif

    //switch input GUI style between classic/modern style
    if ((key_event->modifier & (IME_CTRL_MASK|IME_SHIFT_MASK|IME_ALT_MASK)) == IME_CTRL_MASK && key_event->keycode == IME_VK_BACK_QUOTE) {

        if (pv) {
            CSunpinyinOptions* pup = ((CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER))->m_pPref;
            pup->m_ViewType = (pup->m_ViewType)?0:1;
            sunpinyin_focus_in(ic);
        }
        ret = IME_OK;

    } else if ((key_event->modifier & (IME_CTRL_MASK|IME_SHIFT_MASK|IME_ALT_MASK)) == IME_CTRL_MASK && key_event->keycode == IME_VK_K) {
        if (pv) {
            if (imm_services->ImmGetSessionEncoding(ic) != ENCODE_GB2312) {
                CSunpinyinOptions* pup = ((CSunpinyinUserData*)imm_services->ImmGetData(ic, IME_SCOPE_USER))->m_pPref;
                pup->m_GBK = (pup->m_GBK)?0:1;
                sunpinyin_focus_in(ic);
            }
            ret = IME_OK;
        }
    } else if (pv) {
        ((CCLEWinHandler*)pv->getWinHandler())->setMainWindow(ic);
        if (pv->onKeyEvent(key_event->keycode, key_event->keychar, key_event->modifier))
            ret = IME_OK;
    }

    #ifdef DEBUG
        printf((ret == IME_OK)?"  ==>used!":"==>not used!");
        fflush(stdout);
    #endif

    return ImeResult(ret);
}