include/unotools/compatibility.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_UNOTOOLS_COMPATIBILITY_HXX
  20 #define INCLUDED_UNOTOOLS_COMPATIBILITY_HXX
  21
  22 #include <com/sun/star/uno/Sequence.h>
  23 #include <com/sun/star/uno/Any.hxx>
  24 #include <unotools/options.hxx>
  25 #include <unotools/unotoolsdllapi.h>
  26 #include <rtl/ustring.hxx>
  27 #include <memory>
  28
  29 namespace com { namespace sun { namespace star { namespace beans { struct PropertyValue; } } } }
  30 namespace osl { class Mutex; }
  31
  32 /*-************************************************************************************************************
  33     @descr  Struct to hold information about one compatibility entry
  34 *//*-*************************************************************************************************************/
  35 class UNOTOOLS_DLLPUBLIC SvtCompatibilityEntry
  36 {
  37     public:
  38         /*-************************************************************************************************************
  39             @descr          The method SvtCompatibilityOptions::GetList() returns a list of property values.
  40                             Use follow enum class to separate values by names.
  41                             Sync it with sPropertyName in SvtCompatibilityEntry::getName()
  42         *//*-*************************************************************************************************************/
  43         enum class Index
  44         {
  45             /* Should be in the start. Do not remove it. */
  46             Name,
  47             Module,
  48
  49             /* Editable list of compatibility options. */
  50             UsePrtMetrics,
  51             AddSpacing,
  52             AddSpacingAtPages,
  53             UseOurTabStops,
  54             NoExtLeading,
  55             UseLineSpacing,
  56             AddTableSpacing,
  57             UseObjectPositioning,
  58             UseOurTextWrapping,
  59             ConsiderWrappingStyle,
  60             ExpandWordSpace,
  61             ProtectForm,
  62             MsWordTrailingBlanks,
  63             SubtractFlysAnchoredAtFlys,
  64             EmptyDbFieldHidesPara,
  65             /// special entry: optcomp.cxx converts the other values to
  66             /// integers but not this one because it doesn't have its own
  67             /// checkbox, so keep it at the end!
  68             AddTableLineSpacing,
  69
  70             /* Should be at the end. Do not remove it. */
  71             INVALID
  72         };
  73
  74         SvtCompatibilityEntry();
  75
  76         static OUString getName( const Index rIdx );
  77
  78         static OUString getUserEntryName()
  79         {
  80             return "_user";
  81         }
  82
  83         static OUString getDefaultEntryName()
  84         {
  85             return "_default";
  86         }
  87
  88         static Index getIndex( const OUString& rName )
  89         {
  90             for ( int i = static_cast<int>(Index::Name); i < static_cast<int>(Index::INVALID); ++i )
  91                 if ( getName( Index(i) ) == rName )
  92                     return Index(i);
  93
  94             /* SvtCompatibilityEntry::getIndex() Undeclared compatibility property name */
  95             assert(false);
  96
  97             return Index::INVALID;
  98         }
  99
 100         static size_t getElementCount()
 101         {
 102             return static_cast<size_t>(Index::INVALID);
 103         }
 104
 105         css::uno::Any getValue( const Index rIdx ) const
 106         {
 107             if ( static_cast<size_t>(rIdx) < getElementCount() )
 108             {
 109                 return m_aPropertyValue[ static_cast<int>(rIdx) ];
 110             } else
 111             {
 112                 /* Wrong index. */
 113                 assert( false );
 114                 return css::uno::Any();
 115             }
 116         }
 117
 118         template<typename T>
 119         T getValue( const Index rIdx ) const
 120         {
 121             T aValue = T();
 122
 123             if ( static_cast<size_t>(rIdx) < getElementCount() )
 124             {
 125                 m_aPropertyValue[ static_cast<int>(rIdx) ] >>= aValue;
 126             } else
 127             {
 128                 /* Wrong index. */
 129                 assert( false );
 130             }
 131
 132             return aValue;
 133         }
 134
 135         void setValue( const Index rIdx, css::uno::Any const & rValue )
 136         {
 137             if ( static_cast<size_t>(rIdx) < getElementCount() )
 138             {
 139                 m_aPropertyValue[ static_cast<int>(rIdx) ] = rValue;
 140             } else
 141             {
 142                 /* Wrong index. */
 143                 assert( false );
 144             }
 145         }
 146
 147         template<typename T>
 148         void setValue( const Index rIdx, T rValue )
 149         {
 150             if ( static_cast<size_t>(rIdx) < getElementCount() )
 151             {
 152                 m_aPropertyValue[ static_cast<int>(rIdx) ] = css::uno::Any(rValue);
 153             } else
 154             {
 155                 /* Wrong index. */
 156                 assert( false );
 157             }
 158         }
 159
 160         bool isDefaultEntry() const
 161         {
 162             return m_bDefaultEntry;
 163         }
 164
 165         void setDefaultEntry( bool rValue )
 166         {
 167             m_bDefaultEntry = rValue;
 168         }
 169
 170     private:
 171         std::vector<css::uno::Any> m_aPropertyValue;
 172         bool                       m_bDefaultEntry;
 173 };
 174
 175 /*-************************************************************************************************************
 176     @short          forward declaration to our private date container implementation
 177     @descr          We use these class as internal member to support small memory requirements.
 178                     You can create the container if it is necessary. The class which use these mechanism
 179                     is faster and smaller then a complete implementation!
 180 *//*-*************************************************************************************************************/
 181 class SvtCompatibilityOptions_Impl;
 182
 183 /*-************************************************************************************************************
 184     @short          collect information about dynamic menus
 185     @descr          Make it possible to configure dynamic menu structures of menus like "new" or "wizard".
 186     @devstatus      ready to use
 187 *//*-*************************************************************************************************************/
 188 class UNOTOOLS_DLLPUBLIC SvtCompatibilityOptions final : public utl::detail::Options
 189 {
 190     public:
 191         SvtCompatibilityOptions();
 192         virtual ~SvtCompatibilityOptions() override;
 193
 194         /*-****************************************************************************************************
 195             @short      append a new item
 196             @descr
 197
 198             @seealso    method Clear()
 199
 200             @param      "aItem"             SvtCompatibilityEntry
 201         *//*-*****************************************************************************************************/
 202         void AppendItem( const SvtCompatibilityEntry& aItem );
 203
 204         /*-****************************************************************************************************
 205             @short      clear complete specified list
 206             @descr      Call this methods to clear the whole list.
 207         *//*-*****************************************************************************************************/
 208         void Clear();
 209
 210         void SetDefault( SvtCompatibilityEntry::Index rIdx, bool rValue );
 211         bool GetDefault( SvtCompatibilityEntry::Index rIdx ) const;
 212
 213         /*-****************************************************************************************************
 214             @short      return complete specified list
 215             @descr      Call it to get all entries of compatibility options.
 216                         We return a list of all nodes with its names and properties.
 217             @return     A list of compatibility options is returned.
 218
 219             @onerror    We return an empty list.
 220         *//*-*****************************************************************************************************/
 221         css::uno::Sequence< css::uno::Sequence< css::beans::PropertyValue > > GetList() const;
 222
 223     private:
 224         std::shared_ptr<SvtCompatibilityOptions_Impl> m_pImpl;
 225
 226         /*-****************************************************************************************************
 227             @short      return a reference to a static mutex
 228             @descr      These class is partially threadsafe (for de-/initialization only).
 229                         All access methods aren't safe!
 230                         We create a static mutex only for one ime and use at different times.
 231             @return     A reference to a static mutex member.
 232         *//*-*****************************************************************************************************/
 233         UNOTOOLS_DLLPRIVATE static osl::Mutex& GetOwnStaticMutex();
 234 };
 235
 236 #endif // INCLUDED_UNOTOOLS_COMPATIBILITY_HXX
 237
 238 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */