LCOV - code coverage report
Current view: top level - include/editeng - hangulhanja.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 6 6 100.0 %
Date: 2014-11-03 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             :         // Forbidden and not implemented.
     106             :         HangulHanjaConversion (const HangulHanjaConversion &);
     107             :         HangulHanjaConversion & operator= (const HangulHanjaConversion &);
     108             : 
     109             :     public:
     110             :         HangulHanjaConversion(
     111             :             vcl::Window* _pUIParent,
     112             :             const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext,
     113             :             const ::com::sun::star::lang::Locale& _rSourceLocale,
     114             :             const ::com::sun::star::lang::Locale& _rTargetLocale,
     115             :             const vcl::Font* _pTargetFont,
     116             :             sal_Int32 nOptions,
     117             :             bool _bIsInteractive
     118             :         );
     119             : 
     120             :         virtual ~HangulHanjaConversion( );
     121             : 
     122             :         // converts the whole document
     123             :         void    ConvertDocument();
     124             : 
     125             :         LanguageType    GetSourceLanguage() const;
     126             :         LanguageType    GetTargetLanguage() const;
     127             :         const vcl::Font* GetTargetFont() const;
     128             :         sal_Int32       GetConversionOptions() const;
     129             :         bool            IsInteractive() const;
     130             : 
     131             :         // chinese text conversion
     132             :         static inline bool IsSimplified( LanguageType nLang );
     133             :         static inline bool IsTraditional( LanguageType nLang );
     134             :         static inline bool IsChinese( LanguageType nLang );
     135             : 
     136             :         // used to specify that the conversion direction states from the
     137             :         // last incarnation should be used as
     138             :         // initial conversion direction for the next incarnation.
     139             :         // (A hack used to transport a state information from
     140             :         // one incarnation to the next. Used in Writers text conversion...)
     141             :         static void SetUseSavedConversionDirectionState( bool bVal );
     142             :         static bool IsUseSavedConversionDirectionState();
     143             : 
     144             :     protected:
     145             :         /** retrieves the next text portion which is to be analyzed
     146             : 
     147             :             <p>pseudo-abstract, needs to be overridden</p>
     148             : 
     149             :             @param _rNextPortion
     150             :                 upon return, this must contain the next text portion
     151             :             @param _rLangOfPortion
     152             :                 upon return, this must contain the language for the found text portion.
     153             :                 (necessary for Chinese translation since there are 5 language variants
     154             :                 too look for even if the 'source' language usually is only 'simplified'
     155             :                 or 'traditional'.)
     156             :         */
     157             :         virtual void    GetNextPortion(
     158             :                 OUString& /* [out] */ _rNextPortion,
     159             :                 LanguageType& /* [out] */ _rLangOfPortion,
     160             :                 bool /* [in] */ _bAllowImplicitChangesForNotConvertibleText ) = 0;
     161             : 
     162             :         /** announces a new "current unit"
     163             : 
     164             :             <p>This will be called whenever it is necessary to interactively ask the user for
     165             :             a conversion. In such a case, a range within the current portion (see <member>GetNextPortion</member>)
     166             :             is presented to the user for chosing a substitution. Additionally, this method is called,
     167             :             so that derived classes can e.g. highlight this text range in a document view.</p>
     168             : 
     169             :             <p>Note that the indexes are relative to the most recent replace action. See
     170             :             <member>ReplaceUnit</member> for details.</p>
     171             : 
     172             :             @param _nUnitStart
     173             :                 the start index of the unit
     174             : 
     175             :             @param _nUnitEnd
     176             :                 the start index (exclusively!) of the unit.
     177             : 
     178             :             @param _bAllowImplicitChangesForNotConvertibleText
     179             :                 allows implicit changes other than the text itself for the
     180             :                 text parts not being convertible.
     181             :                 Used for chinese translation to attribute all not convertible
     182             :                 text (e.g. western text, empty paragraphs, spaces, ...) to
     183             :                 the target language and target font of the conversion.
     184             :                 This is to ensure that after the conversion any new text entered
     185             :                 anywhere in the document will have the target language (of course
     186             :                 CJK Language only) and target font (CJK font only) set.
     187             : 
     188             :             @see GetNextPortion
     189             :         */
     190             :         virtual void    HandleNewUnit( const sal_Int32 _nUnitStart, const sal_Int32 _nUnitEnd ) = 0;
     191             : 
     192             :         /** replaces a text unit within a text portion with a new text
     193             : 
     194             :             <p>pseudo-abstract, needs to be overridden</p>
     195             : 
     196             :             <p>Note an important thing about the indices: They are always relative to the <em>previous
     197             :             call</em> of ReplaceUnit. This means whe you get a call to ReplaceUnit, and replace some text
     198             :             in your document, than you have to remember the document position immediately <em>behind</em>
     199             :             the changed text. In a next call to ReplaceUnit, an index of <em>0</em> will denote exactly
     200             :             this position behind the previous replacement<br/>
     201             :             The reaons for this is that this class here does not know anything about your document structure,
     202             :             so after a replacement took place, it's impossible to address anything in the range from the
     203             :             beginning of the portion up to the replaced text.<br/>
     204             :             In the very first call to ReplaceUnit, an index of <em>0</em> denotes the very first position of
     205             :             the current portion.</p>
     206             : 
     207             :             <p>If the language of the text to be replaced is different from
     208             :             the target language (as given by 'GetTargetLanguage') for example
     209             :             when converting simplified Chinese from/to traditional Chinese
     210             :             the language attribute of the new text has to be changed as well,
     211             :             **and** the font is to be set to the default (document) font for
     212             :             that language.</p>
     213             : 
     214             :             @param _nUnitStart
     215             :                 the start index of the range to replace
     216             : 
     217             :             @param _nUnitEnd
     218             :                 the end index (exclusively!) of the range to replace. E.g., an index
     219             :                 pair (4,5) indicates a range of length 1.
     220             : 
     221             :             @param _rOrigText
     222             :                 the original text to be replaced (as returned by GetNextPortion).
     223             :                 Since in Chinese conversion the original text is needed as well
     224             :                 in order to only do the minimal necassry text changes and to keep
     225             :                 as much attributes as possible this is supplied here as well.
     226             : 
     227             :             @param _rReplaceWith
     228             :                 The replacement text
     229             : 
     230             :             @param _rOffsets
     231             :                 An sequence matching the indices (characters) of _rReplaceWith
     232             :                 to the indices of the characters in the original text they are
     233             :                 replacing.
     234             :                 This is necessary since some portions of the text may get
     235             :                 converted in portions of different length than the original.
     236             :                 The sequence will be empty if all conversions in the text are
     237             :                 of equal length. That is if always the character at index i in
     238             :                 _rOffsets is replacing the character at index i in the original
     239             :                 text for all valid index values of i.
     240             : 
     241             :             @param _eAction
     242             :                 replacement action to take
     243             : 
     244             :             @param pNewUnitLanguage
     245             :                 if the replacement unit is required to have a new language that
     246             :                 is specified here. If the language is to be left unchanged this
     247             :                 is the 0 pointer.
     248             :         */
     249             :         virtual void    ReplaceUnit(
     250             :                             const sal_Int32 _nUnitStart, const sal_Int32 _nUnitEnd,
     251             :                             const OUString& _rOrigText,
     252             :                             const OUString& _rReplaceWith,
     253             :                             const ::com::sun::star::uno::Sequence< sal_Int32 > &_rOffsets,
     254             :                             ReplacementAction _eAction,
     255             :                             LanguageType *pNewUnitLanguage
     256             :                         ) = 0;
     257             : 
     258             :         /** specifies if rubies are supported by the document implementing
     259             :             this class.
     260             : 
     261             :             @return
     262             :                 <TRUE/> if rubies are supported.
     263             :         */
     264             :         virtual bool    HasRubySupport() const = 0;
     265             :     };
     266             : 
     267           2 :     bool HangulHanjaConversion::IsSimplified( LanguageType nLang )
     268             :     {
     269           2 :         return MsLangId::isSimplifiedChinese(nLang);
     270             :     }
     271             : 
     272           2 :     bool HangulHanjaConversion::IsTraditional( LanguageType nLang )
     273             :     {
     274           2 :         return MsLangId::isTraditionalChinese(nLang);
     275             :     }
     276             : 
     277          38 :     bool HangulHanjaConversion::IsChinese( LanguageType nLang )
     278             :     {
     279          38 :         return MsLangId::isChinese(nLang);
     280             :     }
     281             : 
     282             : }   // namespace svx
     283             : 
     284             : 
     285             : #endif // INCLUDED_EDITENG_HANGULHANJA_HXX
     286             : 
     287             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10