ime/src/imi_view_modern.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 <locale.h>
#include <ctype.h>

#include "imi_view_modern.h"
#include "imi_uiobjects.h"

#include "imi_keys.h"

CIMIModernView::CIMIModernView()
    : CIMIView(), m_SyllableStr(), m_bNewSyll(false), m_SyllBone(),
      m_CandiList(), m_CandiFirst(0), m_CursorIdx(-1)
{
}

CIMIModernView::~CIMIModernView()
{
}

int
CIMIModernView::getViewType(void)
    { return CIMIViewFactory::SVT_MODERN; }


void
CIMIModernView::attachIC(CIMIContext* pIC)
{
    CIMIView::attachIC(pIC);

    CSunpinyinOptions *ppref = dynamic_cast<CSunpinyinOptions*>(m_pPref);

    m_pIC->setLeft2RightSelection(false);
    if (ppref) {
        m_pIC->enableGBK(ppref->m_GBK);
        m_pIC->setHistoryPower(ppref->m_MemoryPower);
        m_pIC->enableContextRanking(ppref->m_ContextRanking);
    }

    m_SyllableStr.clear();
    m_SyllBone = m_pIC->getLastBone();
    m_CandiList.clear();
    m_CandiFirst = 0;
    m_bNewSyll = true;
    m_CursorIdx = -1;
}

unsigned
CIMIModernView::clearIC(void)
{
    if (!m_pIC->isEmpty()) {
        m_pIC->clear();
        m_SyllableStr.clear();
        m_bNewSyll = true;
        m_SyllBone = m_pIC->getLastBone();
        m_CandiFirst = 0;
        m_pIC->getCandidates(m_SyllBone, m_CandiList);
        m_CursorIdx = -1;
        return (PREEDIT_MASK | CANDIDATE_MASK);
    }

    m_SyllableStr.clear();
    return 0;
}

void
CIMIModernView::setStatusAttrValue(int key, int value)
{
    if (key == CIMIWinHandler::STATUS_ID_CN) {
        if (m_CN != (value != 0)) {
            unsigned int changeMasks = 0;

            if (m_SyllableStr.size() != 0) {
                if (m_pIC->isValidSyllable(m_SyllableStr)) {
                    convertSyllable(CBone::USER_BOUNDARY, m_SyllableStr.size(), changeMasks);
                } else {
                    cancelSyllable(changeMasks);
                }
            }
            updateWindows(changeMasks);

            m_CN = (value != 0);
            if (mp_winHandler)
                mp_winHandler->updateStatus(key, value);
        }
        return;
    }
    CIMIView::setStatusAttrValue(key, value);
}

/**
 * NOTE: We can not use keyrelease information because IIIM do not give
 * such type event.
 *    - If KEY_PRESS type event then
 *        -# m_nKeysWithShift = 1
 *        -# If LShift pressed, m_nKeysWithShift <-- 0, return
 *        -# Process Key Press event according whether or not in syllable editing mode
 *        .
 *    - If LShift released and (m_nKeysWithShift == 0), SwitchCNState()
 */
