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 64 : ::osl::Mutex OLimitedFormats::s_aMutex;
41 64 : Reference< XNumberFormatsSupplier > OLimitedFormats::s_xStandardFormats;
42 :
43 :
44 : //=
45 :
46 :
47 : enum LocaleType
48 : {
49 : ltEnglishUS,
50 : ltGerman,
51 : ltSystem
52 : };
53 :
54 :
55 786 : static const Locale& getLocale(LocaleType _eType)
56 : {
57 786 : static const Locale s_aEnglishUS( OUString("en"), OUString("us"), OUString() );
58 786 : static const Locale s_aGerman( OUString("de"), OUString("DE"), OUString() );
59 786 : static const OUString s_sEmptyString;
60 786 : static const Locale s_aSystem( s_sEmptyString, s_sEmptyString, s_sEmptyString );
61 :
62 786 : switch (_eType)
63 : {
64 : case ltEnglishUS:
65 444 : return s_aEnglishUS;
66 :
67 : case ltGerman:
68 342 : 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 290 : static FormatEntry* lcl_getFormatTable(sal_Int16 nTableId)
88 : {
89 290 : 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 106 : 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 184 : return s_aFormats;
123 : }
124 : }
125 :
126 : OSL_FAIL("lcl_getFormatTable: invalid id!");
127 0 : return NULL;
128 : }
129 :
130 92 : OLimitedFormats::OLimitedFormats(const Reference< XComponentContext >& _rxContext, const sal_Int16 _nClassId)
131 : :m_nFormatEnumPropertyHandle(-1)
132 92 : ,m_nTableId(_nClassId)
133 : {
134 : OSL_ENSURE(_rxContext.is(), "OLimitedFormats::OLimitedFormats: invalid service factory!");
135 92 : acquireSupplier(_rxContext);
136 92 : ensureTableInitialized(m_nTableId);
137 92 : }
138 :
139 :
140 176 : OLimitedFormats::~OLimitedFormats()
141 : {
142 88 : releaseSupplier();
143 88 : }
144 :
145 :
146 92 : void OLimitedFormats::ensureTableInitialized(const sal_Int16 _nTableId)
147 : {
148 92 : FormatEntry* pFormatTable = lcl_getFormatTable(_nTableId);
149 92 : if (-1 == pFormatTable->nKey)
150 : {
151 44 : ::osl::MutexGuard aGuard(s_aMutex);
152 44 : if (-1 == pFormatTable->nKey)
153 : {
154 : // initialize the keys
155 44 : Reference<XNumberFormats> xStandardFormats;
156 44 : if (s_xStandardFormats.is())
157 44 : xStandardFormats = s_xStandardFormats->getNumberFormats();
158 : OSL_ENSURE(xStandardFormats.is(), "OLimitedFormats::ensureTableInitialized: don't have a formats supplier!");
159 :
160 44 : if (xStandardFormats.is())
161 : {
162 : // loop through the table
163 44 : FormatEntry* pLoopFormats = pFormatTable;
164 568 : while (pLoopFormats->pDescription)
165 : {
166 : // get the key for the description
167 480 : pLoopFormats->nKey = xStandardFormats->queryKey(
168 : OUString::createFromAscii(pLoopFormats->pDescription),
169 480 : getLocale(pLoopFormats->eLocale),
170 : sal_False
171 960 : );
172 :
173 480 : if (-1 == pLoopFormats->nKey)
174 : {
175 266 : pLoopFormats->nKey = xStandardFormats->addNew(
176 : OUString::createFromAscii(pLoopFormats->pDescription),
177 266 : getLocale(pLoopFormats->eLocale)
178 532 : );
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 480 : ++pLoopFormats;
193 : }
194 44 : }
195 44 : }
196 : }
197 92 : }
198 :
199 :
200 76 : void OLimitedFormats::clearTable(const sal_Int16 _nTableId)
201 : {
202 76 : ::osl::MutexGuard aGuard(s_aMutex);
203 76 : FormatEntry* pFormats = lcl_getFormatTable(_nTableId);
204 76 : FormatEntry* pResetLoop = pFormats;
205 760 : while (pResetLoop->pDescription)
206 : {
207 608 : pResetLoop->nKey = -1;
208 608 : ++pResetLoop;
209 76 : }
210 76 : }
211 :
212 :
213 180 : 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 180 : m_xAggregate = _rxAggregate;
220 180 : 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 180 : }
235 :
236 :
237 118 : void OLimitedFormats::getFormatKeyPropertyValue( Any& _rValue ) const
238 : {
239 118 : _rValue.clear();
240 :
241 : OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::getFormatKeyPropertyValue: not initialized!");
242 118 : if (m_xAggregate.is())
243 : {
244 : // get the aggregate's enum property value
245 118 : Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
246 118 : sal_Int32 nValue = -1;
247 118 : ::cppu::enum2int(nValue, aEnumPropertyValue);
248 :
249 : // get the translation table
250 118 : const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
251 :
252 : // seek to the nValue'th entry
253 118 : sal_Int32 nLookup = 0;
254 384 : for ( ;
255 532 : (NULL != pFormats->pDescription) && (nLookup < nValue);
256 : ++pFormats, ++nLookup
257 : )
258 : ;
259 : OSL_ENSURE(NULL != pFormats->pDescription, "OLimitedFormats::getFormatKeyPropertyValue: did not find the value!");
260 118 : if (pFormats->pDescription)
261 118 : _rValue <<= pFormats->nKey;
262 : }
263 :
264 : // TODO: should use a standard format for the control type we're working for
265 118 : }
266 :
267 :
268 4 : 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 4 : if (m_xAggregate.is())
273 : {
274 : // the new format key to set
275 4 : sal_Int32 nNewFormat = 0;
276 4 : if (!(_rNewValue >>= nNewFormat))
277 0 : throw IllegalArgumentException();
278 :
279 : // get the old (enum) value from the aggregate
280 4 : Any aEnumPropertyValue = m_xAggregate->getFastPropertyValue(m_nFormatEnumPropertyHandle);
281 4 : sal_Int32 nOldEnumValue = -1;
282 4 : ::cppu::enum2int(nOldEnumValue, aEnumPropertyValue);
283 :
284 : // get the translation table
285 4 : const FormatEntry* pFormats = lcl_getFormatTable(m_nTableId);
286 :
287 4 : _rOldValue.clear();
288 4 : _rConvertedValue.clear();
289 :
290 : // look for the entry with the given format key
291 4 : sal_Int32 nTablePosition = 0;
292 72 : for ( ;
293 68 : (NULL != pFormats->pDescription) && (nNewFormat != pFormats->nKey);
294 : ++pFormats, ++nTablePosition
295 : )
296 : {
297 32 : if (nTablePosition == nOldEnumValue)
298 4 : _rOldValue <<= pFormats->nKey;
299 : }
300 :
301 4 : bool bFoundIt = (NULL != pFormats->pDescription);
302 4 : bool bModified = false;
303 4 : if (bFoundIt)
304 : {
305 0 : _rConvertedValue <<= (sal_Int16)nTablePosition;
306 0 : bModified = nTablePosition != nOldEnumValue;
307 : }
308 :
309 4 : 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 0 : while (pFormats->pDescription)
313 : {
314 0 : if (nTablePosition == nOldEnumValue)
315 : {
316 0 : _rOldValue <<= pFormats->nKey;
317 0 : break;
318 : }
319 :
320 0 : ++pFormats;
321 0 : ++nTablePosition;
322 : }
323 : }
324 :
325 : OSL_ENSURE(_rOldValue.hasValue(), "OLimitedFormats::convertFormatKeyPropertyValue: did not find the old enum value in the table!");
326 :
327 4 : if (!bFoundIt)
328 : { // somebody gave us a format which we can't translate
329 4 : OUString sMessage ("This control supports only a very limited number of formats.");
330 4 : throw IllegalArgumentException(sMessage, NULL, 2);
331 : }
332 :
333 4 : return bModified;
334 : }
335 :
336 0 : return false;
337 : }
338 :
339 :
340 0 : void OLimitedFormats::setFormatKeyPropertyValue( const Any& _rNewValue )
341 : {
342 : OSL_ENSURE(m_xAggregate.is() && (-1 != m_nFormatEnumPropertyHandle), "OLimitedFormats::setFormatKeyPropertyValue: not initialized!");
343 :
344 0 : 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 0 : m_xAggregate->setFastPropertyValue(m_nFormatEnumPropertyHandle, _rNewValue);
349 : }
350 0 : }
351 :
352 :
353 92 : void OLimitedFormats::acquireSupplier(const Reference< XComponentContext >& _rxContext)
354 : {
355 92 : ::osl::MutexGuard aGuard(s_aMutex);
356 92 : if (1 == ++s_nInstanceCount)
357 : { // create the standard formatter
358 40 : s_xStandardFormats = NumberFormatsSupplier::createWithLocale(_rxContext, getLocale(ltEnglishUS));
359 92 : }
360 92 : }
361 :
362 :
363 88 : void OLimitedFormats::releaseSupplier()
364 : {
365 88 : ::osl::MutexGuard aGuard(s_aMutex);
366 88 : if (0 == --s_nInstanceCount)
367 : {
368 38 : ::comphelper::disposeComponent(s_xStandardFormats);
369 38 : s_xStandardFormats = NULL;
370 :
371 38 : clearTable(FormComponentType::TIMEFIELD);
372 38 : clearTable(FormComponentType::DATEFIELD);
373 88 : }
374 88 : }
375 :
376 :
377 192 : } // namespace frm
378 :
379 :
380 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
