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