Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : :
30 : : #include <boost/bind.hpp>
31 : :
32 : : #include <vcl/svapp.hxx>
33 : : #include <comphelper/servicehelper.hxx>
34 : :
35 : : #include <com/sun/star/sheet/ValidationAlertStyle.hpp>
36 : : #include <com/sun/star/sheet/ValidationType.hpp>
37 : : #include <com/sun/star/sheet/TableValidationVisibility.hpp>
38 : :
39 : : #include "fmtuno.hxx"
40 : : #include "miscuno.hxx"
41 : : #include "validat.hxx"
42 : : #include "document.hxx"
43 : : #include "unonames.hxx"
44 : : #include "styleuno.hxx" // ScStyleNameConversion
45 : : #include "tokenarray.hxx"
46 : : #include "tokenuno.hxx"
47 : :
48 : : using namespace ::com::sun::star;
49 : : using namespace ::formula;
50 : :
51 : : //------------------------------------------------------------------------
52 : :
53 : : // Map nur fuer PropertySetInfo
54 : :
55 : 80 : const SfxItemPropertyMapEntry* lcl_GetValidatePropertyMap()
56 : : {
57 : : static SfxItemPropertyMapEntry aValidatePropertyMap_Impl[] =
58 : : {
59 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_ERRALSTY), 0, &getCppuType((sheet::ValidationAlertStyle*)0), 0, 0},
60 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_ERRMESS), 0, &getCppuType((rtl::OUString*)0), 0, 0},
61 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_ERRTITLE), 0, &getCppuType((rtl::OUString*)0), 0, 0},
62 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_IGNOREBL), 0, &getBooleanCppuType(), 0, 0},
63 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_INPMESS), 0, &getCppuType((rtl::OUString*)0), 0, 0},
64 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_INPTITLE), 0, &getCppuType((rtl::OUString*)0), 0, 0},
65 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_SHOWERR), 0, &getBooleanCppuType(), 0, 0},
66 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_SHOWINP), 0, &getBooleanCppuType(), 0, 0},
67 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_SHOWLIST), 0, &getCppuType((sal_Int16*)0), 0, 0},
68 [ + - ]: 1 : {MAP_CHAR_LEN(SC_UNONAME_TYPE), 0, &getCppuType((sheet::ValidationType*)0), 0, 0},
69 : : {0,0,0,0,0,0}
70 [ + + ][ + - ]: 81 : };
[ # # ]
71 : 80 : return aValidatePropertyMap_Impl;
72 : : }
73 : :
74 : : //------------------------------------------------------------------------
75 : :
76 [ # # ]: 0 : SC_SIMPLE_SERVICE_INFO( ScTableConditionalEntry, "ScTableConditionalEntry", "com.sun.star.sheet.TableConditionalEntry" )
77 [ # # ]: 0 : SC_SIMPLE_SERVICE_INFO( ScTableConditionalFormat, "ScTableConditionalFormat", "com.sun.star.sheet.TableConditionalFormat" )
78 [ # # ]: 0 : SC_SIMPLE_SERVICE_INFO( ScTableValidationObj, "ScTableValidationObj", "com.sun.star.sheet.TableValidation" )
79 : :
80 : : //------------------------------------------------------------------------
81 : :
82 : 0 : sal_Int32 lcl_ConditionModeToOperatorNew( ScConditionMode eMode )
83 : : {
84 : 0 : sal_Int32 eOper = sheet::ConditionOperator2::NONE;
85 [ # # # # : 0 : switch (eMode)
# # # # #
# # ]
86 : : {
87 : 0 : case SC_COND_EQUAL: eOper = sheet::ConditionOperator2::EQUAL; break;
88 : 0 : case SC_COND_LESS: eOper = sheet::ConditionOperator2::LESS; break;
89 : 0 : case SC_COND_GREATER: eOper = sheet::ConditionOperator2::GREATER; break;
90 : 0 : case SC_COND_EQLESS: eOper = sheet::ConditionOperator2::LESS_EQUAL; break;
91 : 0 : case SC_COND_EQGREATER: eOper = sheet::ConditionOperator2::GREATER_EQUAL; break;
92 : 0 : case SC_COND_NOTEQUAL: eOper = sheet::ConditionOperator2::NOT_EQUAL; break;
93 : 0 : case SC_COND_BETWEEN: eOper = sheet::ConditionOperator2::BETWEEN; break;
94 : 0 : case SC_COND_NOTBETWEEN: eOper = sheet::ConditionOperator2::NOT_BETWEEN; break;
95 : 0 : case SC_COND_DIRECT: eOper = sheet::ConditionOperator2::FORMULA; break;
96 : 0 : case SC_COND_DUPLICATE: eOper = sheet::ConditionOperator2::DUPLICATE; break;
97 : : default:
98 : : {
99 : : // added to avoid warnings
100 : : }
101 : : }
102 : 0 : return eOper;
103 : : }
104 : :
105 : 4 : sheet::ConditionOperator lcl_ConditionModeToOperator( ScConditionMode eMode )
106 : : {
107 : 4 : sheet::ConditionOperator eOper = sheet::ConditionOperator_NONE;
108 [ + - - - : 4 : switch (eMode)
- - + - -
+ ]
109 : : {
110 : 1 : case SC_COND_EQUAL: eOper = sheet::ConditionOperator_EQUAL; break;
111 : 0 : case SC_COND_LESS: eOper = sheet::ConditionOperator_LESS; break;
112 : 0 : case SC_COND_GREATER: eOper = sheet::ConditionOperator_GREATER; break;
113 : 0 : case SC_COND_EQLESS: eOper = sheet::ConditionOperator_LESS_EQUAL; break;
114 : 0 : case SC_COND_EQGREATER: eOper = sheet::ConditionOperator_GREATER_EQUAL; break;
115 : 0 : case SC_COND_NOTEQUAL: eOper = sheet::ConditionOperator_NOT_EQUAL; break;
116 : 2 : case SC_COND_BETWEEN: eOper = sheet::ConditionOperator_BETWEEN; break;
117 : 0 : case SC_COND_NOTBETWEEN: eOper = sheet::ConditionOperator_NOT_BETWEEN; break;
118 : 0 : case SC_COND_DIRECT: eOper = sheet::ConditionOperator_FORMULA; break;
119 : : default:
120 : : {
121 : : // added to avoid warnings
122 : : }
123 : : }
124 : 4 : return eOper;
125 : : }
126 : :
127 : 2 : ScConditionMode lcl_ConditionOperatorToMode( sheet::ConditionOperator eOper )
128 : : {
129 : 2 : ScConditionMode eMode = SC_COND_NONE;
130 [ - - - - : 2 : switch (eOper)
- - + - -
- ]
131 : : {
132 : 0 : case sheet::ConditionOperator_EQUAL: eMode = SC_COND_EQUAL; break;
133 : 0 : case sheet::ConditionOperator_LESS: eMode = SC_COND_LESS; break;
134 : 0 : case sheet::ConditionOperator_GREATER: eMode = SC_COND_GREATER; break;
135 : 0 : case sheet::ConditionOperator_LESS_EQUAL: eMode = SC_COND_EQLESS; break;
136 : 0 : case sheet::ConditionOperator_GREATER_EQUAL: eMode = SC_COND_EQGREATER; break;
137 : 0 : case sheet::ConditionOperator_NOT_EQUAL: eMode = SC_COND_NOTEQUAL; break;
138 : 2 : case sheet::ConditionOperator_BETWEEN: eMode = SC_COND_BETWEEN; break;
139 : 0 : case sheet::ConditionOperator_NOT_BETWEEN: eMode = SC_COND_NOTBETWEEN; break;
140 : 0 : case sheet::ConditionOperator_FORMULA: eMode = SC_COND_DIRECT; break;
141 : : default:
142 : : {
143 : : // added to avoid warnings
144 : : }
145 : : }
146 : 2 : return eMode;
147 : : }
148 : :
149 : : //------------------------------------------------------------------------
150 : :
151 : 108 : ScCondFormatEntryItem::ScCondFormatEntryItem() :
152 : : meGrammar1( FormulaGrammar::GRAM_UNSPECIFIED ),
153 : : meGrammar2( FormulaGrammar::GRAM_UNSPECIFIED ),
154 [ + - ][ + - ]: 108 : meMode( SC_COND_NONE )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
155 : : {
156 : 108 : }
157 : :
158 : : //------------------------------------------------------------------------
159 : :
160 : 92 : ScTableConditionalFormat::ScTableConditionalFormat(
161 [ + - ]: 92 : ScDocument* pDoc, sal_uLong nKey, SCTAB nTab, FormulaGrammar::Grammar eGrammar)
162 : : {
163 : : // Eintrag aus dem Dokument lesen...
164 : :
165 [ + - ][ + + ]: 92 : if ( pDoc && nKey )
166 : : {
167 [ + - ]: 45 : ScConditionalFormatList* pList = pDoc->GetCondFormList(nTab);
168 [ + - ]: 45 : if (pList)
169 : : {
170 [ + - ]: 45 : const ScConditionalFormat* pFormat = pList->GetFormat( nKey );
171 [ + - ]: 45 : if (pFormat)
172 : : {
173 : : // During save to XML.
174 [ + - ][ - + ]: 45 : if (pDoc->IsInExternalReferenceMarking())
175 [ # # ]: 0 : pFormat->MarkUsedExternalReferences();
176 : :
177 [ + - ]: 45 : size_t nEntryCount = pFormat->size();
178 [ - + ]: 45 : for (size_t i=0; i<nEntryCount; i++)
179 : : {
180 [ # # ]: 0 : ScCondFormatEntryItem aItem;
181 [ # # ]: 0 : const ScFormatEntry* pFrmtEntry = pFormat->GetEntry(i);
182 [ # # ][ # # ]: 0 : if(pFrmtEntry->GetType() != condformat::CONDITION)
183 : 0 : continue;
184 : :
185 : 0 : const ScCondFormatEntry* pFormatEntry = static_cast<const ScCondFormatEntry*>(pFrmtEntry);
186 : 0 : aItem.meMode = pFormatEntry->GetOperation();
187 [ # # ]: 0 : aItem.maPos = pFormatEntry->GetValidSrcPos();
188 [ # # ][ # # ]: 0 : aItem.maExpr1 = pFormatEntry->GetExpression(aItem.maPos, 0, 0, eGrammar);
[ # # ]
189 [ # # ][ # # ]: 0 : aItem.maExpr2 = pFormatEntry->GetExpression(aItem.maPos, 1, 0, eGrammar);
[ # # ]
190 : 0 : aItem.meGrammar1 = aItem.meGrammar2 = eGrammar;
191 [ # # ]: 0 : aItem.maStyle = pFormatEntry->GetStyle();
192 : :
193 [ # # ][ # # ]: 0 : AddEntry_Impl(aItem);
194 [ # # ]: 0 : }
195 : : }
196 : : }
197 : : }
198 : 92 : }
199 : :
200 : : namespace {
201 : :
202 : 154 : FormulaGrammar::Grammar lclResolveGrammar( FormulaGrammar::Grammar eExtGrammar, FormulaGrammar::Grammar eIntGrammar )
203 : : {
204 [ + + ]: 154 : if( eExtGrammar != FormulaGrammar::GRAM_UNSPECIFIED )
205 : 16 : return eExtGrammar;
206 : : OSL_ENSURE( eIntGrammar != FormulaGrammar::GRAM_UNSPECIFIED, "lclResolveGrammar - unspecified grammar, using GRAM_PODF_A1" );
207 [ + + ]: 154 : return (eIntGrammar == FormulaGrammar::GRAM_UNSPECIFIED) ? FormulaGrammar::GRAM_PODF_A1 : eIntGrammar;
208 : : }
209 : :
210 : : } // namespace
211 : :
212 : 29 : void ScTableConditionalFormat::FillFormat( ScConditionalFormat& rFormat,
213 : : ScDocument* pDoc, FormulaGrammar::Grammar eGrammar) const
214 : : {
215 : : // ScConditionalFormat = Core-Struktur, muss leer sein
216 : :
217 : : OSL_ENSURE( rFormat.IsEmpty(), "FillFormat: Format nicht leer" );
218 : :
219 : 29 : std::vector<ScTableConditionalEntry*>::const_iterator iter;
220 [ + - ][ + + ]: 97 : for (iter = aEntries.begin(); iter != aEntries.end(); ++iter)
221 : : {
222 [ + - ]: 68 : ScCondFormatEntryItem aData;
223 [ + - ]: 68 : (*iter)->GetData(aData);
224 : :
225 : 68 : FormulaGrammar::Grammar eGrammar1 = lclResolveGrammar( eGrammar, aData.meGrammar1 );
226 : 68 : FormulaGrammar::Grammar eGrammar2 = lclResolveGrammar( eGrammar, aData.meGrammar2 );
227 : :
228 : : ScCondFormatEntry* pCoreEntry = new ScCondFormatEntry( aData.meMode, aData.maExpr1, aData.maExpr2,
229 [ + - ][ + - ]: 68 : pDoc, aData.maPos, aData.maStyle, aData.maExprNmsp1, aData.maExprNmsp2, eGrammar1, eGrammar2 );
230 : :
231 [ + + ]: 68 : if ( aData.maPosStr.Len() )
232 [ + - ]: 66 : pCoreEntry->SetSrcString( aData.maPosStr );
233 : :
234 [ - + ]: 68 : if ( aData.maTokens1.getLength() )
235 : : {
236 [ # # ]: 0 : ScTokenArray aTokenArray;
237 [ # # ][ # # ]: 0 : if ( ScTokenConversion::ConvertToTokenArray(*pDoc, aTokenArray, aData.maTokens1) )
238 [ # # ][ # # ]: 0 : pCoreEntry->SetFormula1(aTokenArray);
239 : : }
240 : :
241 [ - + ]: 68 : if ( aData.maTokens2.getLength() )
242 : : {
243 [ # # ]: 0 : ScTokenArray aTokenArray;
244 [ # # ][ # # ]: 0 : if ( ScTokenConversion::ConvertToTokenArray(*pDoc, aTokenArray, aData.maTokens2) )
245 [ # # ][ # # ]: 0 : pCoreEntry->SetFormula2(aTokenArray);
246 : : }
247 [ + - ]: 68 : rFormat.AddEntry( pCoreEntry );
248 [ + - ]: 68 : }
249 : 29 : }
250 : :
251 : 92 : ScTableConditionalFormat::~ScTableConditionalFormat()
252 : : {
253 [ + - ][ + - ]: 92 : std::for_each(aEntries.begin(),aEntries.end(),boost::bind(&ScTableConditionalEntry::release,_1));
254 [ - + ]: 184 : }
255 : :
256 : 40 : void ScTableConditionalFormat::AddEntry_Impl(const ScCondFormatEntryItem& aEntry)
257 : : {
258 [ + - ]: 40 : ScTableConditionalEntry* pNew = new ScTableConditionalEntry(aEntry);
259 : 40 : pNew->acquire();
260 [ + - ]: 40 : aEntries.push_back(pNew);
261 : 40 : }
262 : :
263 : : // XSheetConditionalFormat
264 : :
265 : 8 : ScTableConditionalEntry* ScTableConditionalFormat::GetObjectByIndex_Impl(sal_uInt16 nIndex) const
266 : : {
267 [ + + ]: 8 : return nIndex < aEntries.size() ? aEntries[nIndex] : NULL;
268 : : }
269 : :
270 : 40 : void SAL_CALL ScTableConditionalFormat::addNew(
271 : : const uno::Sequence<beans::PropertyValue >& aConditionalEntry )
272 : : throw(uno::RuntimeException)
273 : : {
274 [ + - ]: 40 : SolarMutexGuard aGuard;
275 [ + - ]: 40 : ScCondFormatEntryItem aEntry;
276 : 40 : aEntry.meMode = SC_COND_NONE;
277 : :
278 : 40 : const beans::PropertyValue* pPropArray = aConditionalEntry.getConstArray();
279 : 40 : long nPropCount = aConditionalEntry.getLength();
280 [ + + ]: 372 : for (long i = 0; i < nPropCount; i++)
281 : : {
282 : 332 : const beans::PropertyValue& rProp = pPropArray[i];
283 : :
284 [ + + ]: 332 : if ( rProp.Name == SC_UNONAME_OPERATOR )
285 : : {
286 [ + - ]: 40 : sal_Int32 eOper = ScUnoHelpFunctions::GetEnumFromAny( rProp.Value );
287 [ + - ]: 40 : aEntry.meMode = ScConditionEntry::GetModeFromApi( eOper );
288 : : }
289 [ + + ]: 292 : else if ( rProp.Name == SC_UNONAME_FORMULA1 )
290 : : {
291 : 40 : rtl::OUString aStrVal;
292 [ + - ]: 40 : uno::Sequence<sheet::FormulaToken> aTokens;
293 [ + - ]: 40 : if ( rProp.Value >>= aStrVal )
294 [ + - ]: 40 : aEntry.maExpr1 = aStrVal;
295 [ # # ][ # # ]: 0 : else if ( rProp.Value >>= aTokens )
296 : : {
297 [ # # ]: 0 : aEntry.maExpr1.Erase();
298 [ # # ]: 0 : aEntry.maTokens1 = aTokens;
299 [ + - ]: 40 : }
300 : : }
301 [ + + ]: 252 : else if ( rProp.Name == SC_UNONAME_FORMULA2 )
302 : : {
303 : 40 : rtl::OUString aStrVal;
304 [ + - ]: 40 : uno::Sequence<sheet::FormulaToken> aTokens;
305 [ + - ]: 40 : if ( rProp.Value >>= aStrVal )
306 [ + - ]: 40 : aEntry.maExpr2 = aStrVal;
307 [ # # ][ # # ]: 0 : else if ( rProp.Value >>= aTokens )
308 : : {
309 [ # # ]: 0 : aEntry.maExpr2.Erase();
310 [ # # ]: 0 : aEntry.maTokens2 = aTokens;
311 [ + - ]: 40 : }
312 : : }
313 [ + + ]: 212 : else if ( rProp.Name == SC_UNONAME_SOURCEPOS )
314 : : {
315 : 7 : table::CellAddress aAddress;
316 [ + - ][ + - ]: 7 : if ( rProp.Value >>= aAddress )
317 : 7 : aEntry.maPos = ScAddress( (SCCOL)aAddress.Column, (SCROW)aAddress.Row, aAddress.Sheet );
318 : : }
319 [ + + ]: 205 : else if ( rProp.Name == SC_UNONAME_SOURCESTR )
320 : : {
321 : 33 : rtl::OUString aStrVal;
322 [ + - ]: 33 : if ( rProp.Value >>= aStrVal )
323 [ + - ][ + - ]: 33 : aEntry.maPosStr = String( aStrVal );
[ + - ]
324 : : }
325 [ + + ]: 172 : else if ( rProp.Name == SC_UNONAME_STYLENAME )
326 : : {
327 : 40 : rtl::OUString aStrVal;
328 [ + - ]: 40 : if ( rProp.Value >>= aStrVal )
329 : : aEntry.maStyle = ScStyleNameConversion::ProgrammaticToDisplayName(
330 [ + - ][ + - ]: 40 : aStrVal, SFX_STYLE_FAMILY_PARA );
[ + - ][ + - ]
[ + - ]
331 : : }
332 [ + + ]: 132 : else if ( rProp.Name == SC_UNONAME_FORMULANMSP1 )
333 : : {
334 : 33 : rtl::OUString aStrVal;
335 [ + - ]: 33 : if ( rProp.Value >>= aStrVal )
336 [ + - ]: 33 : aEntry.maExprNmsp1 = aStrVal;
337 : : }
338 [ + + ]: 99 : else if ( rProp.Name == SC_UNONAME_FORMULANMSP2 )
339 : : {
340 : 33 : rtl::OUString aStrVal;
341 [ + - ]: 33 : if ( rProp.Value >>= aStrVal )
342 [ + - ]: 33 : aEntry.maExprNmsp2 = aStrVal;
343 : : }
344 [ + + ]: 66 : else if ( rProp.Name == SC_UNONAME_GRAMMAR1 )
345 : : {
346 : 33 : sal_Int32 nVal = 0;
347 [ + - ]: 33 : if ( rProp.Value >>= nVal )
348 : 33 : aEntry.meGrammar1 = static_cast< FormulaGrammar::Grammar >( nVal );
349 : : }
350 [ + - ]: 33 : else if ( rProp.Name == SC_UNONAME_GRAMMAR2 )
351 : : {
352 : 33 : sal_Int32 nVal = 0;
353 [ + - ]: 33 : if ( rProp.Value >>= nVal )
354 : 33 : aEntry.meGrammar2 = static_cast< FormulaGrammar::Grammar >( nVal );
355 : : }
356 : : else
357 : : {
358 : : OSL_FAIL("falsche Property");
359 : : //! Exception...
360 : : }
361 : : }
362 : :
363 [ + - ][ + - ]: 40 : AddEntry_Impl(aEntry);
[ + - ]
364 : 40 : }
365 : :
366 : 1 : void SAL_CALL ScTableConditionalFormat::removeByIndex( sal_Int32 nIndex )
367 : : throw(uno::RuntimeException)
368 : : {
369 [ + - ]: 1 : SolarMutexGuard aGuard;
370 : :
371 [ + - ]: 1 : if (nIndex < static_cast<sal_Int32>(aEntries.size()))
372 : : {
373 [ + - ]: 1 : std::vector<ScTableConditionalEntry*>::iterator iter = aEntries.begin()+nIndex;
374 : :
375 : 1 : (*iter)->release();
376 [ + - ]: 1 : aEntries.erase(iter);
377 [ + - ]: 1 : }
378 : 1 : }
379 : :
380 : 1 : void SAL_CALL ScTableConditionalFormat::clear() throw(uno::RuntimeException)
381 : : {
382 [ + - ]: 1 : SolarMutexGuard aGuard;
383 : : std::for_each(aEntries.begin(),aEntries.end(),
384 [ + - ][ + - ]: 1 : boost::bind(&ScTableConditionalEntry::release,_1));
385 : :
386 [ + - ]: 1 : aEntries.clear();
387 : 1 : }
388 : :
389 : : // XEnumerationAccess
390 : :
391 : 2 : uno::Reference<container::XEnumeration> SAL_CALL ScTableConditionalFormat::createEnumeration()
392 : : throw(uno::RuntimeException)
393 : : {
394 [ + - ]: 2 : SolarMutexGuard aGuard;
395 [ + - ][ + - ]: 2 : return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.TableConditionalEntryEnumeration")));
[ + - ][ + - ]
[ + - ][ + - ]
396 : : }
397 : :
398 : : // XIndexAccess
399 : :
400 : 8 : sal_Int32 SAL_CALL ScTableConditionalFormat::getCount() throw(uno::RuntimeException)
401 : : {
402 [ + - ]: 8 : SolarMutexGuard aGuard;
403 [ + - ]: 8 : return aEntries.size();
404 : : }
405 : :
406 : 7 : uno::Any SAL_CALL ScTableConditionalFormat::getByIndex( sal_Int32 nIndex )
407 : : throw(lang::IndexOutOfBoundsException,
408 : : lang::WrappedTargetException, uno::RuntimeException)
409 : : {
410 [ + - ]: 7 : SolarMutexGuard aGuard;
411 [ + - ][ + + ]: 7 : uno::Reference<sheet::XSheetConditionalEntry> xEntry(GetObjectByIndex_Impl((sal_uInt16)nIndex));
[ + - ]
412 [ + + ]: 7 : if (xEntry.is())
413 [ + - ]: 10 : return uno::makeAny(xEntry);
414 : : else
415 [ + - ][ + - ]: 7 : throw lang::IndexOutOfBoundsException();
416 : : }
417 : :
418 : 1 : uno::Type SAL_CALL ScTableConditionalFormat::getElementType() throw(uno::RuntimeException)
419 : : {
420 [ + - ]: 1 : SolarMutexGuard aGuard;
421 [ + - ][ + - ]: 1 : return getCppuType((uno::Reference<sheet::XSheetConditionalEntry>*)0);
422 : : }
423 : :
424 : 1 : sal_Bool SAL_CALL ScTableConditionalFormat::hasElements() throw(uno::RuntimeException)
425 : : {
426 [ + - ]: 1 : SolarMutexGuard aGuard;
427 [ + - ][ + - ]: 1 : return ( getCount() != 0 );
428 : : }
429 : :
430 : : // conditional format entries have no real names
431 : : // -> generate name from index
432 : :
433 : 8 : rtl::OUString lcl_GetEntryNameFromIndex( sal_Int32 nIndex )
434 : : {
435 : 8 : rtl::OUString aRet( RTL_CONSTASCII_USTRINGPARAM( "Entry" ) );
436 : 8 : aRet += rtl::OUString::valueOf( nIndex );
437 : 8 : return aRet;
438 : : }
439 : :
440 : 2 : uno::Any SAL_CALL ScTableConditionalFormat::getByName( const rtl::OUString& aName )
441 : : throw(container::NoSuchElementException,
442 : : lang::WrappedTargetException, uno::RuntimeException)
443 : : {
444 [ + - ]: 2 : SolarMutexGuard aGuard;
445 : :
446 : 2 : uno::Reference<sheet::XSheetConditionalEntry> xEntry;
447 : 2 : long nCount = aEntries.size();
448 [ + + ]: 4 : for (long i=0; i<nCount; i++)
449 [ + - ][ + + ]: 3 : if ( aName == lcl_GetEntryNameFromIndex(i) )
450 : : {
451 [ + - ][ + - ]: 1 : xEntry.set(GetObjectByIndex_Impl((sal_uInt16)i));
[ + - ]
452 : 1 : break;
453 : : }
454 : :
455 [ + + ]: 2 : if (xEntry.is())
456 [ + - ]: 2 : return uno::makeAny(xEntry);
457 : : else
458 [ + - ][ + - ]: 2 : throw container::NoSuchElementException();
459 : : }
460 : :
461 : 1 : uno::Sequence<rtl::OUString> SAL_CALL ScTableConditionalFormat::getElementNames()
462 : : throw(uno::RuntimeException)
463 : : {
464 [ + - ]: 1 : SolarMutexGuard aGuard;
465 : :
466 : 1 : long nCount = aEntries.size();
467 [ + - ]: 1 : uno::Sequence<rtl::OUString> aNames(nCount);
468 [ + - ]: 1 : rtl::OUString* pArray = aNames.getArray();
469 [ + + ]: 3 : for (long i=0; i<nCount; i++)
470 [ + - ]: 2 : pArray[i] = lcl_GetEntryNameFromIndex(i);
471 : :
472 [ + - ]: 1 : return aNames;
473 : : }
474 : :
475 : 2 : sal_Bool SAL_CALL ScTableConditionalFormat::hasByName( const rtl::OUString& aName )
476 : : throw(uno::RuntimeException)
477 : : {
478 [ + - ]: 2 : SolarMutexGuard aGuard;
479 : :
480 : 2 : long nCount = aEntries.size();
481 [ + + ]: 4 : for (long i=0; i<nCount; i++)
482 [ + - ][ + + ]: 3 : if ( aName == lcl_GetEntryNameFromIndex(i) )
483 : 1 : return sal_True;
484 : :
485 [ + - ]: 2 : return false;
486 : : }
487 : :
488 : : // XUnoTunnel
489 : :
490 : 29 : sal_Int64 SAL_CALL ScTableConditionalFormat::getSomething(
491 : : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
492 : : {
493 [ + - + - ]: 58 : if ( rId.getLength() == 16 &&
[ + - ]
494 : 29 : 0 == memcmp( getUnoTunnelId().getConstArray(),
495 : 29 : rId.getConstArray(), 16 ) )
496 : : {
497 : 29 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
498 : : }
499 : 29 : return 0;
500 : : }
501 : :
502 : : namespace
503 : : {
504 : : class theScTableConditionalFormatUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScTableConditionalFormatUnoTunnelId> {};
505 : : }
506 : :
507 : 58 : const uno::Sequence<sal_Int8>& ScTableConditionalFormat::getUnoTunnelId()
508 : : {
509 : 58 : return theScTableConditionalFormatUnoTunnelId::get().getSeq();
510 : : }
511 : :
512 : 29 : ScTableConditionalFormat* ScTableConditionalFormat::getImplementation(
513 : : const uno::Reference<sheet::XSheetConditionalEntries> xObj )
514 : : {
515 : 29 : ScTableConditionalFormat* pRet = NULL;
516 [ + - ]: 29 : uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
517 [ + - ]: 29 : if (xUT.is())
518 [ + - ][ + - ]: 29 : pRet = reinterpret_cast<ScTableConditionalFormat*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
[ + - ]
519 : 29 : return pRet;
520 : : }
521 : :
522 : : //------------------------------------------------------------------------
523 : :
524 : 40 : ScTableConditionalEntry::ScTableConditionalEntry(const ScCondFormatEntryItem& aItem) :
525 [ + - ]: 40 : aData( aItem )
526 : : {
527 : : // #i113668# only store the settings, keep no reference to parent object
528 : 40 : }
529 : :
530 [ + - ]: 40 : ScTableConditionalEntry::~ScTableConditionalEntry()
531 : : {
532 [ - + ]: 80 : }
533 : :
534 : 68 : void ScTableConditionalEntry::GetData(ScCondFormatEntryItem& rData) const
535 : : {
536 : 68 : rData = aData;
537 : 68 : }
538 : :
539 : : // XSheetCondition
540 : :
541 : 2 : sheet::ConditionOperator SAL_CALL ScTableConditionalEntry::getOperator()
542 : : throw(uno::RuntimeException)
543 : : {
544 [ + - ]: 2 : SolarMutexGuard aGuard;
545 [ + - ]: 2 : return lcl_ConditionModeToOperator( aData.meMode );
546 : : }
547 : :
548 : 1 : void SAL_CALL ScTableConditionalEntry::setOperator( sheet::ConditionOperator nOperator )
549 : : throw(uno::RuntimeException)
550 : : {
551 [ + - ]: 1 : SolarMutexGuard aGuard;
552 [ + - ]: 1 : aData.meMode = lcl_ConditionOperatorToMode( nOperator );
553 : 1 : }
554 : :
555 : 0 : sal_Int32 SAL_CALL ScTableConditionalEntry::getConditionOperator()
556 : : throw(uno::RuntimeException)
557 : : {
558 [ # # ]: 0 : SolarMutexGuard aGuard;
559 [ # # ]: 0 : return lcl_ConditionModeToOperatorNew( aData.meMode );
560 : : }
561 : :
562 : 0 : void SAL_CALL ScTableConditionalEntry::setConditionOperator( sal_Int32 nOperator )
563 : : throw(uno::RuntimeException)
564 : : {
565 [ # # ]: 0 : SolarMutexGuard aGuard;
566 [ # # ][ # # ]: 0 : aData.meMode = ScConditionEntry::GetModeFromApi( nOperator );
567 : 0 : }
568 : :
569 : 2 : rtl::OUString SAL_CALL ScTableConditionalEntry::getFormula1() throw(uno::RuntimeException)
570 : : {
571 [ + - ]: 2 : SolarMutexGuard aGuard;
572 [ + - ][ + - ]: 2 : return aData.maExpr1;
573 : : }
574 : :
575 : 1 : void SAL_CALL ScTableConditionalEntry::setFormula1( const rtl::OUString& aFormula1 )
576 : : throw(uno::RuntimeException)
577 : : {
578 [ + - ]: 1 : SolarMutexGuard aGuard;
579 [ + - ][ + - ]: 1 : aData.maExpr1 = String( aFormula1 );
[ + - ][ + - ]
580 : 1 : }
581 : :
582 : 2 : rtl::OUString SAL_CALL ScTableConditionalEntry::getFormula2() throw(uno::RuntimeException)
583 : : {
584 [ + - ]: 2 : SolarMutexGuard aGuard;
585 [ + - ][ + - ]: 2 : return aData.maExpr2;
586 : : }
587 : :
588 : 1 : void SAL_CALL ScTableConditionalEntry::setFormula2( const rtl::OUString& aFormula2 )
589 : : throw(uno::RuntimeException)
590 : : {
591 [ + - ]: 1 : SolarMutexGuard aGuard;
592 [ + - ][ + - ]: 1 : aData.maExpr2 = String( aFormula2 );
[ + - ][ + - ]
593 : 1 : }
594 : :
595 : 2 : table::CellAddress SAL_CALL ScTableConditionalEntry::getSourcePosition() throw(uno::RuntimeException)
596 : : {
597 [ + - ]: 2 : SolarMutexGuard aGuard;
598 : 2 : table::CellAddress aRet;
599 : 2 : aRet.Column = aData.maPos.Col();
600 : 2 : aRet.Row = aData.maPos.Row();
601 : 2 : aRet.Sheet = aData.maPos.Tab();
602 [ + - ]: 2 : return aRet;
603 : : }
604 : :
605 : 1 : void SAL_CALL ScTableConditionalEntry::setSourcePosition( const table::CellAddress& aSourcePosition )
606 : : throw(uno::RuntimeException)
607 : : {
608 [ + - ]: 1 : SolarMutexGuard aGuard;
609 [ + - ]: 1 : aData.maPos.Set( (SCCOL)aSourcePosition.Column, (SCROW)aSourcePosition.Row, aSourcePosition.Sheet );
610 : 1 : }
611 : :
612 : : // XSheetConditionalEntry
613 : :
614 : 2 : rtl::OUString SAL_CALL ScTableConditionalEntry::getStyleName() throw(uno::RuntimeException)
615 : : {
616 [ + - ]: 2 : SolarMutexGuard aGuard;
617 [ + - ][ + - ]: 2 : return ScStyleNameConversion::DisplayToProgrammaticName( aData.maStyle, SFX_STYLE_FAMILY_PARA );
[ + - ][ + - ]
618 : : }
619 : :
620 : 1 : void SAL_CALL ScTableConditionalEntry::setStyleName( const rtl::OUString& aStyleName )
621 : : throw(uno::RuntimeException)
622 : : {
623 [ + - ]: 1 : SolarMutexGuard aGuard;
624 [ + - ][ + - ]: 1 : aData.maStyle = ScStyleNameConversion::ProgrammaticToDisplayName( aStyleName, SFX_STYLE_FAMILY_PARA );
[ + - ][ + - ]
[ + - ][ + - ]
625 : 1 : }
626 : :
627 : : //------------------------------------------------------------------------
628 : :
629 : 80 : ScTableValidationObj::ScTableValidationObj(ScDocument* pDoc, sal_uLong nKey,
630 : : const formula::FormulaGrammar::Grammar eGrammar) :
631 [ + - ][ + - ]: 80 : aPropSet( lcl_GetValidatePropertyMap() )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
632 : : {
633 : : // Eintrag aus dem Dokument lesen...
634 : :
635 : 80 : sal_Bool bFound = false;
636 [ + - ][ + + ]: 80 : if ( pDoc && nKey )
637 : : {
638 [ + - ]: 45 : const ScValidationData* pData = pDoc->GetValidationEntry( nKey );
639 [ + - ]: 45 : if (pData)
640 : : {
641 : 45 : nMode = sal::static_int_cast<sal_uInt16>( pData->GetOperation() );
642 [ + - ]: 45 : aSrcPos = pData->GetValidSrcPos(); // valid pos for expressions
643 [ + - ][ + - ]: 45 : aExpr1 = pData->GetExpression( aSrcPos, 0, 0, eGrammar );
[ + - ]
644 [ + - ][ + - ]: 45 : aExpr2 = pData->GetExpression( aSrcPos, 1, 0, eGrammar );
[ + - ]
645 : 45 : meGrammar1 = meGrammar2 = eGrammar;
646 : 45 : nValMode = sal::static_int_cast<sal_uInt16>( pData->GetDataMode() );
647 : 45 : bIgnoreBlank = pData->IsIgnoreBlank();
648 : 45 : nShowList = pData->GetListType();
649 [ + - ]: 45 : bShowInput = pData->GetInput( aInputTitle, aInputMessage );
650 : : ScValidErrorStyle eStyle;
651 [ + - ]: 45 : bShowError = pData->GetErrMsg( aErrorTitle, aErrorMessage, eStyle );
652 : 45 : nErrorStyle = sal::static_int_cast<sal_uInt16>( eStyle );
653 : :
654 : : // During save to XML, sheet::ValidationType_ANY formulas are not
655 : : // saved, even if in the list, see
656 : : // ScMyValidationsContainer::GetCondition(), so shall not mark
657 : : // anything in use.
658 [ # # ][ # # ]: 45 : if (nValMode != SC_VALID_ANY && pDoc->IsInExternalReferenceMarking())
[ - + ][ - + ]
659 [ # # ]: 0 : pData->MarkUsedExternalReferences();
660 : :
661 : 45 : bFound = sal_True;
662 : : }
663 : : }
664 [ + + ]: 80 : if (!bFound)
665 [ + - ]: 35 : ClearData_Impl(); // Defaults
666 : 80 : }
667 : :
668 : 9 : ScValidationData* ScTableValidationObj::CreateValidationData( ScDocument* pDoc,
669 : : formula::FormulaGrammar::Grammar eGrammar ) const
670 : : {
671 : : // ScValidationData = Core-Struktur
672 : :
673 : 9 : FormulaGrammar::Grammar eGrammar1 = lclResolveGrammar( eGrammar, meGrammar1 );
674 : 9 : FormulaGrammar::Grammar eGrammar2 = lclResolveGrammar( eGrammar, meGrammar2 );
675 : :
676 : : ScValidationData* pRet = new ScValidationData( (ScValidationMode)nValMode,
677 : : (ScConditionMode)nMode,
678 : : aExpr1, aExpr2, pDoc, aSrcPos,
679 : : maExprNmsp1, maExprNmsp2,
680 [ + - ]: 9 : eGrammar1, eGrammar2 );
681 : 9 : pRet->SetIgnoreBlank(bIgnoreBlank);
682 : 9 : pRet->SetListType(nShowList);
683 : :
684 [ - + ]: 9 : if ( aTokens1.getLength() )
685 : : {
686 [ # # ]: 0 : ScTokenArray aTokenArray;
687 [ # # ][ # # ]: 0 : if ( ScTokenConversion::ConvertToTokenArray(*pDoc, aTokenArray, aTokens1) )
688 [ # # ][ # # ]: 0 : pRet->SetFormula1(aTokenArray);
689 : : }
690 : :
691 [ - + ]: 9 : if ( aTokens2.getLength() )
692 : : {
693 [ # # ]: 0 : ScTokenArray aTokenArray;
694 [ # # ][ # # ]: 0 : if ( ScTokenConversion::ConvertToTokenArray(*pDoc, aTokenArray, aTokens2) )
695 [ # # ][ # # ]: 0 : pRet->SetFormula2(aTokenArray);
696 : : }
697 : :
698 : : // set strings for error / input even if disabled (and disable afterwards)
699 : 9 : pRet->SetInput( aInputTitle, aInputMessage );
700 [ + - ]: 9 : if (!bShowInput)
701 : 9 : pRet->ResetInput();
702 : 9 : pRet->SetError( aErrorTitle, aErrorMessage, (ScValidErrorStyle)nErrorStyle );
703 [ + - ]: 9 : if (!bShowError)
704 : 9 : pRet->ResetError();
705 : :
706 [ - + ]: 9 : if ( aPosString.Len() )
707 : 0 : pRet->SetSrcString( aPosString );
708 : :
709 : 9 : return pRet;
710 : : }
711 : :
712 : 35 : void ScTableValidationObj::ClearData_Impl()
713 : : {
714 : 35 : nMode = SC_COND_NONE;
715 : 35 : nValMode = SC_VALID_ANY;
716 : 35 : bIgnoreBlank = sal_True;
717 : 35 : nShowList = sheet::TableValidationVisibility::UNSORTED;
718 : 35 : bShowInput = false;
719 : 35 : bShowError = false;
720 : 35 : nErrorStyle = SC_VALERR_STOP;
721 : 35 : aSrcPos.Set(0,0,0);
722 : 35 : aExpr1.Erase();
723 : 35 : aExpr2.Erase();
724 : 35 : maExprNmsp1.Erase();
725 : 35 : maExprNmsp2.Erase();
726 : 35 : meGrammar1 = meGrammar2 = FormulaGrammar::GRAM_UNSPECIFIED; // will be overriden when needed
727 : 35 : aInputTitle.Erase();
728 : 35 : aInputMessage.Erase();
729 : 35 : aErrorTitle.Erase();
730 : 35 : aErrorMessage.Erase();
731 : 35 : }
732 : :
733 [ + - ][ + - ]: 80 : ScTableValidationObj::~ScTableValidationObj()
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
734 : : {
735 [ - + ]: 160 : }
736 : :
737 : : // XSheetCondition
738 : :
739 : 2 : sheet::ConditionOperator SAL_CALL ScTableValidationObj::getOperator()
740 : : throw(uno::RuntimeException)
741 : : {
742 [ + - ]: 2 : SolarMutexGuard aGuard;
743 [ + - ]: 2 : return lcl_ConditionModeToOperator( (ScConditionMode)nMode );
744 : : }
745 : :
746 : 1 : void SAL_CALL ScTableValidationObj::setOperator( sheet::ConditionOperator nOperator )
747 : : throw(uno::RuntimeException)
748 : : {
749 [ + - ]: 1 : SolarMutexGuard aGuard;
750 [ + - ]: 1 : nMode = sal::static_int_cast<sal_uInt16>( lcl_ConditionOperatorToMode( nOperator ) );
751 : 1 : }
752 : :
753 : 0 : sal_Int32 SAL_CALL ScTableValidationObj::getConditionOperator()
754 : : throw(uno::RuntimeException)
755 : : {
756 [ # # ]: 0 : SolarMutexGuard aGuard;
757 [ # # ]: 0 : return lcl_ConditionModeToOperatorNew( (ScConditionMode)nMode );
758 : : }
759 : :
760 : 0 : void SAL_CALL ScTableValidationObj::setConditionOperator( sal_Int32 nOperator )
761 : : throw(uno::RuntimeException)
762 : : {
763 [ # # ]: 0 : SolarMutexGuard aGuard;
764 [ # # ][ # # ]: 0 : nMode = sal::static_int_cast<sal_uInt16>( ScConditionEntry::GetModeFromApi( nOperator ) );
765 : 0 : }
766 : :
767 : 2 : rtl::OUString SAL_CALL ScTableValidationObj::getFormula1() throw(uno::RuntimeException)
768 : : {
769 [ + - ]: 2 : SolarMutexGuard aGuard;
770 [ + - ][ + - ]: 2 : return aExpr1;
771 : : }
772 : :
773 : 1 : void SAL_CALL ScTableValidationObj::setFormula1( const rtl::OUString& aFormula1 )
774 : : throw(uno::RuntimeException)
775 : : {
776 [ + - ]: 1 : SolarMutexGuard aGuard;
777 [ + - ][ + - ]: 1 : aExpr1 = String( aFormula1 );
[ + - ][ + - ]
778 : 1 : }
779 : :
780 : 2 : rtl::OUString SAL_CALL ScTableValidationObj::getFormula2() throw(uno::RuntimeException)
781 : : {
782 [ + - ]: 2 : SolarMutexGuard aGuard;
783 [ + - ][ + - ]: 2 : return aExpr2;
784 : : }
785 : :
786 : 1 : void SAL_CALL ScTableValidationObj::setFormula2( const rtl::OUString& aFormula2 )
787 : : throw(uno::RuntimeException)
788 : : {
789 [ + - ]: 1 : SolarMutexGuard aGuard;
790 [ + - ][ + - ]: 1 : aExpr2 = String( aFormula2 );
[ + - ][ + - ]
791 : 1 : }
792 : :
793 : 2 : table::CellAddress SAL_CALL ScTableValidationObj::getSourcePosition() throw(uno::RuntimeException)
794 : : {
795 [ + - ]: 2 : SolarMutexGuard aGuard;
796 : 2 : table::CellAddress aRet;
797 : 2 : aRet.Column = aSrcPos.Col();
798 : 2 : aRet.Row = aSrcPos.Row();
799 : 2 : aRet.Sheet = aSrcPos.Tab();
800 [ + - ]: 2 : return aRet;
801 : : }
802 : :
803 : 1 : void SAL_CALL ScTableValidationObj::setSourcePosition( const table::CellAddress& aSourcePosition )
804 : : throw(uno::RuntimeException)
805 : : {
806 [ + - ]: 1 : SolarMutexGuard aGuard;
807 [ + - ]: 1 : aSrcPos.Set( (SCCOL)aSourcePosition.Column, (SCROW)aSourcePosition.Row, aSourcePosition.Sheet );
808 : 1 : }
809 : :
810 : 0 : uno::Sequence<sheet::FormulaToken> SAL_CALL ScTableValidationObj::getTokens( sal_Int32 nIndex )
811 : : throw(uno::RuntimeException,lang::IndexOutOfBoundsException)
812 : : {
813 [ # # ]: 0 : SolarMutexGuard aGuard;
814 [ # # ][ # # ]: 0 : if (nIndex >= 2 || nIndex < 0)
815 [ # # ]: 0 : throw lang::IndexOutOfBoundsException();
816 : :
817 [ # # ][ # # ]: 0 : return nIndex == 0 ? aTokens1 : aTokens2;
[ # # ]
818 : : }
819 : :
820 : 0 : void SAL_CALL ScTableValidationObj::setTokens( sal_Int32 nIndex, const uno::Sequence<sheet::FormulaToken>& aTokens )
821 : : throw(uno::RuntimeException,lang::IndexOutOfBoundsException)
822 : : {
823 [ # # ]: 0 : SolarMutexGuard aGuard;
824 [ # # ][ # # ]: 0 : if (nIndex >= 2 || nIndex < 0)
825 [ # # ]: 0 : throw lang::IndexOutOfBoundsException();
826 : :
827 [ # # ]: 0 : if (nIndex == 0)
828 : : {
829 [ # # ]: 0 : aTokens1 = aTokens;
830 [ # # ]: 0 : aExpr1.Erase();
831 : : }
832 [ # # ]: 0 : else if (nIndex == 1)
833 : : {
834 [ # # ]: 0 : aTokens2 = aTokens;
835 [ # # ]: 0 : aExpr2.Erase();
836 [ # # ]: 0 : }
837 : 0 : }
838 : :
839 : 0 : sal_Int32 SAL_CALL ScTableValidationObj::getCount() throw(uno::RuntimeException)
840 : : {
841 : 0 : return 2;
842 : : }
843 : :
844 : 1 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableValidationObj::getPropertySetInfo()
845 : : throw(uno::RuntimeException)
846 : : {
847 [ + - ]: 1 : SolarMutexGuard aGuard;
848 : : static uno::Reference<beans::XPropertySetInfo> aRef(
849 [ + - ][ + - ]: 1 : new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
[ + - ][ + - ]
[ + - ][ # # ]
850 [ + - ]: 1 : return aRef;
851 : : }
852 : :
853 : 20 : void SAL_CALL ScTableValidationObj::setPropertyValue(
854 : : const rtl::OUString& aPropertyName, const uno::Any& aValue )
855 : : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
856 : : lang::IllegalArgumentException, lang::WrappedTargetException,
857 : : uno::RuntimeException)
858 : : {
859 [ + - ]: 20 : SolarMutexGuard aGuard;
860 [ + - ]: 20 : String aString(aPropertyName);
861 : :
862 [ + - ][ + + ]: 20 : if ( aString.EqualsAscii( SC_UNONAME_SHOWINP ) ) bShowInput = ScUnoHelpFunctions::GetBoolFromAny( aValue );
[ + - ]
863 [ + - ][ + + ]: 18 : else if ( aString.EqualsAscii( SC_UNONAME_SHOWERR ) ) bShowError = ScUnoHelpFunctions::GetBoolFromAny( aValue );
[ + - ]
864 [ + - ][ + + ]: 16 : else if ( aString.EqualsAscii( SC_UNONAME_IGNOREBL ) ) bIgnoreBlank = ScUnoHelpFunctions::GetBoolFromAny( aValue );
[ + - ]
865 [ + - ][ + + ]: 14 : else if ( aString.EqualsAscii( SC_UNONAME_SHOWLIST ) ) aValue >>= nShowList;
866 [ + - ][ + + ]: 12 : else if ( aString.EqualsAscii( SC_UNONAME_INPTITLE ) )
867 : : {
868 : 2 : rtl::OUString aStrVal;
869 [ + - ]: 2 : if ( aValue >>= aStrVal )
870 [ + - ][ + - ]: 2 : aInputTitle = String( aStrVal );
[ + - ]
871 : : }
872 [ + - ][ + + ]: 10 : else if ( aString.EqualsAscii( SC_UNONAME_INPMESS ) )
873 : : {
874 : 2 : rtl::OUString aStrVal;
875 [ + - ]: 2 : if ( aValue >>= aStrVal )
876 [ + - ][ + - ]: 2 : aInputMessage = String( aStrVal );
[ + - ]
877 : : }
878 [ + - ][ + + ]: 8 : else if ( aString.EqualsAscii( SC_UNONAME_ERRTITLE ) )
879 : : {
880 : 2 : rtl::OUString aStrVal;
881 [ + - ]: 2 : if ( aValue >>= aStrVal )
882 [ + - ][ + - ]: 2 : aErrorTitle = String( aStrVal );
[ + - ]
883 : : }
884 [ + - ][ + + ]: 6 : else if ( aString.EqualsAscii( SC_UNONAME_ERRMESS ) )
885 : : {
886 : 2 : rtl::OUString aStrVal;
887 [ + - ]: 2 : if ( aValue >>= aStrVal )
888 [ + - ][ + - ]: 2 : aErrorMessage = String( aStrVal );
[ + - ]
889 : : }
890 [ + - ][ + + ]: 4 : else if ( aString.EqualsAscii( SC_UNONAME_TYPE ) )
891 : : {
892 : : sheet::ValidationType eType = (sheet::ValidationType)
893 [ + - ]: 2 : ScUnoHelpFunctions::GetEnumFromAny( aValue );
894 [ - - - + : 2 : switch (eType)
- - - +
- ]
895 : : {
896 : 0 : case sheet::ValidationType_ANY: nValMode = SC_VALID_ANY; break;
897 : 0 : case sheet::ValidationType_WHOLE: nValMode = SC_VALID_WHOLE; break;
898 : 0 : case sheet::ValidationType_DECIMAL: nValMode = SC_VALID_DECIMAL; break;
899 : 1 : case sheet::ValidationType_DATE: nValMode = SC_VALID_DATE; break;
900 : 0 : case sheet::ValidationType_TIME: nValMode = SC_VALID_TIME; break;
901 : 0 : case sheet::ValidationType_TEXT_LEN: nValMode = SC_VALID_TEXTLEN; break;
902 : 0 : case sheet::ValidationType_LIST: nValMode = SC_VALID_LIST; break;
903 : 2 : case sheet::ValidationType_CUSTOM: nValMode = SC_VALID_CUSTOM; break;
904 : : default:
905 : : {
906 : : // added to avoid warnings
907 : : }
908 : : }
909 : : }
910 [ + - ][ + - ]: 2 : else if ( aString.EqualsAscii( SC_UNONAME_ERRALSTY ) )
911 : : {
912 : : sheet::ValidationAlertStyle eStyle = (sheet::ValidationAlertStyle)
913 [ + - ]: 2 : ScUnoHelpFunctions::GetEnumFromAny( aValue );
914 [ - + + - : 2 : switch (eStyle)
- ]
915 : : {
916 : 0 : case sheet::ValidationAlertStyle_STOP: nErrorStyle = SC_VALERR_STOP; break;
917 : 1 : case sheet::ValidationAlertStyle_WARNING: nErrorStyle = SC_VALERR_WARNING; break;
918 : 1 : case sheet::ValidationAlertStyle_INFO: nErrorStyle = SC_VALERR_INFO; break;
919 : 2 : case sheet::ValidationAlertStyle_MACRO: nErrorStyle = SC_VALERR_MACRO; break;
920 : : default:
921 : : {
922 : : // added to avoid warnings
923 : : }
924 : : }
925 : : }
926 [ # # ][ # # ]: 0 : else if ( aString.EqualsAscii( SC_UNONAME_SOURCESTR ) )
927 : : {
928 : : // internal - only for XML filter, not in PropertySetInfo, only set
929 : :
930 : 0 : rtl::OUString aStrVal;
931 [ # # ]: 0 : if ( aValue >>= aStrVal )
932 [ # # ][ # # ]: 0 : aPosString = String( aStrVal );
[ # # ]
933 : : }
934 [ # # ][ # # ]: 0 : else if ( aString.EqualsAscii( SC_UNONAME_FORMULANMSP1 ) )
935 : : {
936 : : // internal - only for XML filter, not in PropertySetInfo, only set
937 : :
938 : 0 : rtl::OUString aStrVal;
939 [ # # ]: 0 : if ( aValue >>= aStrVal )
940 [ # # ]: 0 : maExprNmsp1 = aStrVal;
941 : : }
942 [ # # ][ # # ]: 0 : else if ( aString.EqualsAscii( SC_UNONAME_FORMULANMSP2 ) )
943 : : {
944 : : // internal - only for XML filter, not in PropertySetInfo, only set
945 : :
946 : 0 : rtl::OUString aStrVal;
947 [ # # ]: 0 : if ( aValue >>= aStrVal )
948 [ # # ]: 0 : maExprNmsp2 = aStrVal;
949 : : }
950 [ # # ][ # # ]: 0 : else if ( aString.EqualsAscii( SC_UNONAME_GRAMMAR1 ) )
951 : : {
952 : : // internal - only for XML filter, not in PropertySetInfo, only set
953 : :
954 : 0 : sal_Int32 nVal = 0;
955 [ # # ]: 0 : if ( aValue >>= nVal )
956 : 0 : meGrammar1 = static_cast< FormulaGrammar::Grammar >(nVal);
957 : : }
958 [ # # ][ # # ]: 0 : else if ( aString.EqualsAscii( SC_UNONAME_GRAMMAR2 ) )
959 : : {
960 : : // internal - only for XML filter, not in PropertySetInfo, only set
961 : :
962 : 0 : sal_Int32 nVal = 0;
963 [ # # ]: 0 : if ( aValue >>= nVal )
964 : 0 : meGrammar2 = static_cast< FormulaGrammar::Grammar >(nVal);
965 [ + - ][ + - ]: 20 : }
966 : 20 : }
967 : :
968 : 50 : uno::Any SAL_CALL ScTableValidationObj::getPropertyValue( const rtl::OUString& aPropertyName )
969 : : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
970 : : uno::RuntimeException)
971 : : {
972 [ + - ]: 50 : SolarMutexGuard aGuard;
973 [ + - ]: 50 : String aString(aPropertyName);
974 : 50 : uno::Any aRet;
975 : :
976 [ + + ][ + - ]: 50 : if ( aString.EqualsAscii( SC_UNONAME_SHOWINP ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, bShowInput );
[ + - ]
977 [ + - ][ + + ]: 45 : else if ( aString.EqualsAscii( SC_UNONAME_SHOWERR ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, bShowError );
[ + - ]
978 [ + - ][ + + ]: 40 : else if ( aString.EqualsAscii( SC_UNONAME_IGNOREBL ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, bIgnoreBlank );
[ + - ]
979 [ + - ][ + + ]: 35 : else if ( aString.EqualsAscii( SC_UNONAME_SHOWLIST ) ) aRet <<= nShowList;
[ + - ]
980 [ + - ][ + + ]: 30 : else if ( aString.EqualsAscii( SC_UNONAME_INPTITLE ) ) aRet <<= rtl::OUString( aInputTitle );
[ + - ][ + - ]
981 [ + - ][ + + ]: 25 : else if ( aString.EqualsAscii( SC_UNONAME_INPMESS ) ) aRet <<= rtl::OUString( aInputMessage );
[ + - ][ + - ]
982 [ + - ][ + + ]: 20 : else if ( aString.EqualsAscii( SC_UNONAME_ERRTITLE ) ) aRet <<= rtl::OUString( aErrorTitle );
[ + - ][ + - ]
983 [ + - ][ + + ]: 15 : else if ( aString.EqualsAscii( SC_UNONAME_ERRMESS ) ) aRet <<= rtl::OUString( aErrorMessage );
[ + - ][ + - ]
984 [ + - ][ + + ]: 10 : else if ( aString.EqualsAscii( SC_UNONAME_TYPE ) )
985 : : {
986 : 5 : sheet::ValidationType eType = sheet::ValidationType_ANY;
987 [ + - - + : 5 : switch (nValMode)
- - - +
- ]
988 : : {
989 : 1 : case SC_VALID_ANY: eType = sheet::ValidationType_ANY; break;
990 : 0 : case SC_VALID_WHOLE: eType = sheet::ValidationType_WHOLE; break;
991 : 0 : case SC_VALID_DECIMAL: eType = sheet::ValidationType_DECIMAL; break;
992 : 2 : case SC_VALID_DATE: eType = sheet::ValidationType_DATE; break;
993 : 0 : case SC_VALID_TIME: eType = sheet::ValidationType_TIME; break;
994 : 0 : case SC_VALID_TEXTLEN: eType = sheet::ValidationType_TEXT_LEN; break;
995 : 0 : case SC_VALID_LIST: eType = sheet::ValidationType_LIST; break;
996 : 2 : case SC_VALID_CUSTOM: eType = sheet::ValidationType_CUSTOM; break;
997 : : }
998 [ + - ]: 5 : aRet <<= eType;
999 : : }
1000 [ + - ][ + - ]: 5 : else if ( aString.EqualsAscii( SC_UNONAME_ERRALSTY ) )
1001 : : {
1002 : 5 : sheet::ValidationAlertStyle eStyle = sheet::ValidationAlertStyle_STOP;
1003 [ + + + - : 5 : switch (nErrorStyle)
- ]
1004 : : {
1005 : 1 : case SC_VALERR_STOP: eStyle = sheet::ValidationAlertStyle_STOP; break;
1006 : 2 : case SC_VALERR_WARNING: eStyle = sheet::ValidationAlertStyle_WARNING; break;
1007 : 2 : case SC_VALERR_INFO: eStyle = sheet::ValidationAlertStyle_INFO; break;
1008 : 0 : case SC_VALERR_MACRO: eStyle = sheet::ValidationAlertStyle_MACRO; break;
1009 : : }
1010 [ + - ]: 5 : aRet <<= eStyle;
1011 : : }
1012 : :
1013 [ + - ][ + - ]: 50 : return aRet;
1014 : : }
1015 : :
1016 : 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScTableValidationObj )
1017 : :
1018 : : // XUnoTunnel
1019 : :
1020 : 9 : sal_Int64 SAL_CALL ScTableValidationObj::getSomething(
1021 : : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
1022 : : {
1023 [ + - + - ]: 18 : if ( rId.getLength() == 16 &&
[ + - ]
1024 : 9 : 0 == memcmp( getUnoTunnelId().getConstArray(),
1025 : 9 : rId.getConstArray(), 16 ) )
1026 : : {
1027 : 9 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
1028 : : }
1029 : 9 : return 0;
1030 : : }
1031 : :
1032 : : namespace
1033 : : {
1034 : : class theScTableValidationObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScTableValidationObjUnoTunnelId> {};
1035 : : }
1036 : :
1037 : 18 : const uno::Sequence<sal_Int8>& ScTableValidationObj::getUnoTunnelId()
1038 : : {
1039 : 18 : return theScTableValidationObjUnoTunnelId::get().getSeq();
1040 : : }
1041 : :
1042 : 9 : ScTableValidationObj* ScTableValidationObj::getImplementation(
1043 : : const uno::Reference<beans::XPropertySet> xObj )
1044 : : {
1045 : 9 : ScTableValidationObj* pRet = NULL;
1046 [ + - ]: 9 : uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
1047 [ + - ]: 9 : if (xUT.is())
1048 [ + - ][ + - ]: 9 : pRet = reinterpret_cast<ScTableValidationObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
[ + - ]
1049 : 9 : return pRet;
1050 [ + - ][ + - ]: 153 : }
1051 : :
1052 : : //------------------------------------------------------------------------
1053 : :
1054 : :
1055 : :
1056 : :
1057 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
