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