int
CIMIModernView::onKeyEvent(unsigned keycode, unsigned keyvalue, unsigned modifier)
{
    unsigned int changeMasks = 0;

    #ifdef DEBUG
        printf("ModernView got a key (0x%x-0x%x-0x%x)...", keycode, keyvalue, modifier);
        fflush(stdout);
    #endif

    //Clear other mask bit we do not care
    modifier &= (IM_SHIFT_MASK | IM_CTRL_MASK | IM_ALT_MASK);

    // On ALT+SHIFT, switch CN/EN status, but return the key event back as we do not use it
    if ((keycode == IM_VK_SHIFT) && (modifier == IM_ALT_MASK)) {
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_CN, (!m_CN)?1:0);
        return 0;
    }

    if (keycode == IM_VK_SHIFT || keycode == IM_VK_CONTROL || keycode == IM_VK_ALT)
        return 0;

    if ((keyvalue == IM_VK_PERIOD) && (modifier == IM_CTRL_MASK)) {
        changeMasks |= KEYEVENT_USED;
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLPUNC, (!m_FullPunc)?1:0);

    } else if ((keyvalue == IM_VK_SPACE) && (modifier == IM_SHIFT_MASK)) {
        changeMasks |= KEYEVENT_USED;
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLSIMBOL, (!m_FullSimbol)?1:0);

    } else if ((modifier & (IM_CTRL_MASK | IM_ALT_MASK)) == 0) {
        if (m_SyllableStr.size() > 0)
            pressKeyOnSyllable(keycode, keyvalue, modifier, changeMasks);
        else
            pressKeyOnSentence(keycode, keyvalue, modifier, changeMasks);
    }

    #ifdef DEBUG
        printf("   |-->(Mask=0x%x)\n", changeMasks);
        fflush(stdout);
    #endif

    updateWindows(changeMasks);

    return ((changeMasks & KEYEVENT_USED) != 0)?1:0;
}

void
CIMIModernView::getPreeditString(IPreeditString& ps)
{
    int i, SyllPos, SyllSize, caret;

    ps.clear();
    caret = getSentence(ps.getString(), &SyllPos, &SyllSize);
    if (m_CursorIdx >= 0 && m_CursorIdx < m_SyllableStr.size())
        caret -= m_SyllableStr.size()-m_CursorIdx;
    ps.setCaret(caret);

    IPreeditString::CCharTypeVec& ctv = ps.getCharTypeVec();
    for (i = 0; i < SyllPos; ++i)
        ctv.push_back(IPreeditString::HANZI_CHAR);
    for (SyllPos += SyllSize; i < SyllPos; ++i)
        ctv.push_back(IPreeditString::PINYIN_CHAR);
    for (; i < ps.size(); ++i)
        ctv.push_back(IPreeditString::HANZI_CHAR);
}

void
CIMIModernView::getCandidateList(ICandidateList& cl, int start, int size)
{
    cl.clear();
    ICandidateList::CCandiStrings& css = cl.getCandiStrings();
    ICandidateList::CCandiTypeVec& cts = cl.getCandiTypeVec();

    cl.setFirst(start);
    cl.setTotal(m_CandiList.size());

    size = start+size;
    if (size > m_CandiList.size())
        size = m_CandiList.size();
    for (; start < size; ++start) {
        css.push_back(m_CandiList[start].m_String);
        cts.push_back( (start == 0)?(ICandidateList::BEST_WORD):(ICandidateList::NORMAL_WORD) );
    }
}

void
CIMIModernView::updateWindows(unsigned int mask)
{
    if (mp_winHandler) {
        if ((mask & PREEDIT_MASK) != 0) {
            CPreEditString ps;
            getPreeditString(ps);
            mp_winHandler->updatePreedit(&ps);
        }

        if ((mask & CANDIDATE_MASK) != 0) {
            CCandidateList cl;
            if (m_SyllableStr.size() == 0)
                getCandidateList(cl, m_CandiFirst, s_CandiWindowSize);
            else
                m_CandiFirst = 0;
            mp_winHandler->updateCandidates(&cl);
        }
    }
}

void
CIMIModernView::cancelSyllable(unsigned int& mask)
{
    mask |= PREEDIT_MASK | CANDIDATE_MASK;
    m_CandiFirst = 0;
    m_SyllableStr.clear();
    m_CursorIdx = -1;
}

