sw/source/core/inc/wrong.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
  20 #pragma once
  21
  22 #include <com/sun/star/container/NoSuchElementException.hpp>
  23 #include <com/sun/star/container/XStringKeyMap.hpp>
  24
  25 #include <com/sun/star/awt/FontUnderline.hpp>
  26 #include <com/sun/star/uno/Any.hxx>
  27
  28 #include <vector>
  29 #include <memory>
  30 #include <optional>
  31
  32 #include <tools/color.hxx>
  33 #include <swtypes.hxx>
  34 #include <viewopt.hxx>
  35 #include "TextFrameIndex.hxx"
  36
  37 #if defined _MSC_VER
  38 // For MSVC (without /vmg) SwTextNode must consistently be defined for
  39 // WrongListIterator::m_pGetWrongList of pointer-to-SwTextNode-member type to consistently have the
  40 // same size in all translation units that include this file:
  41 #include <ndtxt.hxx>
  42 #endif
  43
  44 class SwWrongList;
  45
  46 enum WrongAreaLineType
  47 {
  48     WRONGAREA_NONE,
  49     WRONGAREA_WAVE,
  50     WRONGAREA_BOLDWAVE,
  51     WRONGAREA_BOLD,
  52     WRONGAREA_DASHED
  53 };
  54
  55 enum WrongListType
  56 {
  57     WRONGLIST_SPELL,
  58     WRONGLIST_GRAMMAR,
  59     WRONGLIST_SMARTTAG,
  60     WRONGLIST_CHANGETRACKING
  61 };
  62
  63 // ST2
  64 class SwWrongArea
  65 {
  66 public:
  67     OUString maType;
  68     css::uno::Reference< css::container::XStringKeyMap > mxPropertyBag;
  69     sal_Int32 mnPos;
  70     sal_Int32 mnLen;
  71     SwWrongList* mpSubList;
  72
  73     Color mColor;
  74     WrongAreaLineType mLineType;
  75
  76     SwWrongArea( OUString aType,
  77                  WrongListType listType,
  78                  css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag,
  79                  sal_Int32 nPos,
  80                  sal_Int32 nLen);
  81
  82     SwWrongArea( OUString aType,
  83                  css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag,
  84                  sal_Int32 nPos,
  85                  sal_Int32 nLen,
  86                  SwWrongList* pSubList);
  87 private:
  88
  89     static Color getGrammarColor ( css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag)
  90     {
  91         try
  92         {
  93             if (xPropertyBag.is())
  94             {
  95                 css::uno::Any aLineColor = xPropertyBag->getValue(u"LineColor"_ustr);
  96                 ::Color lineColor;
  97
  98                 if (aLineColor >>= lineColor)
  99                 {
 100                     return lineColor;
 101                 }
 102             }
 103         }
 104         catch(const css::container::NoSuchElementException&)
 105         {
 106         }
 107         catch(const css::uno::RuntimeException&)
 108         {
 109         }
 110
 111         return SwViewOption::GetCurrentViewOptions().GetGrammarColor();
 112     }
 113
 114     static WrongAreaLineType getGrammarLineType( css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag )
 115     {
 116         try
 117         {
 118             if (xPropertyBag.is())
 119             {
 120                 css::uno::Any aLineType = xPropertyBag->getValue(u"LineType"_ustr);
 121                 ::sal_Int16 lineType = 0;
 122
 123                 if (!(aLineType >>= lineType))
 124                 {
 125                     return WRONGAREA_WAVE;
 126                 }
 127                 if (css::awt::FontUnderline::BOLDWAVE == lineType)
 128                 {
 129                     return WRONGAREA_BOLDWAVE;
 130                 }
 131                 if (css::awt::FontUnderline::BOLD == lineType)
 132                 {
 133                     return WRONGAREA_BOLD;
 134                 }
 135                 if (css::awt::FontUnderline::DASH == lineType)
 136                 {
 137                     return WRONGAREA_DASHED;
 138                 }
 139                 if (css::awt::FontUnderline::SMALLWAVE == lineType)
 140                 {
 141                     return WRONGAREA_WAVE; //Code draws wave height based on space that fits.
 142                 }
 143             }
 144         }
 145         catch(const css::container::NoSuchElementException&)
 146         {
 147         }
 148         catch(const css::uno::RuntimeException&)
 149         {
 150         }
 151
 152         return WRONGAREA_WAVE;
 153     }
 154
 155     static Color getSmartColor ( css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag)
 156     {
 157         try
 158         {
 159             if (xPropertyBag.is())
 160             {
 161                 css::uno::Any aLineColor = xPropertyBag->getValue(u"LineColor"_ustr);
 162                 ::Color lineColor;
 163
 164                 if (aLineColor >>= lineColor)
 165                 {
 166                     return lineColor;
 167                 }
 168             }
 169         }
 170         catch(const css::container::NoSuchElementException&)
 171         {
 172         }
 173         catch(const css::uno::RuntimeException&)
 174         {
 175         }
 176
 177         return SwViewOption::GetCurrentViewOptions().GetSmarttagColor();
 178     }
 179
 180     static WrongAreaLineType getSmartLineType( css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag )
 181     {
 182         try
 183         {
 184             if (xPropertyBag.is())
 185             {
 186                 css::uno::Any aLineType = xPropertyBag->getValue(u"LineType"_ustr);
 187                 ::sal_Int16 lineType = 0;
 188
 189                 if (!(aLineType >>= lineType))
 190                 {
 191                     return WRONGAREA_DASHED;
 192                 }
 193                 if (css::awt::FontUnderline::WAVE == lineType)
 194                 {
 195                     return WRONGAREA_WAVE;
 196                 }
 197                 if (css::awt::FontUnderline::BOLDWAVE == lineType)
 198                 {
 199                     return WRONGAREA_BOLDWAVE;
 200                 }
 201                 if (css::awt::FontUnderline::BOLD == lineType)
 202                 {
 203                     return WRONGAREA_BOLD;
 204                 }
 205                 if (css::awt::FontUnderline::SMALLWAVE == lineType)
 206                 {
 207                     return WRONGAREA_WAVE; //Code draws wave height based on space that fits.
 208                 }
 209             }
 210         }
 211         catch(const css::container::NoSuchElementException&)
 212         {
 213         }
 214         catch(const css::uno::RuntimeException&)
 215         {
 216         }
 217
 218         return WRONGAREA_DASHED;
 219     }
 220
 221     static Color getWrongAreaColor(WrongListType listType,
 222                             css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag )
 223     {
 224         if (WRONGLIST_SPELL == listType)
 225         {
 226             return SwViewOption::GetCurrentViewOptions().GetSpellColor();
 227         }
 228         else if (WRONGLIST_GRAMMAR == listType)
 229         {
 230             return getGrammarColor(xPropertyBag);
 231         }
 232         else if (WRONGLIST_SMARTTAG == listType)
 233         {
 234             return  getSmartColor(xPropertyBag);
 235         }
 236
 237         return SwViewOption::GetCurrentViewOptions().GetSpellColor();
 238     }
 239
 240     static WrongAreaLineType getWrongAreaLineType(WrongListType listType,
 241                                            css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag )
 242     {
 243         if (WRONGLIST_SPELL == listType)
 244         {
 245             return WRONGAREA_WAVE;
 246         }
 247         else if (WRONGLIST_GRAMMAR == listType)
 248         {
 249             return getGrammarLineType(xPropertyBag);
 250         }
 251         else if (WRONGLIST_SMARTTAG == listType)
 252         {
 253             return getSmartLineType(xPropertyBag);
 254         }
 255
 256         return WRONGAREA_WAVE;
 257     }
 258
 259 };
 260
 261 class SAL_DLLPUBLIC_RTTI SwWrongList
 262 {
 263     std::vector<SwWrongArea> maList;
 264     WrongListType            meType;
 265
 266     sal_Int32 mnBeginInvalid;   // Start of the invalid range
 267     sal_Int32 mnEndInvalid;     // End of the invalid range
 268
 269     static void ShiftLeft( sal_Int32 &rPos, sal_Int32 nStart, sal_Int32 nEnd )
 270     { if( rPos > nStart ) rPos = rPos > nEnd ? rPos - nEnd + nStart : nStart; }
 271     void Invalidate_( sal_Int32 nBegin, sal_Int32 nEnd );
 272
 273     void Insert(sal_uInt16 nWhere, std::vector<SwWrongArea>::iterator startPos, std::vector<SwWrongArea>::iterator const & endPos);
 274     void Remove( sal_uInt16 nIdx, sal_uInt16 nLen );
 275
 276     SwWrongList& operator= (const SwWrongList &) = delete;
 277     SwWrongList( const SwWrongList& rCpy ) = delete;
 278
 279 public:
 280     SwWrongList( WrongListType eType );
 281
 282     virtual ~SwWrongList();
 283     virtual SwWrongList* Clone();
 284     virtual void CopyFrom( const SwWrongList& rCopy );
 285
 286     WrongListType GetWrongListType() const { return meType; }
 287     sal_Int32 GetBeginInv() const { return mnBeginInvalid; }
 288     sal_Int32 GetEndInv() const { return mnEndInvalid; }
 289     void SetInvalid( sal_Int32 nBegin, sal_Int32 nEnd );
 290     void Validate(){ mnBeginInvalid = mnEndInvalid = COMPLETE_STRING; }
 291     void Invalidate( sal_Int32 nBegin, sal_Int32 nEnd );
 292     bool InvalidateWrong();
 293     enum class FreshState { FRESH, CURSOR, NOTHING };
 294     FreshState Fresh( sal_Int32 &rStart, sal_Int32 &rEnd, sal_Int32 nPos,
 295             sal_Int32 nLen, sal_uInt16 nIndex, sal_Int32 nCursorPos );
 296     sal_uInt16 GetWrongPos( sal_Int32 nValue ) const;
 297
 298     bool Check( sal_Int32 &rChk, sal_Int32 &rLn ) const;
 299     bool InWrongWord( sal_Int32 &rChk, sal_Int32 &rLn ) const;
 300     sal_Int32 NextWrong( sal_Int32 nChk ) const;
 301
 302     void Move( sal_Int32 nPos, sal_Int32 nDiff );
 303     void ClearList();
 304
 305     // Divide the list into two part, the wrong words until nSplitPos will be
 306     // removed and transferred to a new SwWrongList.
 307     std::unique_ptr<SwWrongList> SplitList( sal_Int32 nSplitPos );
 308     // Join the next SwWrongList, nInsertPos is my own text length, where
 309     // the other wrong list has to be inserted.
 310     void JoinList( SwWrongList* pNext, sal_Int32 nInsertPos );
 311
 312     sal_Int32 Len( sal_uInt16 nIdx ) const
 313     {
 314         return nIdx < maList.size() ? maList[nIdx].mnLen : 0;
 315     }
 316
 317     sal_Int32 Pos( sal_uInt16 nIdx ) const
 318     {
 319         return nIdx < maList.size() ? maList[nIdx].mnPos : 0;
 320     }
 321
 322     sal_uInt16 Count() const { return o3tl::narrowing<sal_uInt16>(maList.size()); }
 323
 324     void Insert( const OUString& rType,
 325                         css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag,
 326                         sal_Int32 nNewPos, sal_Int32 nNewLen, sal_uInt16 nWhere )
 327     {
 328         std::vector<SwWrongArea>::iterator i = maList.begin();
 329         if ( nWhere >= maList.size() )
 330             i = maList.end(); // robust
 331         else
 332             i += nWhere;
 333
 334         maList.insert(i, SwWrongArea( rType, meType, xPropertyBag, nNewPos, nNewLen) );
 335     }
 336
 337     void Insert( const OUString& rType,
 338                  css::uno::Reference< css::container::XStringKeyMap > const & xPropertyBag,
 339                  sal_Int32 nNewPos, sal_Int32 nNewLen );
 340
 341     SwWrongList* SubList( sal_uInt16 nIdx ) const
 342     {
 343         return nIdx < maList.size() ? maList[nIdx].mpSubList : nullptr;
 344     }
 345
 346     void InsertSubList( sal_Int32 nNewPos, sal_Int32 nNewLen, sal_uInt16 nWhere, SwWrongList* pSubList );
 347
 348     const SwWrongArea* GetElement( sal_uInt16 nIdx ) const
 349     {
 350         return nIdx < maList.size() ? &maList[nIdx] : nullptr;
 351     }
 352     void RemoveEntry( sal_Int32 nBegin, sal_Int32 nEnd );
 353     bool LookForEntry( sal_Int32 nBegin, sal_Int32 nEnd );
 354 };
 355
 356 class SwTextNode;
 357 class SwTextFrame;
 358
 359 namespace sw {
 360
 361 struct MergedPara;
 362
 363 class WrongListIteratorBase
 364 {
 365 protected:
 366     SwWrongList const* (SwTextNode::*const m_pGetWrongList)() const;
 367     sw::MergedPara const*const m_pMergedPara;
 368     size_t m_CurrentExtent;
 369     TextFrameIndex m_CurrentIndex;
 370     SwWrongList const*const m_pWrongList;
 371
 372 public:
 373     /// for the text frame
 374     WrongListIteratorBase(SwTextFrame const& rFrame,
 375         SwWrongList const* (SwTextNode::*pGetWrongList)() const);
 376     /// for SwTextSlot
 377     WrongListIteratorBase(SwWrongList const& rWrongList);
 378 };
 379
 380 class WrongListIterator
 381     : public WrongListIteratorBase
 382 {
 383 public:
 384     /// for the text frame
 385     WrongListIterator(SwTextFrame const& rFrame,
 386         SwWrongList const* (SwTextNode::*pGetWrongList)() const);
 387     /// for SwTextSlot
 388     WrongListIterator(SwWrongList const& rWrongList);
 389
 390     bool Check(TextFrameIndex &rStart, TextFrameIndex &rLen);
 391     const SwWrongArea* GetWrongElement(TextFrameIndex nStart);
 392
 393     bool LooksUseful() { return m_pMergedPara || m_pWrongList; }
 394 };
 395
 396 class WrongListIteratorCounter
 397     : public WrongListIteratorBase
 398 {
 399 public:
 400     WrongListIteratorCounter(SwTextFrame const& rFrame,
 401         SwWrongList const* (SwTextNode::*pGetWrongList)() const);
 402     WrongListIteratorCounter(SwWrongList const& rWrongList);
 403
 404     sal_uInt16 GetElementCount();
 405     std::optional<std::pair<TextFrameIndex, TextFrameIndex>> GetElementAt(sal_uInt16 nIndex);
 406 };
 407
 408 } // namespace sw
 409
 410 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */