Line data Source code
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 8 : const SfxItemPropertyMapEntry* getCondFormatPropset()
45 : {
46 : static const SfxItemPropertyMapEntry aCondFormatPropertyMap_Impl[] =
47 : {
48 1 : {OUString("ID"), ID, cppu::UnoType<sal_Int32>::get(), 0, 0},
49 1 : {OUString("Range"), CondFormat_Range, cppu::UnoType<sheet::XSheetCellRanges>::get(), 0, 0},
50 : {OUString(), 0, css::uno::Type(), 0, 0}
51 11 : };
52 8 : return aCondFormatPropertyMap_Impl;
53 : }
54 :
55 : enum ConditionEntryProperties
56 : {
57 : StyleName,
58 : Formula1,
59 : Formula2,
60 : Operator
61 : };
62 :
63 0 : const SfxItemPropertyMapEntry* getConditionEntryrPropSet()
64 : {
65 : static const SfxItemPropertyMapEntry aConditionEntryPropertyMap_Impl[] =
66 : {
67 0 : {OUString("StyleName"), StyleName, cppu::UnoType<OUString>::get(), 0, 0},
68 0 : {OUString("Formula1"), Formula1, cppu::UnoType<OUString>::get(), 0, 0},
69 0 : {OUString("Formula2"), Formula2, cppu::UnoType<OUString>::get(), 0, 0},
70 0 : {OUString("Operator"), Operator, cppu::UnoType<decltype(sheet::ConditionFormatOperator::EQUAL)>::get(), 0, 0 },
71 : {OUString(), 0, css::uno::Type(), 0, 0}
72 0 : };
73 0 : 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 4 : const SfxItemPropertyMapEntry* getColorScalePropSet()
118 : {
119 : static const SfxItemPropertyMapEntry aColorScalePropertyMap_Impl[] =
120 : {
121 1 : {OUString("ColorScaleEntries"), ColorScaleEntries, cppu::UnoType<uno::Sequence< sheet::XColorScaleEntry >>::get(), 0, 0 },
122 : {OUString(), 0, css::uno::Type(), 0, 0}
123 6 : };
124 4 : 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 5 : const SfxItemPropertyMapEntry* getDataBarPropSet()
158 : {
159 : static const SfxItemPropertyMapEntry aDataBarPropertyMap_Impl[] =
160 : {
161 1 : {OUString("AxisPosition"), AxisPosition, cppu::UnoType<decltype(sheet::DataBarAxis::AXIS_AUTOMATIC)>::get(), 0, 0 },
162 1 : {OUString("UseGradient"), UseGradient, cppu::UnoType<bool>::get(), 0, 0 },
163 1 : {OUString("UseNegativeColor"), UseNegativeColor, cppu::UnoType<bool>::get(), 0, 0 },
164 1 : {OUString("ShowValue"), DataBar_ShowValue, cppu::UnoType<bool>::get(), 0, 0 },
165 1 : {OUString("Color"), DataBar_Color, cppu::UnoType<sal_Int32>::get(), 0, 0},
166 1 : {OUString("AxisColor"), AxisColor, cppu::UnoType<sal_Int32>::get(), 0, 0},
167 1 : {OUString("NegativeColor"), NegativeColor, cppu::UnoType<sal_Int32>::get(), 0, 0},
168 1 : {OUString("DataBarEntries"), DataBarEntries, cppu::UnoType<uno::Sequence< sheet::XDataBarEntry >>::get(), 0, 0 },
169 1 : {OUString("MinimumLength"), MinimumLength, cppu::UnoType<double>::get(), 0, 0 },
170 1 : {OUString("MaximumLength"), MaximumLength, cppu::UnoType<double>::get(), 0, 0 },
171 : {OUString(), 0, css::uno::Type(), 0, 0}
172 16 : };
173 5 : 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 0 : const SfxItemPropertyMapEntry* getIconSetPropSet()
215 : {
216 : static const SfxItemPropertyMapEntry aIconSetPropertyMap_Impl[] =
217 : {
218 0 : {OUString("Icons"), Icons, cppu::UnoType<decltype(sheet::IconSetType::ICONSET_3SYMBOLS)>::get(), 0, 0 },
219 0 : {OUString("Reverse"), Reverse, cppu::UnoType<bool>::get(), 0, 0 },
220 0 : {OUString("ShowValue"), ShowValue, cppu::UnoType<bool>::get(), 0, 0 },
221 0 : {OUString("IconSetEntries"), IconSetEntries, cppu::UnoType<uno::Sequence< sheet::XIconSetEntry >>::get(), 0, 0 },
222 : {OUString(), 0, css::uno::Type(), 0, 0}
223 0 : };
224 0 : 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 0 : const SfxItemPropertyMapEntry* getCondDatePropSet()
278 : {
279 : static const SfxItemPropertyMapEntry aCondDatePropertyMap_Impl[] =
280 : {
281 0 : {OUString("StyleName"), StyleName, cppu::UnoType<OUString>::get(), 0, 0},
282 0 : {OUString("DateType"), Icons, cppu::UnoType<decltype(sheet::DateType::TODAY)>::get(), 0, 0 },
283 : {OUString(), 0, css::uno::Type(), 0, 0}
284 0 : };
285 0 : 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 7 : ScCondFormatsObj::ScCondFormatsObj(ScDocShell* pDocShell, SCTAB nTab):
314 : mnTab(nTab),
315 7 : mpDocShell(pDocShell)
316 : {
317 7 : pDocShell->GetDocument().AddUnoObject(*this);
318 7 : }
319 :
320 21 : ScCondFormatsObj::~ScCondFormatsObj()
321 : {
322 7 : if (mpDocShell)
323 7 : mpDocShell->GetDocument().RemoveUnoObject(*this);
324 14 : }
325 :
326 0 : void ScCondFormatsObj::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
327 : {
328 0 : if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
329 0 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
330 : {
331 0 : mpDocShell = NULL; // ungueltig geworden
332 : }
333 0 : }
334 :
335 0 : sal_Int32 ScCondFormatsObj::createByRange(const uno::Reference< sheet::XSheetCellRanges >& xRanges)
336 : throw(uno::RuntimeException, std::exception)
337 : {
338 0 : SolarMutexGuard aGuard;
339 0 : if (!mpDocShell)
340 0 : throw lang::IllegalArgumentException();
341 :
342 0 : if (!xRanges.is())
343 0 : throw lang::IllegalArgumentException();
344 :
345 : uno::Sequence<table::CellRangeAddress> aRanges =
346 0 : xRanges->getRangeAddresses();
347 :
348 0 : ScRangeList aCoreRange;
349 0 : for (sal_Int32 i = 0, n = aRanges.getLength(); i < n; ++i)
350 : {
351 0 : ScRange aRange;
352 0 : ScUnoConversion::FillScRange(aRange, aRanges[i]);
353 0 : aCoreRange.Join(aRange);
354 : }
355 :
356 0 : if (aCoreRange.empty())
357 0 : throw lang::IllegalArgumentException();
358 :
359 0 : SCTAB nTab = aCoreRange[0]->aStart.Tab();
360 :
361 0 : ScConditionalFormat* pNewFormat = new ScConditionalFormat(0, &mpDocShell->GetDocument());
362 0 : pNewFormat->SetRange(aCoreRange);
363 0 : return mpDocShell->GetDocument().AddCondFormat(pNewFormat, nTab);
364 : }
365 :
366 0 : void ScCondFormatsObj::removeByID(const sal_Int32 nID)
367 : throw(uno::RuntimeException, std::exception)
368 : {
369 0 : SolarMutexGuard aGuard;
370 0 : ScConditionalFormatList* pFormatList = getCoreObject();;
371 0 : pFormatList->erase(nID);
372 0 : }
373 :
374 5 : uno::Sequence<uno::Reference<sheet::XConditionalFormat> > ScCondFormatsObj::getConditionalFormats()
375 : throw(uno::RuntimeException, std::exception)
376 : {
377 5 : SolarMutexGuard aGuard;
378 5 : ScConditionalFormatList* pFormatList = getCoreObject();;
379 5 : size_t n = pFormatList->size();
380 5 : uno::Sequence<uno::Reference<sheet::XConditionalFormat> > aCondFormats(n);
381 5 : sal_Int32 i = 0;
382 13 : for (ScConditionalFormatList::const_iterator itr = pFormatList->begin(); itr != pFormatList->end(); ++itr, ++i) {
383 8 : uno::Reference<sheet::XConditionalFormat> xCondFormat(new ScCondFormatObj(mpDocShell, this, itr->GetKey()));
384 8 : aCondFormats[i] = xCondFormat;
385 8 : }
386 :
387 5 : return aCondFormats;
388 : }
389 :
390 1 : sal_Int32 ScCondFormatsObj::getLength()
391 : throw(uno::RuntimeException, std::exception)
392 : {
393 1 : SolarMutexGuard aGuard;
394 1 : ScConditionalFormatList* pFormatList = getCoreObject();;
395 1 : return pFormatList->size();;
396 : }
397 :
398 117 : ScConditionalFormatList* ScCondFormatsObj::getCoreObject()
399 : {
400 117 : if (!mpDocShell)
401 0 : throw uno::RuntimeException();
402 :
403 117 : ScConditionalFormatList* pList = mpDocShell->GetDocument().GetCondFormList(mnTab);
404 117 : if (!pList)
405 0 : throw uno::RuntimeException();
406 :
407 117 : return pList;
408 : }
409 :
410 : namespace {
411 :
412 9 : uno::Reference<beans::XPropertySet> createConditionEntry(const ScFormatEntry* pEntry,
413 : rtl::Reference<ScCondFormatObj> xParent)
414 : {
415 9 : switch (pEntry->GetType())
416 : {
417 : case condformat::CONDITION:
418 : return new ScConditionEntryObj(xParent,
419 0 : static_cast<const ScCondFormatEntry*>(pEntry));
420 : break;
421 : case condformat::COLORSCALE:
422 : return new ScColorScaleFormatObj(xParent,
423 4 : static_cast<const ScColorScaleFormat*>(pEntry));
424 : break;
425 : case condformat::DATABAR:
426 : return new ScDataBarFormatObj(xParent,
427 5 : static_cast<const ScDataBarFormat*>(pEntry));
428 : break;
429 : case condformat::ICONSET:
430 : return new ScIconSetFormatObj(xParent,
431 0 : static_cast<const ScIconSetFormat*>(pEntry));
432 : break;
433 : case condformat::DATE:
434 : return new ScCondDateFormatObj(xParent,
435 0 : static_cast<const ScCondDateFormatEntry*>(pEntry));
436 : break;
437 : default:
438 0 : break;
439 : }
440 0 : return uno::Reference<beans::XPropertySet>();
441 : }
442 :
443 : }
444 :
445 8 : ScCondFormatObj::ScCondFormatObj(ScDocShell* pDocShell, rtl::Reference<ScCondFormatsObj> xCondFormats,
446 : sal_Int32 nKey):
447 : mxCondFormatList(xCondFormats),
448 : mpDocShell(pDocShell),
449 : maPropSet(getCondFormatPropset()),
450 8 : mnKey(nKey)
451 : {
452 8 : }
453 :
454 16 : ScCondFormatObj::~ScCondFormatObj()
455 : {
456 16 : }
457 :
458 111 : ScConditionalFormat* ScCondFormatObj::getCoreObject()
459 : {
460 111 : ScConditionalFormatList* pList = mxCondFormatList->getCoreObject();
461 111 : ScConditionalFormat* pFormat = pList->GetFormat(mnKey);
462 111 : if (!pFormat)
463 0 : throw uno::RuntimeException();
464 :
465 111 : return pFormat;
466 : }
467 :
468 9 : ScDocShell* ScCondFormatObj::getDocShell()
469 : {
470 9 : return mpDocShell;
471 : }
472 :
473 0 : void ScCondFormatObj::createEntry(const sal_Int32 nType, const sal_Int32 nPos)
474 : throw(uno::RuntimeException, std::exception)
475 : {
476 0 : SolarMutexGuard aGuard;
477 0 : ScConditionalFormat* pFormat = getCoreObject();
478 0 : if (nPos > sal_Int32(pFormat->size()))
479 0 : throw lang::IllegalArgumentException();
480 :
481 0 : ScFormatEntry* pNewEntry = NULL;
482 0 : ScDocument* pDoc = &mpDocShell->GetDocument();
483 0 : switch (nType)
484 : {
485 : case sheet::ConditionEntryType::CONDITION:
486 : pNewEntry = new ScCondFormatEntry(SC_COND_EQUAL, "", "",
487 0 : pDoc, pFormat->GetRange().GetTopLeftCorner(), "");
488 0 : break;
489 : case sheet::ConditionEntryType::COLORSCALE:
490 0 : pNewEntry = new ScColorScaleFormat(pDoc);
491 0 : static_cast<ScColorScaleFormat*>(pNewEntry)->EnsureSize();
492 0 : break;
493 : case sheet::ConditionEntryType::DATABAR:
494 0 : pNewEntry = new ScDataBarFormat(pDoc);
495 0 : static_cast<ScDataBarFormat*>(pNewEntry)->EnsureSize();
496 0 : break;
497 : case sheet::ConditionEntryType::ICONSET:
498 0 : pNewEntry = new ScIconSetFormat(pDoc);
499 0 : static_cast<ScIconSetFormat*>(pNewEntry)->EnsureSize();
500 0 : break;
501 : case sheet::ConditionEntryType::DATE:
502 0 : pNewEntry = new ScCondDateFormatEntry(pDoc);
503 0 : break;
504 : default:
505 : SAL_WARN("sc", "unknown conditional format type");
506 0 : throw lang::IllegalArgumentException();
507 : }
508 :
509 0 : pFormat->AddEntry(pNewEntry);
510 0 : }
511 :
512 0 : void ScCondFormatObj::removeByIndex(const sal_Int32 nIndex)
513 : throw(uno::RuntimeException, std::exception)
514 : {
515 0 : SolarMutexGuard aGuard;
516 0 : if (getCoreObject()->size() >= size_t(nIndex))
517 0 : throw lang::IllegalArgumentException();
518 :
519 0 : getCoreObject()->RemoveEntry(nIndex);
520 0 : }
521 :
522 3 : uno::Type ScCondFormatObj::getElementType()
523 : throw(uno::RuntimeException, std::exception)
524 : {
525 3 : return cppu::UnoType<beans::XPropertySet>::get();
526 : }
527 :
528 3 : sal_Bool ScCondFormatObj::hasElements()
529 : throw(uno::RuntimeException, std::exception)
530 : {
531 3 : SolarMutexGuard aGuard;
532 3 : ScConditionalFormat* pFormat = getCoreObject();
533 3 : return !pFormat->IsEmpty();
534 : }
535 :
536 3 : sal_Int32 ScCondFormatObj::getCount()
537 : throw(uno::RuntimeException, std::exception)
538 : {
539 3 : SolarMutexGuard aGuard;
540 3 : ScConditionalFormat* pFormat = getCoreObject();
541 :
542 3 : return pFormat->size();
543 : }
544 :
545 9 : uno::Any ScCondFormatObj::getByIndex(sal_Int32 nIndex)
546 : throw(uno::RuntimeException, std::exception)
547 : {
548 9 : SolarMutexGuard aGuard;
549 9 : if (getCoreObject()->size() <= size_t(nIndex))
550 0 : throw lang::IllegalArgumentException();
551 :
552 9 : const ScFormatEntry* pEntry = getCoreObject()->GetEntry(nIndex);
553 : uno::Reference<beans::XPropertySet> xCondEntry =
554 18 : createConditionEntry(pEntry, this);
555 9 : uno::Any aAny;
556 9 : aAny <<= xCondEntry;
557 18 : return aAny;
558 : }
559 :
560 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCondFormatObj::getPropertySetInfo()
561 : throw(uno::RuntimeException, std::exception)
562 : {
563 0 : SolarMutexGuard aGuard;
564 : static uno::Reference<beans::XPropertySetInfo> aRef(
565 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap()));
566 0 : return aRef;
567 : }
568 :
569 0 : 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 0 : SolarMutexGuard aGuard;
576 :
577 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
578 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
579 0 : if ( !pEntry )
580 0 : throw beans::UnknownPropertyException();
581 :
582 0 : switch(pEntry->nWID)
583 : {
584 : case ID:
585 0 : throw lang::IllegalArgumentException();
586 : break;
587 : case CondFormat_Range:
588 : {
589 0 : uno::Reference<sheet::XSheetCellRanges> xRange;
590 0 : if (aValue >>= xRange)
591 : {
592 0 : ScConditionalFormat* pFormat = getCoreObject();
593 : uno::Sequence<table::CellRangeAddress> aRanges =
594 0 : xRange->getRangeAddresses();
595 0 : ScRangeList aTargetRange;
596 0 : for (size_t i = 0, n = aRanges.getLength(); i < n; ++i)
597 : {
598 0 : ScRange aRange;
599 0 : ScUnoConversion::FillScRange(aRange, aRanges[i]);
600 0 : aTargetRange.Join(aRange);
601 : }
602 0 : pFormat->SetRange(aTargetRange);
603 0 : }
604 : }
605 0 : break;
606 : default:
607 : SAL_WARN("sc", "unknown property");
608 0 : }
609 0 : }
610 :
611 1 : uno::Any SAL_CALL ScCondFormatObj::getPropertyValue( const OUString& aPropertyName )
612 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
613 : uno::RuntimeException, std::exception)
614 : {
615 1 : SolarMutexGuard aGuard;
616 :
617 1 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
618 1 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
619 1 : if ( !pEntry )
620 0 : throw beans::UnknownPropertyException();
621 :
622 1 : uno::Any aAny;
623 1 : switch(pEntry->nWID)
624 : {
625 : case ID:
626 0 : aAny <<= sal_Int32(getCoreObject()->GetKey());
627 0 : break;
628 : case CondFormat_Range:
629 : {
630 1 : const ScRangeList& rRange = getCoreObject()->GetRange();
631 1 : uno::Reference<sheet::XSheetCellRanges> xRange;
632 1 : xRange.set(new ScCellRangesObj(mpDocShell, rRange));
633 1 : aAny <<= xRange;
634 : }
635 1 : break;
636 : default:
637 : SAL_WARN("sc", "unknown property");
638 : }
639 1 : return aAny;
640 : }
641 :
642 0 : 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 0 : }
649 :
650 0 : 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 0 : }
657 :
658 0 : 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 0 : }
665 :
666 0 : 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 0 : }
673 :
674 : namespace {
675 :
676 86 : bool isObjectStillAlive(ScConditionalFormat* pFormat, const ScFormatEntry* pEntry)
677 : {
678 217 : for(size_t i = 0, n= pFormat->size(); i < n; ++i)
679 : {
680 217 : if (pFormat->GetEntry(i) == pEntry)
681 86 : return true;
682 : }
683 0 : return false;
684 : }
685 :
686 : }
687 :
688 0 : ScConditionEntryObj::ScConditionEntryObj(rtl::Reference<ScCondFormatObj> xParent,
689 : const ScCondFormatEntry* pFormat):
690 0 : mpDocShell(xParent->getDocShell()),
691 : mxParent(xParent),
692 : maPropSet(getConditionEntryrPropSet()),
693 0 : mpFormat(pFormat)
694 : {
695 0 : }
696 :
697 0 : ScConditionEntryObj::~ScConditionEntryObj()
698 : {
699 0 : }
700 :
701 0 : ScCondFormatEntry* ScConditionEntryObj::getCoreObject()
702 : {
703 0 : ScConditionalFormat* pFormat = mxParent->getCoreObject();
704 0 : if (isObjectStillAlive(pFormat, mpFormat))
705 0 : return const_cast<ScCondFormatEntry*>(mpFormat);
706 :
707 0 : throw lang::IllegalArgumentException();
708 : }
709 :
710 0 : sal_Int32 ScConditionEntryObj::getType()
711 : throw(uno::RuntimeException, std::exception)
712 : {
713 0 : return sheet::ConditionEntryType::CONDITION;
714 : }
715 :
716 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScConditionEntryObj::getPropertySetInfo()
717 : throw(uno::RuntimeException, std::exception)
718 : {
719 : static uno::Reference<beans::XPropertySetInfo> aRef(
720 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
721 0 : return aRef;
722 : }
723 :
724 0 : 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 0 : SolarMutexGuard aGuard;
731 :
732 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
733 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
734 0 : if ( !pEntry )
735 0 : throw beans::UnknownPropertyException();
736 :
737 0 : switch(pEntry->nWID)
738 : {
739 : case StyleName:
740 : {
741 0 : OUString aStyleName;
742 0 : if ((aValue >>= aStyleName) && !aStyleName.isEmpty())
743 0 : getCoreObject()->UpdateStyleName(aStyleName);
744 : }
745 0 : break;
746 : case Formula1:
747 : {
748 0 : OUString aFormula;
749 0 : if ((aValue >>= aFormula) && !aFormula.isEmpty())
750 : {
751 0 : ScCompiler aComp(&mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());
752 0 : boost::scoped_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));
753 0 : getCoreObject()->SetFormula1(*pArr);
754 0 : }
755 : }
756 0 : break;
757 : case Formula2:
758 : {
759 0 : OUString aFormula;
760 0 : if ((aValue >>= aFormula) && !aFormula.isEmpty())
761 : {
762 0 : ScCompiler aComp(&mpDocShell->GetDocument(), getCoreObject()->GetSrcPos());
763 0 : boost::scoped_ptr<ScTokenArray> pArr(aComp.CompileString(aFormula));
764 0 : getCoreObject()->SetFormula2(*pArr);
765 0 : }
766 : }
767 0 : break;
768 : case Operator:
769 : {
770 : sal_Int32 nVal;
771 0 : if (aValue >>= nVal)
772 : {
773 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aConditionEntryMap); ++i)
774 : {
775 0 : if (aConditionEntryMap[i].nApiMode == nVal)
776 : {
777 0 : getCoreObject()->SetOperation(aConditionEntryMap[i].eMode);
778 0 : break;
779 : }
780 : }
781 : }
782 : }
783 0 : break;
784 : default:
785 : SAL_WARN("sc", "unsupported property");
786 0 : }
787 0 : }
788 :
789 0 : uno::Any SAL_CALL ScConditionEntryObj::getPropertyValue( const OUString& aPropertyName )
790 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
791 : uno::RuntimeException, std::exception)
792 : {
793 0 : SolarMutexGuard aGuard;
794 :
795 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
796 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
797 0 : if ( !pEntry )
798 0 : throw beans::UnknownPropertyException();
799 :
800 0 : uno::Any aAny;
801 0 : switch(pEntry->nWID)
802 : {
803 : case StyleName:
804 0 : aAny <<= getCoreObject()->GetStyle();
805 0 : break;
806 : case Formula1:
807 : {
808 0 : ScAddress aCursor = getCoreObject()->GetSrcPos();
809 0 : OUString aFormula = getCoreObject()->GetExpression(aCursor, 0);
810 0 : aAny <<= aFormula;
811 : }
812 0 : break;
813 : case Formula2:
814 : {
815 0 : ScAddress aCursor = getCoreObject()->GetSrcPos();
816 0 : OUString aFormula = getCoreObject()->GetExpression(aCursor, 1);
817 0 : aAny <<= aFormula;
818 : }
819 0 : break;
820 : case Operator:
821 : {
822 0 : ScConditionMode eMode = getCoreObject()->GetOperation();
823 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aConditionEntryMap); ++i)
824 : {
825 0 : if (aConditionEntryMap[i].eMode == eMode)
826 : {
827 0 : aAny <<= aConditionEntryMap[i].nApiMode;
828 0 : break;
829 : }
830 : }
831 : }
832 0 : break;
833 : default:
834 : SAL_WARN("sc", "unsupported property");
835 : }
836 0 : return aAny;
837 : }
838 :
839 0 : 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 0 : }
846 :
847 0 : 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 0 : }
854 :
855 0 : 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 0 : }
862 :
863 0 : 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 0 : }
870 :
871 4 : ScColorScaleFormatObj::ScColorScaleFormatObj(rtl::Reference<ScCondFormatObj> xParent,
872 : const ScColorScaleFormat* pFormat):
873 4 : mpDocShell(xParent->getDocShell()),
874 : mxParent(xParent),
875 : maPropSet(getColorScalePropSet()),
876 8 : mpFormat(pFormat)
877 : {
878 4 : }
879 :
880 8 : ScColorScaleFormatObj::~ScColorScaleFormatObj()
881 : {
882 8 : }
883 :
884 35 : ScColorScaleFormat* ScColorScaleFormatObj::getCoreObject()
885 : {
886 35 : ScConditionalFormat* pFormat = mxParent->getCoreObject();
887 35 : if (isObjectStillAlive(pFormat, mpFormat))
888 70 : return const_cast<ScColorScaleFormat*>(mpFormat);
889 :
890 0 : throw lang::IllegalArgumentException();
891 : }
892 :
893 0 : sal_Int32 ScColorScaleFormatObj::getType()
894 : throw(uno::RuntimeException, std::exception)
895 : {
896 0 : return sheet::ConditionEntryType::COLORSCALE;
897 : }
898 :
899 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScColorScaleFormatObj::getPropertySetInfo()
900 : throw(uno::RuntimeException, std::exception)
901 : {
902 : static uno::Reference<beans::XPropertySetInfo> aRef(
903 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
904 0 : return aRef;
905 : }
906 :
907 : namespace {
908 :
909 0 : void setColorScaleEntry(ScColorScaleEntry* pEntry, uno::Reference<sheet::XColorScaleEntry> xEntry)
910 : {
911 0 : ScColorScaleEntryType eType = ScColorScaleEntryType();
912 0 : sal_Int32 nApiType = xEntry->getType();
913 0 : bool bFound = false;
914 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
915 : {
916 0 : if (aColorScaleEntryTypeMap[i].nApiType == nApiType)
917 : {
918 0 : eType = aColorScaleEntryTypeMap[i].eType;
919 0 : bFound = true;
920 0 : break;
921 : }
922 : }
923 :
924 0 : if (!bFound)
925 0 : throw lang::IllegalArgumentException();
926 :
927 0 : pEntry->SetType(eType);
928 0 : pEntry->SetColor(xEntry->getColor());
929 0 : switch (eType)
930 : {
931 : case COLORSCALE_FORMULA:
932 : // TODO: Implement
933 0 : break;
934 : default:
935 : {
936 0 : double nVal = xEntry->getFormula().toDouble();
937 0 : pEntry->SetValue(nVal);
938 : }
939 0 : break;
940 : }
941 0 : }
942 :
943 : }
944 :
945 0 : 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 0 : SolarMutexGuard aGuard;
952 :
953 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
954 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
955 0 : if ( !pEntry )
956 0 : throw beans::UnknownPropertyException();
957 :
958 0 : switch(pEntry->nWID)
959 : {
960 : case ColorScaleEntries:
961 : {
962 0 : uno::Sequence<uno::Reference<sheet::XColorScaleEntry> > aEntries;
963 0 : if (aValue >>= aEntries)
964 : {
965 0 : if (aEntries.getLength() < 2)
966 0 : throw lang::IllegalArgumentException();
967 :
968 : // TODO: we need to make sure that there are enough entries
969 0 : size_t n = size_t(aEntries.getLength());
970 0 : for (size_t i = 0; i < n; ++i)
971 : {
972 0 : setColorScaleEntry(getCoreObject()->GetEntry(i), aEntries[i]);
973 : }
974 : }
975 : else
976 0 : throw lang::IllegalArgumentException();
977 : }
978 0 : break;
979 : default:
980 : SAL_WARN("sc", "unknown property");
981 0 : }
982 0 : }
983 :
984 3 : uno::Any SAL_CALL ScColorScaleFormatObj::getPropertyValue( const OUString& aPropertyName )
985 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
986 : uno::RuntimeException, std::exception)
987 : {
988 3 : SolarMutexGuard aGuard;
989 :
990 3 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
991 3 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
992 3 : if ( !pEntry )
993 0 : throw beans::UnknownPropertyException();
994 :
995 3 : uno::Any aAny;
996 :
997 3 : switch(pEntry->nWID)
998 : {
999 : case ColorScaleEntries:
1000 : {
1001 3 : uno::Sequence<uno::Reference<sheet::XColorScaleEntry> > aEntries(getCoreObject()->size());
1002 11 : for (size_t i = 0; i < getCoreObject()->size(); ++i)
1003 : {
1004 8 : aEntries[i] = new ScColorScaleEntryObj(this, i);
1005 : }
1006 3 : aAny <<= aEntries;
1007 : }
1008 3 : break;
1009 : default:
1010 : SAL_WARN("sc", "unknown property");
1011 : }
1012 :
1013 3 : return aAny;
1014 : }
1015 :
1016 0 : 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 0 : }
1023 :
1024 0 : 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 0 : }
1031 :
1032 0 : 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 0 : }
1039 :
1040 0 : 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 0 : }
1047 :
1048 8 : ScColorScaleEntryObj::ScColorScaleEntryObj(rtl::Reference<ScColorScaleFormatObj> xParent,
1049 : size_t nPos):
1050 : mxParent(xParent),
1051 8 : mnPos(nPos)
1052 : {
1053 8 : }
1054 :
1055 16 : ScColorScaleEntryObj::~ScColorScaleEntryObj()
1056 : {
1057 16 : }
1058 :
1059 21 : ScColorScaleEntry* ScColorScaleEntryObj::getCoreObject()
1060 : {
1061 21 : ScColorScaleFormat* pFormat = mxParent->getCoreObject();
1062 21 : if (pFormat->size() <= mnPos)
1063 0 : throw lang::IllegalArgumentException();
1064 :
1065 21 : return pFormat->GetEntry(mnPos);
1066 : }
1067 :
1068 8 : util::Color ScColorScaleEntryObj::getColor()
1069 : throw(uno::RuntimeException, std::exception)
1070 : {
1071 8 : Color aColor = getCoreObject()->GetColor();
1072 8 : return aColor.GetColor();
1073 : }
1074 :
1075 0 : void ScColorScaleEntryObj::setColor(util::Color aColor)
1076 : throw(uno::RuntimeException, std::exception)
1077 : {
1078 0 : getCoreObject()->SetColor(Color(aColor));
1079 0 : }
1080 :
1081 8 : sal_Int32 ScColorScaleEntryObj::getType()
1082 : throw(uno::RuntimeException, std::exception)
1083 : {
1084 8 : ScColorScaleEntry* pEntry = getCoreObject();
1085 30 : for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
1086 : {
1087 30 : if (aColorScaleEntryTypeMap[i].eType == pEntry->GetType())
1088 : {
1089 16 : return aColorScaleEntryTypeMap[i].nApiType;
1090 : }
1091 : }
1092 :
1093 0 : throw lang::IllegalArgumentException();
1094 : }
1095 :
1096 0 : void ScColorScaleEntryObj::setType(sal_Int32 nType)
1097 : throw(uno::RuntimeException, std::exception)
1098 : {
1099 0 : ScColorScaleEntry* pEntry = getCoreObject();
1100 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aColorScaleEntryTypeMap); ++i)
1101 : {
1102 0 : if (aColorScaleEntryTypeMap[i].nApiType == nType)
1103 : {
1104 0 : pEntry->SetType(aColorScaleEntryTypeMap[i].eType);
1105 0 : return;
1106 : }
1107 : }
1108 0 : throw lang::IllegalArgumentException();
1109 : }
1110 :
1111 5 : OUString ScColorScaleEntryObj::getFormula()
1112 : throw(uno::RuntimeException, std::exception)
1113 : {
1114 5 : ScColorScaleEntry* pEntry = getCoreObject();
1115 5 : switch (pEntry->GetType())
1116 : {
1117 : case COLORSCALE_FORMULA:
1118 : // TODO: Implement
1119 0 : break;
1120 : default:
1121 5 : return OUString::number(pEntry->GetValue());
1122 : }
1123 :
1124 0 : return OUString();
1125 : }
1126 :
1127 0 : void ScColorScaleEntryObj::setFormula(const OUString& rFormula)
1128 : throw(uno::RuntimeException, std::exception)
1129 : {
1130 0 : ScColorScaleEntry* pEntry = getCoreObject();
1131 0 : switch (pEntry->GetType())
1132 : {
1133 : case COLORSCALE_FORMULA:
1134 : // TODO: Implement
1135 : // pEntry->SetFormula(rFormula);
1136 0 : break;
1137 : default:
1138 0 : pEntry->SetValue(rFormula.toDouble());
1139 0 : break;
1140 : }
1141 0 : }
1142 :
1143 :
1144 5 : ScDataBarFormatObj::ScDataBarFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1145 : const ScDataBarFormat* pFormat):
1146 5 : mpDocShell(xParent->getDocShell()),
1147 : mxParent(xParent),
1148 : maPropSet(getDataBarPropSet()),
1149 10 : mpFormat(pFormat)
1150 : {
1151 5 : }
1152 :
1153 10 : ScDataBarFormatObj::~ScDataBarFormatObj()
1154 : {
1155 10 : }
1156 :
1157 51 : ScDataBarFormat* ScDataBarFormatObj::getCoreObject()
1158 : {
1159 51 : ScConditionalFormat* pFormat = mxParent->getCoreObject();
1160 51 : if (isObjectStillAlive(pFormat, mpFormat))
1161 102 : return const_cast<ScDataBarFormat*>(mpFormat);
1162 :
1163 0 : throw lang::IllegalArgumentException();
1164 : }
1165 :
1166 0 : sal_Int32 ScDataBarFormatObj::getType()
1167 : throw(uno::RuntimeException, std::exception)
1168 : {
1169 0 : return sheet::ConditionEntryType::DATABAR;
1170 : }
1171 :
1172 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScDataBarFormatObj::getPropertySetInfo()
1173 : throw(uno::RuntimeException, std::exception)
1174 : {
1175 0 : SolarMutexGuard aGuard;
1176 : static uno::Reference<beans::XPropertySetInfo> aRef(
1177 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1178 0 : return aRef;
1179 : }
1180 :
1181 : namespace {
1182 :
1183 0 : void setDataBarEntry(ScColorScaleEntry* pEntry, uno::Reference<sheet::XDataBarEntry> xEntry)
1184 : {
1185 0 : ScColorScaleEntryType eType = ScColorScaleEntryType();
1186 0 : sal_Int32 nApiType = xEntry->getType();
1187 0 : bool bFound = false;
1188 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1189 : {
1190 0 : if (aDataBarEntryTypeMap[i].nApiType == nApiType)
1191 : {
1192 0 : eType = aDataBarEntryTypeMap[i].eType;
1193 0 : bFound = true;
1194 0 : break;
1195 : }
1196 : }
1197 :
1198 0 : if (!bFound)
1199 0 : throw lang::IllegalArgumentException();
1200 :
1201 0 : pEntry->SetType(eType);
1202 0 : switch (eType)
1203 : {
1204 : case COLORSCALE_FORMULA:
1205 : // TODO: Implement
1206 0 : break;
1207 : default:
1208 : {
1209 0 : double nVal = xEntry->getFormula().toDouble();
1210 0 : pEntry->SetValue(nVal);
1211 : }
1212 0 : break;
1213 : }
1214 0 : }
1215 :
1216 : }
1217 :
1218 0 : 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 0 : SolarMutexGuard aGuard;
1225 :
1226 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1227 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1228 0 : if ( !pEntry )
1229 0 : throw beans::UnknownPropertyException();
1230 :
1231 0 : switch(pEntry->nWID)
1232 : {
1233 : case AxisPosition:
1234 : {
1235 : sal_Int32 nVal;
1236 0 : if (aValue >>= nVal)
1237 : {
1238 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarAxisMap); ++i)
1239 : {
1240 0 : if (aDataBarAxisMap[i].nApiPos == nVal)
1241 : {
1242 0 : getCoreObject()->GetDataBarData()->meAxisPosition =
1243 0 : aDataBarAxisMap[i].ePos;
1244 0 : break;
1245 : }
1246 : }
1247 : }
1248 : }
1249 0 : break;
1250 : case UseGradient:
1251 : {
1252 0 : bool bUseGradient = true;
1253 0 : if (aValue >>= bUseGradient)
1254 : {
1255 0 : getCoreObject()->GetDataBarData()->mbGradient = bUseGradient;
1256 : }
1257 : }
1258 0 : break;
1259 : case UseNegativeColor:
1260 : {
1261 0 : bool bUseNegativeColor = false;
1262 0 : if (aValue >>= bUseNegativeColor)
1263 : {
1264 0 : getCoreObject()->GetDataBarData()->mbNeg = bUseNegativeColor;
1265 0 : if (bUseNegativeColor && !getCoreObject()->GetDataBarData()->mpNegativeColor)
1266 : {
1267 0 : getCoreObject()->GetDataBarData()->mpNegativeColor.reset(new Color(COL_AUTO));
1268 : }
1269 : }
1270 : }
1271 0 : break;
1272 : case DataBar_ShowValue:
1273 : {
1274 0 : bool bShowValue = true;
1275 0 : if (aValue >>= bShowValue)
1276 : {
1277 0 : getCoreObject()->GetDataBarData()->mbOnlyBar = !bShowValue;
1278 : }
1279 : }
1280 0 : break;
1281 : case DataBar_Color:
1282 : {
1283 0 : sal_Int32 nColor = COL_AUTO;
1284 0 : if (aValue >>= nColor)
1285 : {
1286 0 : getCoreObject()->GetDataBarData()->maPositiveColor.SetColor(nColor);
1287 : }
1288 : }
1289 0 : break;
1290 : case AxisColor:
1291 : {
1292 0 : sal_Int32 nAxisColor = COL_AUTO;
1293 0 : if (aValue >>= nAxisColor)
1294 : {
1295 0 : getCoreObject()->GetDataBarData()->maAxisColor.SetColor(nAxisColor);
1296 : }
1297 : }
1298 0 : break;
1299 : case NegativeColor:
1300 : {
1301 0 : sal_Int32 nNegativeColor = COL_AUTO;
1302 0 : if ((aValue >>= nNegativeColor) && getCoreObject()->GetDataBarData()->mbNeg)
1303 : {
1304 0 : getCoreObject()->GetDataBarData()->mpNegativeColor->SetColor(nNegativeColor);
1305 : }
1306 : else
1307 0 : throw lang::IllegalArgumentException();
1308 : }
1309 0 : break;
1310 : case DataBarEntries:
1311 : {
1312 0 : uno::Sequence<uno::Reference<sheet::XDataBarEntry> > aEntries;
1313 0 : if (aValue >>= aEntries)
1314 : {
1315 0 : if (aEntries.getLength() != 2)
1316 0 : throw lang::IllegalArgumentException();
1317 :
1318 0 : setDataBarEntry(getCoreObject()->GetDataBarData()->mpLowerLimit.get(),
1319 0 : aEntries[0]);
1320 0 : setDataBarEntry(getCoreObject()->GetDataBarData()->mpUpperLimit.get(),
1321 0 : aEntries[1]);
1322 : }
1323 : else
1324 0 : throw lang::IllegalArgumentException();
1325 : }
1326 0 : break;
1327 : case MinimumLength:
1328 : {
1329 0 : double nLength = 0;
1330 0 : if ((aValue >>= nLength) && nLength < 100 && nLength >= 0)
1331 : {
1332 0 : getCoreObject()->GetDataBarData()->mnMinLength = nLength;
1333 : }
1334 0 : else throw lang::IllegalArgumentException();
1335 : }
1336 0 : break;
1337 : case MaximumLength:
1338 : {
1339 0 : double nLength = 0;
1340 0 : if ((aValue >>= nLength) && nLength <= 100 && nLength > 0)
1341 : {
1342 0 : getCoreObject()->GetDataBarData()->mnMaxLength = nLength;
1343 : }
1344 0 : else throw lang::IllegalArgumentException();
1345 : }
1346 0 : break;
1347 0 : }
1348 0 : }
1349 :
1350 34 : uno::Any SAL_CALL ScDataBarFormatObj::getPropertyValue( const OUString& aPropertyName )
1351 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1352 : uno::RuntimeException, std::exception)
1353 : {
1354 34 : SolarMutexGuard aGuard;
1355 :
1356 34 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1357 34 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1358 34 : if ( !pEntry )
1359 0 : throw beans::UnknownPropertyException();
1360 :
1361 34 : uno::Any aAny;
1362 34 : switch(pEntry->nWID)
1363 : {
1364 : case AxisPosition:
1365 : {
1366 5 : databar::ScAxisPosition ePos = getCoreObject()->GetDataBarData()->meAxisPosition;
1367 5 : sal_Int32 nApiPos = sheet::DataBarAxis::AXIS_NONE;
1368 20 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarAxisMap); ++i)
1369 : {
1370 15 : if (aDataBarAxisMap[i].ePos == ePos)
1371 : {
1372 5 : nApiPos = aDataBarAxisMap[i].nApiPos;
1373 : }
1374 : }
1375 :
1376 5 : aAny <<= nApiPos;
1377 : }
1378 5 : break;
1379 : case UseGradient:
1380 : {
1381 5 : aAny <<= getCoreObject()->GetDataBarData()->mbGradient;
1382 : }
1383 5 : break;
1384 : case UseNegativeColor:
1385 : {
1386 0 : aAny <<= getCoreObject()->GetDataBarData()->mbNeg;
1387 : }
1388 0 : break;
1389 : case DataBar_ShowValue:
1390 : {
1391 5 : aAny <<= !getCoreObject()->GetDataBarData()->mbOnlyBar;
1392 : }
1393 5 : break;
1394 : case DataBar_Color:
1395 : {
1396 5 : sal_Int32 nColor = getCoreObject()->GetDataBarData()->maPositiveColor.GetColor();
1397 5 : aAny <<= nColor;
1398 : }
1399 5 : break;
1400 : case AxisColor:
1401 : {
1402 5 : sal_Int32 nAxisColor = getCoreObject()->GetDataBarData()->maAxisColor.GetColor();
1403 5 : aAny <<= nAxisColor;
1404 : }
1405 5 : break;
1406 : case NegativeColor:
1407 : {
1408 5 : if (getCoreObject()->GetDataBarData()->mbNeg && getCoreObject()->GetDataBarData()->mpNegativeColor)
1409 : {
1410 5 : sal_Int32 nNegativeColor = getCoreObject()->GetDataBarData()->mpNegativeColor->GetColor();
1411 5 : aAny <<= nNegativeColor;
1412 : }
1413 : }
1414 5 : break;
1415 : case DataBarEntries:
1416 : {
1417 4 : uno::Sequence<uno::Reference<sheet::XDataBarEntry> > aEntries(2);
1418 4 : aEntries[0] = new ScDataBarEntryObj(this, 0);
1419 4 : aEntries[1] = new ScDataBarEntryObj(this, 1);
1420 4 : aAny <<= aEntries;
1421 : }
1422 4 : break;
1423 : }
1424 34 : return aAny;
1425 : }
1426 :
1427 0 : 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 0 : }
1434 :
1435 0 : 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 0 : }
1442 :
1443 0 : 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 0 : }
1450 :
1451 0 : 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 0 : }
1458 :
1459 8 : ScDataBarEntryObj::ScDataBarEntryObj(rtl::Reference<ScDataBarFormatObj> xParent,
1460 : size_t nPos):
1461 : mxParent(xParent),
1462 8 : mnPos(nPos)
1463 : {
1464 8 : }
1465 :
1466 16 : ScDataBarEntryObj::~ScDataBarEntryObj()
1467 : {
1468 16 : }
1469 :
1470 11 : ScColorScaleEntry* ScDataBarEntryObj::getCoreObject()
1471 : {
1472 11 : ScDataBarFormat* pFormat = mxParent->getCoreObject();
1473 : ScColorScaleEntry* pEntry;
1474 11 : if (mnPos == 0)
1475 5 : pEntry = pFormat->GetDataBarData()->mpLowerLimit.get();
1476 : else
1477 6 : pEntry = pFormat->GetDataBarData()->mpUpperLimit.get();
1478 :
1479 11 : return pEntry;
1480 : }
1481 :
1482 8 : sal_Int32 ScDataBarEntryObj::getType()
1483 : throw(uno::RuntimeException, std::exception)
1484 : {
1485 8 : ScColorScaleEntry* pEntry = getCoreObject();
1486 25 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1487 : {
1488 25 : if (aDataBarEntryTypeMap[i].eType == pEntry->GetType())
1489 : {
1490 16 : return aDataBarEntryTypeMap[i].nApiType;
1491 : }
1492 : }
1493 :
1494 0 : throw lang::IllegalArgumentException();
1495 : }
1496 :
1497 0 : void ScDataBarEntryObj::setType(sal_Int32 nType)
1498 : throw(uno::RuntimeException, std::exception)
1499 : {
1500 0 : ScColorScaleEntry* pEntry = getCoreObject();
1501 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDataBarEntryTypeMap); ++i)
1502 : {
1503 0 : if (aDataBarEntryTypeMap[i].nApiType == nType)
1504 : {
1505 0 : pEntry->SetType(aDataBarEntryTypeMap[i].eType);
1506 0 : return;
1507 : }
1508 : }
1509 0 : throw lang::IllegalArgumentException();
1510 : }
1511 :
1512 3 : OUString ScDataBarEntryObj::getFormula()
1513 : throw(uno::RuntimeException, std::exception)
1514 : {
1515 3 : ScColorScaleEntry* pEntry = getCoreObject();
1516 3 : switch (pEntry->GetType())
1517 : {
1518 : case COLORSCALE_FORMULA:
1519 : // TODO: Implement
1520 0 : break;
1521 : default:
1522 3 : return OUString::number(pEntry->GetValue());
1523 : }
1524 :
1525 0 : return OUString();
1526 : }
1527 :
1528 0 : void ScDataBarEntryObj::setFormula(const OUString& rFormula)
1529 : throw(uno::RuntimeException, std::exception)
1530 : {
1531 0 : ScColorScaleEntry* pEntry = getCoreObject();
1532 0 : switch (pEntry->GetType())
1533 : {
1534 : case COLORSCALE_FORMULA:
1535 : // TODO: Implement
1536 : // pEntry->SetFormula(rFormula);
1537 0 : break;
1538 : default:
1539 0 : pEntry->SetValue(rFormula.toDouble());
1540 0 : break;
1541 : }
1542 0 : }
1543 :
1544 :
1545 0 : ScIconSetFormatObj::ScIconSetFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1546 : const ScIconSetFormat* pFormat):
1547 0 : mpDocShell(xParent->getDocShell()),
1548 : mxParent(xParent),
1549 : maPropSet(getIconSetPropSet()),
1550 0 : mpFormat(pFormat)
1551 : {
1552 0 : }
1553 :
1554 0 : ScIconSetFormatObj::~ScIconSetFormatObj()
1555 : {
1556 0 : }
1557 :
1558 0 : ScIconSetFormat* ScIconSetFormatObj::getCoreObject()
1559 : {
1560 0 : ScConditionalFormat* pFormat = mxParent->getCoreObject();
1561 0 : if (isObjectStillAlive(pFormat, mpFormat))
1562 0 : return const_cast<ScIconSetFormat*>(mpFormat);
1563 :
1564 0 : throw lang::IllegalArgumentException();
1565 : }
1566 :
1567 0 : sal_Int32 ScIconSetFormatObj::getType()
1568 : throw(uno::RuntimeException, std::exception)
1569 : {
1570 0 : return sheet::ConditionEntryType::ICONSET;
1571 : }
1572 :
1573 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScIconSetFormatObj::getPropertySetInfo()
1574 : throw(uno::RuntimeException, std::exception)
1575 : {
1576 0 : SolarMutexGuard aGuard;
1577 : static uno::Reference<beans::XPropertySetInfo> aRef(
1578 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1579 0 : return aRef;
1580 : }
1581 :
1582 : namespace {
1583 :
1584 0 : void setIconSetEntry(ScIconSetFormat* pFormat, uno::Reference<sheet::XIconSetEntry> xEntry, size_t nPos)
1585 : {
1586 0 : ScIconSetFormatData* pData = pFormat->GetIconSetData();
1587 0 : ScColorScaleEntryType eType = ScColorScaleEntryType();
1588 0 : sal_Int32 nApiType = xEntry->getType();
1589 0 : bool bFound = false;
1590 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1591 : {
1592 0 : if (aIconSetEntryTypeMap[i].nApiType == nApiType)
1593 : {
1594 0 : eType = aIconSetEntryTypeMap[i].eType;
1595 0 : bFound = true;
1596 0 : break;
1597 : }
1598 : }
1599 :
1600 0 : if (!bFound)
1601 0 : throw lang::IllegalArgumentException();
1602 :
1603 0 : pData->maEntries[nPos].SetType(eType);
1604 0 : switch (eType)
1605 : {
1606 : case COLORSCALE_FORMULA:
1607 : // TODO: Implement
1608 0 : break;
1609 : default:
1610 : {
1611 0 : double nVal = xEntry->getFormula().toDouble();
1612 0 : pData->maEntries[nPos].SetValue(nVal);
1613 : }
1614 0 : break;
1615 : }
1616 0 : }
1617 :
1618 : }
1619 :
1620 0 : 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 0 : SolarMutexGuard aGuard;
1627 :
1628 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1629 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1630 0 : if ( !pEntry )
1631 0 : throw beans::UnknownPropertyException();
1632 :
1633 0 : switch(pEntry->nWID)
1634 : {
1635 : case ShowValue:
1636 : {
1637 0 : bool bShowValue = true;
1638 0 : aValue >>= bShowValue;
1639 0 : getCoreObject()->GetIconSetData()->mbShowValue = bShowValue;
1640 : }
1641 0 : break;
1642 : case Reverse:
1643 : {
1644 0 : bool bReverse = false;
1645 0 : aValue >>= bReverse;
1646 0 : getCoreObject()->GetIconSetData()->mbReverse = bReverse;
1647 : }
1648 0 : break;
1649 : case Icons:
1650 : {
1651 0 : sal_Int32 nApiType = -1;
1652 0 : aValue >>= nApiType;
1653 0 : ScIconSetType eType = IconSet_3Arrows;
1654 0 : bool bFound = false;
1655 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetApiMap); ++i)
1656 : {
1657 0 : if (aIconSetApiMap[i].nApiType == nApiType)
1658 : {
1659 0 : eType = aIconSetApiMap[i].eType;
1660 0 : bFound = true;
1661 0 : break;
1662 : }
1663 : }
1664 :
1665 0 : if (!bFound)
1666 : {
1667 0 : throw lang::IllegalArgumentException();
1668 : }
1669 :
1670 : // TODO: we need to make sure that there are enough entries
1671 0 : getCoreObject()->GetIconSetData()->eIconSetType = eType;
1672 : }
1673 0 : break;
1674 : case IconSetEntries:
1675 : {
1676 0 : uno::Sequence<uno::Reference<sheet::XIconSetEntry> > aEntries;
1677 0 : if (aValue >>= aEntries)
1678 : {
1679 : // TODO: we need to check that the number of entries
1680 : // corresponds to the icon type
1681 0 : sal_Int32 nLength = aEntries.getLength();
1682 0 : for (size_t i = 0; i < size_t(nLength); ++i)
1683 : {
1684 0 : setIconSetEntry(getCoreObject(), aEntries[i], i);
1685 : }
1686 : }
1687 : else
1688 0 : throw lang::IllegalArgumentException();
1689 : }
1690 0 : break;
1691 : default:
1692 0 : break;
1693 0 : }
1694 0 : }
1695 :
1696 0 : uno::Any SAL_CALL ScIconSetFormatObj::getPropertyValue( const OUString& aPropertyName )
1697 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1698 : uno::RuntimeException, std::exception)
1699 : {
1700 0 : SolarMutexGuard aGuard;
1701 :
1702 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1703 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1704 0 : if ( !pEntry )
1705 0 : throw beans::UnknownPropertyException();
1706 :
1707 0 : uno::Any aAny;
1708 :
1709 0 : switch(pEntry->nWID)
1710 : {
1711 : case ShowValue:
1712 0 : aAny <<= getCoreObject()->GetIconSetData()->mbShowValue;
1713 0 : break;
1714 : case Reverse:
1715 0 : aAny <<= getCoreObject()->GetIconSetData()->mbReverse;
1716 0 : break;
1717 : case Icons:
1718 : {
1719 0 : ScIconSetType eType = getCoreObject()->GetIconSetData()->eIconSetType;
1720 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetApiMap); ++i)
1721 : {
1722 0 : if (aIconSetApiMap[i].eType == eType)
1723 : {
1724 0 : aAny <<= aIconSetApiMap[i].nApiType;
1725 0 : break;
1726 : }
1727 : }
1728 : }
1729 0 : break;
1730 : case IconSetEntries:
1731 : {
1732 0 : uno::Sequence<uno::Reference<sheet::XIconSetEntry> > aEntries(getCoreObject()->size());
1733 0 : size_t i = 0;
1734 0 : for (auto it = getCoreObject()->begin(), itEnd = getCoreObject()->end(); it != itEnd; ++it, ++i)
1735 : {
1736 0 : aEntries[i] = new ScIconSetEntryObj(this, i);
1737 : }
1738 0 : aAny <<= aEntries;
1739 : }
1740 0 : break;
1741 : default:
1742 : SAL_WARN("sc", "unknown property");
1743 : }
1744 0 : return aAny;
1745 : }
1746 :
1747 0 : 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 0 : }
1754 :
1755 0 : 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 0 : }
1762 :
1763 0 : 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 0 : }
1770 :
1771 0 : 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 0 : }
1778 :
1779 0 : ScIconSetEntryObj::ScIconSetEntryObj(rtl::Reference<ScIconSetFormatObj> xParent,
1780 : size_t nPos):
1781 : mxParent(xParent),
1782 0 : mnPos(nPos)
1783 : {
1784 0 : }
1785 :
1786 0 : ScIconSetEntryObj::~ScIconSetEntryObj()
1787 : {
1788 0 : }
1789 :
1790 0 : ScColorScaleEntry* ScIconSetEntryObj::getCoreObject()
1791 : {
1792 0 : ScIconSetFormat* pFormat = mxParent->getCoreObject();
1793 0 : if (pFormat->GetIconSetData()->maEntries.size() <= mnPos)
1794 0 : throw lang::IllegalArgumentException();
1795 :
1796 0 : return &pFormat->GetIconSetData()->maEntries[mnPos];
1797 : }
1798 :
1799 0 : sal_Int32 ScIconSetEntryObj::getType()
1800 : throw(uno::RuntimeException, std::exception)
1801 : {
1802 0 : ScColorScaleEntry* pEntry = getCoreObject();
1803 : // the first entry always is minimum
1804 0 : if (mnPos == 0)
1805 0 : return sheet::IconSetFormatEntry::ICONSET_MIN;
1806 :
1807 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1808 : {
1809 0 : if (aIconSetEntryTypeMap[i].eType == pEntry->GetType())
1810 : {
1811 0 : return aIconSetEntryTypeMap[i].nApiType;
1812 : }
1813 : }
1814 :
1815 0 : throw lang::IllegalArgumentException();
1816 : }
1817 :
1818 0 : void ScIconSetEntryObj::setType(sal_Int32 nType)
1819 : throw(uno::RuntimeException, std::exception)
1820 : {
1821 : // first entry is always MIN
1822 0 : if (mnPos == 0)
1823 0 : return;
1824 :
1825 0 : ScColorScaleEntry* pEntry = getCoreObject();
1826 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aIconSetEntryTypeMap); ++i)
1827 : {
1828 0 : if (aIconSetEntryTypeMap[i].nApiType == nType)
1829 : {
1830 0 : pEntry->SetType(aIconSetEntryTypeMap[i].eType);
1831 0 : return;
1832 : }
1833 : }
1834 0 : throw lang::IllegalArgumentException();
1835 : }
1836 :
1837 0 : OUString ScIconSetEntryObj::getFormula()
1838 : throw(uno::RuntimeException, std::exception)
1839 : {
1840 0 : ScColorScaleEntry* pEntry = getCoreObject();
1841 0 : switch (pEntry->GetType())
1842 : {
1843 : case COLORSCALE_FORMULA:
1844 : // TODO: Implement
1845 0 : break;
1846 : default:
1847 0 : return OUString::number(pEntry->GetValue());
1848 : }
1849 :
1850 0 : return OUString();
1851 : }
1852 :
1853 0 : void ScIconSetEntryObj::setFormula(const OUString& rFormula)
1854 : throw(uno::RuntimeException, std::exception)
1855 : {
1856 0 : ScColorScaleEntry* pEntry = getCoreObject();
1857 0 : switch (pEntry->GetType())
1858 : {
1859 : case COLORSCALE_FORMULA:
1860 : // TODO: Implement
1861 : // pEntry->SetFormula(rFormula);
1862 0 : break;
1863 : default:
1864 0 : pEntry->SetValue(rFormula.toDouble());
1865 0 : break;
1866 : }
1867 0 : }
1868 :
1869 0 : ScCondDateFormatObj::ScCondDateFormatObj(rtl::Reference<ScCondFormatObj> xParent,
1870 : const ScCondDateFormatEntry* pFormat):
1871 : mxParent(xParent),
1872 : maPropSet(getCondDatePropSet()),
1873 0 : mpFormat(pFormat)
1874 : {
1875 0 : }
1876 :
1877 0 : ScCondDateFormatObj::~ScCondDateFormatObj()
1878 : {
1879 0 : }
1880 :
1881 0 : ScCondDateFormatEntry* ScCondDateFormatObj::getCoreObject()
1882 : {
1883 0 : ScConditionalFormat* pFormat = mxParent->getCoreObject();
1884 0 : if (isObjectStillAlive(pFormat, mpFormat))
1885 0 : return const_cast<ScCondDateFormatEntry*>(mpFormat);
1886 :
1887 0 : throw lang::IllegalArgumentException();
1888 : }
1889 :
1890 0 : sal_Int32 ScCondDateFormatObj::getType()
1891 : throw(uno::RuntimeException, std::exception)
1892 : {
1893 0 : return sheet::ConditionEntryType::DATE;
1894 : }
1895 :
1896 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCondDateFormatObj::getPropertySetInfo()
1897 : throw(uno::RuntimeException, std::exception)
1898 : {
1899 0 : SolarMutexGuard aGuard;
1900 : static uno::Reference<beans::XPropertySetInfo> aRef(
1901 0 : new SfxItemPropertySetInfo( maPropSet.getPropertyMap() ));
1902 0 : return aRef;
1903 : }
1904 :
1905 0 : 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 0 : SolarMutexGuard aGuard;
1912 :
1913 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1914 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1915 0 : if ( !pEntry )
1916 0 : throw beans::UnknownPropertyException();
1917 :
1918 0 : switch(pEntry->nWID)
1919 : {
1920 : case Date_StyleName:
1921 : {
1922 0 : OUString aStyleName;
1923 0 : if (aValue >>= aStyleName)
1924 : {
1925 0 : getCoreObject()->SetStyleName(aStyleName);
1926 : }
1927 : else
1928 0 : throw lang::IllegalArgumentException();
1929 : }
1930 0 : break;
1931 : case DateType:
1932 : {
1933 0 : sal_Int32 nApiType = -1;
1934 0 : if (!(aValue >>= nApiType))
1935 0 : throw lang::IllegalArgumentException();
1936 :
1937 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDateTypeApiMap); ++i)
1938 : {
1939 0 : if (aDateTypeApiMap[i].nApiType == nApiType)
1940 : {
1941 0 : getCoreObject()->SetDateType(aDateTypeApiMap[i].eType);
1942 0 : break;
1943 : }
1944 : }
1945 : }
1946 0 : break;
1947 : default:
1948 0 : break;
1949 0 : }
1950 0 : }
1951 :
1952 0 : uno::Any SAL_CALL ScCondDateFormatObj::getPropertyValue( const OUString& aPropertyName )
1953 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1954 : uno::RuntimeException, std::exception)
1955 : {
1956 0 : SolarMutexGuard aGuard;
1957 :
1958 0 : const SfxItemPropertyMap& rPropertyMap = maPropSet.getPropertyMap(); // from derived class
1959 0 : const SfxItemPropertySimpleEntry* pEntry = rPropertyMap.getByName( aPropertyName );
1960 0 : if ( !pEntry )
1961 0 : throw beans::UnknownPropertyException();
1962 :
1963 0 : uno::Any aAny;
1964 :
1965 0 : switch(pEntry->nWID)
1966 : {
1967 : case Date_StyleName:
1968 : {
1969 0 : OUString aStyleName = getCoreObject()->GetStyleName();
1970 0 : aAny <<= aStyleName;
1971 : }
1972 0 : break;
1973 : case DateType:
1974 : {
1975 0 : condformat::ScCondFormatDateType eType = getCoreObject()->GetDateType();
1976 0 : for (size_t i = 0; i < SAL_N_ELEMENTS(aDateTypeApiMap); ++i)
1977 : {
1978 0 : if (aDateTypeApiMap[i].eType == eType)
1979 : {
1980 0 : aAny <<= aDateTypeApiMap[i].nApiType;
1981 0 : break;
1982 : }
1983 : }
1984 : }
1985 0 : break;
1986 : default:
1987 : SAL_WARN("sc", "unknown property");
1988 : }
1989 0 : return aAny;
1990 : }
1991 :
1992 0 : 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 0 : }
1999 :
2000 0 : 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 0 : }
2007 :
2008 0 : 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 0 : }
2015 :
2016 0 : 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 156 : }
2023 :
2024 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