void
CIMIModernView::convertSyllable(int boundaryType, int len, unsigned int& mask)
{
    tryCommitLeftSentence(mask);

    std::list<CBone> newBones;
    newBones.push_front(CBone(m_SyllableStr.c_str(), len, boundaryType, CBone::NODE_PINYIN));

    CSkeletonIter it2 = m_SyllBone;
    if (!m_bNewSyll)
        ++it2;

    if (m_pIC->modify(m_SyllBone, it2, newBones)) {
        m_CandiFirst = 0;
        m_SyllBone = it2;
        m_pIC->getCandidates(m_SyllBone, m_CandiList);
    }
    m_bNewSyll = true;

    if (len < m_SyllableStr.size()) {
        wstring tmpstr(m_SyllableStr.c_str()+len);
        if (m_CursorIdx > 0)
            m_CursorIdx -= len;
        m_SyllableStr = tmpstr;
    } else {
        m_SyllableStr.clear();
        m_CursorIdx = -1;
    }
    mask |= PREEDIT_MASK | CANDIDATE_MASK;
}

void
CIMIModernView::makeSelection(int idx, unsigned int& mask)
{
    CCandidate& cand = m_CandiList[m_CandiFirst + idx];
    m_pIC->makeSelection(cand);
    m_SyllBone = cand.m_BoneEnd;
    while (m_SyllBone->m_BoneType != CBone::NODE_PINYIN &&
           m_SyllBone->m_BoneType != CBone::NODE_TAIL)
        ++m_SyllBone;
    m_CandiFirst = 0;
    m_pIC->getCandidates(m_SyllBone, m_CandiList);
    mask |= PREEDIT_MASK | CANDIDATE_MASK;
}

void
CIMIModernView::eraseBone(CSkeletonIter boneIt, unsigned int& mask)
{
    std::list<CBone> dummyBoneList;
    CSkeletonIter it = ++CSkeletonIter(boneIt);
    m_pIC->modify(boneIt, it, dummyBoneList);

    m_SyllBone = it;
    m_pIC->getCandidates(m_SyllBone, m_CandiList);
    m_CandiFirst = 0;

    mask |= PREEDIT_MASK | CANDIDATE_MASK;
}

void
CIMIModernView::insertNonPinyinBone(CBone& bone, unsigned int& mask)
{
    tryCommitLeftSentence(mask);

    mask |= PREEDIT_MASK | CANDIDATE_MASK;
    std::list<CBone> newBones;
    newBones.push_back(bone);
    if (m_pIC->modify(m_SyllBone, m_SyllBone, newBones)) {
        m_CandiFirst = 0;
        m_pIC->getCandidates(m_SyllBone, m_CandiList);
    }
}

unsigned
CIMIModernView::doCommit(bool bConvert)
{
    wstring bs;

    if (bConvert) {
        getIC()->memorize();
        getSentence(bs);
        mp_winHandler->commit(bs.c_str());
    } else {
        CSkeletonIter ite = m_pIC->getLastBone();
        for (CSkeletonIter it = m_pIC->getFirstBone(); it != ite; ++it)
            bs += it->m_String;
        bs += m_SyllableStr;
        mp_winHandler->commit(bs.c_str());
    }

    return PREEDIT_MASK | CANDIDATE_MASK;
}

void
CIMIModernView::tryCommitLeftSentence(unsigned int& mask)
{
    CSkeletonIter firstBone = m_pIC->getSkeleton().begin();
    CSkeletonIter sntnceEnd = m_SyllBone;

    bool needCommit = false;
    while (sntnceEnd != firstBone) {
        --sntnceEnd;
        if (sntnceEnd->m_BoneType == CBone::NODE_PUNC &&
                isTermPuncWide(sntnceEnd->m_String[0])) {
            needCommit = true;
            break;
        }
    }

    if (needCommit) {
        wstring bs;
        ++sntnceEnd;
        m_pIC->getBestSentence(bs, firstBone, sntnceEnd);

        mp_winHandler->commit(bs.c_str());

        std::list<CBone> dummyBoneList;
        m_pIC->modify(firstBone, sntnceEnd, dummyBoneList, false);

        mask |= PREEDIT_MASK | CANDIDATE_MASK;
    }
}

void
CIMIModernView::commitChar(TWCHAR ch)
{
    TWCHAR wa[2] = {ch, 0};

    mp_winHandler->commit(wa);
}

int
CIMIModernView::getSentence(wstring& wstr, int* pSyllPos, int* pSyllSize)
{
    wstr.clear();
    CSkeletonIter it = m_SyllBone;
    m_pIC->getBestSentence(wstr, m_pIC->getSkeleton().begin(), it);
    if (pSyllSize)
        *pSyllSize = m_SyllableStr.size();
    if (pSyllPos)
        *pSyllPos = wstr.size();
    if (m_SyllableStr.size() > 0)
        wstr += m_SyllableStr;
    int caret = wstr.size();
    if (m_SyllableStr.size() > 0 && !m_bNewSyll)
        ++it;
    wstring tmp;
    m_pIC->getBestSentence(tmp, it, m_pIC->getLastBone());
    wstr += tmp;
    return caret;
}

/**
 * -# ESC   -->  cancel current syllable
 * -# SPACE  '  RETURN  --> try to commit current syllable (untouch if can not commit)
 * -# BACKSPACE  --> try to erase the previouse PINYIN char in the syllable. If
 *                   all PINYIN are erased, then:
 *    - if modifying syllable, erase the bone.
 *    - if inserting syllable, back to non-syllable editing mode.
 *    - return
 *    .
 * -# a-z   --> try to seg pinyin, if could be seged, the new PINYIN char are
 *              appended and if have some syllable to commit, commit it. if the
 *              newly input PINYIN char can not be accepted, just skip it. NOTE:
 *              after commit, even if previous is modifying state, the new syllable
 *              editing mode should be inserting. return.
 * -# printable char
 *    - If current syllable is not commitable, skip it
 *    - else
 *        -# commit current syllable
 *        -# call pressNormalKey()
 *        .
 *    .
 */
void
CIMIModernView::pressKeyOnSyllable(unsigned keycode, unsigned keyvalue, unsigned modifier, unsigned int& mask)
{
    mask |= KEYEVENT_USED;
    if (keycode == IM_VK_ESCAPE) {
        m_bNewSyll = true;
        cancelSyllable(mask);
    } else if (keycode == IM_VK_ENTER) {
        mask |= KEYEVENT_USED | doCommit(modifier != IM_SHIFT_MASK);
        mask |= clearIC();
    } else if (keyvalue == IM_VK_SPACE || keyvalue == '\'') {
        if (m_CursorIdx != 0 || keyvalue == IM_VK_SPACE) {
            wstring syllable = m_SyllableStr;
            if (m_CursorIdx > 0 && m_CursorIdx < m_SyllableStr.size() && keyvalue == '\'')
                syllable.resize(m_CursorIdx);
            if (m_pIC->isValidSyllable(syllable)) {
                convertSyllable(CBone::USER_BOUNDARY, syllable.size(), mask);
            }
        }
    } else if (keycode == IM_VK_LEFT) {
        if (m_CursorIdx != 0) {
            mask |= PREEDIT_MASK;
            m_CursorIdx = (m_CursorIdx < 0 ? m_SyllableStr.size() : m_CursorIdx) - 1;
        }
    } else if (keycode == IM_VK_RIGHT) {
        if (m_CursorIdx >= 0 && m_CursorIdx < m_SyllableStr.size()) {
            mask |= PREEDIT_MASK;
            if (++m_CursorIdx == m_SyllableStr.size())
                m_CursorIdx = -1;
        }
    } else if (keycode == IM_VK_HOME) {
        if (m_CursorIdx != 0) {
            mask |= PREEDIT_MASK;
            m_CursorIdx = 0;
        }
    } else if (keycode == IM_VK_END) {
        if ( !(m_CursorIdx < 0 || m_CursorIdx == m_SyllableStr.size()) ) {
            mask |= PREEDIT_MASK;
            m_CursorIdx = -1;
        }
    } else if (keycode == IM_VK_BACK_SPACE) {
        if (m_CursorIdx != 0) {
            mask |= PREEDIT_MASK;
            m_SyllableStr.erase(m_CursorIdx < 0 ? m_SyllableStr.size() - 1 : --m_CursorIdx, 1);
            if (m_SyllableStr.size() == 0) {
                if (!m_bNewSyll)
                    eraseBone(m_SyllBone, mask);
                m_bNewSyll = true;
            } else if (!m_bNewSyll) {
                m_SyllBone->m_String = m_SyllableStr;
            }
         }
    } else if (keycode == IM_VK_DELETE) {
        if ( !(m_CursorIdx < 0 || m_CursorIdx == m_SyllableStr.size()) ) {
            mask |= PREEDIT_MASK;
            m_SyllableStr.erase(m_CursorIdx, 1);
            if (m_CursorIdx >= m_SyllableStr.size())
                m_CursorIdx = -1;
            if (m_SyllableStr.size() == 0) {
                if (!m_bNewSyll)
                    eraseBone(m_SyllBone, mask);
                m_bNewSyll = true;
            } else if (!m_bNewSyll) {
                m_SyllBone->m_String = m_SyllableStr;
            }
         }
    } else if (keyvalue >= 'a' && keyvalue <= 'z') {
        std::list<CBone> newBones;
        TWCHAR wa[2] = {keyvalue, 0};
        m_SyllableStr.insert( m_CursorIdx < 0 ? m_SyllableStr.size() : m_CursorIdx++, wa );
        bool valid_py_char = m_pIC->segPinyinSimplest(m_SyllableStr, newBones);

        if (!valid_py_char) //invalid pinyin character
            m_SyllableStr.erase( m_CursorIdx < 0 ? m_SyllableStr.size() - 1 : --m_CursorIdx, 1);

        if (newBones.size() > 1) {
            if (!m_bNewSyll)
                m_SyllBone->m_String = m_SyllableStr;
            convertSyllable(CBone::AUTO_BOUNDARY, newBones.front().m_String.size(), mask);
            if (!valid_py_char) {
                pressNormalKey(keycode, keyvalue, modifier, mask);
            }
        } else {
            mask |= PREEDIT_MASK;
        }
    } else if (keyvalue < 0x7f && keyvalue > 0x20) {
        if (m_pIC->isValidSyllable(m_SyllableStr)) {
            convertSyllable(CBone::AUTO_BOUNDARY, m_SyllableStr.size(), mask);
            pressNormalKey(keycode, keyvalue, modifier, mask);
        }
    }
}

/**
 * -# if (IC's skeleton is empty) and (the keyValue is not printable)
 *       --> give it back to IM framework
 * -# ESACPE  --> cancel all sentence (clear IC, update UI)
 * -# RETURN  --> commit the sentence
 * -# LEFT_ARROW RIGHT_ARROW  HOME  END  --> move caret
 * -# DEL BACKSPACE  --> erase properiate bone
 * -# ENState --> call pressNormalKey
 * -# ` (KEY left to key 1)  and CN State and current bone contains only one HANZI -->
 *    - Entering current's characters syllable modifying mode
 *    - else ignore it (CNState)
 *    .
 * -# SPACE:
 *    - if candidates displayed, select the candi, and seek new candidate-list position
 *    - (now, it's CNState) commit the sentence
 *    .
 * -# 1-8:
 *     - if candidates displayed, select the candi, seek new position
 *     - (CNState), Processing normal key
 *     .
 * -# =/-
 *     - If candidates displayed, move its display window
 *     - (CNState), Processing normal key
 *     .
 * -# a-z  --> entering syllable editing inserting mode, return
 * -# call pressNormalKey
 */
