/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_i18npool.hxx" #include #include #include #include #include #include #include #include U_CDECL_BEGIN extern const char OpenOffice_dat[]; U_CDECL_END using namespace ::com::sun::star; using namespace ::com::sun::star::lang; using namespace ::rtl; namespace com { namespace sun { namespace star { namespace i18n { #define ERROR ::com::sun::star::uno::RuntimeException() //#define ImplementName "com.sun.star.i18n.BreakIterator_Unicode"; BreakIterator_Unicode::BreakIterator_Unicode() : cBreakIterator( "com.sun.star.i18n.BreakIterator_Unicode" ), // implementation name wordRule( "word" ), lineRule( "line" ), result(), character(), word(), sentence(), line(), icuBI( NULL ), aLocale(), aBreakType(), aWordType() { } BreakIterator_Unicode::~BreakIterator_Unicode() { if (icuBI && icuBI->aBreakIterator) { delete icuBI->aBreakIterator; icuBI->aBreakIterator=NULL; } if (character.aBreakIterator) delete character.aBreakIterator; if (word.aBreakIterator) delete word.aBreakIterator; if (sentence.aBreakIterator) delete sentence.aBreakIterator; if (line.aBreakIterator) delete line.aBreakIterator; } /* Wrapper class to provide public access to the RuleBasedBreakIterator's setbreakType method. */ class OOoRuleBasedBreakIterator : public RuleBasedBreakIterator { public: inline void publicSetBreakType(int32_t type) { setBreakType(type); }; OOoRuleBasedBreakIterator(UDataMemory* image, UErrorCode &status) : RuleBasedBreakIterator(image, status) { }; }; // loading ICU breakiterator on demand. void SAL_CALL BreakIterator_Unicode::loadICUBreakIterator(const com::sun::star::lang::Locale& rLocale, sal_Int16 rBreakType, sal_Int16 rWordType, const sal_Char *rule, const OUString& rText) throw(uno::RuntimeException) { sal_Bool newBreak = sal_False; UErrorCode status = U_ZERO_ERROR; sal_Int16 breakType = 0; switch (rBreakType) { case LOAD_CHARACTER_BREAKITERATOR: icuBI=&character; breakType = 3; break; case LOAD_WORD_BREAKITERATOR: icuBI=&word; switch (rWordType) { case WordType::ANYWORD_IGNOREWHITESPACES: breakType = 0; rule=wordRule = "edit_word"; break; case WordType::DICTIONARY_WORD: breakType = 1; rule=wordRule = "dict_word"; break; case WordType::WORD_COUNT: breakType = 2; rule=wordRule = "count_word"; break; } break; case LOAD_SENTENCE_BREAKITERATOR: icuBI=&sentence; breakType = 5; break; case LOAD_LINE_BREAKITERATOR: icuBI=&line; breakType = 4; break; } if (!icuBI->aBreakIterator || rWordType != aWordType || rLocale.Language != aLocale.Language || rLocale.Country != aLocale.Country || rLocale.Variant != aLocale.Variant) { if (icuBI->aBreakIterator) { delete icuBI->aBreakIterator; icuBI->aBreakIterator=NULL; } if (rule) { uno::Sequence< OUString > breakRules = LocaleData().getBreakIteratorRules(rLocale); status = U_ZERO_ERROR; udata_setAppData("OpenOffice", OpenOffice_dat, &status); if ( !U_SUCCESS(status) ) throw ERROR; OOoRuleBasedBreakIterator *rbi = NULL; if (breakRules.getLength() > breakType && breakRules[breakType].getLength() > 0) { rbi = new OOoRuleBasedBreakIterator(udata_open("OpenOffice", "brk", OUStringToOString(breakRules[breakType], RTL_TEXTENCODING_ASCII_US).getStr(), &status), status); } else { status = U_ZERO_ERROR; OStringBuffer aUDName(64); aUDName.append(rule); aUDName.append('_'); aUDName.append( OUStringToOString(rLocale.Language, RTL_TEXTENCODING_ASCII_US)); UDataMemory* pUData = udata_open("OpenOffice", "brk", aUDName.getStr(), &status); if( U_SUCCESS(status) ) rbi = new OOoRuleBasedBreakIterator( pUData, status); if (!U_SUCCESS(status) ) { status = U_ZERO_ERROR; pUData = udata_open("OpenOffice", "brk", rule, &status); if( U_SUCCESS(status) ) rbi = new OOoRuleBasedBreakIterator( pUData, status); if (!U_SUCCESS(status) ) icuBI->aBreakIterator=NULL; } } if (rbi) { switch (rBreakType) { case LOAD_CHARACTER_BREAKITERATOR: rbi->publicSetBreakType(UBRK_CHARACTER); break; case LOAD_WORD_BREAKITERATOR: rbi->publicSetBreakType(UBRK_WORD); break; case LOAD_SENTENCE_BREAKITERATOR: rbi->publicSetBreakType(UBRK_SENTENCE); break; case LOAD_LINE_BREAKITERATOR: rbi->publicSetBreakType(UBRK_LINE); break; } icuBI->aBreakIterator = rbi; } } if (!icuBI->aBreakIterator) { icu::Locale icuLocale( OUStringToOString(rLocale.Language, RTL_TEXTENCODING_ASCII_US).getStr(), OUStringToOString(rLocale.Country, RTL_TEXTENCODING_ASCII_US).getStr(), OUStringToOString(rLocale.Variant, RTL_TEXTENCODING_ASCII_US).getStr()); status = U_ZERO_ERROR; switch (rBreakType) { case LOAD_CHARACTER_BREAKITERATOR: icuBI->aBreakIterator = icu::BreakIterator::createCharacterInstance(icuLocale, status); break; case LOAD_WORD_BREAKITERATOR: icuBI->aBreakIterator = icu::BreakIterator::createWordInstance(icuLocale, status); break; case LOAD_SENTENCE_BREAKITERATOR: icuBI->aBreakIterator = icu::BreakIterator::createSentenceInstance(icuLocale, status); break; case LOAD_LINE_BREAKITERATOR: icuBI->aBreakIterator = icu::BreakIterator::createLineInstance(icuLocale, status); break; } if ( !U_SUCCESS(status) ) { icuBI->aBreakIterator=NULL; throw ERROR; } } if (icuBI->aBreakIterator) { aLocale=rLocale; aWordType=rWordType; aBreakType=rBreakType; newBreak=sal_True; } else { throw ERROR; } } if (newBreak || icuBI->aICUText.compare(UnicodeString(reinterpret_cast(rText.getStr()), rText.getLength()))) { // UChar != sal_Unicode in MinGW icuBI->aICUText=UnicodeString(reinterpret_cast(rText.getStr()), rText.getLength()); icuBI->aBreakIterator->setText(icuBI->aICUText); } } sal_Int32 SAL_CALL BreakIterator_Unicode::nextCharacters( const OUString& Text, sal_Int32 nStartPos, const lang::Locale &rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone ) throw(uno::RuntimeException) { if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text); for (nDone = 0; nDone < nCount; nDone++) { nStartPos = character.aBreakIterator->following(nStartPos); if (nStartPos == BreakIterator::DONE) return Text.getLength(); } } else { // for CHARACTER mode for (nDone = 0; nDone < nCount && nStartPos < Text.getLength(); nDone++) Text.iterateCodePoints(&nStartPos, 1); } return nStartPos; } sal_Int32 SAL_CALL BreakIterator_Unicode::previousCharacters( const OUString& Text, sal_Int32 nStartPos, const lang::Locale& rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone ) throw(uno::RuntimeException) { if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text); for (nDone = 0; nDone < nCount; nDone++) { nStartPos = character.aBreakIterator->preceding(nStartPos); if (nStartPos == BreakIterator::DONE) return 0; } } else { // for BS to delete one char and CHARACTER mode. for (nDone = 0; nDone < nCount && nStartPos > 0; nDone++) Text.iterateCodePoints(&nStartPos, -1); } return nStartPos; } Boundary SAL_CALL BreakIterator_Unicode::nextWord( const OUString& Text, sal_Int32 nStartPos, const lang::Locale& rLocale, sal_Int16 rWordType ) throw(uno::RuntimeException) { loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text); result.startPos = word.aBreakIterator->following(nStartPos); if( result.startPos >= Text.getLength() || result.startPos == BreakIterator::DONE ) result.endPos = result.startPos; else { if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES || rWordType == WordType::DICTIONARY_WORD ) && u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) ) result.startPos = word.aBreakIterator->following(result.startPos); result.endPos = word.aBreakIterator->following(result.startPos); if(result.endPos == BreakIterator::DONE) result.endPos = result.startPos; } return result; } Boundary SAL_CALL BreakIterator_Unicode::previousWord(const OUString& Text, sal_Int32 nStartPos, const lang::Locale& rLocale, sal_Int16 rWordType) throw(uno::RuntimeException) { loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text); result.startPos = word.aBreakIterator->preceding(nStartPos); if( result.startPos < 0 || result.startPos == BreakIterator::DONE) result.endPos = result.startPos; else { if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES || rWordType == WordType::DICTIONARY_WORD) && u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) ) result.startPos = word.aBreakIterator->preceding(result.startPos); result.endPos = word.aBreakIterator->following(result.startPos); if(result.endPos == BreakIterator::DONE) result.endPos = result.startPos; } return result; } Boundary SAL_CALL BreakIterator_Unicode::getWordBoundary( const OUString& Text, sal_Int32 nPos, const lang::Locale& rLocale, sal_Int16 rWordType, sal_Bool bDirection ) throw(uno::RuntimeException) { loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text); sal_Int32 len = Text.getLength(); if(word.aBreakIterator->isBoundary(nPos)) { result.startPos = result.endPos = nPos; if((bDirection || nPos == 0) && nPos < len) //forward result.endPos = word.aBreakIterator->following(nPos); else result.startPos = word.aBreakIterator->preceding(nPos); } else { if(nPos <= 0) { result.startPos = 0; result.endPos = len ? word.aBreakIterator->following((sal_Int32)0) : 0; } else if(nPos >= len) { result.startPos = word.aBreakIterator->preceding(len); result.endPos = len; } else { result.startPos = word.aBreakIterator->preceding(nPos); result.endPos = word.aBreakIterator->following(nPos); } } if (result.startPos == BreakIterator::DONE) result.startPos = result.endPos; else if (result.endPos == BreakIterator::DONE) result.endPos = result.startPos; return result; } sal_Int32 SAL_CALL BreakIterator_Unicode::beginOfSentence( const OUString& Text, sal_Int32 nStartPos, const lang::Locale &rLocale ) throw(uno::RuntimeException) { loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text); sal_Int32 len = Text.getLength(); if (len > 0 && nStartPos == len) Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence if (!sentence.aBreakIterator->isBoundary(nStartPos)) nStartPos = sentence.aBreakIterator->preceding(nStartPos); // skip preceding space. sal_uInt32 ch = Text.iterateCodePoints(&nStartPos, 1); while (nStartPos < len && u_isWhitespace(ch)) ch = Text.iterateCodePoints(&nStartPos, 1); Text.iterateCodePoints(&nStartPos, -1); return nStartPos; } sal_Int32 SAL_CALL BreakIterator_Unicode::endOfSentence( const OUString& Text, sal_Int32 nStartPos, const lang::Locale &rLocale ) throw(uno::RuntimeException) { loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text); sal_Int32 len = Text.getLength(); if (len > 0 && nStartPos == len) Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence nStartPos = sentence.aBreakIterator->following(nStartPos); sal_Int32 nPos=nStartPos; while (nPos > 0 && u_isWhitespace(Text.iterateCodePoints(&nPos, -1))) nStartPos=nPos; return nStartPos; } LineBreakResults SAL_CALL BreakIterator_Unicode::getLineBreak( const OUString& Text, sal_Int32 nStartPos, const lang::Locale& rLocale, sal_Int32 nMinBreakPos, const LineBreakHyphenationOptions& hOptions, const LineBreakUserOptions& /*rOptions*/ ) throw(uno::RuntimeException) { LineBreakResults lbr; if (nStartPos >= Text.getLength()) { lbr.breakIndex = Text.getLength(); lbr.breakType = BreakType::WORDBOUNDARY; return lbr; } loadICUBreakIterator(rLocale, LOAD_LINE_BREAKITERATOR, 0, lineRule, Text); sal_Bool GlueSpace=sal_True; while (GlueSpace) { if (line.aBreakIterator->preceding(nStartPos + 1) == nStartPos) { //Line boundary break lbr.breakIndex = nStartPos; lbr.breakType = BreakType::WORDBOUNDARY; } else if (hOptions.rHyphenator.is()) { //Hyphenation break Boundary wBoundary = getWordBoundary( Text, nStartPos, rLocale, WordType::DICTIONARY_WORD, false); uno::Reference< linguistic2::XHyphenatedWord > aHyphenatedWord; aHyphenatedWord = hOptions.rHyphenator->hyphenate(Text.copy(wBoundary.startPos, wBoundary.endPos - wBoundary.startPos), rLocale, (sal_Int16) (hOptions.hyphenIndex - wBoundary.startPos), hOptions.aHyphenationOptions); if (aHyphenatedWord.is()) { lbr.rHyphenatedWord = aHyphenatedWord; if(wBoundary.startPos + aHyphenatedWord->getHyphenationPos() + 1 < nMinBreakPos ) lbr.breakIndex = -1; else lbr.breakIndex = wBoundary.startPos; //aHyphenatedWord->getHyphenationPos(); lbr.breakType = BreakType::HYPHENATION; } else { lbr.breakIndex = line.aBreakIterator->preceding(nStartPos); lbr.breakType = BreakType::WORDBOUNDARY;; } } else { //word boundary break lbr.breakIndex = line.aBreakIterator->preceding(nStartPos); lbr.breakType = BreakType::WORDBOUNDARY; } #define WJ 0x2060 // Word Joiner GlueSpace=sal_False; if (lbr.breakType == BreakType::WORDBOUNDARY) { nStartPos = lbr.breakIndex; if (Text[nStartPos--] == WJ) GlueSpace=sal_True; while (nStartPos >= 0 && (u_isWhitespace(Text.iterateCodePoints(&nStartPos, 0)) || Text[nStartPos] == WJ)) { if (Text[nStartPos--] == WJ) GlueSpace=sal_True; } if (GlueSpace && nStartPos < 0) { lbr.breakIndex = 0; break; } } } return lbr; } OUString SAL_CALL BreakIterator_Unicode::getImplementationName(void) throw( uno::RuntimeException ) { return OUString::createFromAscii(cBreakIterator); } sal_Bool SAL_CALL BreakIterator_Unicode::supportsService(const OUString& rServiceName) throw( uno::RuntimeException ) { return !rServiceName.compareToAscii(cBreakIterator); } uno::Sequence< OUString > SAL_CALL BreakIterator_Unicode::getSupportedServiceNames(void) throw( uno::RuntimeException ) { uno::Sequence< OUString > aRet(1); aRet[0] = OUString::createFromAscii(cBreakIterator); return aRet; } } } } }