unotools/source/config/compatibility.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
  20 #include <unotools/compatibility.hxx>
  21 #include <unotools/configitem.hxx>
  22 #include <unotools/syslocale.hxx>
  23 #include <tools/debug.hxx>
  24 #include <sal/log.hxx>
  25 #include <com/sun/star/uno/Any.hxx>
  26 #include <com/sun/star/uno/Sequence.hxx>
  27 #include <com/sun/star/beans/PropertyValue.hpp>
  28 #include <com/sun/star/lang/Locale.hpp>
  29 #include <i18nlangtag/languagetag.hxx>
  30
  31 #include "itemholder1.hxx"
  32
  33 #include <algorithm>
  34
  35 using namespace ::utl;
  36 using namespace ::osl;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::beans;
  39
  40 constexpr OUStringLiteral ROOTNODE_OPTIONS = u"Office.Compatibility";
  41 #define PATHDELIMITER           "/"
  42 #define SETNODE_ALLFILEFORMATS  "AllFileFormats"
  43
  44 SvtCompatibilityEntry::SvtCompatibilityEntry()
  45     : m_aPropertyValue( SvtCompatibilityEntry::getElementCount() )
  46 {
  47     /* Should be in the start. Do not remove it. */
  48     setValue<OUString>( Index::Name, OUString() );
  49     setValue<OUString>( Index::Module, OUString() );
  50
  51     /* Editable list of default values. Sync it with the SvtCompatibilityEntry::Index enum class. */
  52     setValue<bool>( Index::AddSpacing, false );
  53     setValue<bool>( Index::AddSpacingAtPages, false );
  54     setValue<bool>( Index::UseOurTabStops, false );
  55     setValue<bool>( Index::NoExtLeading, false );
  56     setValue<bool>( Index::UseLineSpacing, false );
  57     setValue<bool>( Index::AddTableSpacing, false );
  58     setValue<bool>( Index::UseObjectPositioning, false );
  59     setValue<bool>( Index::UseOurTextWrapping, false );
  60     setValue<bool>( Index::ConsiderWrappingStyle, false );
  61     setValue<bool>( Index::ExpandWordSpace, true );
  62     setValue<bool>( Index::ProtectForm, false );
  63     setValue<bool>( Index::MsWordTrailingBlanks, false );
  64     setValue<bool>( Index::SubtractFlysAnchoredAtFlys, false );
  65     setValue<bool>( Index::EmptyDbFieldHidesPara, true );
  66     setValue<bool>( Index::AddTableLineSpacing, false );
  67 }
  68
  69 OUString SvtCompatibilityEntry::getName( const Index rIdx )
  70 {
  71     static const char* sPropertyName[] =
  72     {
  73         /* Should be in the start. Do not remove it. */
  74         "Name",
  75         "Module",
  76
  77         /* Editable list of compatibility option names. Sync it with the SvtCompatibilityEntry::Index enum class. */
  78         "AddSpacing",
  79         "AddSpacingAtPages",
  80         "UseOurTabStopFormat",
  81         "NoExternalLeading",
  82         "UseLineSpacing",
  83         "AddTableSpacing",
  84         "UseObjectPositioning",
  85         "UseOurTextWrapping",
  86         "ConsiderWrappingStyle",
  87         "ExpandWordSpace",
  88         "ProtectForm",
  89         "MsWordCompTrailingBlanks",
  90         "SubtractFlysAnchoredAtFlys",
  91         "EmptyDbFieldHidesPara",
  92
  93         "AddTableLineSpacing" // Must be the last one
  94     };
  95
  96     /* Size of sPropertyName array not equal size of the SvtCompatibilityEntry::Index enum class */
  97     assert( std::size(sPropertyName) == SvtCompatibilityEntry::getElementCount() );
  98
  99     return OUString::createFromAscii( sPropertyName[ static_cast<int>(rIdx) ] );
 100 }
 101
 102 /*-****************************************************************************************************************
 103     @descr  support simple menu structures and operations on it
 104 ****************************************************************************************************************-*/
 105
 106 /*-****************************************************************************************************
 107     @short      base implementation of public interface for "SvtCompatibilityOptions"!
 108     @descr      These class is used as static member of "SvtCompatibilityOptions" ...
 109                 => The code exist only for one time and isn't duplicated for every instance!
 110 *//*-*****************************************************************************************************/
 111 class SvtCompatibilityOptions_Impl : public ConfigItem
 112 {
 113     public:
 114         SvtCompatibilityOptions_Impl();
 115         virtual ~SvtCompatibilityOptions_Impl() override;
 116
 117         void AppendItem( const SvtCompatibilityEntry& aItem );
 118         void Clear();
 119
 120         void SetDefault( SvtCompatibilityEntry::Index rIdx, bool rValue );
 121         bool GetDefault( SvtCompatibilityEntry::Index rIdx ) const;
 122
 123         const std::vector< SvtCompatibilityEntry > & GetOptions() const { return m_aOptions; }
 124
 125         /*-****************************************************************************************************
 126             @short      called for notify of configmanager
 127             @descr      This method is called from the ConfigManager before the application ends or from the
 128                         PropertyChangeListener if the sub tree broadcasts changes. You must update your
 129                         internal values.
 130
 131             @seealso    baseclass ConfigItem
 132
 133             @param      "lPropertyNames" is the list of properties which should be updated.
 134         *//*-*****************************************************************************************************/
 135         virtual void Notify( const Sequence< OUString >& lPropertyNames ) override;
 136
 137     private:
 138         virtual void ImplCommit() override;
 139
 140         /*-****************************************************************************************************
 141             @short      return list of key names of our configuration management which represent one module tree
 142             @descr      These methods return the current list of key names! We need it to get needed values from our
 143                         configuration management and support dynamical menu item lists!
 144             @return     A list of configuration key names is returned.
 145         *//*-*****************************************************************************************************/
 146         Sequence< OUString > impl_GetPropertyNames( Sequence< OUString >& rItems );
 147
 148     private:
 149         std::vector< SvtCompatibilityEntry > m_aOptions;
 150         SvtCompatibilityEntry                m_aDefOptions;
 151 };
 152
 153 SvtCompatibilityOptions_Impl::SvtCompatibilityOptions_Impl() : ConfigItem( ROOTNODE_OPTIONS )
 154 {
 155     // Get names and values of all accessible menu entries and fill internal structures.
 156     // See impl_GetPropertyNames() for further information.
 157     Sequence< OUString > lNodes;
 158     Sequence< OUString > lNames  = impl_GetPropertyNames( lNodes );
 159     Sequence< Any >      lValues = GetProperties( lNames );
 160
 161     // Safe impossible cases.
 162     // We need values from ALL configuration keys.
 163     // Follow assignment use order of values in relation to our list of key names!
 164     DBG_ASSERT( !( lNames.getLength()!=lValues.getLength() ), "SvtCompatibilityOptions_Impl::SvtCompatibilityOptions_Impl()\nI miss some values of configuration keys!\n" );
 165
 166     // Get names/values for new menu.
 167     // 4 subkeys for every item!
 168     bool bDefaultFound = false;
 169     sal_Int32 nDestStep    = 0;
 170     for ( const auto& rNode : std::as_const(lNodes) )
 171     {
 172         SvtCompatibilityEntry aItem;
 173
 174         aItem.setValue<OUString>( SvtCompatibilityEntry::Index::Name, rNode );
 175
 176         for ( int i = static_cast<int>(SvtCompatibilityEntry::Index::Module); i < static_cast<int>(SvtCompatibilityEntry::Index::INVALID); ++i )
 177         {
 178             aItem.setValue( SvtCompatibilityEntry::Index(i), lValues[ nDestStep ] );
 179             nDestStep++;
 180         }
 181
 182         m_aOptions.push_back( aItem );
 183
 184         if ( !bDefaultFound && aItem.getValue<OUString>( SvtCompatibilityEntry::Index::Name ) == SvtCompatibilityEntry::DEFAULT_ENTRY_NAME )
 185         {
 186             SvtSysLocale aSysLocale;
 187             css::lang::Locale aLocale = aSysLocale.GetLanguageTag().getLocale();
 188             if ( aLocale.Language == "zh" || aLocale.Language == "ja" || aLocale.Language == "ko" )
 189                 aItem.setValue<bool>( SvtCompatibilityEntry::Index::ExpandWordSpace, false );
 190
 191             m_aDefOptions = aItem;
 192             bDefaultFound = true;
 193         }
 194     }
 195 }
 196
 197 SvtCompatibilityOptions_Impl::~SvtCompatibilityOptions_Impl()
 198 {
 199     assert( !IsModified() ); // should have been committed
 200 }
 201
 202 void SvtCompatibilityOptions_Impl::AppendItem( const SvtCompatibilityEntry& aItem )
 203 {
 204     m_aOptions.push_back( aItem );
 205
 206     // default item reset?
 207     if ( aItem.getValue<OUString>( SvtCompatibilityEntry::Index::Name ) == SvtCompatibilityEntry::DEFAULT_ENTRY_NAME )
 208         m_aDefOptions = aItem;
 209
 210     SetModified();
 211 }
 212
 213 void SvtCompatibilityOptions_Impl::Clear()
 214 {
 215     m_aOptions.clear();
 216
 217     SetModified();
 218 }
 219
 220 void SvtCompatibilityOptions_Impl::SetDefault( SvtCompatibilityEntry::Index rIdx, bool rValue )
 221 {
 222     /* Are not set Name and Module */
 223     assert( rIdx != SvtCompatibilityEntry::Index::Name && rIdx != SvtCompatibilityEntry::Index::Module );
 224
 225     m_aDefOptions.setValue<bool>( rIdx, rValue );
 226 }
 227
 228 bool SvtCompatibilityOptions_Impl::GetDefault( SvtCompatibilityEntry::Index rIdx ) const
 229 {
 230     /* Are not set Name and Module */
 231     assert( rIdx != SvtCompatibilityEntry::Index::Name && rIdx != SvtCompatibilityEntry::Index::Module );
 232
 233     return m_aDefOptions.getValue<bool>( rIdx );
 234 }
 235
 236 void SvtCompatibilityOptions_Impl::Notify( const Sequence< OUString >& )
 237 {
 238     SAL_WARN( "unotools.config", "SvtCompatibilityOptions_Impl::Notify() Not implemented yet! I don't know how I can handle a dynamical list of unknown properties ..." );
 239 }
 240
 241 void SvtCompatibilityOptions_Impl::ImplCommit()
 242 {
 243     // Write all properties!
 244     // Delete complete set first.
 245     ClearNodeSet( SETNODE_ALLFILEFORMATS );
 246
 247     Sequence< PropertyValue > lPropertyValues( SvtCompatibilityEntry::getElementCount() - 1 );
 248     auto lPropertyValuesRange = asNonConstRange(lPropertyValues);
 249     sal_uInt32 nNewCount = m_aOptions.size();
 250     for ( sal_uInt32 nItem = 0; nItem < nNewCount; ++nItem )
 251     {
 252         SvtCompatibilityEntry aItem = m_aOptions[ nItem ];
 253         OUString              sNode = SETNODE_ALLFILEFORMATS PATHDELIMITER + aItem.getValue<OUString>( SvtCompatibilityEntry::Index::Name ) + PATHDELIMITER;
 254
 255         for ( int i = static_cast<int>(SvtCompatibilityEntry::Index::Module); i < static_cast<int>(SvtCompatibilityEntry::Index::INVALID); ++i )
 256         {
 257             lPropertyValuesRange[ i - 1 ].Name  = sNode + SvtCompatibilityEntry::getName( SvtCompatibilityEntry::Index(i) );
 258             lPropertyValuesRange[ i - 1 ].Value = aItem.getValue( SvtCompatibilityEntry::Index(i) );
 259         }
 260
 261         SetSetProperties( SETNODE_ALLFILEFORMATS, lPropertyValues );
 262     }
 263 }
 264
 265 Sequence< OUString > SvtCompatibilityOptions_Impl::impl_GetPropertyNames( Sequence< OUString >& rItems )
 266 {
 267     // First get ALL names of current existing list items in configuration!
 268     rItems = GetNodeNames( SETNODE_ALLFILEFORMATS );
 269
 270     // expand list to result list ...
 271     Sequence< OUString > lProperties( rItems.getLength() * ( SvtCompatibilityEntry::getElementCount() - 1 ) );
 272     auto lPropertiesRange = asNonConstRange(lProperties);
 273
 274     sal_Int32 nDestStep    = 0;
 275     // Copy entries to destination and expand every item with 2 supported sub properties.
 276     for ( const auto& rItem : std::as_const(rItems) )
 277     {
 278         OUString sFixPath = SETNODE_ALLFILEFORMATS PATHDELIMITER + rItem + PATHDELIMITER;
 279         for ( int i = static_cast<int>(SvtCompatibilityEntry::Index::Module); i < static_cast<int>(SvtCompatibilityEntry::Index::INVALID); ++i )
 280         {
 281             lPropertiesRange[ nDestStep ] = sFixPath + SvtCompatibilityEntry::getName( SvtCompatibilityEntry::Index(i) );
 282             nDestStep++;
 283         }
 284     }
 285
 286     // Return result.
 287     return lProperties;
 288 }
 289
 290 namespace
 291 {
 292     std::weak_ptr<SvtCompatibilityOptions_Impl> theOptions;
 293 }
 294
 295 SvtCompatibilityOptions::SvtCompatibilityOptions()
 296 {
 297     // Global access, must be guarded (multithreading!).
 298     MutexGuard aGuard( GetOwnStaticMutex() );
 299
 300     m_pImpl = theOptions.lock();
 301     if ( !m_pImpl )
 302     {
 303         m_pImpl    = std::make_shared<SvtCompatibilityOptions_Impl>();
 304         theOptions = m_pImpl;
 305         ItemHolder1::holdConfigItem( EItem::Compatibility );
 306     }
 307 }
 308
 309 SvtCompatibilityOptions::~SvtCompatibilityOptions()
 310 {
 311     // Global access, must be guarded (multithreading!)
 312     MutexGuard aGuard( GetOwnStaticMutex() );
 313     m_pImpl.reset();
 314 }
 315
 316 void SvtCompatibilityOptions::AppendItem( const SvtCompatibilityEntry& aItem )
 317 {
 318     MutexGuard aGuard( GetOwnStaticMutex() );
 319     m_pImpl->AppendItem( aItem );
 320 }
 321
 322 void SvtCompatibilityOptions::Clear()
 323 {
 324     MutexGuard aGuard( GetOwnStaticMutex() );
 325     m_pImpl->Clear();
 326 }
 327
 328 void SvtCompatibilityOptions::SetDefault( SvtCompatibilityEntry::Index rIdx, bool rValue )
 329 {
 330     MutexGuard aGuard( GetOwnStaticMutex() );
 331     m_pImpl->SetDefault( rIdx, rValue );
 332 }
 333
 334 bool SvtCompatibilityOptions::GetDefault( SvtCompatibilityEntry::Index rIdx ) const
 335 {
 336     MutexGuard aGuard( GetOwnStaticMutex() );
 337     return m_pImpl->GetDefault( rIdx );
 338 }
 339
 340 std::vector< SvtCompatibilityEntry > SvtCompatibilityOptions::GetList() const
 341 {
 342     MutexGuard aGuard( GetOwnStaticMutex() );
 343
 344     return m_pImpl->GetOptions();
 345 }
 346
 347 Mutex& SvtCompatibilityOptions::GetOwnStaticMutex()
 348 {
 349     static osl::Mutex aMutex;
 350     return aMutex;
 351 }
 352
 353 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */