include/editeng/hangulhanja.hxx

   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 syllabification 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 brackets 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 following two values should be used for initialization
 102         static bool                 m_bTryBothDirectionsSave;
 103         static ConversionDirection  m_ePrimaryConversionDirectionSave;
 104
 105         HangulHanjaConversion (const HangulHanjaConversion &) = delete;
 106         HangulHanjaConversion & operator= (const HangulHanjaConversion &) = delete;
 107
 108     public:
 109         HangulHanjaConversion(
 110             vcl::Window* _pUIParent,
 111             const css::uno::Reference< css::uno::XComponentContext >& rxContext,
 112             const css::lang::Locale& _rSourceLocale,
 113             const css::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 when 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 reason 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 necessary 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 css::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     bool HangulHanjaConversion::IsSimplified( LanguageType nLang )
 267     {
 268         return MsLangId::isSimplifiedChinese(nLang);
 269     }
 270
 271     bool HangulHanjaConversion::IsTraditional( LanguageType nLang )
 272     {
 273         return MsLangId::isTraditionalChinese(nLang);
 274     }
 275
 276     bool HangulHanjaConversion::IsChinese( LanguageType nLang )
 277     {
 278         return MsLangId::isChinese(nLang);
 279     }
 280
 281 }
 282
 283
 284 #endif // INCLUDED_EDITENG_HANGULHANJA_HXX
 285
 286 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */