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