forms/source/misc/limitedformats.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 "limitedformats.hxx"
  21 #include "services.hxx"
  22 #include <osl/diagnose.h>
  23 #include <comphelper/types.hxx>
  24 #include <comphelper/extract.hxx>
  25 #include <com/sun/star/form/FormComponentType.hpp>
  26 #include <com/sun/star/util/NumberFormatsSupplier.hpp>
  27
  28
  29 namespace frm
  30 {
  31
  32
  33     using namespace ::com::sun::star::uno;
  34     using namespace ::com::sun::star::util;
  35     using namespace ::com::sun::star::lang;
  36     using namespace ::com::sun::star::form;
  37     using namespace ::com::sun::star::beans;
  38
  39     sal_Int32                               OLimitedFormats::s_nInstanceCount(0);
  40     ::osl::Mutex                            OLimitedFormats::s_aMutex;
  41     Reference< XNumberFormatsSupplier >     OLimitedFormats::s_xStandardFormats;
  42
  43
  44     //=
  45
  46
  47     enum LocaleType
  48     {
  49         ltEnglishUS,
  50         ltGerman,
  51         ltSystem
  52     };
  53
  54
  55     static const Locale& getLocale(LocaleType _eType)
  56     {
  57         static const Locale s_aEnglishUS( OUString("en"), OUString("us"), OUString() );
  58         static const Locale s_aGerman( OUString("de"), OUString("DE"), OUString() );
  59         static const OUString s_sEmptyString;
  60         static const Locale s_aSystem( s_sEmptyString, s_sEmptyString, s_sEmptyString );
  61
  62         switch (_eType)
  63         {
  64             case ltEnglishUS:
  65                 return s_aEnglishUS;
  66
  67             case ltGerman:
  68                 return s_aGerman;
  69
  70             case ltSystem:
  71                 return s_aSystem;
  72         }
  73
  74         OSL_FAIL("getLocale: invalid enum value!");
  75         return s_aSystem;
  76     }
  77
  78
  79     struct FormatEntry
  80     {
  81         const sal_Char* pDescription;
  82         sal_Int32       nKey;
  83         LocaleType      eLocale;
  84     };
  85
  86
  87     static FormatEntry* lcl_getFormatTable(sal_Int16 nTableId)
  88     {
  89         switch (nTableId)
  90         {
  91             case FormComponentType::TIMEFIELD:
  92             {
  93                 static FormatEntry s_aFormats[] = {
  94                     { "HH:MM", -1, ltEnglishUS },
  95                     { "HH:MM:SS", -1, ltEnglishUS },
  96                     { "HH:MM AM/PM", -1, ltEnglishUS },
  97                     { "HH:MM:SS AM/PM", -1, ltEnglishUS },
  98                     { nullptr, -1, ltSystem }
  99                 };
 100                 return s_aFormats;
 101             }
 102             case FormComponentType::DATEFIELD:
 103             {
 104                 static FormatEntry s_aFormats[] = {
 105                     { "T-M-JJ", -1, ltGerman },
 106                     { "TT-MM-JJ", -1, ltGerman },
 107                     { "TT-MM-JJJJ", -1, ltGerman },
 108                     { "NNNNT. MMMM JJJJ", -1, ltGerman },
 109
 110                     { "DD/MM/YY", -1, ltEnglishUS },
 111                     { "MM/DD/YY", -1, ltEnglishUS },
 112                     { "YY/MM/DD", -1, ltEnglishUS },
 113                     { "DD/MM/YYYY", -1, ltEnglishUS },
 114                     { "MM/DD/YYYY", -1, ltEnglishUS },
 115                     { "YYYY/MM/DD", -1, ltEnglishUS },
 116
 117                     { "JJ-MM-TT", -1, ltGerman },
 118                     { "JJJJ-MM-TT", -1, ltGerman },
 119
 120                     { nullptr, -1, ltSystem }
 121                 };
 122                 return s_aFormats;
 123             }
 124         }
 125
 126         OSL_FAIL("lcl_getFormatTable: invalid id!");
 127         return nullptr;
 128     }
 129
 130     OLimitedFormats::OLimitedFormats(const Reference< XComponentContext >& _rxContext, const sal_Int16 _nClassId)
 131         :m_nFormatEnumPropertyHandle(-1)
 132         ,m_nTableId(_nClassId)
 133     {
 134         OSL_ENSURE(_rxContext.is(), "OLimitedFormats::OLimitedFormats: invalid service factory!");
 135         acquireSupplier(_rxContext);
 136         ensureTableInitialized(m_nTableId);
 137     }
 138
 139
 140     OLimitedFormats::~OLimitedFormats()
 141     {
 142         releaseSupplier();
 143     }
 144
 145
 146     void OLimitedFormats::ensureTableInitialized(const sal_Int16 _nTableId)
 147     {
 148         FormatEntry* pFormatTable = lcl_getFormatTable(_nTableId);
 149         if (-1 == pFormatTable->nKey)
 150         {
 151             ::osl::MutexGuard aGuard(s_aMutex);
 152             if (-1 == pFormatTable->nKey)
 153             {
 154                 // initialize the keys
 155                 Reference<XNumberFormats> xStandardFormats;
 156                 if (s_xStandardFormats.is())
 157                     xStandardFormats = s_xStandardFormats->getNumberFormats();
 158                 OSL_ENSURE(xStandardFormats.is(), "OLimitedFormats::ensureTableInitialized: don't have a formats supplier!");
 159
 160                 if (xStandardFormats.is())
 161                 {
 162                     // loop through the table
 163                     FormatEntry* pLoopFormats = pFormatTable;
 164                     while (pLoopFormats->pDescription)
 165                     {
 166                         // get the key for the description
 167                         pLoopFormats->nKey = xStandardFormats->queryKey(
 168                             OUString::createFromAscii(pLoopFormats->pDescription),
 169                             getLocale(pLoopFormats->eLocale),
 170                             false
 171                         );
 172
 173                         if (-1 == pLoopFormats->nKey)
 174                         {
 175                             pLoopFormats->nKey = xStandardFormats->addNew(
 176                                 OUString::createFromAscii(pLoopFormats->pDescription),
 177                                 getLocale(pLoopFormats->eLocale)
 178                             );
 179 #ifdef DBG_UTIL
 180                             try
 181                             {
 182                                 xStandardFormats->getByKey(pLoopFormats->nKey);
 183                             }
 184                             catch(const Exception&)
 185                             {
 186                                 OSL_FAIL("OLimitedFormats::ensureTableInitialized: adding the key to the formats collection failed!");
 187                             }
 188 #endif
 189                         }
 190
 191                         // next
 192                         ++pLoopFormats;
 193                     }
 194                 }
 195             }
 196         }
 197     }
 198
 199
 200     void OLimitedFormats::clearTable(const sal_Int16 _nTableId)
 201     {
 202         ::osl::MutexGuard aGuard(s_aMutex);
 203         FormatEntry* pFormats = lcl_getFormatTable(_nTableId);
 204         FormatEntry* pResetLoop = pFormats;
 205         while (pResetLoop->pDescription)
 206         {
 207             pResetLoop->nKey = -1;
 208             ++pResetLoop;
 209         }
 210     }
 211
 212
 213     void OLimitedFormats::setAggregateSet(const Reference< XFastPropertySet >& _rxAggregate, sal_Int32 _nOriginalPropertyHandle)
 214     {
 215         // changes (NULL -> not NULL) and (not NULL -> NULL) are allowed
 216         OSL_ENSURE(!m_xAggregate.is() || !_rxAggregate.is(), "OLimitedFormats::setAggregateSet: already have an aggregate!");
 217         OSL_ENSURE(_rxAggregate.is() || m_xAggregate.is(), "OLimitedFormats::setAggregateSet: invalid new aggregate!");
 218
 219         m_xAggregate = _rxAggregate;
 220         m_nFormatEnumPropertyHandle = _nOriginalPropertyHandle;
 221 #ifdef DBG_UTIL
 222         if (m_xAggregate.is())
 223         {
 224             try
 225             {
 226                 m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 227             }
 228             catch(const Exception&)
 229             {
 230                 OSL_FAIL("OLimitedFormats::setAggregateSet: invalid handle!");
 231             }
 232         }
 233 #endif
 234     }
 235
 236
 237     void OLimitedFormats::getFormatKeyPropertyValue( Any& _rValue ) const
 238     {
 239         _rValue.clear();
 240
 241         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::getFormatKeyPropertyValue: not initialized!");
 242         if (m_xAggregate.is())
 243         {
 244             // get the aggregate's enum property value
 245             Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 246             sal_Int32 nValue = -1;
 247             ::cppu::enum2int(nValue, aEnumPropertyValue);
 248
 249             // get the translation table
 250             const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
 251
 252             // seek to the nValue'th entry
 253             sal_Int32 nLookup = 0;
 254             for (   ;
 255                     (nullptr != pFormats->pDescription) && (nLookup < nValue);
 256                     ++pFormats, ++nLookup
 257                 )
 258                 ;
 259             OSL_ENSURE(nullptr != pFormats->pDescription, "OLimitedFormats::getFormatKeyPropertyValue: did not find the value!");
 260             if (pFormats->pDescription)
 261                 _rValue <<= pFormats->nKey;
 262         }
 263
 264         // TODO: should use a standard format for the control type we're working for
 265     }
 266
 267
 268     bool OLimitedFormats::convertFormatKeyPropertyValue(Any& _rConvertedValue, Any& _rOldValue, const Any& _rNewValue)
 269     {
 270         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::convertFormatKeyPropertyValue: not initialized!");
 271
 272         if (m_xAggregate.is())
 273         {
 274             // the new format key to set
 275             sal_Int32 nNewFormat = 0;
 276             if (!(_rNewValue >>= nNewFormat))
 277                 throw IllegalArgumentException();
 278
 279             // get the old (enum) value from the aggregate
 280             Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 281             sal_Int32 nOldEnumValue = -1;
 282             ::cppu::enum2int(nOldEnumValue, aEnumPropertyValue);
 283
 284             // get the translation table
 285             const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
 286
 287             _rOldValue.clear();
 288             _rConvertedValue.clear();
 289
 290             // look for the entry with the given format key
 291             sal_Int32 nTablePosition = 0;
 292             for (   ;
 293                     (nullptr != pFormats->pDescription) && (nNewFormat != pFormats->nKey);
 294                     ++pFormats, ++nTablePosition
 295                 )
 296             {
 297                 if (nTablePosition == nOldEnumValue)
 298                     _rOldValue <<= pFormats->nKey;
 299             }
 300
 301             bool bFoundIt = (nullptr != pFormats->pDescription);
 302             bool bModified = false;
 303             if (bFoundIt)
 304             {
 305                 _rConvertedValue <<= (sal_Int16)nTablePosition;
 306                 bModified = nTablePosition != nOldEnumValue;
 307             }
 308
 309             if (!_rOldValue.hasValue())
 310             {   // did not reach the end of the table (means we found nNewFormat)
 311                 // -> go to the end to ensure that _rOldValue is set
 312                 while (pFormats->pDescription)
 313                 {
 314                     if (nTablePosition == nOldEnumValue)
 315                     {
 316                         _rOldValue <<= pFormats->nKey;
 317                         break;
 318                     }
 319
 320                     ++pFormats;
 321                     ++nTablePosition;
 322                 }
 323             }
 324
 325             OSL_ENSURE(_rOldValue.hasValue(), "OLimitedFormats::convertFormatKeyPropertyValue: did not find the old enum value in the table!");
 326
 327             if (!bFoundIt)
 328             {   // somebody gave us a format which we can't translate
 329                 OUString sMessage ("This control supports only a very limited number of formats.");
 330                 throw IllegalArgumentException(sMessage, nullptr, 2);
 331             }
 332
 333             return bModified;
 334         }
 335
 336         return false;
 337     }
 338
 339
 340     void OLimitedFormats::setFormatKeyPropertyValue( const Any& _rNewValue )
 341     {
 342         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::setFormatKeyPropertyValue: not initialized!");
 343
 344         if (m_xAggregate.is())
 345         {   // this is to be called after convertFormatKeyPropertyValue, where
 346             // we translated the format key into an enum value.
 347             // So now we can simply forward this enum value to our aggregate
 348             m_xAggregate->setFastPropertyValue(m_nFormatEnumPropertyHandle, _rNewValue);
 349         }
 350     }
 351
 352
 353     void OLimitedFormats::acquireSupplier(const Reference< XComponentContext >& _rxContext)
 354     {
 355         ::osl::MutexGuard aGuard(s_aMutex);
 356         if (1 == ++s_nInstanceCount)
 357         {   // create the standard formatter
 358             s_xStandardFormats = NumberFormatsSupplier::createWithLocale(_rxContext, getLocale(ltEnglishUS));
 359         }
 360     }
 361
 362
 363     void OLimitedFormats::releaseSupplier()
 364     {
 365         ::osl::MutexGuard aGuard(s_aMutex);
 366         if (0 == --s_nInstanceCount)
 367         {
 368             ::comphelper::disposeComponent(s_xStandardFormats);
 369             s_xStandardFormats = nullptr;
 370
 371             clearTable(FormComponentType::TIMEFIELD);
 372             clearTable(FormComponentType::DATEFIELD);
 373         }
 374     }
 375
 376
 377 }   // namespace frm
 378
 379
 380 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */