forms/source/misc/limitedformats.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: limitedformats.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_forms.hxx"
  33 #include "limitedformats.hxx"
  34 #include "services.hxx"
  35 #include <osl/diagnose.h>
  36 #include <comphelper/types.hxx>
  37 #include <comphelper/extract.hxx>
  38 #include <com/sun/star/form/FormComponentType.hpp>
  39
  40 //.........................................................................
  41 namespace frm
  42 {
  43 //.........................................................................
  44
  45     using namespace ::com::sun::star::uno;
  46     using namespace ::com::sun::star::util;
  47     using namespace ::com::sun::star::lang;
  48     using namespace ::com::sun::star::form;
  49     using namespace ::com::sun::star::beans;
  50
  51     sal_Int32                                                           OLimitedFormats::s_nInstanceCount(0);
  52     ::osl::Mutex                                                        OLimitedFormats::s_aMutex;
  53     Reference< XNumberFormatsSupplier >         OLimitedFormats::s_xStandardFormats;
  54
  55     //=====================================================================
  56     //=
  57     //=====================================================================
  58     //---------------------------------------------------------------------
  59     enum LocaleType
  60     {
  61         ltEnglishUS,
  62         ltGerman,
  63         ltSystem
  64     };
  65
  66     //---------------------------------------------------------------------
  67     static const Locale& getLocale(LocaleType _eType)
  68     {
  69         static const Locale s_aEnglishUS( ::rtl::OUString::createFromAscii("en"), ::rtl::OUString::createFromAscii("us"), ::rtl::OUString() );
  70         static const Locale s_aGerman( ::rtl::OUString::createFromAscii("de"), ::rtl::OUString::createFromAscii("DE"), ::rtl::OUString() );
  71         static const ::rtl::OUString s_sEmptyString;
  72         static const Locale s_aSystem( s_sEmptyString, s_sEmptyString, s_sEmptyString );
  73
  74         switch (_eType)
  75         {
  76             case ltEnglishUS:
  77                 return s_aEnglishUS;
  78
  79             case ltGerman:
  80                 return s_aGerman;
  81
  82             case ltSystem:
  83                 return s_aSystem;
  84         }
  85
  86         OSL_ENSURE(sal_False, "getLocale: invalid enum value!");
  87         return s_aSystem;
  88     }
  89
  90     //---------------------------------------------------------------------
  91     struct FormatEntry
  92     {
  93         const sal_Char* pDescription;
  94         sal_Int32               nKey;
  95         LocaleType              eLocale;
  96     };
  97
  98     //---------------------------------------------------------------------
  99     static const FormatEntry* lcl_getFormatTable(sal_Int16 nTableId)
 100     {
 101         switch (nTableId)
 102         {
 103             case FormComponentType::TIMEFIELD:
 104             {
 105                 static FormatEntry s_aFormats[] = {
 106                     { "HH:MM", -1, ltEnglishUS },
 107                     { "HH:MM:SS", -1, ltEnglishUS },
 108                     { "HH:MM AM/PM", -1, ltEnglishUS },
 109                     { "HH:MM:SS AM/PM", -1, ltEnglishUS },
 110                     { NULL, -1, ltSystem }
 111                 };
 112                 // don't switch this table here to const. The compiler could be tempted to really place this
 113                 // in a non-writeable segment, but we want to fill in the format keys later ....
 114                 return s_aFormats;
 115             }
 116             case FormComponentType::DATEFIELD:
 117             {
 118                 static FormatEntry s_aFormats[] = {
 119                     { "T-M-JJ", -1, ltGerman },
 120                     { "TT-MM-JJ", -1, ltGerman },
 121                     { "TT-MM-JJJJ", -1, ltGerman },
 122                     { "NNNNT. MMMM JJJJ", -1, ltGerman },
 123
 124                     { "DD/MM/YY", -1, ltEnglishUS },
 125                     { "MM/DD/YY", -1, ltEnglishUS },
 126                     { "YY/MM/DD", -1, ltEnglishUS },
 127                     { "DD/MM/YYYY", -1, ltEnglishUS },
 128                     { "MM/DD/YYYY", -1, ltEnglishUS },
 129                     { "YYYY/MM/DD", -1, ltEnglishUS },
 130
 131                     { "JJ-MM-TT", -1, ltGerman },
 132                     { "JJJJ-MM-TT", -1, ltGerman },
 133
 134                     { NULL, -1, ltSystem }
 135                 };
 136                 return s_aFormats;
 137             }
 138         }
 139
 140         OSL_ENSURE(sal_False, "lcl_getFormatTable: invalid id!");
 141         return NULL;
 142     }
 143
 144     //=====================================================================
 145     //= OLimitedFormats
 146     //=====================================================================
 147     //---------------------------------------------------------------------
 148     OLimitedFormats::OLimitedFormats(const Reference< XMultiServiceFactory >& _rxORB, const sal_Int16 _nClassId)
 149         :m_nFormatEnumPropertyHandle(-1)
 150         ,m_nTableId(_nClassId)
 151     {
 152         OSL_ENSURE(_rxORB.is(), "OLimitedFormats::OLimitedFormats: invalid service factory!");
 153         acquireSupplier(_rxORB);
 154         ensureTableInitialized(m_nTableId);
 155     }
 156
 157     //---------------------------------------------------------------------
 158     OLimitedFormats::~OLimitedFormats()
 159     {
 160         releaseSupplier();
 161     }
 162
 163     //---------------------------------------------------------------------
 164     void OLimitedFormats::ensureTableInitialized(const sal_Int16 _nTableId)
 165     {
 166         const FormatEntry* pFormatTable = lcl_getFormatTable(_nTableId);
 167         if (-1 == pFormatTable->nKey)
 168         {
 169             ::osl::MutexGuard aGuard(s_aMutex);
 170             if (-1 == pFormatTable->nKey)
 171             {
 172                 // initialize the keys
 173                 Reference<XNumberFormats> xStandardFormats;
 174                 if (s_xStandardFormats.is())
 175                     xStandardFormats = s_xStandardFormats->getNumberFormats();
 176                 OSL_ENSURE(xStandardFormats.is(), "OLimitedFormats::ensureTableInitialized: don't have a formats supplier!");
 177
 178                 if (xStandardFormats.is())
 179                 {
 180                     // loop through the table
 181                     FormatEntry* pLoopFormats = const_cast<FormatEntry*>(pFormatTable);
 182                     while (pLoopFormats->pDescription)
 183                     {
 184                         // get the key for the description
 185                         pLoopFormats->nKey = xStandardFormats->queryKey(
 186                             ::rtl::OUString::createFromAscii(pLoopFormats->pDescription),
 187                             getLocale(pLoopFormats->eLocale),
 188                             sal_False
 189                         );
 190
 191                         if (-1 == pLoopFormats->nKey)
 192                         {
 193                             pLoopFormats->nKey = xStandardFormats->addNew(
 194                                 ::rtl::OUString::createFromAscii(pLoopFormats->pDescription),
 195                                 getLocale(pLoopFormats->eLocale)
 196                             );
 197 #ifdef DBG_UTIL
 198                             try
 199                             {
 200                                 xStandardFormats->getByKey(pLoopFormats->nKey);
 201                             }
 202                             catch(const Exception&)
 203                             {
 204                                 OSL_ENSURE(sal_False, "OLimitedFormats::ensureTableInitialized: adding the key to the formats collection failed!");
 205                             }
 206 #endif
 207                         }
 208
 209                         // next
 210                         ++pLoopFormats;
 211                     }
 212                 }
 213             }
 214         }
 215     }
 216
 217     //---------------------------------------------------------------------
 218     void OLimitedFormats::clearTable(const sal_Int16 _nTableId)
 219     {
 220         ::osl::MutexGuard aGuard(s_aMutex);
 221         const FormatEntry* pFormats = lcl_getFormatTable(_nTableId);
 222         FormatEntry* pResetLoop = const_cast<FormatEntry*>(pFormats);
 223         while (pResetLoop->pDescription)
 224         {
 225             pResetLoop->nKey = -1;
 226             ++pResetLoop;
 227         }
 228     }
 229
 230     //---------------------------------------------------------------------
 231     void OLimitedFormats::setAggregateSet(const Reference< XFastPropertySet >& _rxAggregate, sal_Int32 _nOriginalPropertyHandle)
 232     {
 233         // changes (NULL -> not NULL) and (not NULL -> NULL) are allowed
 234         OSL_ENSURE(!m_xAggregate.is() || !_rxAggregate.is(), "OLimitedFormats::setAggregateSet: already have an aggregate!");
 235         OSL_ENSURE(_rxAggregate.is() || m_xAggregate.is(), "OLimitedFormats::setAggregateSet: invalid new aggregate!");
 236
 237         m_xAggregate = _rxAggregate;
 238         m_nFormatEnumPropertyHandle = _nOriginalPropertyHandle;
 239 #ifdef DBG_UTIL
 240         if (m_xAggregate.is())
 241         {
 242             try
 243             {
 244                 m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 245             }
 246             catch(const Exception&)
 247             {
 248                 OSL_ENSURE(sal_False, "OLimitedFormats::setAggregateSet: invalid handle!");
 249             }
 250         }
 251 #endif
 252     }
 253
 254     //---------------------------------------------------------------------
 255     void OLimitedFormats::getFormatKeyPropertyValue( Any& _rValue ) const
 256     {
 257         _rValue.clear();
 258
 259         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::getFormatKeyPropertyValue: not initialized!");
 260         if (m_xAggregate.is())
 261         {
 262             // get the aggregate's enum property value
 263             Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 264             sal_Int32 nValue = -1;
 265             ::cppu::enum2int(nValue, aEnumPropertyValue);
 266
 267             // get the translation table
 268             const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
 269
 270             // seek to the nValue'th entry
 271             sal_Int32 nLookup = 0;
 272             for (       ;
 273                     (NULL != pFormats->pDescription) && (nLookup < nValue);
 274                     ++pFormats, ++nLookup
 275                 )
 276                 ;
 277             OSL_ENSURE(NULL != pFormats->pDescription, "OLimitedFormats::getFormatKeyPropertyValue: did not find the value!");
 278             if (pFormats->pDescription)
 279                 _rValue <<= pFormats->nKey;
 280         }
 281
 282         // TODO: should use a standard format for the control type we're working for
 283     }
 284
 285     //---------------------------------------------------------------------
 286     sal_Bool OLimitedFormats::convertFormatKeyPropertyValue(Any& _rConvertedValue, Any& _rOldValue, const Any& _rNewValue)
 287     {
 288         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::convertFormatKeyPropertyValue: not initialized!");
 289
 290         if (m_xAggregate.is())
 291         {
 292             // the new format key to set
 293             sal_Int32 nNewFormat = 0;
 294             if (!(_rNewValue >>= nNewFormat))
 295                 throw IllegalArgumentException();
 296
 297             // get the old (enum) value from the aggregate
 298             Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
 299             sal_Int32 nOldEnumValue = -1;
 300             ::cppu::enum2int(nOldEnumValue, aEnumPropertyValue);
 301
 302             // get the translation table
 303             const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
 304
 305             _rOldValue.clear();
 306             _rConvertedValue.clear();
 307
 308             // look for the entry with the given format key
 309             sal_Int32 nTablePosition = 0;
 310             for (       ;
 311                     (NULL != pFormats->pDescription) && (nNewFormat != pFormats->nKey);
 312                     ++pFormats, ++nTablePosition
 313                 )
 314             {
 315                 if (nTablePosition == nOldEnumValue)
 316                     _rOldValue <<= pFormats->nKey;
 317             }
 318
 319             sal_Bool bFoundIt = (NULL != pFormats->pDescription);
 320             sal_Bool bModified = sal_False;
 321             if (bFoundIt)
 322             {
 323                 _rConvertedValue <<= (sal_Int16)nTablePosition;
 324                 bModified = nTablePosition != nOldEnumValue;
 325             }
 326
 327             if (!_rOldValue.hasValue())
 328             {   // did not reach the end of the table (means we found nNewFormat)
 329                 // -> go to the end to ensure that _rOldValue is set
 330                 while (pFormats->pDescription)
 331                 {
 332                     if (nTablePosition == nOldEnumValue)
 333                     {
 334                         _rOldValue <<= pFormats->nKey;
 335                         break;
 336                     }
 337
 338                     ++pFormats;
 339                     ++nTablePosition;
 340                 }
 341             }
 342
 343             OSL_ENSURE(_rOldValue.hasValue(), "OLimitedFormats::convertFormatKeyPropertyValue: did not find the old enum value in the table!");
 344
 345             if (!bFoundIt)
 346             {   // somebody gave us an format which we can't translate
 347                 ::rtl::OUString sMessage = ::rtl::OUString::createFromAscii("This control supports only a very limited number of formats.");
 348                 throw IllegalArgumentException(sMessage, NULL, 2);
 349             }
 350
 351             return bModified;
 352         }
 353
 354         return sal_False;
 355     }
 356
 357     //---------------------------------------------------------------------
 358     void OLimitedFormats::setFormatKeyPropertyValue( const Any& _rNewValue )
 359     {
 360         OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::setFormatKeyPropertyValue: not initialized!");
 361
 362         if (m_xAggregate.is())
 363         {       // this is to be called after convertFormatKeyPropertyValue, where
 364             // we translated the format key into a enum value.
 365             // So now we can simply forward this enum value to our aggreate
 366             m_xAggregate->setFastPropertyValue(m_nFormatEnumPropertyHandle, _rNewValue);
 367         }
 368     }
 369
 370     //---------------------------------------------------------------------
 371     void OLimitedFormats::acquireSupplier(const Reference< XMultiServiceFactory >& _rxORB)
 372     {
 373         ::osl::MutexGuard aGuard(s_aMutex);
 374         if ((1 == ++s_nInstanceCount) && _rxORB.is())
 375         {       // create the standard formatter
 376
 377             Sequence< Any > aInit(1);
 378             aInit[0] <<= getLocale(ltEnglishUS);
 379
 380             Reference< XInterface > xSupplier = _rxORB->createInstanceWithArguments(FRM_NUMBER_FORMATS_SUPPLIER, aInit);
 381             OSL_ENSURE(xSupplier.is(), "OLimitedFormats::OLimitedFormats: could not create a formats supplier!");
 382
 383             s_xStandardFormats = Reference< XNumberFormatsSupplier >(xSupplier, UNO_QUERY);
 384             OSL_ENSURE(s_xStandardFormats.is() || !xSupplier.is(), "OLimitedFormats::OLimitedFormats: missing an interface!");
 385         }
 386     }
 387
 388     //---------------------------------------------------------------------
 389     void OLimitedFormats::releaseSupplier()
 390     {
 391         ::osl::MutexGuard aGuard(s_aMutex);
 392         if (0 == --s_nInstanceCount)
 393         {
 394             ::comphelper::disposeComponent(s_xStandardFormats);
 395             s_xStandardFormats = NULL;
 396
 397             clearTable(FormComponentType::TIMEFIELD);
 398             clearTable(FormComponentType::DATEFIELD);
 399         }
 400     }
 401
 402 //.........................................................................
 403 }       // namespace frm
 404 //.........................................................................
 405