LCOV - code coverage report
Current view: top level - forms/source/misc - limitedformats.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 126 0.0 %
Date: 2014-04-14 Functions: 0 14 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10