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