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