/*
 * 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 "imi_view_classic.h"
#include "imi_uiobjects.h"

#include "imi_keys.h"

CIMIClassicView::CIMIClassicView() : CIMIView(),
    m_CursorBone(), m_CursorIdx(0), m_CandiBone(),
    m_CandiList(), m_CandiFirst(0), m_TailSentence()
    { }

CIMIClassicView::~CIMIClassicView()
    { }

int
CIMIClassicView::getViewType(void)
    { return CIMIViewFactory::SVT_CLASSIC; }


void
CIMIClassicView::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_pIC->clear();
    m_CursorBone = m_pIC->getLastBone();
    m_CursorIdx = 0;
    m_CandiBone = m_pIC->getLastBone();
    m_CandiList.clear();
    m_CandiFirst = 0;
}

unsigned
CIMIClassicView::clearIC(void)
{
    if (!m_pIC->isEmpty()) {
        m_pIC->clear();
        m_CursorBone = m_pIC->getLastBone();
        m_CursorIdx = 0;
        m_CandiBone = m_pIC->getLastBone();
        m_CandiList.clear();
        m_CandiFirst = 0;
        m_TailSentence.clear();
        return PREEDIT_MASK | CANDIDATE_MASK;
    }
    return 0;
}

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

        if ((mask & PREEDIT_MASK) != 0 || (mask & CANDIDATE_MASK) != 0) {
            int wlen = getSentence(m_TailSentence, m_CandiBone);
            if (wlen <= 1) m_TailSentence.clear();
        }

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

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

    mp_winHandler->commit(wa);
}

void
CIMIClassicView::doCommit(bool bConvert)
{
    wstring bs;

    if (bConvert) {
        getIC()->memorize();
        getSentence(bs, m_pIC->getFirstBone());
        mp_winHandler->commit(bs.c_str());
    } else {
        CSkeletonIter ite = m_pIC->getLastBone();
        for (CSkeletonIter it = m_pIC->getFirstBone(); it != ite; ++it) {
            if (it->isPinyinNode())
                bs += it->m_String;
            else
                bs += (unsigned)it->m_BoundaryType;
            if (it->isPinyinNode() && it->isUserBoundary())
                bs += TWCHAR('\'');
        }
        mp_winHandler->commit(bs.c_str());
    }
}

int
CIMIClassicView::onKeyEvent(unsigned keycode, unsigned keyvalue, unsigned modifier)
{
    unsigned changeMasks = 0;
    CSunpinyinOptions *ppref = dynamic_cast<CSunpinyinOptions*>(m_pPref);

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

    #ifdef DEBUG
        printf("Classic View got a key (0x%x-0x%x-0x%x)...", keycode, keyvalue, modifier);

        if (((modifier & IM_CTRL_MASK) != 0) && (keyvalue == 'P' || keyvalue=='p')) {
            m_pIC->print_lattice();
        }

        fflush(stdout);
    #endif

    if (keycode == IM_VK_SHIFT && modifier == IM_ALT_MASK) {
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_CN, (!m_CN)?1:0);
        return 0;
    } else if (keyvalue == IM_VK_PERIOD && modifier == IM_CTRL_MASK) {
        // On CTRL+. switch Full/Half punc
        changeMasks |= KEYEVENT_USED;
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLPUNC, (!m_FullPunc)?1:0);

    } else if (keyvalue == IM_VK_SPACE && modifier == IM_SHIFT_MASK) {
        // On CTRL+, switch Full/Half simbol
        changeMasks |= KEYEVENT_USED;
        setStatusAttrValue(CIMIWinHandler::STATUS_ID_FULLSIMBOL, (!m_FullSimbol)?1:0);

    } else if (modifier == IM_CTRL_MASK && keycode == IM_VK_LEFT) { //move left syllable
        if (!m_pIC->isEmpty()) {
            changeMasks |= KEYEVENT_USED;
            moveLeftSyllable(changeMasks);
        }

    } else if (modifier == 0 && keycode == IM_VK_LEFT) { //move left
        if (!m_pIC->isEmpty()) {
            changeMasks |= KEYEVENT_USED;
            moveLeft(changeMasks);
        }

    } else if (modifier == IM_CTRL_MASK && keycode == IM_VK_RIGHT) { //move syllable right
        if (!m_pIC->isEmpty()) {
            changeMasks |= KEYEVENT_USED;
            moveRightSyllable(changeMasks);
        }

    } else if (modifier == 0 && keycode == IM_VK_RIGHT) { //move right
        if (!m_pIC->isEmpty()) {
            changeMasks |= KEYEVENT_USED;
            moveRight(changeMasks);
        }

    } else if ((ppref != NULL) && (ppref->isPageUpKey(keycode, keyvalue, modifier)) && !m_pIC->isEmpty()) {
        changeMasks |= KEYEVENT_USED;
        int sz = m_CandiList.size() + ((m_TailSentence.size() > 0)?1:0);
        if (sz > 0 && m_CandiFirst > 0) {
            m_CandiFirst -= s_CandiWindowSize;
            if (m_CandiFirst < 0) m_CandiFirst = 0;
            changeMasks |= CANDIDATE_MASK;
        }

    } else if ((ppref != NULL) && (ppref->isPageDnKey(keycode, keyvalue, modifier)) && !m_pIC->isEmpty()) {
        changeMasks |= KEYEVENT_USED;
        int sz = m_CandiList.size() + ((m_TailSentence.size() > 0)?1:0);
        if (sz > 0 && m_CandiFirst + s_CandiWindowSize < sz) {
            m_CandiFirst += s_CandiWindowSize;
            changeMasks |= CANDIDATE_MASK;
        }

    } else if ((modifier & (IM_CTRL_MASK | IM_ALT_MASK)) == 0) {
        if (islower(keyvalue)) { // insert a PINYIN char
            changeMasks |= KEYEVENT_USED;
            if (m_pIC->getSkeleton().size() < 32) {
                insertPinyin(keyvalue, changeMasks);
            }

        } else if (keycode == IM_VK_BACK_SPACE || keycode == IM_VK_DELETE) { // delete
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                erase((keycode == IM_VK_BACK_SPACE), changeMasks);
            }

        } else if (keycode == IM_VK_HOME) { //move home
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                moveHome(changeMasks);
            }
        } else if (keycode == IM_VK_END) {  //move end
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                moveEnd(changeMasks);
            }

        } else if (keyvalue == '\'') {
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                insertBoundary(changeMasks);
            }

        } else if (isdigit(keyvalue) &&
                   ((s_CandiWindowSize >= 10) ||
                    (s_CandiWindowSize < 10 && keyvalue < ('1'+s_CandiWindowSize)))) { // try to make selections
#ifdef DEBUG
            printf("onKeyEvent:number: %d, %d, %d\n", keycode, keyvalue, s_CandiWindowSize);
#endif
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                unsigned selection = (keyvalue == '0' ? 9 : keyvalue-'1');
                makeSelection(selection, changeMasks);
            }

        } else if (keyvalue == IM_VK_SPACE) { // select or commit
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED;
                makeSelection(0, changeMasks);
            }

        } else if (keycode == IM_VK_ENTER) { // commit PINYIN string
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED | CANDIDATE_MASK | PREEDIT_MASK;
                doCommit(false);
                clearIC();
            }

        } else if (keycode == IM_VK_ESCAPE) {
            if (!m_pIC->isEmpty()) {
                changeMasks |= KEYEVENT_USED | CANDIDATE_MASK | PREEDIT_MASK;
                clearIC();
            }
        } else if (keyvalue > 0x20 && keyvalue < 0x7F ) { // isprint() && !isblank()
            if (m_pIC->getSkeleton().size() < 32)
                pressNormalKey(keyvalue, changeMasks);
            else
                changeMasks |= KEYEVENT_USED;
        }
    }

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

    updateWindows(changeMasks);

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

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

    if (!m_pIC->isEmpty()) {
        changeMasks |= KEYEVENT_USED;
        int sz = m_CandiList.size() + ((m_TailSentence.size() > 0)?1:0);
        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 == -1) { //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
CIMIClassicView::onCandidateSelectRequest(int index)
{
    unsigned changeMasks = 0;

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


void
CIMIClassicView::pressNormalKey(unsigned keyvalue, unsigned int& mask)
{
    unsigned orig_key = keyvalue;
    unsigned int bone_type = CBone::NODE_ASCII;

    if (m_FullSimbol) {
        keyvalue = (unsigned int)(getFullSimbol(TWCHAR(keyvalue)));
    }
    if (m_FullPunc) {
        keyvalue = (unsigned int)(getFullPunc(TWCHAR(keyvalue)));
        bone_type = CBone::NODE_PUNC;
    }
    mask |= KEYEVENT_USED;
    if (m_pIC->isEmpty()) {
        commitChar(TWCHAR(keyvalue));
    } else {
        insertNormalChar(bone_type, orig_key, keyvalue, mask);
    }
}

CSkeletonIter
CIMIClassicView::moveLeft(unsigned int& changeMask, bool searchAgain)
{
    CSkeletonIter leftmost = m_pIC->getLastBone();
    if (m_CursorIdx > 0) {
        --m_CursorIdx;
        changeMask |= PREEDIT_MASK;
    } else if (m_CursorBone != m_pIC->getFirstBone()) {
        changeMask |= PREEDIT_MASK;
        if (m_CursorBone-- == m_CandiBone) {
            changeMask |= CANDIDATE_MASK;
            if (m_CursorBone->isValidPinyinNode()) {
                leftmost = m_CandiBone = m_pIC->cancelSelection(m_CursorBone, searchAgain);
            } else {
                m_CandiBone = m_CursorBone;
            }
            getCandidates();
        }

        m_CursorIdx = m_CursorBone->m_String.size();
        if (!m_CursorBone->isPinyinNode())
            --m_CursorIdx;
    } // else we already at head of the string
    return leftmost;
}

CSkeletonIter
CIMIClassicView::moveLeftSyllable(unsigned int& changeMask, bool searchAgain)
{
    CSkeletonIter leftmost = m_pIC->getLastBone();
    if (m_CursorIdx > 0) {
        m_CursorIdx = 0;
        changeMask |= PREEDIT_MASK;
    } else if (m_CursorBone != m_pIC->getFirstBone()) {
        changeMask |= PREEDIT_MASK;
        if (m_CursorBone-- == m_CandiBone) {
            changeMask |= CANDIDATE_MASK;
            if (m_CursorBone->isValidPinyinNode()) {
                leftmost = m_CandiBone = m_pIC->cancelSelection(m_CursorBone, searchAgain);
            } else {
                m_CandiBone = m_CursorBone;
            }
            getCandidates();
        }
        m_CursorIdx = 0;
    }  // else we already at head of the string
    return leftmost;
}

CSkeletonIter
CIMIClassicView::moveHome(unsigned int& changeMask, bool searchAgain)
{
    CSkeletonIter leftmost = m_pIC->getLastBone();
    CSkeletonIter firstBone = m_pIC->getFirstBone();

    if (m_CursorBone != firstBone || m_CursorIdx != 0)
        changeMask |= PREEDIT_MASK;

    if (m_CandiBone != firstBone) {
        bool usCanceled = false;
        for (CSkeletonIter bit = m_pIC->getFirstBone(); bit != m_CandiBone; ++bit) {
            if (bit->isValidPinyinNode() && bit->isUserSelectionStart()) {
                m_pIC->cancelSelection(bit, false);
                usCanceled = true;
            }
        }
        if (usCanceled) {
            changeMask |= CANDIDATE_MASK;
            leftmost = m_CandiBone = firstBone;
            getCandidates();
            if (searchAgain) m_pIC->searchFrom(firstBone);
        }
    }
    m_CursorIdx = 0;
    m_CursorBone = firstBone;
    return leftmost;
}

void
CIMIClassicView::moveRight(unsigned int& changeMask)
{
    CSkeletonIter itLast = m_pIC->getLastBone();
    if (m_CursorBone != itLast) {
        CSkeletonIter itNext = ++CSkeletonIter(m_CursorBone);
        if (m_CursorIdx < m_CursorBone->m_String.size()-1) {
            ++m_CursorIdx;
            changeMask |= PREEDIT_MASK;
        } else if (m_CursorIdx == m_CursorBone->m_String.size()-1) {
            if (m_CursorBone->isPinyinNode()) {
                ++m_CursorIdx;
                changeMask |= PREEDIT_MASK;
            } else {
                m_CursorIdx = 0;
                ++m_CursorBone;
                changeMask |= PREEDIT_MASK;
            }
        } else { // m_CursorIdx == m_CursorBone->m_String.size(), must be PinyinNode
            if (itNext != itLast || m_CursorBone->isUserBoundary()) {
                m_CursorIdx = 0;
                ++m_CursorBone;
                changeMask |= PREEDIT_MASK;
            }
        }
    }
}

void
CIMIClassicView::moveRightSyllable(unsigned int& changeMask)
{
    CSkeletonIter itLast = m_pIC->getLastBone();
    if (m_CursorBone != itLast) {
        CSkeletonIter itNext = ++CSkeletonIter(m_CursorBone);
        if (itNext == itLast && m_CursorBone->isPinyinNode() && !m_CursorBone->isUserBoundary()) {
            if (m_CursorIdx != m_CursorBone->m_String.size()) {
                m_CursorIdx = m_CursorBone->m_String.size();
                changeMask |= PREEDIT_MASK;
            } // else we already at tail
        } else {
            m_CursorIdx = 0;
            ++m_CursorBone;
            changeMask |= PREEDIT_MASK;
        }
    }
}

void
CIMIClassicView::moveEnd(unsigned int& changeMask)
{
    CSkeletonIter itLast = m_pIC->getLastBone();
    if (m_CursorBone != itLast) {
        CSkeletonIter itPrev = --CSkeletonIter(itLast);
        if (m_CursorBone != itPrev) {
            m_CursorBone = itPrev;
            m_CursorIdx = 0;
        }
        moveRightSyllable(changeMask);
    }
}

void
CIMIClassicView::erase(bool bLeft, unsigned int& changeMask)
{
    if (bLeft && m_CursorBone == m_pIC->getFirstBone() && m_CursorIdx == 0) return;
    if (!bLeft && cursorAtTail()) return;

    // default stick direction here
    bool stickLeft = bLeft;

    if (bLeft)  moveLeft(changeMask);

    changeMask |= PREEDIT_MASK;
    if (m_CursorBone->m_String.size() == m_CursorIdx){
        if (m_CursorBone->m_BoundaryType == CBone::USER_BOUNDARY) {
            CSkeleton skel;
            CSkeletonIter old_cursor = m_CursorBone;
            skel.push_front(*old_cursor);
            skel.front().m_BoundaryType = CBone::AUTO_BOUNDARY;
            m_CursorBone = skel.begin();
            bool upd_candi = m_pIC->modifyAndReseg(
                        old_cursor, ++CSkeletonIter(old_cursor), skel,
                        m_CursorBone, m_CursorIdx, m_CandiBone,
                        stickLeft, true
                    );
            if (upd_candi) getCandidates();
            changeMask |= CANDIDATE_MASK;
        } else {
            if (!bLeft) moveRight(changeMask);
        }
    } else {
        CSkeleton skel;
        CSkeletonIter old_cursor = m_CursorBone;
        skel.push_front(*old_cursor);
        skel.front().m_String.erase(m_CursorIdx, 1);
        if (skel.front().m_String.size() == 0) {
            skel.pop_front();
            m_CursorBone = skel.end();
            m_CursorIdx = 0;
        } else {
            if (m_CursorIdx == 0)
                stickLeft = false;
            else if (m_CursorIdx == m_CursorBone->m_String.size()-1)
                stickLeft = true;
            m_CursorBone = skel.begin();
        }
        bool upd_candi = m_pIC->modifyAndReseg(
                    old_cursor, ++CSkeletonIter(old_cursor), skel,
                    m_CursorBone, m_CursorIdx, m_CandiBone,
                    stickLeft, true
                );
        if (upd_candi) getCandidates();
        changeMask |= CANDIDATE_MASK;
    }
}

void
CIMIClassicView::insertPinyin(unsigned int keyvalue, unsigned int& changeMask)
{
    CSkeleton skel;
    CSkeletonIter cursor1 = m_CursorBone, cursor2 = m_CursorBone;

    changeMask |= PREEDIT_MASK | CANDIDATE_MASK;
    if (m_CursorBone == m_pIC->getLastBone()) {
        skel.push_front(CBone((const TWCHAR*)&keyvalue, 1, CBone::AUTO_BOUNDARY, CBone::NODE_PINYIN));
        m_CursorBone = skel.begin();
        m_CursorIdx = 1;
    } else if (!m_CursorBone->isPinyinNode()){
        // The cursor could not on the tail of non-pinyin nodes
        if (m_CursorIdx > 0) {
            ++cursor2;
            skel.push_back(CBone(*m_CursorBone));
            skel.back().m_String.erase(m_CursorIdx);
            skel.push_back(CBone((const TWCHAR*)&keyvalue, 1, CBone::AUTO_BOUNDARY, CBone::NODE_PINYIN));
            skel.push_back(CBone(*m_CursorBone));
            skel.back().m_String.erase(0, m_CursorIdx);
            m_CursorBone = skel.begin(); ++m_CursorBone;
            m_CursorIdx = 1;
        } else {
            skel.push_front(CBone((const TWCHAR*)&keyvalue, 1, CBone::AUTO_BOUNDARY, CBone::NODE_PINYIN));
            m_CursorBone = skel.begin();
            m_CursorIdx = 0;
        }
    } else {
        skel.push_front(*m_CursorBone);
        skel.front().m_String.insert(m_CursorIdx, 1, TWCHAR(keyvalue));
        m_CursorBone = skel.begin();
        ++m_CursorIdx;
        ++cursor2;
    }

    bool upd_candi = m_pIC->modifyAndReseg(cursor1, cursor2, skel, m_CursorBone, m_CursorIdx, m_CandiBone);

    if (upd_candi) getCandidates();
}

void
CIMIClassicView::insertBoundary(unsigned int& changeMask)
{
    CSkeletonIter itLast = m_pIC->getLastBone();
    CSkeletonIter itFirst = m_pIC->getFirstBone();

    if (m_CursorIdx == 0) {
        if (m_CursorBone != itFirst) {
            CSkeletonIter itPrev = --CSkeletonIter(m_CursorBone);
            if (itPrev->isPinyinNode() && itPrev->isAutoBoundary()) {
                changeMask |= PREEDIT_MASK; // Only the color of the boundary needed to be updated
                itPrev->m_BoundaryType = CBone::USER_BOUNDARY;
            }
        }
    } else if (m_CursorBone != itLast && m_CursorIdx == m_CursorBone->m_String.size()) {
        if (m_CursorBone->isAutoBoundary()) { // hidden condition: it is a pinyin node
            changeMask |= PREEDIT_MASK; // Only the color of the boundary needed to be updated
            m_CursorBone->m_BoundaryType = CBone::USER_BOUNDARY;
            moveRight(changeMask);
        }
    } else if (m_CursorBone != itLast && m_CursorIdx < m_CursorBone->m_String.size()) {
        if (m_CursorBone->isPinyinNode()) {
            changeMask |= PREEDIT_MASK | CANDIDATE_MASK;

            if (m_CursorBone != itFirst) {
                bool saveNonCompleteSyllable = m_pIC->canNonCompleteSyllable();
                m_pIC->setNonCompleteSyllable(false);
                do { // whether current syllable should be connected with the previous one.
                    CSkeletonIter itPrev = --CSkeletonIter(m_CursorBone);
                    if (!itPrev->isAutoBoundary()) break;

                    std::list<CBone> newBones;
                    wstring newSyllable;

                    newSyllable.append(m_CursorBone->m_String, 0, m_CursorIdx);
                    m_pIC->segPinyinSimplest(newSyllable, newBones);
                    if ( !(newBones.size() == 0 || newBones.front().m_BoneType == CBone::NODE_INCOMPLETE_PINYIN) ) break;

                    newBones.clear();
                    newSyllable.insert(0, itPrev->m_String);
                    m_pIC->segPinyinSimplest(newSyllable, newBones);
                    if (newBones.size() != 1 || newBones.front().m_BoneType != CBone::NODE_PINYIN) break;

                    m_pIC->setNonCompleteSyllable(saveNonCompleteSyllable);

                    newBones.front().m_BoundaryType = CBone::USER_BOUNDARY;
                    m_pIC->modify(itPrev, m_CursorBone, newBones);
                    if (m_CandiBone == itPrev)
                        m_CandiBone = --CSkeletonIter(m_CursorBone);

                    CSkeleton skel;
                    CSkeletonIter cursor1 = m_CursorBone;
                    CSkeletonIter cursor2 = m_CursorBone;
                    ++cursor2;

                    skel.push_back(CBone(*m_CursorBone));
                    skel.back().m_String.erase(0, m_CursorIdx);
                    m_CursorBone = skel.begin();
                    m_CursorIdx = 0;
                    m_pIC->modifyAndReseg(
                            cursor1, cursor2, skel,
                            m_CursorBone, m_CursorIdx, m_CandiBone, false
                        );
                    getCandidates();
                    return;
                } while (false);
                m_pIC->setNonCompleteSyllable(saveNonCompleteSyllable);
            }

            CSkeleton skel;
            CSkeletonIter cursor1 = m_CursorBone;
            CSkeletonIter cursor2 = m_CursorBone;
            ++cursor2;

            skel.push_back(CBone(*m_CursorBone));
            skel.back().m_String.erase(m_CursorIdx);
            skel.back().m_BoundaryType = CBone::USER_BOUNDARY;
            skel.push_back(CBone(*m_CursorBone));
            skel.back().m_String.erase(0, m_CursorIdx);
            m_CursorBone = skel.begin();
            ++m_CursorBone;
            m_CursorIdx = 0;
            bool upd_candi = m_pIC->modifyAndReseg(
                    cursor1, cursor2, skel,
                    m_CursorBone, m_CursorIdx, m_CandiBone, false
                );
            if (upd_candi) getCandidates();
        }
    }
}

int
CIMIClassicView::getSentence(wstring& wstr, CSkeletonIter itStart)
{
    return m_pIC->getBestSentence(wstr, itStart, m_pIC->getLastBone());
}

void
CIMIClassicView::insertNormalChar(int boneType, unsigned originalKey, unsigned keyvalue, unsigned int& mask)
{
    CSkeleton skel;
    CSkeletonIter cursor1;
    CSkeletonIter cursor2;
    CSkeletonIter ite = m_pIC->getLastBone();
    mask |= PREEDIT_MASK | CANDIDATE_MASK;
    if (m_CursorBone == ite || m_CursorBone->m_String.size() == 0) {
        cursor1 = cursor2 = m_CursorBone;
        skel.push_back(CBone((TWCHAR*)&keyvalue, 1, originalKey, boneType));
    } else if (m_CursorBone != ite && m_CursorBone->m_String.size() == m_CursorIdx) {
        cursor1 = cursor2 = ++m_CursorBone;
        skel.push_back(CBone((TWCHAR*)&keyvalue, 1, originalKey, boneType));
        m_CursorBone = skel.begin();
        ++m_CursorBone;
        m_CursorIdx = 0;

    } else {
        cursor1 = cursor2 = m_CursorBone; ++cursor2;
        skel.push_back(CBone(*m_CursorBone));
        skel.back().m_String.erase(m_CursorIdx);
        skel.push_back(CBone((TWCHAR*)&keyvalue, 1, originalKey, boneType));
        skel.push_back(CBone(*m_CursorBone));
        skel.back().m_String.erase(0, m_CursorIdx);
        m_CursorBone = skel.begin();
        ++(++m_CursorBone);
        m_CursorIdx = 0;
    }
    bool upd_candi = m_pIC->modifyAndReseg(cursor1, cursor2, skel, m_CursorBone,
                                           m_CursorIdx, m_CandiBone, false);
    if (upd_candi) getCandidates();
}

void
CIMIClassicView::getCandidates()
{
    m_CandiFirst = 0;
    m_pIC->getCandidates(m_CandiBone, m_CandiList);
}

bool
CIMIClassicView::cursorAtTail()
{
    CSkeletonIter itLast = m_pIC->getLastBone();
    if (m_CursorBone == itLast)
        return true;
    CSkeletonIter itNext = ++CSkeletonIter(m_CursorBone);
    return (itNext == itLast && m_CursorBone->m_String.size() == m_CursorIdx && !m_CursorBone->isUserBoundary());
    // Hidden condition m_CursorBone->isPinyinNode() == true
}

void
CIMIClassicView::makeSelection(int idx, unsigned int& mask)
{
    idx += m_CandiFirst;
    if (m_TailSentence.size() > 0) --idx;
    if (idx < 0) {
        mask |= PREEDIT_MASK | CANDIDATE_MASK;
        doCommit(true);
        clearIC();
    } else if (idx < m_CandiList.size()) {
        mask |= PREEDIT_MASK | CANDIDATE_MASK;
        CCandidate& cand = m_CandiList[idx];
        m_pIC->makeSelection(cand);
        m_CandiBone = cand.m_BoneEnd;
        while (!m_CandiBone->isTailNode() && !m_CandiBone->isPinyinNode())
            ++m_CandiBone;
        if (m_CandiBone->isTailNode()) {
            doCommit(true);
            clearIC();
        } else {
            for (CSkeletonIter it=cand.m_BoneStart; it != m_CandiBone; ++it) {
                if (m_CursorBone == it) {
                    m_CursorBone = m_CandiBone;
                    m_CursorIdx = 0;
                    break;
                }
            }
            m_CandiFirst = 0;
            getCandidates();
        }
    }
}

void
CIMIClassicView::getPreeditString(IPreeditString& ps)
{
    ps.clear();

    wstring & wstr = ps.getString();
    IPreeditString::CCharTypeVec& charTypes = ps.getCharTypeVec();

    m_pIC->getBestSentence(wstr, m_pIC->getFirstBone(), m_CandiBone);

    int caret = wstr.size();
    charTypes.reserve(caret);
    for (int i=0; i < caret; ++i)
        charTypes.push_back(IPreeditString::HANZI_CHAR | IPreeditString::USER_CHOICE);
    ps.setCandiStart(caret);

    CSkeletonIter ite = m_pIC->getLastBone();
    for (CSkeletonIter it = m_CandiBone; it != ite; ) {
        CSkeletonIter curIt = it++;
        if (curIt == m_CursorBone)
            caret = wstr.size() + m_CursorIdx;

        if (curIt->isPinyinNode())
            wstr += curIt->m_String;
        else
            wstr.push_back((unsigned)curIt->m_BoundaryType);

        int ct = IPreeditString::PINYIN_CHAR;
        if (curIt->m_BoneType == CBone::NODE_INVALID_PINYIN)
            ct |= IPreeditString::ILLEGAL;
        else if (curIt->m_BoneType == CBone::NODE_ASCII)
            ct = IPreeditString::ASCII_CHAR;
        else if (!curIt->isPinyinNode())
            ct = IPreeditString::SIMBOL_CHAR;

        for (int i=0; i < curIt->m_String.size(); ++i)
            charTypes.push_back(ct);

        if (curIt->isPinyinNode()) {
            if (curIt->m_BoundaryType == CBone::USER_BOUNDARY) {
                wstr += '\'';
                charTypes.push_back(IPreeditString::BOUNDARY);
            } else if (it != ite) {
                wstr += ' ';
                charTypes.push_back(IPreeditString::BOUNDARY | IPreeditString::USER_CHOICE);
            }
        }
    }
    if (m_CursorBone == ite)
        caret = wstr.size();
    ps.setCaret(caret);
}

void
CIMIClassicView::getCandidateList(ICandidateList& cl, int start, int size)
{
    cl.clear();
    cl.reserve(size);

    int  tscount = (m_TailSentence.size() > 0)?1:0;

    cl.setFirst(start);
    cl.setTotal(tscount + m_CandiList.size());
    ICandidateList::CCandiStrings& css = cl.getCandiStrings();
    ICandidateList::CCandiTypeVec& cts = cl.getCandiTypeVec();

    //Loop used for future n-best sentence candidates usage
    for (; start < tscount && size > 0; ++start, --size) {
        css.push_back(m_TailSentence);
        cts.push_back(ICandidateList::BEST_TAIL);
    }

    start -= tscount;
    for (int sz=m_CandiList.size(); start < sz && size > 0; ++start, --size) {
        css.push_back(m_CandiList[start].m_String);
        cts.push_back( (start == 0)?(ICandidateList::BEST_WORD):(ICandidateList::NORMAL_WORD) );
    }
}

Indexes created Sat Nov 07 16:53:30 UTC 2009

Terms of Use | Privacy | Trademarks | Copyright Policy | Site Guidelines | Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.