sc/source/ui/unoobj/fmtuno.cxx

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