sc/source/ui/unoobj/condformatuno.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
  10 #include "condformatuno.hxx"
  11
  12 #include "document.hxx"
  13 #include "conditio.hxx"
  14 #include "colorscale.hxx"
  15 #include "docsh.hxx"
  16 #include "miscuno.hxx"
  17 #include "compiler.hxx"
  18 #include "tokenarray.hxx"
  19
  20 #include "cellsuno.hxx"
  21 #include "convuno.hxx"
  22
  23 #include <vcl/svapp.hxx>
  24 #include <rtl/ustring.hxx>
  25
  26 #include <com/sun/star/sheet/DataBarAxis.hpp>
  27 #include <com/sun/star/sheet/IconSetType.hpp>
  28 #include <com/sun/star/sheet/DataBarAxis.hpp>
  29 #include <com/sun/star/sheet/ConditionFormatOperator.hpp>
  30 #include <com/sun/star/sheet/DataBarEntryType.hpp>
  31 #include <com/sun/star/sheet/ColorScaleEntryType.hpp>
  32 #include <com/sun/star/sheet/IconSetFormatEntry.hpp>
  33 #include <com/sun/star/sheet/ConditionEntryType.hpp>
  34 #include <com/sun/star/sheet/DateType.hpp>
  35
  36 namespace {
  37
  38 enum CondFormatProperties
  39 {
  40     ID,
  41     CondFormat_Range
  42 };
  43
  44 const SfxItemPropertyMapEntry* getCondFormatPropset()
  45 {
  46     static const SfxItemPropertyMapEntry aCondFormatPropertyMap_Impl[] =
  47     {
  48         {OUString("ID"), ID, cppu::UnoType<sal_Int32>::get(), 0, 0},
  49         {OUString("Range"), CondFormat_Range, cppu::UnoType<sheet::XSheetCellRanges>::get(), 0, 0},
  50         {OUString(), 0, css::uno::Type(), 0, 0}
  51     };
  52     return aCondFormatPropertyMap_Impl;
  53 }
  54
  55 enum ConditionEntryProperties
  56 {
  57     StyleName,
  58     Formula1,
  59     Formula2,
  60     Operator
  61 };
  62
  63 const SfxItemPropertyMapEntry* getConditionEntryrPropSet()
  64 {
  65     static const SfxItemPropertyMapEntry aConditionEntryPropertyMap_Impl[] =
  66     {
  67         {OUString("StyleName"), StyleName, cppu::UnoType<OUString>::get(), 0, 0},
  68         {OUString("Formula1"), Formula1, cppu::UnoType<OUString>::get(), 0, 0},
  69         {OUString("Formula2"), Formula2, cppu::UnoType<OUString>::get(), 0, 0},
  70         {OUString("Operator"), Operator, cppu::UnoType<decltype(sheet::ConditionFormatOperator::EQUAL)>::get(), 0, 0 },
  71         {OUString(), 0, css::uno::Type(), 0, 0}
  72     };
  73     return aConditionEntryPropertyMap_Impl;
  74 }
  75
  76 struct ConditionEntryApiMap
  77 {
  78     ScConditionMode eMode;
  79     sal_Int32 nApiMode;
  80 };
  81
  82 ConditionEntryApiMap aConditionEntryMap[] =
  83 {
  84     {SC_COND_EQUAL, sheet::ConditionFormatOperator::EQUAL},
  85     {SC_COND_LESS, sheet::ConditionFormatOperator::LESS},
  86     {SC_COND_GREATER, sheet::ConditionFormatOperator::GREATER},
  87     {SC_COND_EQLESS, sheet::ConditionFormatOperator::LESS_EQUAL},
  88     {SC_COND_EQGREATER, sheet::ConditionFormatOperator::GREATER_EQUAL},
  89     {SC_COND_NOTEQUAL, sheet::ConditionFormatOperator::NOT_EQUAL},
  90     {SC_COND_BETWEEN, sheet::ConditionFormatOperator::BETWEEN},
  91     {SC_COND_NOTBETWEEN, sheet::ConditionFormatOperator::NOT_BETWEEN},
  92     {SC_COND_DUPLICATE, sheet::ConditionFormatOperator::DUPLICATE},
  93     {SC_COND_NOTDUPLICATE, sheet::ConditionFormatOperator::UNIQUE},
  94     {SC_COND_DIRECT, sheet::ConditionFormatOperator::EXPRESSION},
  95     {SC_COND_TOP10, sheet::ConditionFormatOperator::TOP_N_ELEMENTS},
  96     {SC_COND_BOTTOM10, sheet::ConditionFormatOperator::BOTTOM_N_ELEMENTS},
  97     {SC_COND_TOP_PERCENT, sheet::ConditionFormatOperator::TOP_N_PERCENT},
  98     {SC_COND_BOTTOM_PERCENT, sheet::ConditionFormatOperator::BOTTOM_N_PERCENT},
  99     {SC_COND_ABOVE_AVERAGE, sheet::ConditionFormatOperator::ABOVE_AVERAGE},
 100     {SC_COND_BELOW_AVERAGE, sheet::ConditionFormatOperator::BELOW_AVERAGE},
 101     {SC_COND_ABOVE_EQUAL_AVERAGE, sheet::ConditionFormatOperator::ABOVE_EQUAL_AVERAGE},
 102     {SC_COND_BELOW_EQUAL_AVERAGE, sheet::ConditionFormatOperator::BELOW_EQUAL_AVERAGE},
 103     {SC_COND_ERROR, sheet::ConditionFormatOperator::ERROR},
 104     {SC_COND_NOERROR, sheet::ConditionFormatOperator::NO_ERROR},
 105     {SC_COND_BEGINS_WITH, sheet::ConditionFormatOperator::BEGINS_WITH},
 106     {SC_COND_ENDS_WITH, sheet::ConditionFormatOperator::ENDS_WITH},
 107     {SC_COND_CONTAINS_TEXT, sheet::ConditionFormatOperator::CONTAINS},
 108     {SC_COND_NOT_CONTAINS_TEXT, sheet::ConditionFormatOperator::NOT_CONTAINS},
 109     {SC_COND_NONE, sheet::ConditionFormatOperator::EQUAL},
 110 };
 111
 112 enum ColorScaleProperties
 113 {
 114     ColorScaleEntries
 115 };
 116
 117 const SfxItemPropertyMapEntry* getColorScalePropSet()
 118 {
 119     static const SfxItemPropertyMapEntry aColorScalePropertyMap_Impl[] =
 120     {
 121         {OUString("ColorScaleEntries"), ColorScaleEntries, cppu::UnoType<uno::Sequence< sheet::XColorScaleEntry >>::get(), 0, 0 },
 122         {OUString(), 0, css::uno::Type(), 0, 0}
 123     };
 124     return aColorScalePropertyMap_Impl;
 125 }
 126
 127 struct ColorScaleEntryTypeApiMap
 128 {
 129     ScColorScaleEntryType eType;
 130     sal_Int32 nApiType;
 131 };
 132
 133 ColorScaleEntryTypeApiMap aColorScaleEntryTypeMap[] =
 134 {
 135     { COLORSCALE_MIN, sheet::ColorScaleEntryType::COLORSCALE_MIN },
 136     { COLORSCALE_MAX, sheet::ColorScaleEntryType::COLORSCALE_MAX },
 137     { COLORSCALE_VALUE, sheet::ColorScaleEntryType::COLORSCALE_VALUE },
 138     { COLORSCALE_FORMULA, sheet::ColorScaleEntryType::COLORSCALE_FORMULA },
 139     { COLORSCALE_PERCENT, sheet::ColorScaleEntryType::COLORSCALE_PERCENT },
 140     { COLORSCALE_PERCENTILE, sheet::ColorScaleEntryType::COLORSCALE_PERCENTILE }
 141 };
 142
 143 enum DataBarProperties
 144 {
 145     AxisPosition,
 146     UseGradient,
 147     UseNegativeColor,
 148     DataBar_ShowValue,
 149     DataBar_Color,
 150     AxisColor,
 151     NegativeColor,
 152     DataBarEntries,
 153     MinimumLength,
 154     MaximumLength
 155 };
 156
 157 const SfxItemPropertyMapEntry* getDataBarPropSet()
 158 {
 159     static const SfxItemPropertyMapEntry aDataBarPropertyMap_Impl[] =
 160     {
 161         {OUString("AxisPosition"), AxisPosition, cppu::UnoType<decltype(sheet::DataBarAxis::AXIS_AUTOMATIC)>::get(), 0, 0 },
 162         {OUString("UseGradient"), UseGradient, cppu::UnoType<bool>::get(), 0, 0 },
 163         {OUString("UseNegativeColor"), UseNegativeColor, cppu::UnoType<bool>::get(), 0, 0 },
 164         {OUString("ShowValue"), DataBar_ShowValue, cppu::UnoType<bool>::get(), 0, 0 },
 165         {OUString("Color"), DataBar_Color, cppu::UnoType<sal_Int32>::get(), 0, 0},
 166         {OUString("AxisColor"), AxisColor, cppu::UnoType<sal_Int32>::get(), 0, 0},
 167         {OUString("NegativeColor"), NegativeColor, cppu::UnoType<sal_Int32>::get(), 0, 0},
 168         {OUString("DataBarEntries"), DataBarEntries, cppu::UnoType<uno::Sequence< sheet::XDataBarEntry >>::get(), 0, 0 },
 169         {OUString("MinimumLength"), MinimumLength, cppu::UnoType<double>::get(), 0, 0 },
 170         {OUString("MaximumLength"), MaximumLength, cppu::UnoType<double>::get(), 0, 0 },
 171         {OUString(), 0, css::uno::Type(), 0, 0}
 172     };
 173     return aDataBarPropertyMap_Impl;
 174 }
 175
 176 struct DataBarAxisApiMap
 177 {
 178     databar::ScAxisPosition ePos;
 179     sal_Int32 nApiPos;
 180 };
 181
 182 DataBarAxisApiMap aDataBarAxisMap[] =
 183 {
 184     { databar::NONE, sheet::DataBarAxis::AXIS_NONE },
 185     { databar::AUTOMATIC, sheet::DataBarAxis::AXIS_AUTOMATIC },
 186     { databar::MIDDLE, sheet::DataBarAxis::AXIS_MIDDLE }
 187 };
 188
 189 struct DataBarEntryTypeApiMap
 190 {
 191     ScColorScaleEntryType eType;
 192     sal_Int32 nApiType;
 193 };
 194
 195 DataBarEntryTypeApiMap aDataBarEntryTypeMap[] =
 196 {
 197     { COLORSCALE_AUTO, sheet::DataBarEntryType::DATABAR_AUTO },
 198     { COLORSCALE_MIN, sheet::DataBarEntryType::DATABAR_MIN },
 199     { COLORSCALE_MAX, sheet::DataBarEntryType::DATABAR_MAX },
 200     { COLORSCALE_VALUE, sheet::DataBarEntryType::DATABAR_VALUE },
 201     { COLORSCALE_FORMULA, sheet::DataBarEntryType::DATABAR_FORMULA },
 202     { COLORSCALE_PERCENT, sheet::DataBarEntryType::DATABAR_PERCENT },
 203     { COLORSCALE_PERCENTILE, sheet::DataBarEntryType::DATABAR_PERCENTILE }
 204 };
 205
 206 enum IconSetProperties
 207 {
 208     Icons,
 209     Reverse,
 210     ShowValue,
 211     IconSetEntries
 212 };
 213
 214 const SfxItemPropertyMapEntry* getIconSetPropSet()
 215 {
 216     static const SfxItemPropertyMapEntry aIconSetPropertyMap_Impl[] =
 217     {
 218         {OUString("Icons"), Icons, cppu::UnoType<decltype(sheet::IconSetType::ICONSET_3SYMBOLS)>::get(), 0, 0 },
 219         {OUString("Reverse"), Reverse, cppu::UnoType<bool>::get(), 0, 0 },
 220         {OUString("ShowValue"), ShowValue, cppu::UnoType<bool>::get(), 0, 0 },
 221         {OUString("IconSetEntries"), IconSetEntries, cppu::UnoType<uno::Sequence< sheet::XIconSetEntry >>::get(), 0, 0 },
 222         {OUString(), 0, css::uno::Type(), 0, 0}
 223     };
 224     return aIconSetPropertyMap_Impl;
 225 }
 226
 227 struct IconSetTypeApiMap
 228 {
 229     ScIconSetType eType;
 230     sal_Int32 nApiType;
 231 };
 232
 233 const IconSetTypeApiMap aIconSetApiMap[] =
 234 {
 235     { IconSet_3Arrows, sheet::IconSetType::ICONSET_3ARROWS },
 236     { IconSet_3ArrowsGray, sheet::IconSetType::ICONSET_3ARROWS_GRAY },
 237     { IconSet_3Flags, sheet::IconSetType::ICONSET_3FLAGS },
 238     { IconSet_3TrafficLights1, sheet::IconSetType::ICONSET_3TRAFFICLIGHTS1 },
 239     { IconSet_3TrafficLights2, sheet::IconSetType::ICONSET_3TRAFFICLIGHTS2 },
 240     { IconSet_3Signs, sheet::IconSetType::ICONSET_3SIGNS },
 241     { IconSet_3Symbols, sheet::IconSetType::ICONSET_3SYMBOLS },
 242     { IconSet_3Symbols2, sheet::IconSetType::ICONSET_3SYMBOLS2 },
 243     { IconSet_3Smilies, sheet::IconSetType::ICONSET_3SMILIES },
 244     { IconSet_3ColorSmilies, sheet::IconSetType::ICONSET_3COLOR_SIMILIES },
 245     { IconSet_4Arrows, sheet::IconSetType::ICONSET_4ARROWS },
 246     { IconSet_4ArrowsGray, sheet::IconSetType::ICONSET_4ARROWS_GRAY },
 247     { IconSet_4Rating, sheet::IconSetType::ICONSET_4RATING },
 248     { IconSet_4RedToBlack, sheet::IconSetType::ICONSET_4RED_TO_BLACK },
 249     { IconSet_4TrafficLights, sheet::IconSetType::ICONSET_4TRAFFICLIGHTS },
 250     { IconSet_5Arrows, sheet::IconSetType::ICONSET_5ARROWS },
 251     { IconSet_5ArrowsGray, sheet::IconSetType::ICONSET_4ARROWS_GRAY },
 252     { IconSet_5Ratings, sheet::IconSetType::ICONSET_5RATINGS },
 253     { IconSet_5Quarters, sheet::IconSetType::ICONSET_5QUARTERS },
 254 };
 255
 256 struct IconSetEntryTypeApiMap
 257 {
 258     ScColorScaleEntryType eType;
 259     sal_Int32 nApiType;
 260 };
 261
 262 IconSetEntryTypeApiMap aIconSetEntryTypeMap[] =
 263 {
 264     { COLORSCALE_MIN, sheet::IconSetFormatEntry::ICONSET_MIN },
 265     { COLORSCALE_VALUE, sheet::IconSetFormatEntry::ICONSET_VALUE },
 266     { COLORSCALE_FORMULA, sheet::IconSetFormatEntry::ICONSET_FORMULA },
 267     { COLORSCALE_PERCENT, sheet::IconSetFormatEntry::ICONSET_PERCENT },
 268     { COLORSCALE_PERCENTILE, sheet::IconSetFormatEntry::ICONSET_PERCENTILE }
 269 };
 270
 271 enum DateProperties
 272 {
 273     Date_StyleName,
 274     DateType
 275 };
 276
 277 const SfxItemPropertyMapEntry* getCondDatePropSet()
 278 {
 279     static const SfxItemPropertyMapEntry aCondDatePropertyMap_Impl[] =
 280     {
 281         {OUString("StyleName"), StyleName, cppu::UnoType<OUString>::get(), 0, 0},
 282         {OUString("DateType"), Icons, cppu::UnoType<decltype(sheet::DateType::TODAY)>::get(), 0, 0 },
 283         {OUString(), 0, css::uno::Type(), 0, 0}
 284     };
 285     return aCondDatePropertyMap_Impl;
 286 }
 287
 288 struct DateTypeApiMap
 289 {
 290     condformat::ScCondFormatDateType eType;
 291     sal_Int32 nApiType;
 292 };
 293
 294 DateTypeApiMap aDateTypeApiMap[] =
 295 {
 296     { condformat::TODAY, sheet::DateType::TODAY },
 297     { condformat::YESTERDAY, sheet::DateType::YESTERDAY },
 298     { condformat::TOMORROW, sheet::DateType::TOMORROW },
 299     { condformat::LAST7DAYS, sheet::DateType::LAST7DAYS },
 300     { condformat::THISWEEK, sheet::DateType::THISWEEK },
 301     { condformat::LASTWEEK, sheet::DateType::LASTWEEK },
 302     { condformat::NEXTWEEK, sheet::DateType::NEXTWEEK },
 303     { condformat::THISMONTH, sheet::DateType::THISMONTH },
 304     { condformat::LASTMONTH, sheet::DateType::LASTMONTH },
 305     { condformat::NEXTMONTH, sheet::DateType::NEXTMONTH },
 306     { condformat::THISYEAR, sheet::DateType::THISYEAR },
 307     { condformat::LASTYEAR, sheet::DateType::LASTYEAR },
 308     { condformat::NEXTYEAR, sheet::DateType::NEXTYEAR }
 309 };
 310
 311 }
 312
 313 ScCondFormatsObj::ScCondFormatsObj(ScDocShell* pDocShell, SCTAB nTab):
 314     mnTab(nTab),
 315     mpDocShell(pDocShell)
 316 {
 317     pDocShell->GetDocument().AddUnoObject(*this);
 318 }
 319
 320 ScCondFormatsObj::~ScCondFormatsObj()
 321 {
 322     if (mpDocShell)
 323         mpDocShell->GetDocument().RemoveUnoObject(*this);
 324 }
 325
 326 void ScCondFormatsObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
 327 {
 328     if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
 329             static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
 330     {
 331         mpDocShell = NULL;       // ungueltig geworden
 332     }
 333 }
 334
 335 sal_Int32 ScCondFormatsObj::createByRange(const uno::Reference< sheet::XSheetCellRanges >& xRanges)
 336     throw(uno::RuntimeException, std::exception)
 337 {
 338     SolarMutexGuard aGuard;
 339     if (!mpDocShell)
 340         throw lang::IllegalArgumentException();
 341
 342     if (!xRanges.is())
 343         throw lang::IllegalArgumentException();
 344
 345     uno::Sequence<table::CellRangeAddress> aRanges =
 346         xRanges->getRangeAddresses();
 347
 348     ScRangeList aCoreRange;
 349     for (sal_Int32 i = 0, n = aRanges.getLength(); i < n; ++i)
 350     {
 351         ScRange aRange;
 352         ScUnoConversion::FillScRange(aRange, aRanges[i]);
 353         aCoreRange.Join(aRange);
 354     }
 355
 356     if (aCoreRange.empty())
 357         throw lang::IllegalArgumentException();
 358
 359     SCTAB nTab = aCoreRange[0]->aStart.Tab();
 360
 361     ScConditionalFormat* pNewFormat = new ScConditionalFormat(0, &mpDocShell->GetDocument());
 362     pNewFormat->SetRange(aCoreRange);
 363     return mpDocShell->GetDocument().AddCondFormat(pNewFormat, nTab);
 364 }
 365
 366 void ScCondFormatsObj::removeByID(const sal_Int32 nID)
 367     throw(uno::RuntimeException, std::exception)
 368 {
 369     SolarMutexGuard aGuard;
 370     ScConditionalFormatList* pFormatList = getCoreObject();;
 371     pFormatList->erase(nID);
 372 }
 373
 374 uno::Sequence<uno::Reference<sheet::XConditionalFormat> > ScCondFormatsObj::getConditionalFormats()
 375     throw(uno::RuntimeException, std::exception)
 376 {
 377     SolarMutexGuard aGuard;
 378     ScConditionalFormatList* pFormatList = getCoreObject();;
 379     size_t n = pFormatList->size();
 380     uno::Sequence<uno::Reference<sheet::XConditionalFormat> > aCondFormats(n);
 381     sal_Int32 i = 0;
 382     for (ScConditionalFormatList::const_iterator itr = pFormatList->begin(); itr != pFormatList->end(); ++itr, ++i) {
 383         uno::Reference<sheet::XConditionalFormat> xCondFormat(new ScCondFormatObj(mpDocShell, this, itr->GetKey()));
 384         aCondFormats[i] = xCondFormat;
 385     }
 386
 387     return aCondFormats;
 388 }
 389
 390 sal_Int32 ScCondFormatsObj::getLength()
 391     throw(uno::RuntimeException, std::exception)
 392 {
 393     SolarMutexGuard aGuard;
 394     ScConditionalFormatList* pFormatList = getCoreObject();;
 395     return pFormatList->size();;
 396 }
 397
 398 ScConditionalFormatList* ScCondFormatsObj::getCoreObject()
 399 {
 400     if (!mpDocShell)
 401         throw uno::RuntimeException();
 402
 403     ScConditionalFormatList* pList = mpDocShell->GetDocument().GetCondFormList(mnTab);
 404     if (!pList)
 405         throw uno::RuntimeException();
 406
 407     return pList;
 408 }
 409
 410 namespace {
 411
 412 uno::Reference<beans::XPropertySet> createConditionEntry(const ScFormatEntry* pEntry,
 413         rtl::Reference<ScCondFormatObj> xParent)
 414 {
 415     switch (pEntry->GetType())
 416     {
 417         case condformat::CONDITION:
 418             return new ScConditionEntryObj(xParent,
 419                     static_cast<const ScCondFormatEntry*>(pEntry));
 420         break;
 421         case condformat::COLORSCALE:
 422             return new ScColorScaleFormatObj(xParent,
 423                     static_cast<const ScColorScaleFormat*>(pEntry));
 424         break;
 425         case condformat::DATABAR:
 426             return new ScDataBarFormatObj(xParent,
 427                     static_cast<const ScDataBarFormat*>(pEntry));
 428         break;
 429         case condformat::ICONSET:
 430             return new ScIconSetFormatObj(xParent,
 431                     static_cast<const ScIconSetFormat*>(pEntry));
 432         break;
 433         case condformat::DATE:
 434             return new ScCondDateFormatObj(xParent,
 435                     static_cast<const ScCondDateFormatEntry*>(pEntry));
 436         break;
 437         default:
 438         break;
 439     }
 440     return uno::Reference<beans::XPropertySet>();
 441 }
 442
 443 }
 444
 445 ScCondFormatObj::ScCondFormatObj(ScDocShell* pDocShell, rtl::Reference<ScCondFormatsObj> xCondFormats,
 446         sal_Int32 nKey):
 447     mxCondFormatList(xCondFormats),
 448     mpDocShell(pDocShell),
 449     maPropSet(getCondFormatPropset()),
 450     mnKey(nKey)
 451 {
 452 }
 453
 454 ScCondFormatObj::~ScCondFormatObj()
 455 {
 456 }
 457
 458 ScConditionalFormat* ScCondFormatObj::getCoreObject()
 459 {
 460     ScConditionalFormatList* pList = mxCondFormatList->getCoreObject();
 461     ScConditionalFormat* pFormat = pList->GetFormat(mnKey);
 462     if (!pFormat)
 463         throw uno::RuntimeException();
 464
 465     return pFormat;
 466 }
 467
 468 ScDocShell* ScCondFormatObj::getDocShell()
 469 {
 470     return mpDocShell;
 471 }
 472
 473 void ScCondFormatObj::createEntry(const sal_Int32 nType, const sal_Int32 nPos)
 474     throw(uno::RuntimeException, std::exception)
 475 {
 476     SolarMutexGuard aGuard;
 477     ScConditionalFormat* pFormat = getCoreObject();
 478     if (nPos > sal_Int32(pFormat->size()))
 479         throw lang::IllegalArgumentException();
 480
 481     ScFormatEntry* pNewEntry = NULL;
 482     ScDocument* pDoc = &mpDocShell->GetDocument();
 483     switch (nType)
 484     {
 485         case sheet::ConditionEntryType::CONDITION:
 486             pNewEntry = new ScCondFormatEntry(SC_COND_EQUAL, "", "",
 487                     pDoc, pFormat->GetRange().GetTopLeftCorner(), "");
 488         break;
 489         case sheet::ConditionEntryType::COLORSCALE:
 490             pNewEntry = new ScColorScaleFormat(pDoc);
 491             static_cast<ScColorScaleFormat*>(pNewEntry)->EnsureSize();
 492         break;
 493         case sheet::ConditionEntryType::DATABAR:
 494             pNewEntry = new ScDataBarFormat(pDoc);
 495             static_cast<ScDataBarFormat*>(pNewEntry)->EnsureSize();
 496         break;
 497         case sheet::ConditionEntryType::ICONSET:
 498             pNewEntry = new ScIconSetFormat(pDoc);
 499             static_cast<ScIconSetFormat*>(pNewEntry)->EnsureSize();
 500         break;
 501         case sheet::ConditionEntryType::DATE:
 502             pNewEntry = new ScCondDateFormatEntry(pDoc);
 503         break;
 504         default:
 505             SAL_WARN("sc", "unknown conditional format type");
 506             throw lang::IllegalArgumentException();
 507     }
 508
 509     pFormat->AddEntry(pNewEntry);
 510 }
 511
 512 void ScCondFormatObj::removeByIndex(const sal_Int32 nIndex)
 513     throw(uno::RuntimeException, std::exception)
 514 {
 515     SolarMutexGuard aGuard;
 516     if (getCoreObject()->size() >= size_t(nIndex))
 517         throw lang::IllegalArgumentException();
 518
 519     getCoreObject()->RemoveEntry(nIndex);
 520 }
 521
 522 uno::Type ScCondFormatObj::getElementType()
 523     throw(uno::RuntimeException, std::exception)
 524 {
 525     return cppu::UnoType<beans::XPropertySet>::get();
 526 }
 527
 528 sal_Bool ScCondFormatObj::hasElements()
 529     throw(uno::RuntimeException, std::exception)
 530 {
 531     SolarMutexGuard aGuard;
 532     ScConditionalFormat* pFormat = getCoreObject();
 533     return !pFormat->IsEmpty();
 534 }
 535
 536 sal_Int32 ScCondFormatObj::getCount()
 537     throw(uno::RuntimeException, std::exception)
 538 {
 539     SolarMutexGuard aGuard;
 540     ScConditionalFormat* pFormat = getCoreObject();
 541
 542     return pFormat->size();
 543 }
 544
 545 uno::Any ScCondFormatObj::getByIndex(sal_Int32 nIndex)
 546     throw(uno::RuntimeException, std::exception)
 547 {
 548     SolarMutexGuard aGuard;
 549     if (getCoreObject()->size() <= size_t(nIndex))
 550         throw lang::IllegalArgumentException();
 551
 552     const ScFormatEntry* pEntry = getCoreObject()->GetEntry(nIndex);
 553     uno::Reference<beans::XPropertySet> xCondEntry =
 554         createConditionEntry(pEntry, this);
 555     uno::Any aAny;
 556     aAny <<= xCondEntry;
 557     return aAny;
 558 }
 559
 560 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCondFormatObj::getPropertySetInfo()
 561     throw(uno::RuntimeException, std::exception)
 562 {
 563     SolarMutexGuard aGuard;
 564     static uno::Reference<beans::XPropertySetInfo> aRef(
 565         new SfxItemPropertySetInfo( maPropSet.getPropertyMap()));
 566     return aRef;
 567 }
 568
 569 void SAL_CALL ScCondFormatObj::setPropertyValue(
 570                         const OUString& aPropertyName, const uno::Any& aValue )
 571                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 572                         lang::IllegalArgumentException, lang::WrappedTargetException,
 573                         uno::RuntimeException, std::exception)
 574 {
 575     SolarMutexGuard aGuard;
 576
 577     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 578     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 579     if ( !pEntry )
 580         throw beans::UnknownPropertyException();
 581
 582     switch(pEntry->nWID)
 583     {
 584         case ID:
 585             throw lang::IllegalArgumentException();
 586         break;
 587         case CondFormat_Range:
 588         {
 589             uno::Reference<sheet::XSheetCellRanges> xRange;
 590             if (aValue >>= xRange)
 591             {
 592                 ScConditionalFormat* pFormat = getCoreObject();
 593                 uno::Sequence<table::CellRangeAddress> aRanges =
 594                     xRange->getRangeAddresses();
 595                 ScRangeList aTargetRange;
 596                 for (size_t i = 0, n = aRanges.getLength(); i < n; ++i)
 597                 {
 598                     ScRange aRange;
 599                     ScUnoConversion::FillScRange(aRange, aRanges[i]);
 600                     aTargetRange.Join(aRange);
 601                 }
 602                 pFormat->SetRange(aTargetRange);
 603             }
 604         }
 605         break;
 606         default:
 607             SAL_WARN("sc", "unknown property");
 608     }
 609 }
 610
 611 uno::Any SAL_CALL ScCondFormatObj::getPropertyValue( const OUString& aPropertyName )
 612                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 613                         uno::RuntimeException, std::exception)
 614 {
 615     SolarMutexGuard aGuard;
 616
 617     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 618     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 619     if ( !pEntry )
 620         throw beans::UnknownPropertyException();
 621
 622     uno::Any aAny;
 623     switch(pEntry->nWID)
 624     {
 625         case ID:
 626             aAny <<= sal_Int32(getCoreObject()->GetKey());
 627         break;
 628         case CondFormat_Range:
 629         {
 630             const ScRangeList& rRange = getCoreObject()->GetRange();
 631             uno::Reference<sheet::XSheetCellRanges> xRange;
 632             xRange.set(new ScCellRangesObj(mpDocShell, rRange));
 633             aAny <<= xRange;
 634         }
 635         break;
 636         default:
 637             SAL_WARN("sc", "unknown property");
 638     }
 639     return aAny;
 640 }
 641
 642 void SAL_CALL ScCondFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
 643                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
 644                             throw(beans::UnknownPropertyException,
 645                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 646 {
 647     SAL_WARN("sc", "not implemented");
 648 }
 649
 650 void SAL_CALL ScCondFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
 651                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
 652                             throw(beans::UnknownPropertyException,
 653                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 654 {
 655     SAL_WARN("sc", "not implemented");
 656 }
 657
 658 void SAL_CALL ScCondFormatObj::addVetoableChangeListener( const OUString&,
 659                             const uno::Reference<beans::XVetoableChangeListener>&)
 660                             throw(beans::UnknownPropertyException,
 661                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 662 {
 663     SAL_WARN("sc", "not implemented");
 664 }
 665
 666 void SAL_CALL ScCondFormatObj::removeVetoableChangeListener( const OUString&,
 667                             const uno::Reference<beans::XVetoableChangeListener>&)
 668                             throw(beans::UnknownPropertyException,
 669                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 670 {
 671     SAL_WARN("sc", "not implemented");
 672 }
 673
 674 namespace {
 675
 676 bool isObjectStillAlive(ScConditionalFormat* pFormat, const ScFormatEntry* pEntry)
 677 {
 678     for(size_t i = 0, n= pFormat->size(); i < n; ++i)
 679     {
 680         if (pFormat->GetEntry(i) == pEntry)
 681             return true;
 682     }
 683     return false;
 684 }
 685
 686 }
 687
 688 ScConditionEntryObj::ScConditionEntryObj(rtl::Reference<ScCondFormatObj> xParent,
 689         const ScCondFormatEntry* pFormat):
 690     mpDocShell(xParent->getDocShell()),
 691     mxParent(xParent),
 692     maPropSet(getConditionEntryrPropSet()),
 693     mpFormat(pFormat)
 694 {
 695 }
 696
 697 ScConditionEntryObj::~ScConditionEntryObj()
 698 {
 699 }
 700
 701 ScCondFormatEntry* ScConditionEntryObj::getCoreObject()
 702 {
 703     ScConditionalFormat* pFormat = mxParent->getCoreObject();
 704     if (isObjectStillAlive(pFormat, mpFormat))
 705         return const_cast<ScCondFormatEntry*>(mpFormat);
 706
 707     throw lang::IllegalArgumentException();
 708 }
 709
 710 sal_Int32 ScConditionEntryObj::getType()
 711     throw(uno::RuntimeException, std::exception)
 712 {
 713     return sheet::ConditionEntryType::CONDITION;
 714 }
 715
 716 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScConditionEntryObj::getPropertySetInfo()
 717     throw(uno::RuntimeException, std::exception)
 718 {
 719     static uno::Reference<beans::XPropertySetInfo> aRef(
 720         new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
 721     return aRef;
 722 }
 723
 724 void SAL_CALL ScConditionEntryObj::setPropertyValue(
 725                         const OUString& aPropertyName, const uno::Any& aValue )
 726                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 727                         lang::IllegalArgumentException, lang::WrappedTargetException,
 728                         uno::RuntimeException, std::exception)
 729 {
 730     SolarMutexGuard aGuard;
 731
 732     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 733     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 734     if ( !pEntry )
 735         throw beans::UnknownPropertyException();
 736
 737     switch(pEntry->nWID)
 738     {
 739         case StyleName:
 740         {
 741             OUString aStyleName;
 742             if ((aValue >>= aStyleName) && !aStyleName.isEmpty())
 743                 getCoreObject()->UpdateStyleName(aStyleName);
 744         }
 745         break;
 746         case Formula1:
 747         {
 748             OUString aFormula;
 749             if ((aValue >>= aFormula) && !aFormula.isEmpty())
 750             {
 751                 ScCompiler aComp(&mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());
 752                 boost::scoped_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));
 753                 getCoreObject()->SetFormula1(*pArr);
 754             }
 755         }
 756         break;
 757         case Formula2:
 758         {
 759             OUString aFormula;
 760             if ((aValue >>= aFormula) && !aFormula.isEmpty())
 761             {
 762                 ScCompiler aComp(&mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());
 763                 boost::scoped_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));
 764                 getCoreObject()->SetFormula2(*pArr);
 765             }
 766         }
 767         break;
 768         case Operator:
 769         {
 770             sal_Int32 nVal;
 771             if (aValue >>= nVal)
 772             {
 773                 for (size_t i = 0; i < SAL_N_ELEMENTS(aConditionEntryMap); ++i)
 774                 {
 775                     if (aConditionEntryMap[i].nApiMode == nVal)
 776                     {
 777                         getCoreObject()->SetOperation(aConditionEntryMap[i].eMode);
 778                         break;
 779                     }
 780                 }
 781             }
 782         }
 783         break;
 784         default:
 785             SAL_WARN("sc", "unsupported property");
 786     }
 787 }
 788
 789 uno::Any SAL_CALL ScConditionEntryObj::getPropertyValue( const OUString& aPropertyName )
 790                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 791                         uno::RuntimeException, std::exception)
 792 {
 793     SolarMutexGuard aGuard;
 794
 795     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 796     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 797     if ( !pEntry )
 798         throw beans::UnknownPropertyException();
 799
 800     uno::Any aAny;
 801     switch(pEntry->nWID)
 802     {
 803         case StyleName:
 804             aAny <<= getCoreObject()->GetStyle();
 805         break;
 806         case Formula1:
 807         {
 808             ScAddress aCursor = getCoreObject()->GetSrcPos();
 809             OUString aFormula = getCoreObject()->GetExpression(aCursor, 0);
 810             aAny <<= aFormula;
 811         }
 812         break;
 813         case Formula2:
 814         {
 815             ScAddress aCursor = getCoreObject()->GetSrcPos();
 816             OUString aFormula = getCoreObject()->GetExpression(aCursor, 1);
 817             aAny <<= aFormula;
 818         }
 819         break;
 820         case Operator:
 821         {
 822             ScConditionMode eMode = getCoreObject()->GetOperation();
 823             for (size_t i = 0; i < SAL_N_ELEMENTS(aConditionEntryMap); ++i)
 824             {
 825                 if (aConditionEntryMap[i].eMode == eMode)
 826                 {
 827                     aAny <<= aConditionEntryMap[i].nApiMode;
 828                     break;
 829                 }
 830             }
 831         }
 832         break;
 833         default:
 834             SAL_WARN("sc", "unsupported property");
 835     }
 836     return aAny;
 837 }
 838
 839 void SAL_CALL ScConditionEntryObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
 840                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
 841                             throw(beans::UnknownPropertyException,
 842                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 843 {
 844     SAL_WARN("sc", "not implemented");
 845 }
 846
 847 void SAL_CALL ScConditionEntryObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
 848                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
 849                             throw(beans::UnknownPropertyException,
 850                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
 851 {
 852     SAL_WARN("sc", "not implemented");
 853 }
 854
 855 void SAL_CALL ScConditionEntryObj::addVetoableChangeListener( const OUString&,
 856                             const uno::Reference<beans::XVetoableChangeListener>&)
 857                             throw(beans::UnknownPropertyException,
 858                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 859 {
 860     SAL_WARN("sc", "not implemented");
 861 }
 862
 863 void SAL_CALL ScConditionEntryObj::removeVetoableChangeListener( const OUString&,
 864                             const uno::Reference<beans::XVetoableChangeListener>&)
 865                             throw(beans::UnknownPropertyException,
 866                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
 867 {
 868     SAL_WARN("sc", "not implemented");
 869 }
 870
 871 ScColorScaleFormatObj::ScColorScaleFormatObj(rtl::Reference<ScCondFormatObj> xParent,
 872         const ScColorScaleFormat* pFormat):
 873     mpDocShell(xParent->getDocShell()),
 874     mxParent(xParent),
 875     maPropSet(getColorScalePropSet()),
 876     mpFormat(pFormat)
 877 {
 878 }
 879
 880 ScColorScaleFormatObj::~ScColorScaleFormatObj()
 881 {
 882 }
 883
 884 ScColorScaleFormat* ScColorScaleFormatObj::getCoreObject()
 885 {
 886     ScConditionalFormat* pFormat = mxParent->getCoreObject();
 887     if (isObjectStillAlive(pFormat, mpFormat))
 888         return const_cast<ScColorScaleFormat*>(mpFormat);
 889
 890     throw lang::IllegalArgumentException();
 891 }
 892
 893 sal_Int32 ScColorScaleFormatObj::getType()
 894     throw(uno::RuntimeException, std::exception)
 895 {
 896     return sheet::ConditionEntryType::COLORSCALE;
 897 }
 898
 899 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScColorScaleFormatObj::getPropertySetInfo()
 900     throw(uno::RuntimeException, std::exception)
 901 {
 902     static uno::Reference<beans::XPropertySetInfo> aRef(
 903         new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
 904     return aRef;
 905 }
 906
 907 namespace {
 908
 909 void setColorScaleEntry(ScColorScaleEntry* pEntry, uno::Reference<sheet::XColorScaleEntry> xEntry)
 910 {
 911     ScColorScaleEntryType eType = ScColorScaleEntryType();
 912     sal_Int32 nApiType = xEntry->getType();
 913     bool bFound = false;
 914     for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
 915     {
 916         if (aColorScaleEntryTypeMap[i].nApiType == nApiType)
 917         {
 918             eType = aColorScaleEntryTypeMap[i].eType;
 919             bFound = true;
 920             break;
 921         }
 922     }
 923
 924     if (!bFound)
 925         throw lang::IllegalArgumentException();
 926
 927     pEntry->SetType(eType);
 928     pEntry->SetColor(xEntry->getColor());
 929     switch (eType)
 930     {
 931         case COLORSCALE_FORMULA:
 932             // TODO: Implement
 933         break;
 934         default:
 935         {
 936             double nVal = xEntry->getFormula().toDouble();
 937             pEntry->SetValue(nVal);
 938         }
 939         break;
 940     }
 941 }
 942
 943 }
 944
 945 void SAL_CALL ScColorScaleFormatObj::setPropertyValue(
 946                         const OUString& aPropertyName, const uno::Any& aValue )
 947                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 948                         lang::IllegalArgumentException, lang::WrappedTargetException,
 949                         uno::RuntimeException, std::exception)
 950 {
 951     SolarMutexGuard aGuard;
 952
 953     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 954     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 955     if ( !pEntry )
 956         throw beans::UnknownPropertyException();
 957
 958     switch(pEntry->nWID)
 959     {
 960         case ColorScaleEntries:
 961         {
 962             uno::Sequence<uno::Reference<sheet::XColorScaleEntry> > aEntries;
 963             if (aValue >>= aEntries)
 964             {
 965                 if (aEntries.getLength() < 2)
 966                     throw lang::IllegalArgumentException();
 967
 968                 // TODO: we need to make sure that there are enough entries
 969                 size_t n = size_t(aEntries.getLength());
 970                 for (size_t i = 0; i < n; ++i)
 971                 {
 972                     setColorScaleEntry(getCoreObject()->GetEntry(i), aEntries[i]);
 973                 }
 974             }
 975             else
 976                 throw lang::IllegalArgumentException();
 977         }
 978         break;
 979         default:
 980             SAL_WARN("sc", "unknown property");
 981     }
 982 }
 983
 984 uno::Any SAL_CALL ScColorScaleFormatObj::getPropertyValue( const OUString& aPropertyName )
 985                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
 986                         uno::RuntimeException, std::exception)
 987 {
 988     SolarMutexGuard aGuard;
 989
 990     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
 991     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
 992     if ( !pEntry )
 993         throw beans::UnknownPropertyException();
 994
 995     uno::Any aAny;
 996
 997     switch(pEntry->nWID)
 998     {
 999         case ColorScaleEntries:
1000         {
1001             uno::Sequence<uno::Reference<sheet::XColorScaleEntry> > aEntries(getCoreObject()->size());
1002             for (size_t i = 0; i < getCoreObject()->size(); ++i)
1003             {
1004                 aEntries[i] = new ScColorScaleEntryObj(this, i);
1005             }
1006             aAny <<= aEntries;
1007         }
1008         break;
1009         default:
1010             SAL_WARN("sc", "unknown property");
1011     }
1012
1013     return aAny;
1014 }
1015
1016 void SAL_CALL ScColorScaleFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
1017                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1018                             throw(beans::UnknownPropertyException,
1019                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1020 {
1021     SAL_WARN("sc", "not implemented");
1022 }
1023
1024 void SAL_CALL ScColorScaleFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
1025                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1026                             throw(beans::UnknownPropertyException,
1027                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1028 {
1029     SAL_WARN("sc", "not implemented");
1030 }
1031
1032 void SAL_CALL ScColorScaleFormatObj::addVetoableChangeListener( const OUString&,
1033                             const uno::Reference<beans::XVetoableChangeListener>&)
1034                             throw(beans::UnknownPropertyException,
1035                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1036 {
1037     SAL_WARN("sc", "not implemented");
1038 }
1039
1040 void SAL_CALL ScColorScaleFormatObj::removeVetoableChangeListener( const OUString&,
1041                             const uno::Reference<beans::XVetoableChangeListener>&)
1042                             throw(beans::UnknownPropertyException,
1043                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1044 {
1045     SAL_WARN("sc", "not implemented");
1046 }
1047
1048 ScColorScaleEntryObj::ScColorScaleEntryObj(rtl::Reference<ScColorScaleFormatObj> xParent,
1049         size_t nPos):
1050     mxParent(xParent),
1051     mnPos(nPos)
1052 {
1053 }
1054
1055 ScColorScaleEntryObj::~ScColorScaleEntryObj()
1056 {
1057 }
1058
1059 ScColorScaleEntry* ScColorScaleEntryObj::getCoreObject()
1060 {
1061     ScColorScaleFormat* pFormat = mxParent->getCoreObject();
1062     if (pFormat->size() <= mnPos)
1063         throw lang::IllegalArgumentException();
1064
1065     return pFormat->GetEntry(mnPos);
1066 }
1067
1068 util::Color ScColorScaleEntryObj::getColor()
1069     throw(uno::RuntimeException, std::exception)
1070 {
1071     Color aColor = getCoreObject()->GetColor();
1072     return aColor.GetColor();
1073 }
1074
1075 void ScColorScaleEntryObj::setColor(util::Color aColor)
1076     throw(uno::RuntimeException, std::exception)
1077 {
1078     getCoreObject()->SetColor(Color(aColor));
1079 }
1080
1081 sal_Int32 ScColorScaleEntryObj::getType()
1082     throw(uno::RuntimeException, std::exception)
1083 {
1084     ScColorScaleEntry* pEntry = getCoreObject();
1085     for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
1086     {
1087         if (aColorScaleEntryTypeMap[i].eType == pEntry->GetType())
1088         {
1089             return aColorScaleEntryTypeMap[i].nApiType;
1090         }
1091     }
1092
1093     throw lang::IllegalArgumentException();
1094 }
1095
1096 void ScColorScaleEntryObj::setType(sal_Int32 nType)
1097     throw(uno::RuntimeException, std::exception)
1098 {
1099     ScColorScaleEntry* pEntry = getCoreObject();
1100     for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
1101     {
1102         if (aColorScaleEntryTypeMap[i].nApiType == nType)
1103         {
1104             pEntry->SetType(aColorScaleEntryTypeMap[i].eType);
1105             return;
1106         }
1107     }
1108     throw lang::IllegalArgumentException();
1109 }
1110
1111 OUString ScColorScaleEntryObj::getFormula()
1112     throw(uno::RuntimeException, std::exception)
1113 {
1114     ScColorScaleEntry* pEntry = getCoreObject();
1115     switch (pEntry->GetType())
1116     {
1117         case COLORSCALE_FORMULA:
1118             // TODO: Implement
1119         break;
1120         default:
1121             return OUString::number(pEntry->GetValue());
1122     }
1123
1124     return OUString();
1125 }
1126
1127 void ScColorScaleEntryObj::setFormula(const OUString& rFormula)
1128     throw(uno::RuntimeException, std::exception)
1129 {
1130     ScColorScaleEntry* pEntry = getCoreObject();
1131     switch (pEntry->GetType())
1132     {
1133         case COLORSCALE_FORMULA:
1134             // TODO: Implement
1135             // pEntry->SetFormula(rFormula);
1136         break;
1137         default:
1138             pEntry->SetValue(rFormula.toDouble());
1139         break;
1140     }
1141 }
1142
1143
1144 ScDataBarFormatObj::ScDataBarFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1145         const ScDataBarFormat* pFormat):
1146     mpDocShell(xParent->getDocShell()),
1147     mxParent(xParent),
1148     maPropSet(getDataBarPropSet()),
1149     mpFormat(pFormat)
1150 {
1151 }
1152
1153 ScDataBarFormatObj::~ScDataBarFormatObj()
1154 {
1155 }
1156
1157 ScDataBarFormat* ScDataBarFormatObj::getCoreObject()
1158 {
1159     ScConditionalFormat* pFormat = mxParent->getCoreObject();
1160     if (isObjectStillAlive(pFormat, mpFormat))
1161         return const_cast<ScDataBarFormat*>(mpFormat);
1162
1163     throw lang::IllegalArgumentException();
1164 }
1165
1166 sal_Int32 ScDataBarFormatObj::getType()
1167     throw(uno::RuntimeException, std::exception)
1168 {
1169     return sheet::ConditionEntryType::DATABAR;
1170 }
1171
1172 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDataBarFormatObj::getPropertySetInfo()
1173     throw(uno::RuntimeException, std::exception)
1174 {
1175     SolarMutexGuard aGuard;
1176     static uno::Reference<beans::XPropertySetInfo> aRef(
1177         new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1178     return aRef;
1179 }
1180
1181 namespace {
1182
1183 void setDataBarEntry(ScColorScaleEntry* pEntry, uno::Reference<sheet::XDataBarEntry> xEntry)
1184 {
1185     ScColorScaleEntryType eType = ScColorScaleEntryType();
1186     sal_Int32 nApiType = xEntry->getType();
1187     bool bFound = false;
1188     for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1189     {
1190         if (aDataBarEntryTypeMap[i].nApiType == nApiType)
1191         {
1192             eType = aDataBarEntryTypeMap[i].eType;
1193             bFound = true;
1194             break;
1195         }
1196     }
1197
1198     if (!bFound)
1199         throw lang::IllegalArgumentException();
1200
1201     pEntry->SetType(eType);
1202     switch (eType)
1203     {
1204         case COLORSCALE_FORMULA:
1205             // TODO: Implement
1206         break;
1207         default:
1208         {
1209             double nVal = xEntry->getFormula().toDouble();
1210             pEntry->SetValue(nVal);
1211         }
1212         break;
1213     }
1214 }
1215
1216 }
1217
1218 void SAL_CALL ScDataBarFormatObj::setPropertyValue(
1219                         const OUString& aPropertyName, const uno::Any& aValue )
1220                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1221                         lang::IllegalArgumentException, lang::WrappedTargetException,
1222                         uno::RuntimeException, std::exception)
1223 {
1224     SolarMutexGuard aGuard;
1225
1226     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1227     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1228     if ( !pEntry )
1229         throw beans::UnknownPropertyException();
1230
1231     switch(pEntry->nWID)
1232     {
1233         case AxisPosition:
1234         {
1235             sal_Int32 nVal;
1236             if (aValue >>= nVal)
1237             {
1238                 for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarAxisMap); ++i)
1239                 {
1240                     if (aDataBarAxisMap[i].nApiPos == nVal)
1241                     {
1242                         getCoreObject()->GetDataBarData()->meAxisPosition =
1243                             aDataBarAxisMap[i].ePos;
1244                         break;
1245                     }
1246                 }
1247             }
1248         }
1249         break;
1250         case UseGradient:
1251         {
1252             bool bUseGradient = true;
1253             if (aValue >>= bUseGradient)
1254             {
1255                 getCoreObject()->GetDataBarData()->mbGradient = bUseGradient;
1256             }
1257         }
1258         break;
1259         case UseNegativeColor:
1260         {
1261             bool bUseNegativeColor = false;
1262             if (aValue >>= bUseNegativeColor)
1263             {
1264                 getCoreObject()->GetDataBarData()->mbNeg = bUseNegativeColor;
1265                 if (bUseNegativeColor && !getCoreObject()->GetDataBarData()->mpNegativeColor)
1266                 {
1267                     getCoreObject()->GetDataBarData()->mpNegativeColor.reset(new Color(COL_AUTO));
1268                 }
1269             }
1270         }
1271         break;
1272         case DataBar_ShowValue:
1273         {
1274             bool bShowValue = true;
1275             if (aValue >>= bShowValue)
1276             {
1277                 getCoreObject()->GetDataBarData()->mbOnlyBar = !bShowValue;
1278             }
1279         }
1280         break;
1281         case DataBar_Color:
1282         {
1283             sal_Int32 nColor = COL_AUTO;
1284             if (aValue >>= nColor)
1285             {
1286                 getCoreObject()->GetDataBarData()->maPositiveColor.SetColor(nColor);
1287             }
1288         }
1289         break;
1290         case AxisColor:
1291         {
1292             sal_Int32 nAxisColor = COL_AUTO;
1293             if (aValue >>= nAxisColor)
1294             {
1295                 getCoreObject()->GetDataBarData()->maAxisColor.SetColor(nAxisColor);
1296             }
1297         }
1298         break;
1299         case NegativeColor:
1300         {
1301             sal_Int32 nNegativeColor = COL_AUTO;
1302             if ((aValue >>= nNegativeColor) && getCoreObject()->GetDataBarData()->mbNeg)
1303             {
1304                 getCoreObject()->GetDataBarData()->mpNegativeColor->SetColor(nNegativeColor);
1305             }
1306             else
1307                 throw lang::IllegalArgumentException();
1308         }
1309         break;
1310         case DataBarEntries:
1311         {
1312             uno::Sequence<uno::Reference<sheet::XDataBarEntry> > aEntries;
1313             if (aValue >>= aEntries)
1314             {
1315                 if (aEntries.getLength() != 2)
1316                     throw lang::IllegalArgumentException();
1317
1318                 setDataBarEntry(getCoreObject()->GetDataBarData()->mpLowerLimit.get(),
1319                         aEntries[0]);
1320                 setDataBarEntry(getCoreObject()->GetDataBarData()->mpUpperLimit.get(),
1321                         aEntries[1]);
1322             }
1323             else
1324                 throw lang::IllegalArgumentException();
1325         }
1326         break;
1327         case MinimumLength:
1328         {
1329             double nLength = 0;
1330             if ((aValue >>= nLength) && nLength < 100 && nLength >= 0)
1331             {
1332                 getCoreObject()->GetDataBarData()->mnMinLength = nLength;
1333             }
1334             else throw lang::IllegalArgumentException();
1335         }
1336         break;
1337         case MaximumLength:
1338         {
1339             double nLength = 0;
1340             if ((aValue >>= nLength) && nLength <= 100 && nLength > 0)
1341             {
1342                 getCoreObject()->GetDataBarData()->mnMaxLength = nLength;
1343             }
1344             else throw lang::IllegalArgumentException();
1345         }
1346         break;
1347     }
1348 }
1349
1350 uno::Any SAL_CALL ScDataBarFormatObj::getPropertyValue( const OUString& aPropertyName )
1351                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1352                         uno::RuntimeException, std::exception)
1353 {
1354     SolarMutexGuard aGuard;
1355
1356     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1357     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1358     if ( !pEntry )
1359         throw beans::UnknownPropertyException();
1360
1361     uno::Any aAny;
1362     switch(pEntry->nWID)
1363     {
1364         case AxisPosition:
1365         {
1366             databar::ScAxisPosition ePos = getCoreObject()->GetDataBarData()->meAxisPosition;
1367             sal_Int32 nApiPos = sheet::DataBarAxis::AXIS_NONE;
1368             for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarAxisMap); ++i)
1369             {
1370                 if (aDataBarAxisMap[i].ePos == ePos)
1371                 {
1372                     nApiPos = aDataBarAxisMap[i].nApiPos;
1373                 }
1374             }
1375
1376             aAny <<= nApiPos;
1377         }
1378         break;
1379         case UseGradient:
1380         {
1381            aAny <<= getCoreObject()->GetDataBarData()->mbGradient;
1382         }
1383         break;
1384         case UseNegativeColor:
1385         {
1386            aAny <<= getCoreObject()->GetDataBarData()->mbNeg;
1387         }
1388         break;
1389         case DataBar_ShowValue:
1390         {
1391             aAny <<= !getCoreObject()->GetDataBarData()->mbOnlyBar;
1392         }
1393         break;
1394         case DataBar_Color:
1395         {
1396             sal_Int32 nColor = getCoreObject()->GetDataBarData()->maPositiveColor.GetColor();
1397             aAny <<= nColor;
1398         }
1399         break;
1400         case AxisColor:
1401         {
1402             sal_Int32 nAxisColor = getCoreObject()->GetDataBarData()->maAxisColor.GetColor();
1403             aAny <<= nAxisColor;
1404         }
1405         break;
1406         case NegativeColor:
1407         {
1408             if (getCoreObject()->GetDataBarData()->mbNeg && getCoreObject()->GetDataBarData()->mpNegativeColor)
1409             {
1410                 sal_Int32 nNegativeColor = getCoreObject()->GetDataBarData()->mpNegativeColor->GetColor();
1411                 aAny <<= nNegativeColor;
1412             }
1413         }
1414         break;
1415         case DataBarEntries:
1416         {
1417             uno::Sequence<uno::Reference<sheet::XDataBarEntry> > aEntries(2);
1418             aEntries[0] = new ScDataBarEntryObj(this, 0);
1419             aEntries[1] = new ScDataBarEntryObj(this, 1);
1420             aAny <<= aEntries;
1421         }
1422         break;
1423     }
1424     return aAny;
1425 }
1426
1427 void SAL_CALL ScDataBarFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
1428                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1429                             throw(beans::UnknownPropertyException,
1430                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1431 {
1432     SAL_WARN("sc", "not implemented");
1433 }
1434
1435 void SAL_CALL ScDataBarFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
1436                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1437                             throw(beans::UnknownPropertyException,
1438                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1439 {
1440     SAL_WARN("sc", "not implemented");
1441 }
1442
1443 void SAL_CALL ScDataBarFormatObj::addVetoableChangeListener( const OUString&,
1444                             const uno::Reference<beans::XVetoableChangeListener>&)
1445                             throw(beans::UnknownPropertyException,
1446                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1447 {
1448     SAL_WARN("sc", "not implemented");
1449 }
1450
1451 void SAL_CALL ScDataBarFormatObj::removeVetoableChangeListener( const OUString&,
1452                             const uno::Reference<beans::XVetoableChangeListener>&)
1453                             throw(beans::UnknownPropertyException,
1454                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1455 {
1456     SAL_WARN("sc", "not implemented");
1457 }
1458
1459 ScDataBarEntryObj::ScDataBarEntryObj(rtl::Reference<ScDataBarFormatObj> xParent,
1460         size_t nPos):
1461     mxParent(xParent),
1462     mnPos(nPos)
1463 {
1464 }
1465
1466 ScDataBarEntryObj::~ScDataBarEntryObj()
1467 {
1468 }
1469
1470 ScColorScaleEntry* ScDataBarEntryObj::getCoreObject()
1471 {
1472     ScDataBarFormat* pFormat = mxParent->getCoreObject();
1473     ScColorScaleEntry* pEntry;
1474     if (mnPos == 0)
1475         pEntry = pFormat->GetDataBarData()->mpLowerLimit.get();
1476     else
1477         pEntry = pFormat->GetDataBarData()->mpUpperLimit.get();
1478
1479     return pEntry;
1480 }
1481
1482 sal_Int32 ScDataBarEntryObj::getType()
1483     throw(uno::RuntimeException, std::exception)
1484 {
1485     ScColorScaleEntry* pEntry = getCoreObject();
1486     for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1487     {
1488         if (aDataBarEntryTypeMap[i].eType == pEntry->GetType())
1489         {
1490             return aDataBarEntryTypeMap[i].nApiType;
1491         }
1492     }
1493
1494     throw lang::IllegalArgumentException();
1495 }
1496
1497 void ScDataBarEntryObj::setType(sal_Int32 nType)
1498     throw(uno::RuntimeException, std::exception)
1499 {
1500     ScColorScaleEntry* pEntry = getCoreObject();
1501     for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1502     {
1503         if (aDataBarEntryTypeMap[i].nApiType == nType)
1504         {
1505             pEntry->SetType(aDataBarEntryTypeMap[i].eType);
1506             return;
1507         }
1508     }
1509     throw lang::IllegalArgumentException();
1510 }
1511
1512 OUString ScDataBarEntryObj::getFormula()
1513     throw(uno::RuntimeException, std::exception)
1514 {
1515     ScColorScaleEntry* pEntry = getCoreObject();
1516     switch (pEntry->GetType())
1517     {
1518         case COLORSCALE_FORMULA:
1519             // TODO: Implement
1520         break;
1521         default:
1522             return OUString::number(pEntry->GetValue());
1523     }
1524
1525     return OUString();
1526 }
1527
1528 void ScDataBarEntryObj::setFormula(const OUString& rFormula)
1529     throw(uno::RuntimeException, std::exception)
1530 {
1531     ScColorScaleEntry* pEntry = getCoreObject();
1532     switch (pEntry->GetType())
1533     {
1534         case COLORSCALE_FORMULA:
1535             // TODO: Implement
1536             // pEntry->SetFormula(rFormula);
1537         break;
1538         default:
1539             pEntry->SetValue(rFormula.toDouble());
1540         break;
1541     }
1542 }
1543
1544
1545 ScIconSetFormatObj::ScIconSetFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1546         const ScIconSetFormat* pFormat):
1547     mpDocShell(xParent->getDocShell()),
1548     mxParent(xParent),
1549     maPropSet(getIconSetPropSet()),
1550     mpFormat(pFormat)
1551 {
1552 }
1553
1554 ScIconSetFormatObj::~ScIconSetFormatObj()
1555 {
1556 }
1557
1558 ScIconSetFormat* ScIconSetFormatObj::getCoreObject()
1559 {
1560     ScConditionalFormat* pFormat = mxParent->getCoreObject();
1561     if (isObjectStillAlive(pFormat, mpFormat))
1562         return const_cast<ScIconSetFormat*>(mpFormat);
1563
1564     throw lang::IllegalArgumentException();
1565 }
1566
1567 sal_Int32 ScIconSetFormatObj::getType()
1568     throw(uno::RuntimeException, std::exception)
1569 {
1570     return sheet::ConditionEntryType::ICONSET;
1571 }
1572
1573 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScIconSetFormatObj::getPropertySetInfo()
1574     throw(uno::RuntimeException, std::exception)
1575 {
1576     SolarMutexGuard aGuard;
1577     static uno::Reference<beans::XPropertySetInfo> aRef(
1578         new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1579     return aRef;
1580 }
1581
1582 namespace {
1583
1584 void setIconSetEntry(ScIconSetFormat* pFormat, uno::Reference<sheet::XIconSetEntry> xEntry, size_t nPos)
1585 {
1586     ScIconSetFormatData* pData = pFormat->GetIconSetData();
1587     ScColorScaleEntryType eType = ScColorScaleEntryType();
1588     sal_Int32 nApiType = xEntry->getType();
1589     bool bFound = false;
1590     for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1591     {
1592         if (aIconSetEntryTypeMap[i].nApiType == nApiType)
1593         {
1594             eType = aIconSetEntryTypeMap[i].eType;
1595             bFound = true;
1596             break;
1597         }
1598     }
1599
1600     if (!bFound)
1601         throw lang::IllegalArgumentException();
1602
1603     pData->maEntries[nPos].SetType(eType);
1604     switch (eType)
1605     {
1606         case COLORSCALE_FORMULA:
1607             // TODO: Implement
1608         break;
1609         default:
1610         {
1611             double nVal = xEntry->getFormula().toDouble();
1612             pData->maEntries[nPos].SetValue(nVal);
1613         }
1614         break;
1615     }
1616 }
1617
1618 }
1619
1620 void SAL_CALL ScIconSetFormatObj::setPropertyValue(
1621                         const OUString& aPropertyName, const uno::Any& aValue )
1622                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1623                         lang::IllegalArgumentException, lang::WrappedTargetException,
1624                         uno::RuntimeException, std::exception)
1625 {
1626     SolarMutexGuard aGuard;
1627
1628     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1629     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1630     if ( !pEntry )
1631         throw beans::UnknownPropertyException();
1632
1633     switch(pEntry->nWID)
1634     {
1635         case ShowValue:
1636         {
1637             bool bShowValue = true;
1638             aValue >>= bShowValue;
1639             getCoreObject()->GetIconSetData()->mbShowValue = bShowValue;
1640         }
1641         break;
1642         case Reverse:
1643         {
1644             bool bReverse = false;
1645             aValue >>= bReverse;
1646             getCoreObject()->GetIconSetData()->mbReverse = bReverse;
1647         }
1648         break;
1649         case Icons:
1650         {
1651             sal_Int32 nApiType = -1;
1652             aValue >>= nApiType;
1653             ScIconSetType eType = IconSet_3Arrows;
1654             bool bFound = false;
1655             for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetApiMap); ++i)
1656             {
1657                 if (aIconSetApiMap[i].nApiType == nApiType)
1658                 {
1659                     eType = aIconSetApiMap[i].eType;
1660                     bFound = true;
1661                     break;
1662                 }
1663             }
1664
1665             if (!bFound)
1666             {
1667                 throw lang::IllegalArgumentException();
1668             }
1669
1670             // TODO: we need to make sure that there are enough entries
1671             getCoreObject()->GetIconSetData()->eIconSetType = eType;
1672         }
1673         break;
1674         case IconSetEntries:
1675         {
1676             uno::Sequence<uno::Reference<sheet::XIconSetEntry> > aEntries;
1677             if (aValue >>= aEntries)
1678             {
1679                 // TODO: we need to check that the number of entries
1680                 // corresponds to the icon type
1681                 sal_Int32 nLength = aEntries.getLength();
1682                 for (size_t i = 0; i < size_t(nLength); ++i)
1683                 {
1684                     setIconSetEntry(getCoreObject(), aEntries[i], i);
1685                 }
1686             }
1687             else
1688                 throw lang::IllegalArgumentException();
1689         }
1690         break;
1691         default:
1692         break;
1693     }
1694 }
1695
1696 uno::Any SAL_CALL ScIconSetFormatObj::getPropertyValue( const OUString& aPropertyName )
1697                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1698                         uno::RuntimeException, std::exception)
1699 {
1700     SolarMutexGuard aGuard;
1701
1702     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1703     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1704     if ( !pEntry )
1705         throw beans::UnknownPropertyException();
1706
1707     uno::Any aAny;
1708
1709     switch(pEntry->nWID)
1710     {
1711         case ShowValue:
1712             aAny <<= getCoreObject()->GetIconSetData()->mbShowValue;
1713         break;
1714         case Reverse:
1715             aAny <<= getCoreObject()->GetIconSetData()->mbReverse;
1716         break;
1717         case Icons:
1718         {
1719             ScIconSetType eType = getCoreObject()->GetIconSetData()->eIconSetType;
1720             for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetApiMap); ++i)
1721             {
1722                 if (aIconSetApiMap[i].eType == eType)
1723                 {
1724                     aAny <<= aIconSetApiMap[i].nApiType;
1725                     break;
1726                 }
1727             }
1728         }
1729         break;
1730         case IconSetEntries:
1731         {
1732             uno::Sequence<uno::Reference<sheet::XIconSetEntry> > aEntries(getCoreObject()->size());
1733             size_t i = 0;
1734             for (auto it = getCoreObject()->begin(), itEnd = getCoreObject()->end(); it != itEnd; ++it, ++i)
1735             {
1736                 aEntries[i] = new ScIconSetEntryObj(this, i);
1737             }
1738             aAny <<= aEntries;
1739         }
1740         break;
1741         default:
1742             SAL_WARN("sc", "unknown property");
1743     }
1744     return aAny;
1745 }
1746
1747 void SAL_CALL ScIconSetFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
1748                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1749                             throw(beans::UnknownPropertyException,
1750                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1751 {
1752     SAL_WARN("sc", "not implemented");
1753 }
1754
1755 void SAL_CALL ScIconSetFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
1756                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1757                             throw(beans::UnknownPropertyException,
1758                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1759 {
1760     SAL_WARN("sc", "not implemented");
1761 }
1762
1763 void SAL_CALL ScIconSetFormatObj::addVetoableChangeListener( const OUString&,
1764                             const uno::Reference<beans::XVetoableChangeListener>&)
1765                             throw(beans::UnknownPropertyException,
1766                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1767 {
1768     SAL_WARN("sc", "not implemented");
1769 }
1770
1771 void SAL_CALL ScIconSetFormatObj::removeVetoableChangeListener( const OUString&,
1772                             const uno::Reference<beans::XVetoableChangeListener>&)
1773                             throw(beans::UnknownPropertyException,
1774                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
1775 {
1776     SAL_WARN("sc", "not implemented");
1777 }
1778
1779 ScIconSetEntryObj::ScIconSetEntryObj(rtl::Reference<ScIconSetFormatObj> xParent,
1780         size_t nPos):
1781     mxParent(xParent),
1782     mnPos(nPos)
1783 {
1784 }
1785
1786 ScIconSetEntryObj::~ScIconSetEntryObj()
1787 {
1788 }
1789
1790 ScColorScaleEntry* ScIconSetEntryObj::getCoreObject()
1791 {
1792     ScIconSetFormat* pFormat = mxParent->getCoreObject();
1793     if (pFormat->GetIconSetData()->maEntries.size() <= mnPos)
1794         throw lang::IllegalArgumentException();
1795
1796     return &pFormat->GetIconSetData()->maEntries[mnPos];
1797 }
1798
1799 sal_Int32 ScIconSetEntryObj::getType()
1800     throw(uno::RuntimeException, std::exception)
1801 {
1802     ScColorScaleEntry* pEntry = getCoreObject();
1803     // the first entry always is minimum
1804     if (mnPos == 0)
1805         return sheet::IconSetFormatEntry::ICONSET_MIN;
1806
1807     for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1808     {
1809         if (aIconSetEntryTypeMap[i].eType == pEntry->GetType())
1810         {
1811             return aIconSetEntryTypeMap[i].nApiType;
1812         }
1813     }
1814
1815     throw lang::IllegalArgumentException();
1816 }
1817
1818 void ScIconSetEntryObj::setType(sal_Int32 nType)
1819     throw(uno::RuntimeException, std::exception)
1820 {
1821     // first entry is always MIN
1822     if (mnPos == 0)
1823         return;
1824
1825     ScColorScaleEntry* pEntry = getCoreObject();
1826     for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1827     {
1828         if (aIconSetEntryTypeMap[i].nApiType == nType)
1829         {
1830             pEntry->SetType(aIconSetEntryTypeMap[i].eType);
1831             return;
1832         }
1833     }
1834     throw lang::IllegalArgumentException();
1835 }
1836
1837 OUString ScIconSetEntryObj::getFormula()
1838     throw(uno::RuntimeException, std::exception)
1839 {
1840     ScColorScaleEntry* pEntry = getCoreObject();
1841     switch (pEntry->GetType())
1842     {
1843         case COLORSCALE_FORMULA:
1844             // TODO: Implement
1845         break;
1846         default:
1847             return OUString::number(pEntry->GetValue());
1848     }
1849
1850     return OUString();
1851 }
1852
1853 void ScIconSetEntryObj::setFormula(const OUString& rFormula)
1854     throw(uno::RuntimeException, std::exception)
1855 {
1856     ScColorScaleEntry* pEntry = getCoreObject();
1857     switch (pEntry->GetType())
1858     {
1859         case COLORSCALE_FORMULA:
1860             // TODO: Implement
1861             // pEntry->SetFormula(rFormula);
1862         break;
1863         default:
1864             pEntry->SetValue(rFormula.toDouble());
1865         break;
1866     }
1867 }
1868
1869 ScCondDateFormatObj::ScCondDateFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1870         const ScCondDateFormatEntry* pFormat):
1871     mxParent(xParent),
1872     maPropSet(getCondDatePropSet()),
1873     mpFormat(pFormat)
1874 {
1875 }
1876
1877 ScCondDateFormatObj::~ScCondDateFormatObj()
1878 {
1879 }
1880
1881 ScCondDateFormatEntry* ScCondDateFormatObj::getCoreObject()
1882 {
1883     ScConditionalFormat* pFormat = mxParent->getCoreObject();
1884     if (isObjectStillAlive(pFormat, mpFormat))
1885         return const_cast<ScCondDateFormatEntry*>(mpFormat);
1886
1887     throw lang::IllegalArgumentException();
1888 }
1889
1890 sal_Int32 ScCondDateFormatObj::getType()
1891     throw(uno::RuntimeException, std::exception)
1892 {
1893     return sheet::ConditionEntryType::DATE;
1894 }
1895
1896 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCondDateFormatObj::getPropertySetInfo()
1897     throw(uno::RuntimeException, std::exception)
1898 {
1899     SolarMutexGuard aGuard;
1900     static uno::Reference<beans::XPropertySetInfo> aRef(
1901         new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1902     return aRef;
1903 }
1904
1905 void SAL_CALL ScCondDateFormatObj::setPropertyValue(
1906                         const OUString& aPropertyName, const uno::Any& aValue )
1907                 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1908                         lang::IllegalArgumentException, lang::WrappedTargetException,
1909                         uno::RuntimeException, std::exception)
1910 {
1911     SolarMutexGuard aGuard;
1912
1913     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1914     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1915     if ( !pEntry )
1916         throw beans::UnknownPropertyException();
1917
1918     switch(pEntry->nWID)
1919     {
1920         case Date_StyleName:
1921         {
1922             OUString aStyleName;
1923             if (aValue >>= aStyleName)
1924             {
1925                 getCoreObject()->SetStyleName(aStyleName);
1926             }
1927             else
1928                 throw lang::IllegalArgumentException();
1929         }
1930         break;
1931         case DateType:
1932         {
1933             sal_Int32 nApiType = -1;
1934             if (!(aValue >>= nApiType))
1935                 throw lang::IllegalArgumentException();
1936
1937             for (size_t i = 0; i < SAL_N_ELEMENTS(aDateTypeApiMap); ++i)
1938             {
1939                 if (aDateTypeApiMap[i].nApiType == nApiType)
1940                 {
1941                     getCoreObject()->SetDateType(aDateTypeApiMap[i].eType);
1942                     break;
1943                 }
1944             }
1945         }
1946         break;
1947         default:
1948         break;
1949     }
1950 }
1951
1952 uno::Any SAL_CALL ScCondDateFormatObj::getPropertyValue( const OUString& aPropertyName )
1953                 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1954                         uno::RuntimeException, std::exception)
1955 {
1956     SolarMutexGuard aGuard;
1957
1958     const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap();     // from derived class
1959     const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1960     if ( !pEntry )
1961         throw beans::UnknownPropertyException();
1962
1963     uno::Any aAny;
1964
1965     switch(pEntry->nWID)
1966     {
1967         case Date_StyleName:
1968         {
1969             OUString aStyleName = getCoreObject()->GetStyleName();
1970             aAny <<= aStyleName;
1971         }
1972         break;
1973         case DateType:
1974         {
1975             condformat::ScCondFormatDateType eType = getCoreObject()->GetDateType();
1976             for (size_t i = 0; i < SAL_N_ELEMENTS(aDateTypeApiMap); ++i)
1977             {
1978                 if (aDateTypeApiMap[i].eType == eType)
1979                 {
1980                     aAny <<= aDateTypeApiMap[i].nApiType;
1981                     break;
1982                 }
1983             }
1984         }
1985         break;
1986         default:
1987             SAL_WARN("sc", "unknown property");
1988     }
1989     return aAny;
1990 }
1991
1992 void SAL_CALL ScCondDateFormatObj::addPropertyChangeListener( const OUString& /* aPropertyName */,
1993                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
1994                             throw(beans::UnknownPropertyException,
1995                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
1996 {
1997     SAL_WARN("sc", "not implemented");
1998 }
1999
2000 void SAL_CALL ScCondDateFormatObj::removePropertyChangeListener( const OUString& /* aPropertyName */,
2001                             const uno::Reference<beans::XPropertyChangeListener>& /* aListener */)
2002                             throw(beans::UnknownPropertyException,
2003                                     lang::WrappedTargetException, uno::RuntimeException, std::exception)
2004 {
2005     SAL_WARN("sc", "not implemented");
2006 }
2007
2008 void SAL_CALL ScCondDateFormatObj::addVetoableChangeListener( const OUString&,
2009                             const uno::Reference<beans::XVetoableChangeListener>&)
2010                             throw(beans::UnknownPropertyException,
2011                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
2012 {
2013     SAL_WARN("sc", "not implemented");
2014 }
2015
2016 void SAL_CALL ScCondDateFormatObj::removeVetoableChangeListener( const OUString&,
2017                             const uno::Reference<beans::XVetoableChangeListener>&)
2018                             throw(beans::UnknownPropertyException,
2019                                 lang::WrappedTargetException, uno::RuntimeException, std::exception)
2020 {
2021     SAL_WARN("sc", "not implemented");
2022 }
2023
2024 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */