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