void
CIMIModernView::pressKeyOnSentence(unsigned keycode, unsigned keyvalue, unsigned modifier, unsigned int& mask)
{
    //unsigned int key = event->keyval;
    CSunpinyinOptions *ppref = dynamic_cast<CSunpinyinOptions*>(m_pPref);

    if (m_pIC->isEmpty() && !(keyvalue >= 'a' && keyvalue <= 'z'))
      return pressNormalKey(keycode, keyvalue, modifier, mask);

    if (keycode == IM_VK_ESCAPE) {
        mask |= KEYEVENT_USED | clearIC();

    } else if (keycode == IM_VK_ENTER) {
        mask |= KEYEVENT_USED | doCommit(modifier != IM_SHIFT_MASK);
        mask |= clearIC();

    } else if (keycode == IM_VK_HOME || keycode == IM_VK_LEFT) {
        mask |= KEYEVENT_USED;
        if (m_SyllBone != m_pIC->getSkeleton().begin()){
            if (keycode != IM_VK_HOME)
                --m_SyllBone;
            else
                m_SyllBone = m_pIC->getSkeleton().begin();
            m_CandiFirst = 0;
            m_pIC->getCandidates(m_SyllBone, m_CandiList);
            mask |= PREEDIT_MASK | CANDIDATE_MASK;
        }
    } else if (keycode == IM_VK_END || keycode == IM_VK_RIGHT) {
        mask |= KEYEVENT_USED;
        if (m_SyllBone != m_pIC->getLastBone()){
            if (keycode != IM_VK_END)
                ++m_SyllBone;
            else
                m_SyllBone = m_pIC->getLastBone();
            m_CandiFirst = 0;
            m_pIC->getCandidates(m_SyllBone, m_CandiList);
            mask |= KEYEVENT_USED | PREEDIT_MASK | CANDIDATE_MASK;
        }
    } else if (keycode == IM_VK_DELETE) {
        mask |= KEYEVENT_USED;
        if (m_SyllBone != m_pIC->getLastBone()){
            eraseBone(m_SyllBone, mask);
        }
    } else if (keycode == IM_VK_BACK_SPACE) {
        mask |= KEYEVENT_USED;
        if (m_SyllBone != m_pIC->getSkeleton().begin()){
            eraseBone(--CSkeletonIter(m_SyllBone), mask);
        }
    } else if (!m_CN) {
        pressNormalKey(keycode, keyvalue, modifier, mask);
    } else if (keycode == IM_VK_BACK_QUOTE) {
        mask |= KEYEVENT_USED;
        if (m_SyllBone->m_BoneType == CBone::NODE_PINYIN) {
            m_bNewSyll = false;
            m_SyllableStr = m_SyllBone->m_String;
            mask |= PREEDIT_MASK | CANDIDATE_MASK;
        }
    } else if (keyvalue == IM_VK_SPACE) {
        mask |= KEYEVENT_USED;
        if (m_CandiList.size() > 0) {
            makeSelection(0, mask);
        } else { // (m_CN is true)
            mask |= doCommit();
            mask |= clearIC();
        }
    } else if ((keyvalue >= '1' && keyvalue < '1'+s_CandiWindowSize) ||
               (keyvalue == '0' && s_CandiWindowSize == 10))  {
        mask |= KEYEVENT_USED;
        if (m_CandiList.size() > m_CandiFirst + (keyvalue == '0' ? 9 : keyvalue-'1')) {
            makeSelection(keyvalue == '0' ? 9 : keyvalue-'1', mask);
        } else {
            pressNormalKey(keycode, keyvalue, modifier, mask);
        }
    } else if ((ppref != NULL) && (ppref->isPageUpKey(keycode, keyvalue, modifier))) {
        mask |= KEYEVENT_USED;
        if (m_CandiList.size() && m_CandiFirst > 0) {
            m_CandiFirst -= s_CandiWindowSize;
            if (m_CandiFirst < 0) m_CandiFirst = 0;
            mask |= CANDIDATE_MASK;
        }
    } else if ((ppref != NULL) && (ppref->isPageDnKey(keycode, keyvalue, modifier))) {
        mask |= KEYEVENT_USED;
        if (m_CandiFirst + s_CandiWindowSize < m_CandiList.size()) {
            m_CandiFirst += s_CandiWindowSize;
            mask |= CANDIDATE_MASK;
        }
    } else if (keyvalue >= 'a' && keyvalue <= 'z') {
        mask |= KEYEVENT_USED;
        m_bNewSyll = true;
        m_SyllableStr += TWCHAR(keyvalue);

        std::list<CBone> newBones;
        if (m_pIC->segPinyinSimplest(m_SyllableStr, newBones)) {
            mask |= PREEDIT_MASK | CANDIDATE_MASK; //hide the candi-window
        } else {  //invalid Pinyin character, like u, i
            m_SyllableStr.clear();
            pressNormalKey(keycode, keyvalue, modifier, mask);
        }
    } else {
        pressNormalKey(keycode, keyvalue, modifier, mask);
    }
}

