svx/source/sidebar/nbdtmg.cxx

   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 #include <svx/nbdtmg.hxx>
  20 #include <svx/svxids.hrc>
  21 #include <vcl/svapp.hxx>
  22 #include <svl/itemset.hxx>
  23 #include <sfx2/request.hxx>
  24 #include <svl/stritem.hxx>
  25 #include <svtools/ctrltool.hxx>
  26 #include <sfx2/objsh.hxx>
  27 #include <editeng/flstitem.hxx>
  28 #include <svl/itempool.hxx>
  29 #include <vcl/outdev.hxx>
  30 #include <editeng/brushitem.hxx>
  31 #include <svx/dialmgr.hxx>
  32 #include <svx/strings.hrc>
  33 #include <vcl/graph.hxx>
  34 #include <vcl/settings.hxx>
  35
  36 #include <i18nlangtag/languagetag.hxx>
  37 #include <o3tl/temporary.hxx>
  38 #include <tools/debug.hxx>
  39 #include <tools/urlobj.hxx>
  40 #include <unotools/ucbstreamhelper.hxx>
  41 #include <unotools/pathoptions.hxx>
  42 #include <editeng/eeitem.hxx>
  43
  44 #include <com/sun/star/text/VertOrientation.hpp>
  45 #include <com/sun/star/style/NumberingType.hpp>
  46 #include <com/sun/star/container/XIndexAccess.hpp>
  47 #include <com/sun/star/text/DefaultNumberingProvider.hpp>
  48 #include <com/sun/star/beans/PropertyValue.hpp>
  49 #include <comphelper/processfactory.hxx>
  50 #include <memory>
  51
  52 using namespace com::sun::star;
  53 using namespace com::sun::star::uno;
  54 using namespace com::sun::star::beans;
  55 using namespace com::sun::star::lang;
  56 using namespace com::sun::star::text;
  57 using namespace com::sun::star::container;
  58 using namespace com::sun::star::style;
  59
  60 namespace svx::sidebar {
  61
  62 namespace {
  63
  64 const vcl::Font& lcl_GetDefaultBulletFont()
  65 {
  66     static vcl::Font aDefBulletFont = [&]()
  67     {
  68         static vcl::Font tmp("OpenSymbol", "", Size(0, 14));
  69         tmp.SetCharSet( RTL_TEXTENCODING_SYMBOL );
  70         tmp.SetFamily( FAMILY_DONTKNOW );
  71         tmp.SetPitch( PITCH_DONTKNOW );
  72         tmp.SetWeight( WEIGHT_DONTKNOW );
  73         tmp.SetTransparent( true );
  74         return tmp;
  75     }();
  76     return aDefBulletFont;
  77 }
  78
  79 const sal_Unicode aDefaultBulletTypes[] =
  80 {
  81     0x2022,
  82     0x25cf,
  83     0xe00c,
  84     0xe00a,
  85     0x2794,
  86     0x27a2,
  87     0x2717,
  88     0x2714
  89 };
  90
  91 NumSettings_Impl* lcl_CreateNumberingSettingsPtr(const Sequence<PropertyValue>& rLevelProps)
  92 {
  93     NumSettings_Impl* pNew = new NumSettings_Impl;
  94     for(const PropertyValue& rValue : rLevelProps)
  95     {
  96         if(rValue.Name == "NumberingType")
  97         {
  98             sal_Int16 nTmp;
  99             if (rValue.Value >>= nTmp)
 100                 pNew->nNumberType = static_cast<SvxNumType>(nTmp);
 101         }
 102         else if(rValue.Name == "Prefix")
 103             rValue.Value >>= pNew->sPrefix;
 104         else if(rValue.Name == "Suffix")
 105             rValue.Value >>= pNew->sSuffix;
 106         else if(rValue.Name == "ParentNumbering")
 107             rValue.Value >>= pNew->nParentNumbering;
 108         else if(rValue.Name == "BulletChar")
 109             rValue.Value >>= pNew->sBulletChar;
 110         else if(rValue.Name == "BulletFontName")
 111             rValue.Value >>= pNew->sBulletFont;
 112     }
 113     const sal_Unicode cLocalPrefix = pNew->sPrefix.getLength() ? pNew->sPrefix[0] : 0;
 114     const sal_Unicode cLocalSuffix = pNew->sSuffix.getLength() ? pNew->sSuffix[0] : 0;
 115     if( cLocalPrefix == ' ') pNew->sPrefix.clear();
 116     if( cLocalSuffix == ' ') pNew->sSuffix.clear();
 117     return pNew;
 118 }
 119
 120 }
 121
 122 sal_uInt16 NBOTypeMgrBase:: IsSingleLevel(sal_uInt16 nCurLevel)
 123 {
 124     sal_uInt16 nLv = sal_uInt16(0xFFFF);
 125     sal_uInt16 nCount = 0;
 126     sal_uInt16 nMask = 1;
 127     for( sal_uInt16 i = 0; i < SVX_MAX_NUM; i++ )
 128     {
 129         if(nCurLevel & nMask)
 130         {
 131             nCount++;
 132             nLv=i;
 133         }
 134         nMask <<= 1 ;
 135     }
 136
 137     if ( nCount == 1)
 138         return nLv;
 139     else
 140         return sal_uInt16(0xFFFF);
 141 }
 142
 143 void NBOTypeMgrBase::SetItems(const SfxItemSet* pArg) {
 144     pSet = pArg;
 145     if ( !pSet )
 146         return;
 147
 148     SfxAllItemSet aSet(*pSet);
 149
 150     const SfxStringItem* pBulletCharFmt = aSet.GetItem<SfxStringItem>(SID_BULLET_CHAR_FMT, false);
 151     if (pBulletCharFmt)
 152         aBulletCharFmtName = pBulletCharFmt->GetValue();
 153
 154     const SfxStringItem* pNumCharFmt = aSet.GetItem<SfxStringItem>(SID_NUM_CHAR_FMT, false);
 155     if (pNumCharFmt)
 156         aNumCharFmtName = pNumCharFmt->GetValue();
 157
 158     const SfxPoolItem* pItem;
 159     SfxItemState eState = pSet->GetItemState(SID_ATTR_NUMBERING_RULE, false, &pItem);
 160     if(eState == SfxItemState::SET)
 161     {
 162         eCoreUnit = pSet->GetPool()->GetMetric(pSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE));
 163     } else {
 164         //sd use different sid for numbering rule
 165         eState = pSet->GetItemState(EE_PARA_NUMBULLET, false, &pItem);
 166         if(eState == SfxItemState::SET)
 167         {
 168             eCoreUnit = pSet->GetPool()->GetMetric(pSet->GetPool()->GetWhich(EE_PARA_NUMBULLET));
 169         }
 170     }
 171 }
 172
 173 void NBOTypeMgrBase::ImplLoad(std::u16string_view filename)
 174 {
 175     bIsLoading = true;
 176     MapUnit      eOldCoreUnit=eCoreUnit;
 177     eCoreUnit = MapUnit::Map100thMM;
 178     INetURLObject aFile( SvtPathOptions().GetUserConfigPath() );
 179     aFile.Append( filename);
 180     std::unique_ptr<SvStream> xIStm(::utl::UcbStreamHelper::CreateStream( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ ));
 181     if( xIStm ) {
 182         sal_uInt32                  nVersion = 0;
 183         sal_Int32                   nNumIndex = 0;
 184         xIStm->ReadUInt32( nVersion );
 185         if (nVersion==DEFAULT_NUMBERING_CACHE_FORMAT_VERSION) //first version
 186         {
 187             xIStm->ReadInt32( nNumIndex );
 188             while (nNumIndex>=0 && nNumIndex<DEFAULT_NUM_VALUSET_COUNT) {
 189                 SvxNumRule aNum(*xIStm);
 190                 //bullet color in font properties is not stored correctly. Need set transparency bits manually
 191                 for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++)
 192                 {
 193                     SvxNumberFormat aFmt(aNum.GetLevel(i));
 194                     if (aFmt.GetBulletFont()) {
 195                         vcl::Font aFont(*aFmt.GetBulletFont());
 196                         Color c=aFont.GetColor();
 197                         c.SetAlpha(0);
 198                         aFont.SetColor(c);
 199                         aFmt.SetBulletFont(&aFont);
 200                         aNum.SetLevel(i, aFmt);
 201                     }
 202                 }
 203                 RelplaceNumRule(aNum,nNumIndex,0x1/*nLevel*/);
 204                 xIStm->ReadInt32( nNumIndex );
 205             }
 206         }
 207     }
 208     eCoreUnit = eOldCoreUnit;
 209     bIsLoading = false;
 210 }
 211 void NBOTypeMgrBase::ImplStore(std::u16string_view filename)
 212 {
 213     if (bIsLoading) return;
 214     MapUnit      eOldCoreUnit=eCoreUnit;
 215     eCoreUnit = MapUnit::Map100thMM;
 216     INetURLObject aFile( SvtPathOptions().GetUserConfigPath() );
 217     aFile.Append( filename);
 218     std::unique_ptr<SvStream> xOStm(::utl::UcbStreamHelper::CreateStream( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::WRITE ));
 219     if( xOStm ) {
 220         sal_uInt32                      nVersion;
 221         sal_Int32                       nNumIndex;
 222         nVersion = DEFAULT_NUMBERING_CACHE_FORMAT_VERSION;
 223         xOStm->WriteUInt32( nVersion );
 224         for(sal_Int32 nItem = 0; nItem < DEFAULT_NUM_VALUSET_COUNT; nItem++ ) {
 225             if (IsCustomized(nItem)) {
 226                 SvxNumRule aDefNumRule( SvxNumRuleFlags::BULLET_REL_SIZE | SvxNumRuleFlags::CONTINUOUS | SvxNumRuleFlags::BULLET_COLOR,
 227                     10, false,
 228                     SvxNumRuleType::NUMBERING, SvxNumberFormat::LABEL_ALIGNMENT);
 229                 xOStm->WriteInt32( nItem );
 230                 ApplyNumRule(aDefNumRule,nItem,0x1/*nLevel*/,false,true);
 231                 aDefNumRule.Store(*xOStm);
 232             }
 233         }
 234         nNumIndex = -1;
 235         xOStm->WriteInt32( nNumIndex );  //write end flag
 236     }
 237     eCoreUnit = eOldCoreUnit;
 238 }
 239
 240 // Character Bullet Type lib
 241 BulletsSettings* BulletsTypeMgr::pActualBullets[] ={nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr};
 242 sal_Unicode BulletsTypeMgr::aDynamicBulletTypes[]={' ',' ',' ',' ',' ',' ',' ',' '};
 243 sal_Unicode BulletsTypeMgr::aDynamicRTLBulletTypes[]={' ',' ',' ',' ',' ',' ',' ',' '};
 244
 245 BulletsTypeMgr::BulletsTypeMgr()
 246     : NBOTypeMgrBase()
 247 {
 248     Init();
 249 }
 250
 251 namespace {
 252
 253 class theBulletsTypeMgr : public rtl::Static<BulletsTypeMgr, theBulletsTypeMgr> {};
 254
 255 }
 256
 257 BulletsTypeMgr& BulletsTypeMgr::GetInstance()
 258 {
 259     return theBulletsTypeMgr::get();
 260 }
 261
 262 void BulletsTypeMgr::Init()
 263 {
 264     const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont();
 265
 266     for (sal_uInt16 i=0;i<DEFAULT_BULLET_TYPES;i++)
 267     {
 268         pActualBullets[i] = new BulletsSettings;
 269         pActualBullets[i]->cBulletChar = aDefaultBulletTypes[i];
 270         pActualBullets[i]->aFont = rActBulletFont;
 271         pActualBullets[i]->sDescription = SvxResId( RID_SVXSTR_BULLET_DESCRIPTION_0 + i );
 272     }
 273 }
 274 sal_uInt16 BulletsTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 mLevel,sal_uInt16 nFromIndex)
 275 {
 276     if ( mLevel == sal_uInt16(0xFFFF) || mLevel == 0)
 277         return sal_uInt16(0xFFFF);
 278     //if ( !lcl_IsNumFmtSet(pNR, mLevel) ) return (sal_uInt16)0xFFFF;
 279
 280     sal_uInt16 nActLv = IsSingleLevel(mLevel);
 281
 282     if ( nActLv == sal_uInt16(0xFFFF) )
 283         return sal_uInt16(0xFFFF);
 284
 285     const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv));
 286     sal_UCS4 cChar = aFmt.GetBulletChar();
 287     for(sal_uInt16 i = nFromIndex; i < DEFAULT_BULLET_TYPES; i++)
 288     {
 289         if ( (cChar == pActualBullets[i]->cBulletChar) ||
 290              (cChar == 9830 && 57356 == pActualBullets[i]->cBulletChar) ||
 291              (cChar == 9632 && 57354 == pActualBullets[i]->cBulletChar)   )
 292         {
 293             return i+1;
 294         }
 295     }
 296
 297     return sal_uInt16(0xFFFF);
 298 }
 299
 300 void BulletsTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel)
 301 {
 302     if ( mLevel == sal_uInt16(0xFFFF) || mLevel == 0)
 303         return;
 304
 305     if ( GetNBOIndexForNumRule(aNum,mLevel) != sal_uInt16(0xFFFF) )
 306         return;
 307
 308     sal_uInt16 nActLv = IsSingleLevel(mLevel);
 309
 310     if ( nActLv == sal_uInt16(0xFFFF) )
 311         return;
 312
 313     SvxNumberFormat aFmt(aNum.GetLevel(nActLv));
 314     sal_UCS4 cChar = aFmt.GetBulletChar();
 315     const vcl::Font* pFont = aFmt.GetBulletFont();
 316     if ( nIndex >= DEFAULT_BULLET_TYPES )
 317         return;
 318
 319     pActualBullets[nIndex]->cBulletChar = cChar;
 320     if ( pFont )
 321         pActualBullets[nIndex]->aFont = *pFont;
 322     pActualBullets[nIndex]->bIsCustomized = true;
 323 }
 324
 325 void BulletsTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel, bool /*isDefault*/, bool isResetSize)
 326 {
 327     if ( nIndex >= DEFAULT_BULLET_TYPES )
 328         return;
 329     sal_UCS4 cChar = pActualBullets[nIndex]->cBulletChar;
 330     const vcl::Font& rActBulletFont = pActualBullets[nIndex]->aFont;
 331
 332     sal_uInt16 nMask = 1;
 333     OUString sBulletCharFormatName = GetBulletCharFmtName();
 334     for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++)
 335     {
 336         if(mLevel & nMask)
 337         {
 338             SvxNumberFormat aFmt(aNum.GetLevel(i));
 339             aFmt.SetNumberingType( SVX_NUM_CHAR_SPECIAL );
 340             aFmt.SetBulletFont(&rActBulletFont);
 341             aFmt.SetBulletChar(cChar);
 342             aFmt.SetCharFormatName(sBulletCharFormatName);
 343             aFmt.SetListFormat( "" );
 344             if (isResetSize) aFmt.SetBulletRelSize(45);
 345             aNum.SetLevel(i, aFmt);
 346         }
 347         nMask <<= 1;
 348     }
 349 }
 350
 351 OUString BulletsTypeMgr::GetDescription(sal_uInt16 nIndex, bool /*isDefault*/)
 352 {
 353     OUString sRet;
 354
 355     if ( nIndex >= DEFAULT_BULLET_TYPES )
 356         return sRet;
 357     else
 358         sRet = pActualBullets[nIndex]->sDescription;
 359
 360     return sRet;
 361 }
 362
 363 bool BulletsTypeMgr::IsCustomized(sal_uInt16 nIndex)
 364 {
 365     bool bRet = false;
 366
 367     if ( nIndex >= DEFAULT_BULLET_TYPES )
 368         bRet = false;
 369     else
 370         bRet = pActualBullets[nIndex]->bIsCustomized;
 371
 372     return bRet;
 373 }
 374
 375 // Numbering Type lib
 376 NumberingTypeMgr::NumberingTypeMgr()
 377     : NBOTypeMgrBase()
 378 {
 379     Init();
 380     maDefaultNumberSettingsArr = maNumberSettingsArr;
 381     ImplLoad(u"standard.syb");
 382 }
 383
 384 NumberingTypeMgr::~NumberingTypeMgr()
 385 {
 386 }
 387
 388 static const char* RID_SVXSTR_SINGLENUM_DESCRIPTIONS[] =
 389 {
 390     RID_SVXSTR_SINGLENUM_DESCRIPTION_0,
 391     RID_SVXSTR_SINGLENUM_DESCRIPTION_1,
 392     RID_SVXSTR_SINGLENUM_DESCRIPTION_2,
 393     RID_SVXSTR_SINGLENUM_DESCRIPTION_3,
 394     RID_SVXSTR_SINGLENUM_DESCRIPTION_4,
 395     RID_SVXSTR_SINGLENUM_DESCRIPTION_5,
 396     RID_SVXSTR_SINGLENUM_DESCRIPTION_6,
 397     RID_SVXSTR_SINGLENUM_DESCRIPTION_7
 398 };
 399
 400 namespace {
 401
 402 class theNumberingTypeMgr : public rtl::Static<NumberingTypeMgr, theNumberingTypeMgr> {};
 403
 404 }
 405
 406 NumberingTypeMgr& NumberingTypeMgr::GetInstance()
 407 {
 408     return theNumberingTypeMgr::get();
 409 }
 410
 411 void NumberingTypeMgr::Init()
 412 {
 413     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 414     Reference<XDefaultNumberingProvider> xDefNum = DefaultNumberingProvider::create( xContext );
 415
 416     Sequence< Sequence< PropertyValue > > aNumberings;
 417     Locale aLocale(Application::GetSettings().GetLanguageTag().getLocale());
 418     try
 419     {
 420         aNumberings = xDefNum->getDefaultContinuousNumberingLevels( aLocale );
 421
 422         sal_Int32 nLength = aNumberings.getLength();
 423
 424         const Sequence<PropertyValue>* pValuesArr = aNumberings.getConstArray();
 425         for(sal_Int32 i = 0; i < nLength; i++)
 426         {
 427             NumSettings_Impl* pNew = lcl_CreateNumberingSettingsPtr(pValuesArr[i]);
 428             std::shared_ptr<NumberSettings_Impl> pNumEntry = std::make_shared<NumberSettings_Impl>();
 429             pNumEntry->pNumSetting = pNew;
 430             if ( i < 8 )
 431                 pNumEntry->sDescription = SvxResId(RID_SVXSTR_SINGLENUM_DESCRIPTIONS[i]);
 432             maNumberSettingsArr.push_back(pNumEntry);
 433         }
 434     }
 435     catch(Exception&)
 436     {
 437     }
 438 }
 439
 440 sal_uInt16 NumberingTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 mLevel,sal_uInt16 nFromIndex)
 441 {
 442     if ( mLevel == sal_uInt16(0xFFFF) || mLevel > aNum.GetLevelCount() || mLevel == 0)
 443         return sal_uInt16(0xFFFF);
 444
 445     sal_uInt16 nActLv = IsSingleLevel(mLevel);
 446
 447     if ( nActLv == sal_uInt16(0xFFFF) )
 448         return sal_uInt16(0xFFFF);
 449
 450     const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv));
 451     //sal_Unicode cPrefix = OUString(aFmt.GetPrefix())[0];
 452     //sal_Unicode cSuffix = :OUString(aFmt.GetSuffix())[0];
 453     const OUString& sPrefix = aFmt.GetPrefix();
 454     const OUString& sLclSuffix = aFmt.GetSuffix();
 455     sal_Int16 eNumType = aFmt.GetNumberingType();
 456
 457     sal_uInt16 nCount = maNumberSettingsArr.size();
 458     for(sal_uInt16 i = nFromIndex; i < nCount; ++i)
 459     {
 460         NumberSettings_Impl* _pSet = maNumberSettingsArr[i].get();
 461         sal_Int16 eNType = _pSet->pNumSetting->nNumberType;
 462         OUString sLocalPrefix = _pSet->pNumSetting->sPrefix;
 463         OUString sLocalSuffix = _pSet->pNumSetting->sSuffix;
 464         if (sPrefix == sLocalPrefix &&
 465             sLclSuffix == sLocalSuffix &&
 466             eNumType == eNType )
 467         {
 468             return i+1;
 469         }
 470     }
 471
 472
 473     return sal_uInt16(0xFFFF);
 474 }
 475
 476 void NumberingTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel)
 477 {
 478     sal_uInt16 nActLv = IsSingleLevel(mLevel);
 479
 480     if ( nActLv == sal_uInt16(0xFFFF) )
 481         return;
 482
 483     const SvxNumberFormat& aFmt(aNum.GetLevel(nActLv));
 484     SvxNumType eNumType = aFmt.GetNumberingType();
 485
 486     sal_uInt16 nCount = maNumberSettingsArr.size();
 487     if ( nIndex >= nCount )
 488         return;
 489
 490     NumberSettings_Impl* _pSet = maNumberSettingsArr[nIndex].get();
 491
 492     _pSet->pNumSetting->sPrefix = aFmt.GetPrefix();
 493     _pSet->pNumSetting->sSuffix = aFmt.GetSuffix();
 494     _pSet->pNumSetting->nNumberType = eNumType;
 495     _pSet->bIsCustomized = true;
 496
 497     SvxNumRule aTmpRule1(aNum);
 498     SvxNumRule aTmpRule2(aNum);
 499     ApplyNumRule(aTmpRule1,nIndex,mLevel,true);
 500     ApplyNumRule(aTmpRule2,nIndex,mLevel);
 501     if (aTmpRule1==aTmpRule2) _pSet->bIsCustomized=false;
 502     if (!_pSet->bIsCustomized) {
 503         _pSet->sDescription = GetDescription(nIndex,true);
 504     }
 505     ImplStore(u"standard.syb");
 506 }
 507
 508 void NumberingTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel, bool isDefault, bool isResetSize)
 509 {
 510     if(maNumberSettingsArr.size() <= nIndex)
 511         return;
 512     NumberSettingsArr_Impl*     pCurrentNumberSettingsArr = &maNumberSettingsArr;
 513     if (isDefault) pCurrentNumberSettingsArr = &maDefaultNumberSettingsArr;
 514     NumberSettings_Impl* _pSet = (*pCurrentNumberSettingsArr)[nIndex].get();
 515     SvxNumType eNewType = _pSet->pNumSetting->nNumberType;
 516
 517     sal_uInt16 nMask = 1;
 518     OUString sNumCharFmtName = GetNumCharFmtName();
 519     for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++)
 520     {
 521         if(mLevel & nMask)
 522         {
 523             SvxNumberFormat aFmt(aNum.GetLevel(i));
 524             if (eNewType!=aFmt.GetNumberingType()) isResetSize=true;
 525             aFmt.SetNumberingType(eNewType);
 526             aFmt.SetListFormat(_pSet->pNumSetting->sPrefix, _pSet->pNumSetting->sSuffix, i);
 527             aFmt.SetCharFormatName(sNumCharFmtName);
 528             if (isResetSize) aFmt.SetBulletRelSize(100);
 529             aNum.SetLevel(i, aFmt);
 530         }
 531         nMask <<= 1 ;
 532     }
 533 }
 534
 535 OUString NumberingTypeMgr::GetDescription(sal_uInt16 nIndex, bool isDefault)
 536 {
 537     OUString sRet;
 538     sal_uInt16 nLength = maNumberSettingsArr.size();
 539
 540     if ( nIndex >= nLength )
 541         return sRet;
 542     else
 543         sRet = maNumberSettingsArr[nIndex]->sDescription;
 544     if (isDefault) sRet = maDefaultNumberSettingsArr[nIndex]->sDescription;
 545
 546     return sRet;
 547 }
 548
 549 bool NumberingTypeMgr::IsCustomized(sal_uInt16 nIndex)
 550 {
 551     bool bRet = false;
 552     sal_uInt16 nLength = maNumberSettingsArr.size();
 553
 554     if ( nIndex >= nLength )
 555         bRet = false;
 556     else
 557         bRet = maNumberSettingsArr[nIndex]->bIsCustomized;
 558
 559     return bRet;
 560 }
 561 // Multi-level /Outline Type lib
 562 OutlineTypeMgr::OutlineTypeMgr()
 563     : NBOTypeMgrBase()
 564 {
 565     Init();
 566     for(sal_Int32 nItem = 0; nItem < DEFAULT_NUM_VALUSET_COUNT; nItem++ )
 567     {
 568         pDefaultOutlineSettingsArrs[nItem] = pOutlineSettingsArrs[nItem];
 569     }
 570     //Initial the first time to store the default value. Then do it again for customized value
 571     Init();
 572     ImplLoad(u"standard.syc");
 573 }
 574
 575 namespace {
 576
 577 class theOutlineTypeMgr : public rtl::Static<OutlineTypeMgr, theOutlineTypeMgr> {};
 578
 579 }
 580
 581 OutlineTypeMgr& OutlineTypeMgr::GetInstance()
 582 {
 583     return theOutlineTypeMgr::get();
 584 }
 585
 586 void OutlineTypeMgr::Init()
 587 {
 588     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 589     Reference<XDefaultNumberingProvider> xDefNum = DefaultNumberingProvider::create( xContext );
 590
 591     Sequence<Reference<XIndexAccess> > aOutlineAccess;
 592     Locale aLocale(Application::GetSettings().GetLanguageTag().getLocale());
 593     try
 594     {
 595         aOutlineAccess = xDefNum->getDefaultOutlineNumberings( aLocale );
 596
 597         SvxNumRule aDefNumRule( SvxNumRuleFlags::BULLET_REL_SIZE | SvxNumRuleFlags::CONTINUOUS | SvxNumRuleFlags::BULLET_COLOR,
 598             10, false,
 599             SvxNumRuleType::NUMBERING, SvxNumberFormat::LABEL_ALIGNMENT);
 600
 601         auto nSize = std::min<sal_Int32>(aOutlineAccess.getLength(), DEFAULT_NUM_VALUSET_COUNT);
 602         for(sal_Int32 nItem = 0; nItem < nSize; nItem++ )
 603         {
 604             pOutlineSettingsArrs[ nItem ] = new OutlineSettings_Impl;
 605             OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[ nItem ];
 606             pItemArr->sDescription = SvxResId( RID_SVXSTR_OUTLINENUM_DESCRIPTION_0 + nItem );
 607             pItemArr->pNumSettingsArr = new NumSettingsArr_Impl;
 608             Reference<XIndexAccess> xLevel = aOutlineAccess.getConstArray()[nItem];
 609             for(sal_Int32 nLevel = 0; nLevel < xLevel->getCount() && nLevel < 5; nLevel++)
 610             {
 611                 Any aValueAny = xLevel->getByIndex(nLevel);
 612                 Sequence<PropertyValue> aLevelProps;
 613                 aValueAny >>= aLevelProps;
 614                 NumSettings_Impl* pNew = lcl_CreateNumberingSettingsPtr(aLevelProps);
 615                 const SvxNumberFormat& aNumFmt( aDefNumRule.GetLevel( nLevel) );
 616                 pNew->eLabelFollowedBy = aNumFmt.GetLabelFollowedBy();
 617                 pNew->nTabValue = aNumFmt.GetListtabPos();
 618                 pNew->eNumAlign = aNumFmt.GetNumAdjust();
 619                 pNew->nNumAlignAt = aNumFmt.GetFirstLineIndent();
 620                 pNew->nNumIndentAt = aNumFmt.GetIndentAt();
 621                 pItemArr->pNumSettingsArr->push_back(std::shared_ptr<NumSettings_Impl>(pNew));
 622             }
 623         }
 624     }
 625     catch(Exception&)
 626     {
 627     }
 628 }
 629
 630 sal_uInt16 OutlineTypeMgr::GetNBOIndexForNumRule(SvxNumRule& aNum,sal_uInt16 /*mLevel*/,sal_uInt16 nFromIndex)
 631 {
 632     sal_uInt16 const nLength = SAL_N_ELEMENTS(pOutlineSettingsArrs);
 633     for(sal_uInt16 iDex = nFromIndex; iDex < nLength; iDex++)
 634     {
 635         bool bNotMatch = false;
 636         OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[iDex];
 637         sal_uInt16 nCount = pItemArr->pNumSettingsArr->size();
 638         for (sal_uInt16 iLevel=0;iLevel < nCount;iLevel++)
 639         {
 640             NumSettings_Impl* _pSet = (*pItemArr->pNumSettingsArr)[iLevel].get();
 641             sal_Int16 eNType = _pSet->nNumberType;
 642
 643             const SvxNumberFormat& aFmt(aNum.GetLevel(iLevel));
 644             const OUString& sPrefix = aFmt.GetPrefix();
 645             const OUString& sLclSuffix = aFmt.GetSuffix();
 646             sal_Int16 eNumType = aFmt.GetNumberingType();
 647             if( eNumType == SVX_NUM_CHAR_SPECIAL)
 648             {
 649                 sal_UCS4 cChar = aFmt.GetBulletChar();
 650
 651                 sal_UCS4 ccChar
 652                     = _pSet->sBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0)));
 653
 654                 if ( !((cChar == ccChar) &&
 655                     _pSet->eLabelFollowedBy == aFmt.GetLabelFollowedBy() &&
 656                     _pSet->nTabValue == aFmt.GetListtabPos() &&
 657                     _pSet->eNumAlign == aFmt.GetNumAdjust() &&
 658                     _pSet->nNumAlignAt == aFmt.GetFirstLineIndent() &&
 659                     _pSet->nNumIndentAt == aFmt.GetIndentAt()))
 660                 {
 661                     bNotMatch = true;
 662                     break;
 663                 }
 664                 }else if ((eNumType&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) {
 665                         const SvxBrushItem* pBrsh1 = aFmt.GetBrush();
 666                         const SvxBrushItem* pBrsh2 = _pSet->pBrushItem;
 667                         bool bIsMatch = false;
 668                         if (pBrsh1==pBrsh2) bIsMatch = true;
 669                         if (pBrsh1 && pBrsh2) {
 670                             const Graphic* pGrf1 = pBrsh1->GetGraphic();
 671                             const Graphic* pGrf2 = pBrsh2->GetGraphic();
 672                             if (pGrf1==pGrf2) bIsMatch = true;
 673                             if (pGrf1 && pGrf2) {
 674                                 if ( pGrf1->GetBitmapEx() == pGrf2->GetBitmapEx() &&
 675                                      _pSet->aSize == aFmt.GetGraphicSize())
 676                                     bIsMatch = true;
 677                             }
 678                         }
 679                         if (!bIsMatch) {
 680                             bNotMatch = true;
 681                             break;
 682                         }
 683                 } else
 684                 {
 685                 if (!(sPrefix == _pSet->sPrefix &&
 686                       sLclSuffix == _pSet->sSuffix &&
 687                       eNumType == eNType &&
 688                       _pSet->eLabelFollowedBy == aFmt.GetLabelFollowedBy() &&
 689                       _pSet->nTabValue == aFmt.GetListtabPos() &&
 690                       _pSet->eNumAlign == aFmt.GetNumAdjust() &&
 691                       _pSet->nNumAlignAt == aFmt.GetFirstLineIndent() &&
 692                       _pSet->nNumIndentAt == aFmt.GetIndentAt()))
 693                 {
 694                     bNotMatch = true;
 695                     break;
 696                 }
 697                 }
 698         }
 699         if ( !bNotMatch )
 700             return iDex+1;
 701     }
 702
 703
 704     return sal_uInt16(0xFFFF);
 705 }
 706
 707 void OutlineTypeMgr::RelplaceNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 mLevel)
 708 {
 709     sal_uInt16 const nLength = SAL_N_ELEMENTS(pOutlineSettingsArrs);
 710     if ( nIndex >= nLength )
 711         return;
 712
 713     OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex];
 714     sal_uInt16 nCount = pItemArr->pNumSettingsArr->size();
 715     for (sal_uInt16 iLevel=0;iLevel < nCount;iLevel++)
 716     {
 717         const SvxNumberFormat& aFmt(aNum.GetLevel(iLevel));
 718         SvxNumType eNumType = aFmt.GetNumberingType();
 719
 720         NumSettings_Impl* _pSet = (*pItemArr->pNumSettingsArr)[iLevel].get();
 721
 722         _pSet->eLabelFollowedBy = aFmt.GetLabelFollowedBy();
 723         _pSet->nTabValue = aFmt.GetListtabPos();
 724         _pSet->eNumAlign = aFmt.GetNumAdjust();
 725         _pSet->nNumAlignAt = aFmt.GetFirstLineIndent();
 726         _pSet->nNumIndentAt = aFmt.GetIndentAt();
 727
 728         if( eNumType == SVX_NUM_CHAR_SPECIAL)
 729         {
 730             sal_UCS4 cChar = aFmt.GetBulletChar();
 731             OUString sChar(&cChar, 1);
 732             _pSet->sBulletChar = sChar;
 733             if ( aFmt.GetBulletFont() )
 734                 _pSet->sBulletFont = aFmt.GetBulletFont()->GetFamilyName();
 735             _pSet->nNumberType = eNumType;
 736             pItemArr->bIsCustomized = true;
 737         }else if ((eNumType&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) {
 738             if (_pSet->pBrushItem) {
 739                 delete _pSet->pBrushItem;
 740                 _pSet->pBrushItem=nullptr;
 741             }
 742             if (aFmt.GetBrush())
 743                 _pSet->pBrushItem = new SvxBrushItem(*aFmt.GetBrush());
 744             _pSet->aSize = aFmt.GetGraphicSize();
 745             _pSet->nNumberType = eNumType;
 746         } else
 747         {
 748             _pSet->sPrefix = aFmt.GetPrefix();
 749             _pSet->sSuffix = aFmt.GetSuffix();
 750             _pSet->nNumberType = eNumType;
 751             if ( aFmt.GetBulletFont() )
 752                 _pSet->sBulletFont = aFmt.GetBulletFont()->GetFamilyName();
 753             pItemArr->bIsCustomized = true;
 754          }
 755     }
 756     SvxNumRule aTmpRule1(aNum);
 757     SvxNumRule aTmpRule2(aNum);
 758     ApplyNumRule(aTmpRule1,nIndex,mLevel,true);
 759     ApplyNumRule(aTmpRule2,nIndex,mLevel);
 760     if (aTmpRule1==aTmpRule2) pItemArr->bIsCustomized=false;
 761     if (!pItemArr->bIsCustomized) {
 762         pItemArr->sDescription = GetDescription(nIndex,true);
 763     }
 764     ImplStore(u"standard.syc");
 765 }
 766
 767 void OutlineTypeMgr::ApplyNumRule(SvxNumRule& aNum, sal_uInt16 nIndex, sal_uInt16 /*mLevel*/, bool isDefault, bool isResetSize)
 768 {
 769     DBG_ASSERT(DEFAULT_NUM_VALUSET_COUNT > nIndex, "wrong index");
 770     if(DEFAULT_NUM_VALUSET_COUNT <= nIndex)
 771         return;
 772
 773     const FontList* pList = nullptr;
 774
 775     OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex];
 776     if (isDefault) pItemArr=pDefaultOutlineSettingsArrs[nIndex];
 777
 778     NumSettingsArr_Impl *pNumSettingsArr=pItemArr->pNumSettingsArr;
 779
 780     NumSettings_Impl* pLevelSettings = nullptr;
 781     for(sal_uInt16 i = 0; i < aNum.GetLevelCount(); i++)
 782     {
 783         if(pNumSettingsArr->size() > i)
 784             pLevelSettings = (*pNumSettingsArr)[i].get();
 785
 786         if(!pLevelSettings)
 787             break;
 788
 789         SvxNumberFormat aFmt(aNum.GetLevel(i));
 790         const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont();
 791         if (pLevelSettings->nNumberType !=aFmt.GetNumberingType()) isResetSize=true;
 792         aFmt.SetNumberingType( pLevelSettings->nNumberType );
 793         sal_uInt16 nUpperLevelOrChar = static_cast<sal_uInt16>(pLevelSettings->nParentNumbering);
 794         if(aFmt.GetNumberingType() == SVX_NUM_CHAR_SPECIAL)
 795         {
 796             if( pLevelSettings->sBulletFont.getLength() &&
 797                 pLevelSettings->sBulletFont != rActBulletFont.GetFamilyName() )
 798             {
 799                 //search for the font
 800                 if(!pList)
 801                 {
 802                     SfxObjectShell* pCurDocShell = SfxObjectShell::Current();
 803                     const SvxFontListItem* pFontListItem = static_cast<const SvxFontListItem*>( pCurDocShell->GetItem( SID_ATTR_CHAR_FONTLIST ) );
 804                     pList = pFontListItem ? pFontListItem->GetFontList() : nullptr;
 805                 }
 806                 if(pList && pList->IsAvailable( pLevelSettings->sBulletFont ) )
 807                 {
 808                     FontMetric aFontMetric = pList->Get(pLevelSettings->sBulletFont,WEIGHT_NORMAL, ITALIC_NONE);
 809                     vcl::Font aFont(aFontMetric);
 810                     aFmt.SetBulletFont(&aFont);
 811                 }
 812                 else
 813                 {
 814                     //if it cannot be found then create a new one
 815                     vcl::Font aCreateFont( pLevelSettings->sBulletFont, OUString(), Size( 0, 14 ) );
 816                     aCreateFont.SetCharSet( RTL_TEXTENCODING_DONTKNOW );
 817                     aCreateFont.SetFamily( FAMILY_DONTKNOW );
 818                     aCreateFont.SetPitch( PITCH_DONTKNOW );
 819                     aCreateFont.SetWeight( WEIGHT_DONTKNOW );
 820                     aCreateFont.SetTransparent( true );
 821                     aFmt.SetBulletFont( &aCreateFont );
 822                 }
 823             }else
 824                 aFmt.SetBulletFont( &rActBulletFont );
 825
 826             sal_UCS4 cChar = 0;
 827             if( !pLevelSettings->sBulletChar.isEmpty() )
 828             {
 829                 cChar
 830                     = pLevelSettings->sBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0)));
 831             }
 832             if( AllSettings::GetLayoutRTL() )
 833             {
 834                 if( 0 == i && cChar == BulletsTypeMgr::aDynamicBulletTypes[5] )
 835                     cChar = BulletsTypeMgr::aDynamicRTLBulletTypes[5];
 836                 else if( 1 == i )
 837                 {
 838                     const SvxNumberFormat& numberFmt = aNum.GetLevel(0);
 839                     if( numberFmt.GetBulletChar() == BulletsTypeMgr::aDynamicRTLBulletTypes[5] )
 840                         cChar = BulletsTypeMgr::aDynamicRTLBulletTypes[4];
 841                 }
 842             }
 843
 844             aFmt.SetBulletChar(cChar);
 845             aFmt.SetCharFormatName( GetBulletCharFmtName() );
 846             if (isResetSize) aFmt.SetBulletRelSize(45);
 847         }else if ((aFmt.GetNumberingType()&(~LINK_TOKEN)) == SVX_NUM_BITMAP ) {
 848             if (pLevelSettings->pBrushItem) {
 849                     const Graphic* pGrf = pLevelSettings->pBrushItem->GetGraphic();
 850                     Size aSize = pLevelSettings->aSize;
 851                     sal_Int16 eOrient = text::VertOrientation::LINE_CENTER;
 852                     if (!isResetSize  && aFmt.GetGraphicSize()!=Size(0,0))\
 853                         aSize = aFmt.GetGraphicSize();
 854                     else if (aSize.IsEmpty() && pGrf)
 855                         aSize = SvxNumberFormat::GetGraphicSizeMM100( pGrf );
 856                     aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(GetMapUnit()));
 857                     aFmt.SetGraphicBrush( pLevelSettings->pBrushItem, &aSize, &eOrient );
 858             }
 859         } else
 860         {
 861             aFmt.SetIncludeUpperLevels(sal::static_int_cast< sal_uInt8 >(0 != nUpperLevelOrChar ? aNum.GetLevelCount() : 1));
 862             aFmt.SetCharFormatName(GetNumCharFmtName());
 863             if (isResetSize) aFmt.SetBulletRelSize(100);
 864         }
 865         if(pNumSettingsArr->size() > i) {
 866             aFmt.SetLabelFollowedBy(pLevelSettings->eLabelFollowedBy);
 867             aFmt.SetListtabPos(pLevelSettings->nTabValue);
 868             aFmt.SetNumAdjust(pLevelSettings->eNumAlign);
 869             aFmt.SetFirstLineIndent(pLevelSettings->nNumAlignAt);
 870             aFmt.SetIndentAt(pLevelSettings->nNumIndentAt);
 871         }
 872         aFmt.SetListFormat(pLevelSettings->sPrefix, pLevelSettings->sSuffix, i);
 873         aNum.SetLevel(i, aFmt);
 874     }
 875 }
 876
 877 OUString OutlineTypeMgr::GetDescription(sal_uInt16 nIndex, bool isDefault)
 878 {
 879     OUString sRet;
 880
 881     if ( nIndex >= SAL_N_ELEMENTS(pOutlineSettingsArrs) )
 882         return sRet;
 883     else
 884     {
 885         OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex];
 886         if (isDefault) pItemArr = pDefaultOutlineSettingsArrs[nIndex];
 887         if ( pItemArr )
 888         {
 889             sRet = pItemArr->sDescription;
 890         }
 891     }
 892     return sRet;
 893 }
 894
 895 bool OutlineTypeMgr::IsCustomized(sal_uInt16 nIndex)
 896 {
 897     bool bRet = false;
 898
 899     if ( nIndex >= SAL_N_ELEMENTS(pOutlineSettingsArrs) )
 900         return bRet;
 901     else
 902     {
 903         OutlineSettings_Impl* pItemArr = pOutlineSettingsArrs[nIndex];
 904         if ( pItemArr )
 905         {
 906             bRet = pItemArr->bIsCustomized;
 907         }
 908     }
 909
 910     return bRet;
 911 }
 912
 913
 914 }
 915
 916 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */