LCOV - code coverage report
Current view: top level - include/editeng - hangulhanja.hxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 6 6 100.0 %
Date: 2015-06-13 12:38:46 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : #ifndef INCLUDED_EDITENG_HANGULHANJA_HXX
      20             : #define INCLUDED_EDITENG_HANGULHANJA_HXX
      21             : 
      22             : #include <vcl/window.hxx>
      23             : #include <memory>
      24             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      25             : #include <com/sun/star/lang/Locale.hpp>
      26             : #include <com/sun/star/uno/Sequence.hxx>
      27             : #include <com/sun/star/uno/XComponentContext.hpp>
      28             : #include <editeng/editengdllapi.h>
      29             : #include <i18nlangtag/mslangid.hxx>
      30             : 
      31             : 
      32             : namespace editeng
      33             : {
      34             : 
      35             : 
      36             :     class HangulHanjaConversion_Impl;
      37             : 
      38             : 
      39             :     //= HangulHanjaConversion
      40             : 
      41             :     /** encapsulates Hangul-Hanja conversion functionality
      42             : 
      43             :         <p>terminology:
      44             :             <ul><li>A <b>text <em>portion</em></b> is some (potentially large) piece of text
      45             :                 which is to be analyzed for convertible sub-strings.</li>
      46             :                 <li>A <b>text <em>unit</em></b> is a sub string in a text portion, which is
      47             :                 to be converted as a whole.</li>
      48             :             </ul>
      49             :             For instance, you could have two independent selections within your document, which are then
      50             :             two text portions. A text unit would be single Hangul/Hanja words within a portion, or even
      51             :             single Hangul syllabills when "replace by character" is enabled.
      52             :         </p>
      53             :     */
      54             :     class EDITENG_DLLPUBLIC HangulHanjaConversion
      55             :     {
      56             :         friend class HangulHanjaConversion_Impl;
      57             : 
      58             :     public:
      59             :         enum ReplacementAction
      60             :         {
      61             :             eExchange,              // simply exchange one text with another
      62             :             eReplacementBracketed,  // keep the original, and put the replacement in brackets after it
      63             :             eOriginalBracketed,     // replace the original text, but put it in brackeds after the replacement
      64             :             eReplacementAbove,      // keep the original, and put the replacement text as ruby text above it
      65             :             eOriginalAbove,         // replace the original text, but put it as ruby text above it
      66             :             eReplacementBelow,      // keep the original, and put the replacement text as ruby text below it
      67             :             eOriginalBelow          // replace the original text, but put it as ruby text below it
      68             :         };
      69             : 
      70             :         enum ConversionType             // does not specify direction...
      71             :         {
      72             :             eConvHangulHanja,           // Korean Hangul/Hanja conversion
      73             :             eConvSimplifiedTraditional  // Chinese simplified / Chinese traditional conversion
      74             :         };
      75             : 
      76             :         // Note: conversion direction for eConvSimplifiedTraditional is
      77             :         // specified by source language.
      78             :         // This one is for Hangul/Hanja where source and target language
      79             :         // are the same.
      80             :         enum ConversionDirection
      81             :         {
      82             :             eHangulToHanja,
      83             :             eHanjaToHangul
      84             :         };
      85             : 
      86             :         enum ConversionFormat
      87             :         {
      88             :             eSimpleConversion,          // used for simplified / traditional Chinese as well
      89             :             eHangulBracketed,
      90             :             eHanjaBracketed,
      91             :             eRubyHanjaAbove,
      92             :             eRubyHanjaBelow,
      93             :             eRubyHangulAbove,
      94             :             eRubyHangulBelow
      95             :         };
      96             : 
      97             :     private:
      98             :         ::std::unique_ptr< HangulHanjaConversion_Impl >   m_pImpl;
      99             : 
     100             :         // used to set initial values of m_pImpl object from saved ones
     101             :         static bool                 m_bUseSavedValues;  // defines if the followng two values should be used for initialization
     102             :         static bool                 m_bTryBothDirectionsSave;
     103             :         static ConversionDirection  m_ePrimaryConversionDirectionSave;
     104             : 
     105             :         HangulHanjaConversion (const HangulHanjaConversion &) SAL_DELETED_FUNCTION;
     106             :         HangulHanjaConversion & operator= (const HangulHanjaConversion &) SAL_DELETED_FUNCTION;
     107             : 
     108             :     public:
     109             :         HangulHanjaConversion(
     110             :             vcl::Window* _pUIParent,
     111             :             const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext,
     112             :             const ::com::sun::star::lang::Locale& _rSourceLocale,
     113             :             const ::com::sun::star::lang::Locale& _rTargetLocale,
     114             :             const vcl::Font* _pTargetFont,
     115             :             sal_Int32 nOptions,
     116             :             bool _bIsInteractive
     117             :         );
     118             : 
     119             :         virtual ~HangulHanjaConversion( );
     120             : 
     121             :         // converts the whole document
     122             :         void    ConvertDocument();
     123             : 
     124             :         LanguageType    GetSourceLanguage() const;
     125             :         LanguageType    GetTargetLanguage() const;
     126             :         const vcl::Font* GetTargetFont() const;
     127             :         sal_Int32       GetConversionOptions() const;
     128             :         bool            IsInteractive() const;
     129             : 
     130             :         // chinese text conversion
     131             :         static inline bool IsSimplified( LanguageType nLang );
     132             :         static inline bool IsTraditional( LanguageType nLang );
     133             :         static inline bool IsChinese( LanguageType nLang );
     134             : 
     135             :         // used to specify that the conversion direction states from the
     136             :         // last incarnation should be used as
     137             :         // initial conversion direction for the next incarnation.
     138             :         // (A hack used to transport a state information from
     139             :         // one incarnation to the next. Used in Writers text conversion...)
     140             :         static void SetUseSavedConversionDirectionState( bool bVal );
     141             :         static bool IsUseSavedConversionDirectionState();
     142             : 
     143             :     protected:
     144             :         /** retrieves the next text portion which is to be analyzed
     145             : 
     146             :             <p>pseudo-abstract, needs to be overridden</p>
     147             : 
     148             :             @param _rNextPortion
     149             :                 upon return, this must contain the next text portion
     150             :             @param _rLangOfPortion
     151             :                 upon return, this must contain the language for the found text portion.
     152             :                 (necessary for Chinese translation since there are 5 language variants
     153             :                 too look for even if the 'source' language usually is only 'simplified'
     154             :                 or 'traditional'.)
     155             :         */
     156             :         virtual void    GetNextPortion(
     157             :                 OUString& /* [out] */ _rNextPortion,
     158             :                 LanguageType& /* [out] */ _rLangOfPortion,
     159             :                 bool /* [in] */ _bAllowImplicitChangesForNotConvertibleText ) = 0;
     160             : 
     161             :         /** announces a new "current unit"
     162             : 
     163             :             <p>This will be called whenever it is necessary to interactively ask the user for
     164             :             a conversion. In such a case, a range within the current portion (see <member>GetNextPortion</member>)
     165             :             is presented to the user for chosing a substitution. Additionally, this method is called,
     166             :             so that derived classes can e.g. highlight this text range in a document view.</p>
     167             : 
     168             :             <p>Note that the indexes are relative to the most recent replace action. See
     169             :             <member>ReplaceUnit</member> for details.</p>
     170             : 
     171             :             @param _nUnitStart
     172             :                 the start index of the unit
     173             : 
     174             :             @param _nUnitEnd
     175             :                 the start index (exclusively!) of the unit.
     176             : 
     177             :             @param _bAllowImplicitChangesForNotConvertibleText
     178             :                 allows implicit changes other than the text itself for the
     179             :                 text parts not being convertible.
     180             :                 Used for chinese translation to attribute all not convertible
     181             :                 text (e.g. western text, empty paragraphs, spaces, ...) to
     182             :                 the target language and target font of the conversion.
     183             :                 This is to ensure that after the conversion any new text entered
     184             :                 anywhere in the document will have the target language (of course
     185             :                 CJK Language only) and target font (CJK font only) set.
     186             : 
     187             :             @see GetNextPortion
     188             :         */
     189             :         virtual void    HandleNewUnit( const sal_Int32 _nUnitStart, const sal_Int32 _nUnitEnd ) = 0;
     190             : 
     191             :         /** replaces a text unit within a text portion with a new text
     192             : 
     193             :             <p>pseudo-abstract, needs to be overridden</p>
     194             : 
     195             :             <p>Note an important thing about the indices: They are always relative to the <em>previous
     196             :             call</em> of ReplaceUnit. This means whe you get a call to ReplaceUnit, and replace some text
     197             :             in your document, than you have to remember the document position immediately <em>behind</em>
     198             :             the changed text. In a next call to ReplaceUnit, an index of <em>0</em> will denote exactly
     199             :             this position behind the previous replacement<br/>
     200             :             The reaons for this is that this class here does not know anything about your document structure,
     201             :             so after a replacement took place, it's impossible to address anything in the range from the
     202             :             beginning of the portion up to the replaced text.<br/>
     203             :             In the very first call to ReplaceUnit, an index of <em>0</em> denotes the very first position of
     204             :             the current portion.</p>
     205             : 
     206             :             <p>If the language of the text to be replaced is different from
     207             :             the target language (as given by 'GetTargetLanguage') for example
     208             :             when converting simplified Chinese from/to traditional Chinese
     209             :             the language attribute of the new text has to be changed as well,
     210             :             **and** the font is to be set to the default (document) font for
     211             :             that language.</p>
     212             : 
     213             :             @param _nUnitStart
     214             :                 the start index of the range to replace
     215             : 
     216             :             @param _nUnitEnd
     217             :                 the end index (exclusively!) of the range to replace. E.g., an index
     218             :                 pair (4,5) indicates a range of length 1.
     219             : 
     220             :             @param _rOrigText
     221             :                 the original text to be replaced (as returned by GetNextPortion).
     222             :                 Since in Chinese conversion the original text is needed as well
     223             :                 in order to only do the minimal necassry text changes and to keep
     224             :                 as much attributes as possible this is supplied here as well.
     225             : 
     226             :             @param _rReplaceWith
     227             :                 The replacement text
     228             : 
     229             :             @param _rOffsets
     230             :                 An sequence matching the indices (characters) of _rReplaceWith
     231             :                 to the indices of the characters in the original text they are
     232             :                 replacing.
     233             :                 This is necessary since some portions of the text may get
     234             :                 converted in portions of different length than the original.
     235             :                 The sequence will be empty if all conversions in the text are
     236             :                 of equal length. That is if always the character at index i in
     237             :                 _rOffsets is replacing the character at index i in the original
     238             :                 text for all valid index values of i.
     239             : 
     240             :             @param _eAction
     241             :                 replacement action to take
     242             : 
     243             :             @param pNewUnitLanguage
     244             :                 if the replacement unit is required to have a new language that
     245             :                 is specified here. If the language is to be left unchanged this
     246             :                 is the 0 pointer.
     247             :         */
     248             :         virtual void    ReplaceUnit(
     249             :                             const sal_Int32 _nUnitStart, const sal_Int32 _nUnitEnd,
     250             :                             const OUString& _rOrigText,
     251             :                             const OUString& _rReplaceWith,
     252             :                             const ::com::sun::star::uno::Sequence< sal_Int32 > &_rOffsets,
     253             :                             ReplacementAction _eAction,
     254             :                             LanguageType *pNewUnitLanguage
     255             :                         ) = 0;
     256             : 
     257             :         /** specifies if rubies are supported by the document implementing
     258             :             this class.
     259             : 
     260             :             @return
     261             :                 <TRUE/> if rubies are supported.
     262             :         */
     263             :         virtual bool    HasRubySupport() const = 0;
     264             :     };
     265             : 
     266           1 :     bool HangulHanjaConversion::IsSimplified( LanguageType nLang )
     267             :     {
     268           1 :         return MsLangId::isSimplifiedChinese(nLang);
     269             :     }
     270             : 
     271           1 :     bool HangulHanjaConversion::IsTraditional( LanguageType nLang )
     272             :     {
     273           1 :         return MsLangId::isTraditionalChinese(nLang);
     274             :     }
     275             : 
     276          19 :     bool HangulHanjaConversion::IsChinese( LanguageType nLang )
     277             :     {
     278          19 :         return MsLangId::isChinese(nLang);
     279             :     }
     280             : 
     281             : }
     282             : 
     283             : 
     284             : #endif // INCLUDED_EDITENG_HANGULHANJA_HXX
     285             : 
     286             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11