int
CIMIModernView::onCandidatePageRequest(int pgno, bool relative)
{
    unsigned changeMasks = 0;
    int      ncandi, lastpgidx;

    if (!m_pIC->isEmpty()) {
        changeMasks |= KEYEVENT_USED;
        int sz = m_CandiList.size();
        if (sz > 0) {
           lastpgidx = (sz-1)/s_CandiWindowSize * s_CandiWindowSize;
           if (relative == true) {
                ncandi = m_CandiFirst + pgno*s_CandiWindowSize;
                if (ncandi >= sz)
                   ncandi = lastpgidx;
                if (ncandi < 0)
                    ncandi = 0;
                if (ncandi != m_CandiFirst) {
                    m_CandiFirst = ncandi;
                    changeMasks |= CANDIDATE_MASK;
                }
            } else {
                if (pgno < 0) { //last page
                    ncandi = lastpgidx;
                } else {
                    ncandi = pgno * s_CandiWindowSize;
                    if (ncandi > lastpgidx)
                        ncandi = lastpgidx;
                }
                if (ncandi != m_CandiFirst) {
                    m_CandiFirst = ncandi;
                    changeMasks |= CANDIDATE_MASK;
                }
            }
        }
    }

    updateWindows(changeMasks);
    return 0;
}

int
CIMIModernView::onCandidateSelectRequest(int index)
{
    unsigned changeMasks = 0;

    if (!m_pIC->isEmpty()) {
        makeSelection(index, changeMasks);
    }
    updateWindows(changeMasks);
    return 0;
}

/**
 * I will change the core to make that every punc/simbol/Eng char be a single
 * bone soon. this could make this function much simpler.
 * -# ch <--  the char of the key press
 * -# not printable, return (nothing changed, the event key is not processed by IMI)
 * -# word id <-- 0
 * -# if is PuncChar and FullPuncState,
 *    - convert ch into Chinese Punc,
 *    - get its word id
 * -# if is Simbol char, convert ch into Chinese Simbol
 * -# insert the char or commit the char
 *     - if (IC's Skeleton is not empty)
 *         - create a bone and insert it into IC's skeleton
 *         - if ch in (A-Z) and in CN state, change the state into EN automatically
 *         .
 *     - else commit the char directly
 */
void
CIMIModernView::pressNormalKey(unsigned keycode, unsigned keyvalue, unsigned modifier, unsigned int& mask)
{
    //unsigned int key = event->keyval;
    unsigned int bone_type = CBone::NODE_ASCII;

    if (keyvalue <= 0x20 || keyvalue >= 0x7F )
        return;
    if (m_FullSimbol)
        keyvalue = (unsigned int)(getFullSimbol(TWCHAR(keyvalue)));
    if (m_FullPunc) {
        keyvalue = (unsigned int)(getFullPunc(TWCHAR(keyvalue)));
        bone_type = CBone::NODE_PUNC;
    }
    if (m_pIC->isEmpty()) {
        mask |= KEYEVENT_USED;
        commitChar(TWCHAR(keyvalue));
    } else {
        mask |= KEYEVENT_USED;
        CBone bone(CBone::AUTO_BOUNDARY, bone_type);
        bone.m_String.clear();
        bone.m_String += TWCHAR(keyvalue);
        insertNonPinyinBone(bone, mask);
    }
}