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 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <svl/smplhint.hxx>
21 : #include <vcl/svapp.hxx>
22 :
23 : #include <com/sun/star/sheet/NamedRangeFlag.hpp>
24 : #include <com/sun/star/awt/XBitmap.hpp>
25 : #include <com/sun/star/beans/PropertyAttribute.hpp>
26 :
27 : #include <comphelper/servicehelper.hxx>
28 : #include <cppuhelper/supportsservice.hxx>
29 :
30 : using namespace ::com::sun::star;
31 : using ::com::sun::star::uno::Reference;
32 : using ::com::sun::star::uno::Any;
33 :
34 : #include "nameuno.hxx"
35 : #include "miscuno.hxx"
36 : #include "cellsuno.hxx"
37 : #include "convuno.hxx"
38 : #include "targuno.hxx"
39 : #include "tokenuno.hxx"
40 : #include "tokenarray.hxx"
41 : #include "docsh.hxx"
42 : #include "docfunc.hxx"
43 : #include "rangenam.hxx"
44 : #include "unonames.hxx"
45 :
46 : #include "scui_def.hxx"
47 :
48 0 : static const SfxItemPropertyMapEntry* lcl_GetNamedRangeMap()
49 : {
50 : static const SfxItemPropertyMapEntry aNamedRangeMap_Impl[] =
51 : {
52 0 : {OUString(SC_UNO_LINKDISPBIT), 0, cppu::UnoType<awt::XBitmap>::get(), beans::PropertyAttribute::READONLY, 0 },
53 0 : {OUString(SC_UNO_LINKDISPNAME), 0, cppu::UnoType<OUString>::get(), beans::PropertyAttribute::READONLY, 0 },
54 0 : {OUString(SC_UNONAME_TOKENINDEX), 0, cppu::UnoType<sal_Int32>::get(), beans::PropertyAttribute::READONLY, 0 },
55 0 : {OUString(SC_UNONAME_ISSHAREDFMLA), 0, cppu::UnoType<bool>::get(), 0, 0 },
56 : { OUString(), 0, css::uno::Type(), 0, 0 }
57 0 : };
58 0 : return aNamedRangeMap_Impl;
59 : }
60 :
61 0 : static const SfxItemPropertyMapEntry* lcl_GetNamedRangesMap()
62 : {
63 : static const SfxItemPropertyMapEntry aNamedRangesMap_Impl[] =
64 : {
65 0 : {OUString(SC_UNO_MODIFY_BROADCAST), 0, cppu::UnoType<bool>::get(), 0, 0 },
66 : { OUString(), 0, css::uno::Type(), 0, 0 }
67 0 : };
68 0 : return aNamedRangesMap_Impl;
69 : }
70 :
71 : #define SCNAMEDRANGEOBJ_SERVICE "com.sun.star.sheet.NamedRange"
72 :
73 0 : SC_SIMPLE_SERVICE_INFO( ScLabelRangeObj, "ScLabelRangeObj", "com.sun.star.sheet.LabelRange" )
74 0 : SC_SIMPLE_SERVICE_INFO( ScLabelRangesObj, "ScLabelRangesObj", "com.sun.star.sheet.LabelRanges" )
75 0 : SC_SIMPLE_SERVICE_INFO( ScNamedRangesObj, "ScNamedRangesObj", "com.sun.star.sheet.NamedRanges" )
76 :
77 276 : static bool lcl_UserVisibleName(const ScRangeData& rData)
78 : {
79 : //! as method to ScRangeData
80 :
81 276 : return !rData.HasType(RT_DATABASE);
82 : }
83 :
84 168 : ScNamedRangeObj::ScNamedRangeObj( rtl::Reference< ScNamedRangesObj > xParent, ScDocShell* pDocSh, const OUString& rNm, Reference<container::XNamed> xSheet):
85 : mxParent(xParent),
86 : pDocShell( pDocSh ),
87 : aName( rNm ),
88 168 : mxSheet( xSheet )
89 : {
90 168 : pDocShell->GetDocument().AddUnoObject(*this);
91 168 : }
92 :
93 504 : ScNamedRangeObj::~ScNamedRangeObj()
94 : {
95 168 : SolarMutexGuard g;
96 :
97 168 : if (pDocShell)
98 162 : pDocShell->GetDocument().RemoveUnoObject(*this);
99 336 : }
100 :
101 27 : void ScNamedRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
102 : {
103 : // reference update is of no interest
104 :
105 27 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
106 27 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
107 6 : pDocShell = NULL; // became invalid
108 27 : }
109 :
110 : // Helper functions
111 :
112 162 : ScRangeData* ScNamedRangeObj::GetRangeData_Impl()
113 : {
114 162 : ScRangeData* pRet = NULL;
115 162 : if (pDocShell)
116 : {
117 : ScRangeName* pNames;
118 162 : SCTAB nTab = GetTab_Impl();
119 162 : if (nTab >= 0)
120 0 : pNames = pDocShell->GetDocument().GetRangeName(nTab);
121 : else
122 162 : pNames = pDocShell->GetDocument().GetRangeName();
123 162 : if (pNames)
124 : {
125 162 : pRet = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
126 162 : if (pRet)
127 162 : pRet->ValidateTabRefs(); // adjust relative tab refs to valid tables
128 : }
129 : }
130 162 : return pRet;
131 : }
132 :
133 173 : SCTAB ScNamedRangeObj::GetTab_Impl()
134 : {
135 173 : if (mxSheet.is())
136 : {
137 0 : if (!pDocShell)
138 0 : return -2;
139 0 : ScDocument& rDoc = pDocShell->GetDocument();
140 : SCTAB nTab;
141 0 : OUString sName = mxSheet->getName();
142 0 : bool bFound = rDoc.GetTable(sName, nTab);
143 : assert(bFound); (void)bFound; // fouled up?
144 0 : return nTab;
145 : }
146 : else
147 173 : return -1;//global range name
148 : }
149 :
150 : // sheet::XNamedRange
151 :
152 11 : void ScNamedRangeObj::Modify_Impl( const OUString* pNewName, const ScTokenArray* pNewTokens, const OUString* pNewContent,
153 : const ScAddress* pNewPos, const sal_uInt16* pNewType,
154 : const formula::FormulaGrammar::Grammar eGrammar )
155 : {
156 11 : if (!pDocShell)
157 0 : return;
158 :
159 11 : ScDocument& rDoc = pDocShell->GetDocument();
160 : ScRangeName* pNames;
161 11 : SCTAB nTab = GetTab_Impl();
162 11 : if (nTab >= 0)
163 0 : pNames = rDoc.GetRangeName(nTab);
164 : else
165 11 : pNames = rDoc.GetRangeName();
166 11 : if (!pNames)
167 0 : return;
168 :
169 11 : const ScRangeData* pOld = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
170 11 : if (!pOld)
171 0 : return;
172 :
173 11 : ScRangeName* pNewRanges = new ScRangeName(*pNames);
174 :
175 11 : OUString aInsName = pOld->GetName();
176 11 : if (pNewName)
177 2 : aInsName = *pNewName;
178 :
179 22 : OUString aContent; // Content string based =>
180 11 : pOld->GetSymbol( aContent, eGrammar); // no problems with changed positions and such.
181 11 : if (pNewContent)
182 3 : aContent = *pNewContent;
183 :
184 11 : ScAddress aPos = pOld->GetPos();
185 11 : if (pNewPos)
186 1 : aPos = *pNewPos;
187 :
188 11 : sal_uInt16 nType = pOld->GetType();
189 11 : if (pNewType)
190 5 : nType = *pNewType;
191 :
192 11 : ScRangeData* pNew = NULL;
193 11 : if (pNewTokens)
194 0 : pNew = new ScRangeData( &rDoc, aInsName, *pNewTokens, aPos, nType );
195 : else
196 11 : pNew = new ScRangeData( &rDoc, aInsName, aContent, aPos, nType, eGrammar );
197 :
198 11 : pNew->SetIndex( pOld->GetIndex() );
199 :
200 11 : pNewRanges->erase(*pOld);
201 11 : if (pNewRanges->insert(pNew))
202 : {
203 11 : pDocShell->GetDocFunc().SetNewRangeNames(pNewRanges, mxParent->IsModifyAndBroadcast(), nTab);
204 :
205 11 : aName = aInsName; //! broadcast?
206 : }
207 : else
208 : {
209 0 : pNew = NULL; //! uno::Exception/Error or something
210 0 : delete pNewRanges;
211 11 : }
212 : }
213 :
214 14 : OUString SAL_CALL ScNamedRangeObj::getName() throw(uno::RuntimeException, std::exception)
215 : {
216 14 : SolarMutexGuard aGuard;
217 14 : return aName;
218 : }
219 :
220 2 : void SAL_CALL ScNamedRangeObj::setName( const OUString& aNewName )
221 : throw (uno::RuntimeException, std::exception)
222 : {
223 2 : SolarMutexGuard aGuard;
224 : //! adapt formulas ?????
225 :
226 4 : OUString aNewStr(aNewName);
227 : // GRAM_PODF_A1 for API compatibility.
228 2 : Modify_Impl( &aNewStr, NULL, NULL, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
229 :
230 2 : if ( aName != aNewStr ) // some error occurred...
231 2 : throw uno::RuntimeException(); // no other exceptions specified
232 2 : }
233 :
234 27 : OUString SAL_CALL ScNamedRangeObj::getContent() throw(uno::RuntimeException, std::exception)
235 : {
236 27 : SolarMutexGuard aGuard;
237 27 : OUString aContent;
238 27 : ScRangeData* pData = GetRangeData_Impl();
239 27 : if (pData)
240 : // GRAM_PODF_A1 for API compatibility.
241 27 : pData->GetSymbol( aContent,formula::FormulaGrammar::GRAM_PODF_A1);
242 27 : return aContent;
243 : }
244 :
245 3 : void SAL_CALL ScNamedRangeObj::setContent( const OUString& aContent )
246 : throw (uno::RuntimeException, std::exception)
247 : {
248 3 : SolarMutexGuard aGuard;
249 6 : OUString aContStr(aContent);
250 : // GRAM_PODF_A1 for API compatibility.
251 6 : Modify_Impl( NULL, NULL, &aContStr, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
252 3 : }
253 :
254 2 : table::CellAddress SAL_CALL ScNamedRangeObj::getReferencePosition()
255 : throw(uno::RuntimeException, std::exception)
256 : {
257 2 : SolarMutexGuard aGuard;
258 2 : ScAddress aPos;
259 2 : ScRangeData* pData = GetRangeData_Impl();
260 2 : if (pData)
261 2 : aPos = pData->GetPos();
262 2 : table::CellAddress aAddress;
263 2 : aAddress.Column = aPos.Col();
264 2 : aAddress.Row = aPos.Row();
265 2 : aAddress.Sheet = aPos.Tab();
266 2 : if (pDocShell)
267 : {
268 2 : SCTAB nDocTabs = pDocShell->GetDocument().GetTableCount();
269 2 : if ( aAddress.Sheet >= nDocTabs && nDocTabs > 0 )
270 : {
271 : // Even after ValidateTabRefs, the position can be invalid if
272 : // the content points to preceding tables. The resulting string
273 : // is invalid in any case, so the position is just shifted.
274 0 : aAddress.Sheet = nDocTabs - 1;
275 : }
276 : }
277 2 : return aAddress;
278 : }
279 :
280 1 : void SAL_CALL ScNamedRangeObj::setReferencePosition( const table::CellAddress& aReferencePosition )
281 : throw (uno::RuntimeException, std::exception)
282 : {
283 1 : SolarMutexGuard aGuard;
284 1 : ScAddress aPos( (SCCOL)aReferencePosition.Column, (SCROW)aReferencePosition.Row, aReferencePosition.Sheet );
285 : // GRAM_PODF_A1 for API compatibility.
286 1 : Modify_Impl( NULL, NULL, NULL, &aPos, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
287 1 : }
288 :
289 6 : sal_Int32 SAL_CALL ScNamedRangeObj::getType() throw(uno::RuntimeException, std::exception)
290 : {
291 6 : SolarMutexGuard aGuard;
292 6 : sal_Int32 nType=0;
293 6 : ScRangeData* pData = GetRangeData_Impl();
294 6 : if (pData)
295 : {
296 : // do not return internal RT_* flags
297 : // see property 'IsSharedFormula' for RT_SHARED
298 6 : if ( pData->HasType(RT_CRITERIA) ) nType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
299 6 : if ( pData->HasType(RT_PRINTAREA) ) nType |= sheet::NamedRangeFlag::PRINT_AREA;
300 6 : if ( pData->HasType(RT_COLHEADER) ) nType |= sheet::NamedRangeFlag::COLUMN_HEADER;
301 6 : if ( pData->HasType(RT_ROWHEADER) ) nType |= sheet::NamedRangeFlag::ROW_HEADER;
302 : }
303 6 : return nType;
304 : }
305 :
306 5 : void SAL_CALL ScNamedRangeObj::setType( sal_Int32 nUnoType )
307 : throw (uno::RuntimeException, std::exception)
308 : {
309 : // see property 'IsSharedFormula' for RT_SHARED
310 5 : SolarMutexGuard aGuard;
311 5 : sal_uInt16 nNewType = RT_NAME;
312 5 : if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= RT_CRITERIA;
313 5 : if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= RT_PRINTAREA;
314 5 : if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= RT_COLHEADER;
315 5 : if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= RT_ROWHEADER;
316 :
317 : // GRAM_PODF_A1 for API compatibility.
318 5 : Modify_Impl( NULL, NULL, NULL, NULL, &nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
319 5 : }
320 :
321 : // XFormulaTokens
322 :
323 0 : uno::Sequence<sheet::FormulaToken> SAL_CALL ScNamedRangeObj::getTokens()
324 : throw (uno::RuntimeException, std::exception)
325 : {
326 0 : SolarMutexGuard aGuard;
327 0 : uno::Sequence<sheet::FormulaToken> aSequence;
328 0 : ScRangeData* pData = GetRangeData_Impl();
329 0 : if (pData && pDocShell)
330 : {
331 0 : ScTokenArray* pTokenArray = pData->GetCode();
332 0 : if ( pTokenArray )
333 0 : (void)ScTokenConversion::ConvertToTokenSequence( pDocShell->GetDocument(), aSequence, *pTokenArray );
334 : }
335 0 : return aSequence;
336 : }
337 :
338 0 : void SAL_CALL ScNamedRangeObj::setTokens( const uno::Sequence<sheet::FormulaToken>& rTokens )
339 : throw (uno::RuntimeException, std::exception)
340 : {
341 0 : SolarMutexGuard aGuard;
342 0 : if( pDocShell )
343 : {
344 0 : ScTokenArray aTokenArray;
345 0 : (void)ScTokenConversion::ConvertToTokenArray( pDocShell->GetDocument(), aTokenArray, rTokens );
346 : // GRAM_PODF_A1 for API compatibility.
347 0 : Modify_Impl( NULL, &aTokenArray, NULL, NULL, NULL, formula::FormulaGrammar::GRAM_PODF_A1 );
348 0 : }
349 0 : }
350 :
351 : // XCellRangeSource
352 :
353 119 : uno::Reference<table::XCellRange> SAL_CALL ScNamedRangeObj::getReferredCells()
354 : throw(uno::RuntimeException, std::exception)
355 : {
356 119 : SolarMutexGuard aGuard;
357 119 : ScRange aRange;
358 119 : ScRangeData* pData = GetRangeData_Impl();
359 119 : if ( pData && pData->IsValidReference( aRange ) )
360 : {
361 : //! static function to create ScCellObj/ScCellRangeObj at ScCellRangeObj ???
362 :
363 113 : if ( aRange.aStart == aRange.aEnd )
364 107 : return new ScCellObj( pDocShell, aRange.aStart );
365 : else
366 6 : return new ScCellRangeObj( pDocShell, aRange );
367 : }
368 6 : return NULL;
369 : }
370 :
371 : // beans::XPropertySet
372 :
373 0 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScNamedRangeObj::getPropertySetInfo()
374 : throw(uno::RuntimeException, std::exception)
375 : {
376 0 : SolarMutexGuard aGuard;
377 0 : static uno::Reference< beans::XPropertySetInfo > aRef(new SfxItemPropertySetInfo( lcl_GetNamedRangeMap() ));
378 0 : return aRef;
379 : }
380 :
381 0 : void SAL_CALL ScNamedRangeObj::setPropertyValue(
382 : const OUString& rPropertyName, const uno::Any& /*aValue*/ )
383 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
384 : lang::IllegalArgumentException, lang::WrappedTargetException,
385 : uno::RuntimeException, std::exception)
386 : {
387 0 : SolarMutexGuard aGuard;
388 0 : if ( rPropertyName == SC_UNONAME_ISSHAREDFMLA )
389 : {
390 : // Ignore this.
391 0 : }
392 0 : }
393 :
394 0 : uno::Any SAL_CALL ScNamedRangeObj::getPropertyValue( const OUString& rPropertyName )
395 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
396 : uno::RuntimeException, std::exception)
397 : {
398 0 : SolarMutexGuard aGuard;
399 0 : uno::Any aRet;
400 0 : if ( rPropertyName == SC_UNO_LINKDISPBIT )
401 : {
402 : // no target bitmaps for individual entries (would be all equal)
403 : // ScLinkTargetTypeObj::SetLinkTargetBitmap( aRet, SC_LINKTARGETTYPE_RANGENAME );
404 : }
405 0 : else if ( rPropertyName == SC_UNO_LINKDISPNAME )
406 0 : aRet <<= OUString( aName );
407 0 : else if ( rPropertyName == SC_UNONAME_TOKENINDEX )
408 : {
409 : // get index for use in formula tokens (read-only)
410 0 : ScRangeData* pData = GetRangeData_Impl();
411 0 : if (pData)
412 0 : aRet <<= static_cast<sal_Int32>(pData->GetIndex());
413 : }
414 0 : else if ( rPropertyName == SC_UNONAME_ISSHAREDFMLA )
415 : {
416 0 : if (GetRangeData_Impl())
417 0 : aRet <<= false;
418 : }
419 0 : return aRet;
420 : }
421 :
422 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScNamedRangeObj )
423 :
424 : // lang::XServiceInfo
425 :
426 0 : OUString SAL_CALL ScNamedRangeObj::getImplementationName() throw(uno::RuntimeException, std::exception)
427 : {
428 0 : return OUString( "ScNamedRangeObj" );
429 : }
430 :
431 0 : sal_Bool SAL_CALL ScNamedRangeObj::supportsService( const OUString& rServiceName )
432 : throw(uno::RuntimeException, std::exception)
433 : {
434 0 : return cppu::supportsService(this, rServiceName);
435 : }
436 :
437 0 : uno::Sequence<OUString> SAL_CALL ScNamedRangeObj::getSupportedServiceNames()
438 : throw(uno::RuntimeException, std::exception)
439 : {
440 0 : uno::Sequence<OUString> aRet(2);
441 0 : aRet[0] = SCNAMEDRANGEOBJ_SERVICE;
442 0 : aRet[1] = SCLINKTARGET_SERVICE;
443 0 : return aRet;
444 : }
445 :
446 : // XUnoTunnel
447 :
448 0 : sal_Int64 SAL_CALL ScNamedRangeObj::getSomething(
449 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
450 : {
451 0 : if ( rId.getLength() == 16 &&
452 0 : 0 == memcmp( getUnoTunnelId().getConstArray(),
453 0 : rId.getConstArray(), 16 ) )
454 : {
455 0 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
456 : }
457 0 : return 0;
458 : }
459 :
460 : namespace
461 : {
462 : class theScNamedRangeObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScNamedRangeObjUnoTunnelId> {};
463 : }
464 :
465 0 : const uno::Sequence<sal_Int8>& ScNamedRangeObj::getUnoTunnelId()
466 : {
467 0 : return theScNamedRangeObjUnoTunnelId::get().getSeq();
468 : }
469 :
470 1561 : ScNamedRangesObj::ScNamedRangesObj(ScDocShell* pDocSh) :
471 : mbModifyAndBroadcast(true),
472 1561 : pDocShell( pDocSh )
473 : {
474 1561 : pDocShell->GetDocument().AddUnoObject(*this);
475 1561 : }
476 :
477 3122 : ScNamedRangesObj::~ScNamedRangesObj()
478 : {
479 1561 : SolarMutexGuard g;
480 :
481 1561 : if (pDocShell)
482 1554 : pDocShell->GetDocument().RemoveUnoObject(*this);
483 1561 : }
484 :
485 215 : void ScNamedRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
486 : {
487 : // reference update is of no interest
488 :
489 215 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
490 215 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
491 : {
492 7 : pDocShell = NULL; // became invalid
493 : }
494 215 : }
495 :
496 : // sheet::XNamedRanges
497 :
498 13 : void SAL_CALL ScNamedRangesObj::addNewByName( const OUString& aName,
499 : const OUString& aContent, const table::CellAddress& aPosition,
500 : sal_Int32 nUnoType )
501 : throw (uno::RuntimeException, std::exception)
502 : {
503 13 : SolarMutexGuard aGuard;
504 13 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, aPosition.Sheet );
505 :
506 13 : sal_uInt16 nNewType = RT_NAME;
507 13 : if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= RT_CRITERIA;
508 13 : if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= RT_PRINTAREA;
509 13 : if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= RT_COLHEADER;
510 13 : if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= RT_ROWHEADER;
511 :
512 13 : bool bDone = false;
513 13 : if (pDocShell)
514 : {
515 13 : ScDocument& rDoc = pDocShell->GetDocument();
516 13 : ScRangeName* pNames = GetRangeName_Impl();
517 13 : if (pNames && !pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName)))
518 : {
519 13 : ScRangeName* pNewRanges = new ScRangeName( *pNames );
520 : // GRAM_PODF_A1 for API compatibility.
521 : ScRangeData* pNew = new ScRangeData( &rDoc, aName, aContent,
522 13 : aPos, nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
523 13 : if ( pNewRanges->insert(pNew) )
524 : {
525 13 : pDocShell->GetDocFunc().SetNewRangeNames(pNewRanges, mbModifyAndBroadcast, GetTab_Impl());
526 13 : bDone = true;
527 : }
528 : else
529 : {
530 0 : pNew = NULL;
531 0 : delete pNewRanges;
532 : }
533 : }
534 : }
535 :
536 13 : if (!bDone)
537 0 : throw uno::RuntimeException(); // no other exceptions specified
538 13 : }
539 :
540 2 : void SAL_CALL ScNamedRangesObj::addNewFromTitles( const table::CellRangeAddress& aSource,
541 : sheet::Border aBorder ) throw(uno::RuntimeException, std::exception)
542 : {
543 2 : SolarMutexGuard aGuard;
544 : //! this cannot be an enum, because multiple bits can be set !!!
545 :
546 2 : bool bTop = ( aBorder == sheet::Border_TOP );
547 2 : bool bLeft = ( aBorder == sheet::Border_LEFT );
548 2 : bool bBottom = ( aBorder == sheet::Border_BOTTOM );
549 2 : bool bRight = ( aBorder == sheet::Border_RIGHT );
550 :
551 2 : ScRange aRange;
552 2 : ScUnoConversion::FillScRange( aRange, aSource );
553 :
554 2 : sal_uInt16 nFlags = 0;
555 2 : if (bTop) nFlags |= NAME_TOP;
556 2 : if (bLeft) nFlags |= NAME_LEFT;
557 2 : if (bBottom) nFlags |= NAME_BOTTOM;
558 2 : if (bRight) nFlags |= NAME_RIGHT;
559 :
560 2 : if (nFlags)
561 2 : pDocShell->GetDocFunc().CreateNames( aRange, nFlags, true, GetTab_Impl() );
562 2 : }
563 :
564 5 : void SAL_CALL ScNamedRangesObj::removeByName( const OUString& aName )
565 : throw(uno::RuntimeException, std::exception)
566 : {
567 5 : SolarMutexGuard aGuard;
568 5 : bool bDone = false;
569 5 : if (pDocShell)
570 : {
571 5 : ScRangeName* pNames = GetRangeName_Impl();
572 5 : if (pNames)
573 : {
574 5 : const ScRangeData* pData = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
575 5 : if (pData && lcl_UserVisibleName(*pData))
576 : {
577 5 : ScRangeName* pNewRanges = new ScRangeName(*pNames);
578 5 : pNewRanges->erase(*pData);
579 5 : pDocShell->GetDocFunc().SetNewRangeNames( pNewRanges, mbModifyAndBroadcast, GetTab_Impl());
580 5 : bDone = true;
581 : }
582 : }
583 : }
584 :
585 5 : if (!bDone)
586 0 : throw uno::RuntimeException(); // no other exceptions specified
587 5 : }
588 :
589 4 : void SAL_CALL ScNamedRangesObj::outputList( const table::CellAddress& aOutputPosition )
590 : throw(uno::RuntimeException, std::exception)
591 : {
592 4 : SolarMutexGuard aGuard;
593 4 : ScAddress aPos( (SCCOL)aOutputPosition.Column, (SCROW)aOutputPosition.Row, aOutputPosition.Sheet );
594 4 : if (pDocShell)
595 4 : pDocShell->GetDocFunc().InsertNameList( aPos, true );
596 4 : }
597 :
598 : // container::XEnumerationAccess
599 :
600 2 : uno::Reference<container::XEnumeration> SAL_CALL ScNamedRangesObj::createEnumeration()
601 : throw(uno::RuntimeException, std::exception)
602 : {
603 2 : SolarMutexGuard aGuard;
604 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.NamedRangesEnumeration"));
605 : }
606 :
607 : // container::XIndexAccess
608 :
609 16 : sal_Int32 SAL_CALL ScNamedRangesObj::getCount() throw(uno::RuntimeException, std::exception)
610 : {
611 16 : SolarMutexGuard aGuard;
612 16 : long nRet = 0;
613 16 : if (pDocShell)
614 : {
615 16 : ScRangeName* pNames = GetRangeName_Impl();
616 16 : if (pNames)
617 : {
618 16 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
619 48 : for (; itr != itrEnd; ++itr)
620 32 : if (lcl_UserVisibleName(*itr->second))
621 32 : ++nRet;
622 : }
623 : }
624 16 : return nRet;
625 : }
626 :
627 12 : uno::Any SAL_CALL ScNamedRangesObj::getByIndex( sal_Int32 nIndex )
628 : throw(lang::IndexOutOfBoundsException,
629 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
630 : {
631 12 : SolarMutexGuard aGuard;
632 24 : uno::Reference< sheet::XNamedRange > xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
633 12 : if ( xRange.is() )
634 20 : return uno::makeAny(xRange);
635 : else
636 14 : throw lang::IndexOutOfBoundsException();
637 : }
638 :
639 1 : uno::Type SAL_CALL ScNamedRangesObj::getElementType() throw(uno::RuntimeException, std::exception)
640 : {
641 1 : SolarMutexGuard aGuard;
642 1 : return cppu::UnoType<sheet::XNamedRange>::get(); // must be suitable for getByIndex
643 : }
644 :
645 1 : sal_Bool SAL_CALL ScNamedRangesObj::hasElements() throw(uno::RuntimeException, std::exception)
646 : {
647 1 : SolarMutexGuard aGuard;
648 1 : return ( getCount() != 0 );
649 : }
650 :
651 0 : Reference<beans::XPropertySetInfo> SAL_CALL ScNamedRangesObj::getPropertySetInfo()
652 : throw(uno::RuntimeException, std::exception)
653 : {
654 : static Reference<beans::XPropertySetInfo> aRef(
655 0 : new SfxItemPropertySetInfo(lcl_GetNamedRangesMap()));
656 0 : return aRef;
657 : }
658 :
659 0 : void SAL_CALL ScNamedRangesObj::setPropertyValue(
660 : const OUString& rPropertyName, const uno::Any& aValue )
661 : throw(beans::UnknownPropertyException, beans::PropertyVetoException,
662 : lang::IllegalArgumentException, lang::WrappedTargetException,
663 : uno::RuntimeException, std::exception)
664 : {
665 0 : if ( rPropertyName == SC_UNO_MODIFY_BROADCAST )
666 : {
667 0 : aValue >>= mbModifyAndBroadcast;
668 : }
669 0 : }
670 :
671 0 : Any SAL_CALL ScNamedRangesObj::getPropertyValue( const OUString& rPropertyName )
672 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
673 : uno::RuntimeException, std::exception)
674 : {
675 0 : Any aRet;
676 0 : if ( rPropertyName == SC_UNO_MODIFY_BROADCAST )
677 : {
678 0 : aRet <<= mbModifyAndBroadcast;
679 : }
680 :
681 0 : return aRet;
682 : }
683 :
684 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScNamedRangesObj )
685 :
686 717 : uno::Any SAL_CALL ScNamedRangesObj::getByName( const OUString& aName )
687 : throw(container::NoSuchElementException,
688 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
689 : {
690 717 : SolarMutexGuard aGuard;
691 1434 : uno::Reference< sheet::XNamedRange > xRange(GetObjectByName_Impl(aName));
692 717 : if ( xRange.is() )
693 316 : return uno::makeAny(xRange);
694 : else
695 1276 : throw container::NoSuchElementException();
696 : }
697 :
698 1 : uno::Sequence<OUString> SAL_CALL ScNamedRangesObj::getElementNames()
699 : throw(uno::RuntimeException, std::exception)
700 : {
701 1 : SolarMutexGuard aGuard;
702 1 : if (pDocShell)
703 : {
704 1 : ScRangeName* pNames = GetRangeName_Impl();
705 1 : if (pNames)
706 : {
707 1 : long nVisCount = getCount(); // names with lcl_UserVisibleName
708 1 : uno::Sequence<OUString> aSeq(nVisCount);
709 1 : OUString* pAry = aSeq.getArray();
710 1 : sal_uInt16 nVisPos = 0;
711 1 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
712 2 : for (; itr != itrEnd; ++itr)
713 : {
714 1 : if (lcl_UserVisibleName(*itr->second))
715 1 : pAry[nVisPos++] = itr->second->GetName();
716 : }
717 1 : return aSeq;
718 : }
719 : }
720 0 : return uno::Sequence<OUString>(0);
721 : }
722 :
723 2520 : sal_Bool SAL_CALL ScNamedRangesObj::hasByName( const OUString& aName )
724 : throw(uno::RuntimeException, std::exception)
725 : {
726 2520 : SolarMutexGuard aGuard;
727 2520 : if (pDocShell)
728 : {
729 2520 : ScRangeName* pNames = GetRangeName_Impl();
730 2520 : if (pNames)
731 : {
732 2520 : const ScRangeData* pData = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
733 2520 : if (pData && lcl_UserVisibleName(*pData))
734 226 : return sal_True;
735 : }
736 : }
737 2294 : return false;
738 : }
739 :
740 : /** called from the XActionLockable interface methods on initial locking */
741 0 : void ScNamedRangesObj::lock()
742 : {
743 0 : pDocShell->GetDocument().PreprocessRangeNameUpdate();
744 0 : }
745 :
746 : /** called from the XActionLockable interface methods on final unlock */
747 0 : void ScNamedRangesObj::unlock()
748 : {
749 0 : pDocShell->GetDocument().CompileHybridFormula();
750 0 : }
751 :
752 : // document::XActionLockable
753 :
754 0 : sal_Bool ScNamedRangesObj::isActionLocked() throw(uno::RuntimeException, std::exception)
755 : {
756 0 : SolarMutexGuard aGuard;
757 0 : return pDocShell->GetDocument().GetNamedRangesLockCount() != 0;
758 : }
759 :
760 0 : void ScNamedRangesObj::addActionLock() throw(uno::RuntimeException, std::exception)
761 : {
762 0 : SolarMutexGuard aGuard;
763 0 : ScDocument& rDoc = pDocShell->GetDocument();
764 0 : sal_Int16 nLockCount = rDoc.GetNamedRangesLockCount();
765 0 : ++nLockCount;
766 0 : if ( nLockCount == 1 )
767 : {
768 0 : lock();
769 : }
770 0 : rDoc.SetNamedRangesLockCount( nLockCount );
771 0 : }
772 :
773 0 : void ScNamedRangesObj::removeActionLock() throw(uno::RuntimeException, std::exception)
774 : {
775 0 : SolarMutexGuard aGuard;
776 0 : ScDocument& rDoc = pDocShell->GetDocument();
777 0 : sal_Int16 nLockCount = rDoc.GetNamedRangesLockCount();
778 0 : if ( nLockCount > 0 )
779 : {
780 0 : --nLockCount;
781 0 : if ( nLockCount == 0 )
782 : {
783 0 : unlock();
784 : }
785 0 : rDoc.SetNamedRangesLockCount( nLockCount );
786 0 : }
787 0 : }
788 :
789 0 : void ScNamedRangesObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException, std::exception)
790 : {
791 0 : SolarMutexGuard aGuard;
792 0 : if ( nLock >= 0 )
793 : {
794 0 : ScDocument& rDoc = pDocShell->GetDocument();
795 0 : sal_Int16 nLockCount = rDoc.GetNamedRangesLockCount();
796 0 : if ( nLock == 0 && nLockCount > 0 )
797 : {
798 0 : unlock();
799 : }
800 0 : if ( nLock > 0 && nLockCount == 0 )
801 : {
802 0 : lock();
803 : }
804 0 : rDoc.SetNamedRangesLockCount( nLock );
805 0 : }
806 0 : }
807 :
808 0 : sal_Int16 ScNamedRangesObj::resetActionLocks() throw(uno::RuntimeException, std::exception)
809 : {
810 0 : SolarMutexGuard aGuard;
811 0 : ScDocument& rDoc = pDocShell->GetDocument();
812 0 : sal_Int16 nLockCount = rDoc.GetNamedRangesLockCount();
813 0 : if ( nLockCount > 0 )
814 : {
815 0 : unlock();
816 : }
817 0 : rDoc.SetNamedRangesLockCount( 0 );
818 0 : return nLockCount;
819 : }
820 :
821 1561 : ScGlobalNamedRangesObj::ScGlobalNamedRangesObj(ScDocShell* pDocSh)
822 1561 : : ScNamedRangesObj(pDocSh)
823 : {
824 :
825 1561 : }
826 :
827 3122 : ScGlobalNamedRangesObj::~ScGlobalNamedRangesObj()
828 : {
829 :
830 3122 : }
831 :
832 12 : ScNamedRangeObj* ScGlobalNamedRangesObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
833 : {
834 12 : if (!pDocShell)
835 0 : return NULL;
836 :
837 12 : ScRangeName* pNames = pDocShell->GetDocument().GetRangeName();
838 12 : if (!pNames)
839 0 : return NULL;
840 :
841 12 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
842 12 : sal_uInt16 nPos = 0;
843 14 : for (; itr != itrEnd; ++itr)
844 : {
845 12 : if (lcl_UserVisibleName(*itr->second))
846 : {
847 12 : if (nPos == nIndex)
848 10 : return new ScNamedRangeObj(this, pDocShell, itr->second->GetName());
849 : }
850 2 : ++nPos;
851 : }
852 2 : return NULL;
853 : }
854 :
855 717 : ScNamedRangeObj* ScGlobalNamedRangesObj::GetObjectByName_Impl(const OUString& aName)
856 : {
857 717 : if ( pDocShell && hasByName(aName) )
858 158 : return new ScNamedRangeObj(this, pDocShell, aName);
859 559 : return NULL;
860 : }
861 :
862 2555 : ScRangeName* ScGlobalNamedRangesObj::GetRangeName_Impl()
863 : {
864 2555 : return pDocShell->GetDocument().GetRangeName();
865 : }
866 :
867 20 : SCTAB ScGlobalNamedRangesObj::GetTab_Impl()
868 : {
869 20 : return -1;
870 : }
871 :
872 0 : ScLocalNamedRangesObj::ScLocalNamedRangesObj( ScDocShell* pDocSh, uno::Reference<container::XNamed> xSheet )
873 : : ScNamedRangesObj(pDocSh),
874 0 : mxSheet(xSheet)
875 : {
876 :
877 0 : }
878 :
879 0 : ScLocalNamedRangesObj::~ScLocalNamedRangesObj()
880 : {
881 :
882 0 : }
883 :
884 0 : ScNamedRangeObj* ScLocalNamedRangesObj::GetObjectByName_Impl(const OUString& aName)
885 : {
886 0 : if ( pDocShell && hasByName( aName ) )
887 0 : return new ScNamedRangeObj( this, pDocShell, aName, mxSheet);
888 0 : return NULL;
889 :
890 : }
891 :
892 0 : ScNamedRangeObj* ScLocalNamedRangesObj::GetObjectByIndex_Impl( sal_uInt16 nIndex )
893 : {
894 0 : if (!pDocShell)
895 0 : return NULL;
896 :
897 0 : OUString aName = mxSheet->getName();
898 0 : ScDocument& rDoc = pDocShell->GetDocument();
899 : SCTAB nTab;
900 0 : if (!rDoc.GetTable(aName, nTab))
901 0 : return NULL;
902 :
903 0 : ScRangeName* pNames = rDoc.GetRangeName( nTab );
904 0 : if (!pNames)
905 0 : return NULL;
906 :
907 0 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
908 0 : sal_uInt16 nPos = 0;
909 0 : for (; itr != itrEnd; ++itr)
910 : {
911 0 : if (lcl_UserVisibleName(*itr->second))
912 : {
913 0 : if (nPos == nIndex)
914 0 : return new ScNamedRangeObj(this, pDocShell, itr->second->GetName(), mxSheet);
915 : }
916 0 : ++nPos;
917 : }
918 0 : return NULL;
919 : }
920 :
921 0 : ScRangeName* ScLocalNamedRangesObj::GetRangeName_Impl()
922 : {
923 0 : SCTAB nTab = GetTab_Impl();
924 0 : return pDocShell->GetDocument().GetRangeName( nTab );
925 : }
926 :
927 0 : SCTAB ScLocalNamedRangesObj::GetTab_Impl()
928 : {
929 : SCTAB nTab;
930 0 : (void)pDocShell->GetDocument().GetTable(mxSheet->getName(), nTab);
931 0 : return nTab;
932 : }
933 :
934 5 : ScLabelRangeObj::ScLabelRangeObj(ScDocShell* pDocSh, bool bCol, const ScRange& rR) :
935 : pDocShell( pDocSh ),
936 : bColumn( bCol ),
937 5 : aRange( rR )
938 : {
939 5 : pDocShell->GetDocument().AddUnoObject(*this);
940 5 : }
941 :
942 15 : ScLabelRangeObj::~ScLabelRangeObj()
943 : {
944 5 : SolarMutexGuard g;
945 :
946 5 : if (pDocShell)
947 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
948 10 : }
949 :
950 13 : void ScLabelRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
951 : {
952 : //! Ref-Update !!!
953 :
954 13 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
955 13 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
956 5 : pDocShell = NULL; // became invalid
957 13 : }
958 :
959 : // Helper functions
960 :
961 2 : ScRangePair* ScLabelRangeObj::GetData_Impl()
962 : {
963 2 : ScRangePair* pRet = NULL;
964 2 : if (pDocShell)
965 : {
966 2 : ScDocument& rDoc = pDocShell->GetDocument();
967 2 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
968 2 : if (pList)
969 2 : pRet = pList->Find( aRange );
970 : }
971 2 : return pRet;
972 : }
973 :
974 2 : void ScLabelRangeObj::Modify_Impl( const ScRange* pLabel, const ScRange* pData )
975 : {
976 2 : if (pDocShell)
977 : {
978 2 : ScDocument& rDoc = pDocShell->GetDocument();
979 2 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
980 2 : if (pOldList)
981 : {
982 2 : ScRangePairListRef xNewList(pOldList->Clone());
983 2 : ScRangePair* pEntry = xNewList->Find( aRange );
984 2 : if (pEntry)
985 : {
986 2 : xNewList->Remove( pEntry ); // only removed from list, not deleted
987 :
988 2 : if ( pLabel )
989 1 : pEntry->GetRange(0) = *pLabel;
990 2 : if ( pData )
991 1 : pEntry->GetRange(1) = *pData;
992 :
993 2 : xNewList->Join( *pEntry );
994 2 : delete pEntry;
995 :
996 2 : if (bColumn)
997 2 : rDoc.GetColNameRangesRef() = xNewList;
998 : else
999 0 : rDoc.GetRowNameRangesRef() = xNewList;
1000 :
1001 2 : rDoc.CompileColRowNameFormula();
1002 2 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1003 2 : pDocShell->SetDocumentModified();
1004 :
1005 : //! Undo ?!?! (here and from dialog)
1006 :
1007 2 : if ( pLabel )
1008 1 : aRange = *pLabel; // adapt object to find range again
1009 2 : }
1010 : }
1011 : }
1012 2 : }
1013 :
1014 : // sheet::XLabelRange
1015 :
1016 1 : table::CellRangeAddress SAL_CALL ScLabelRangeObj::getLabelArea()
1017 : throw(uno::RuntimeException, std::exception)
1018 : {
1019 1 : SolarMutexGuard aGuard;
1020 1 : table::CellRangeAddress aRet;
1021 1 : ScRangePair* pData = GetData_Impl();
1022 1 : if (pData)
1023 1 : ScUnoConversion::FillApiRange( aRet, pData->GetRange(0) );
1024 1 : return aRet;
1025 : }
1026 :
1027 1 : void SAL_CALL ScLabelRangeObj::setLabelArea( const table::CellRangeAddress& aLabelArea )
1028 : throw(uno::RuntimeException, std::exception)
1029 : {
1030 1 : SolarMutexGuard aGuard;
1031 1 : ScRange aLabelRange;
1032 1 : ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
1033 1 : Modify_Impl( &aLabelRange, NULL );
1034 1 : }
1035 :
1036 1 : table::CellRangeAddress SAL_CALL ScLabelRangeObj::getDataArea()
1037 : throw(uno::RuntimeException, std::exception)
1038 : {
1039 1 : SolarMutexGuard aGuard;
1040 1 : table::CellRangeAddress aRet;
1041 1 : ScRangePair* pData = GetData_Impl();
1042 1 : if (pData)
1043 1 : ScUnoConversion::FillApiRange( aRet, pData->GetRange(1) );
1044 1 : return aRet;
1045 : }
1046 :
1047 1 : void SAL_CALL ScLabelRangeObj::setDataArea( const table::CellRangeAddress& aDataArea )
1048 : throw(uno::RuntimeException, std::exception)
1049 : {
1050 1 : SolarMutexGuard aGuard;
1051 1 : ScRange aDataRange;
1052 1 : ScUnoConversion::FillScRange( aDataRange, aDataArea );
1053 1 : Modify_Impl( NULL, &aDataRange );
1054 1 : }
1055 :
1056 69 : ScLabelRangesObj::ScLabelRangesObj(ScDocShell* pDocSh, bool bCol) :
1057 : pDocShell( pDocSh ),
1058 69 : bColumn( bCol )
1059 : {
1060 69 : pDocShell->GetDocument().AddUnoObject(*this);
1061 69 : }
1062 :
1063 207 : ScLabelRangesObj::~ScLabelRangesObj()
1064 : {
1065 69 : SolarMutexGuard g;
1066 :
1067 69 : if (pDocShell)
1068 58 : pDocShell->GetDocument().RemoveUnoObject(*this);
1069 138 : }
1070 :
1071 306 : void ScLabelRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
1072 : {
1073 : // reference update is of no interest
1074 :
1075 306 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
1076 306 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
1077 : {
1078 11 : pDocShell = NULL; // became invalid
1079 : }
1080 306 : }
1081 :
1082 : // sheet::XLabelRanges
1083 :
1084 7 : ScLabelRangeObj* ScLabelRangesObj::GetObjectByIndex_Impl(size_t nIndex)
1085 : {
1086 7 : if (pDocShell)
1087 : {
1088 7 : ScDocument& rDoc = pDocShell->GetDocument();
1089 7 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1090 7 : if ( pList && nIndex < pList->size() )
1091 : {
1092 5 : ScRangePair* pData = (*pList)[nIndex];
1093 5 : if (pData)
1094 5 : return new ScLabelRangeObj( pDocShell, bColumn, pData->GetRange(0) );
1095 : }
1096 : }
1097 2 : return NULL;
1098 : }
1099 :
1100 4 : void SAL_CALL ScLabelRangesObj::addNew( const table::CellRangeAddress& aLabelArea,
1101 : const table::CellRangeAddress& aDataArea )
1102 : throw(uno::RuntimeException, std::exception)
1103 : {
1104 4 : SolarMutexGuard aGuard;
1105 4 : if (pDocShell)
1106 : {
1107 4 : ScDocument& rDoc = pDocShell->GetDocument();
1108 4 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1109 4 : if (pOldList)
1110 : {
1111 4 : ScRangePairListRef xNewList(pOldList->Clone());
1112 :
1113 4 : ScRange aLabelRange;
1114 4 : ScRange aDataRange;
1115 4 : ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
1116 4 : ScUnoConversion::FillScRange( aDataRange, aDataArea );
1117 4 : xNewList->Join( ScRangePair( aLabelRange, aDataRange ) );
1118 :
1119 4 : if (bColumn)
1120 4 : rDoc.GetColNameRangesRef() = xNewList;
1121 : else
1122 0 : rDoc.GetRowNameRangesRef() = xNewList;
1123 :
1124 4 : rDoc.CompileColRowNameFormula();
1125 4 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1126 4 : pDocShell->SetDocumentModified();
1127 :
1128 : //! Undo ?!?! (here and from dialog)
1129 : }
1130 4 : }
1131 4 : }
1132 :
1133 2 : void SAL_CALL ScLabelRangesObj::removeByIndex( sal_Int32 nIndex )
1134 : throw(uno::RuntimeException, std::exception)
1135 : {
1136 2 : SolarMutexGuard aGuard;
1137 2 : bool bDone = false;
1138 2 : if (pDocShell)
1139 : {
1140 2 : ScDocument& rDoc = pDocShell->GetDocument();
1141 2 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1142 :
1143 2 : if ( pOldList && nIndex >= 0 && nIndex < (sal_Int32)pOldList->size() )
1144 : {
1145 1 : ScRangePairListRef xNewList(pOldList->Clone());
1146 :
1147 1 : ScRangePair* pEntry = (*xNewList)[nIndex];
1148 1 : if (pEntry)
1149 : {
1150 1 : xNewList->Remove( pEntry );
1151 1 : delete pEntry;
1152 :
1153 1 : if (bColumn)
1154 1 : rDoc.GetColNameRangesRef() = xNewList;
1155 : else
1156 0 : rDoc.GetRowNameRangesRef() = xNewList;
1157 :
1158 1 : rDoc.CompileColRowNameFormula();
1159 1 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1160 1 : pDocShell->SetDocumentModified();
1161 1 : bDone = true;
1162 :
1163 : //! Undo ?!?! (here and from dialog)
1164 1 : }
1165 : }
1166 : }
1167 2 : if (!bDone)
1168 1 : throw uno::RuntimeException(); // no other exceptions specified
1169 1 : }
1170 :
1171 : // container::XEnumerationAccess
1172 :
1173 2 : uno::Reference<container::XEnumeration> SAL_CALL ScLabelRangesObj::createEnumeration()
1174 : throw(uno::RuntimeException, std::exception)
1175 : {
1176 2 : SolarMutexGuard aGuard;
1177 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.LabelRangesEnumeration"));
1178 : }
1179 :
1180 : // container::XIndexAccess
1181 :
1182 66 : sal_Int32 SAL_CALL ScLabelRangesObj::getCount() throw(uno::RuntimeException, std::exception)
1183 : {
1184 66 : SolarMutexGuard aGuard;
1185 66 : if (pDocShell)
1186 : {
1187 66 : ScDocument& rDoc = pDocShell->GetDocument();
1188 66 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1189 66 : if (pList)
1190 66 : return pList->size();
1191 : }
1192 0 : return 0;
1193 : }
1194 :
1195 7 : uno::Any SAL_CALL ScLabelRangesObj::getByIndex( sal_Int32 nIndex )
1196 : throw(lang::IndexOutOfBoundsException,
1197 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
1198 : {
1199 7 : SolarMutexGuard aGuard;
1200 14 : uno::Reference< sheet::XLabelRange > xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
1201 7 : if ( xRange.is() )
1202 10 : return uno::makeAny(xRange);
1203 : else
1204 9 : throw lang::IndexOutOfBoundsException();
1205 : }
1206 :
1207 1 : uno::Type SAL_CALL ScLabelRangesObj::getElementType() throw(uno::RuntimeException, std::exception)
1208 : {
1209 1 : SolarMutexGuard aGuard;
1210 1 : return cppu::UnoType<sheet::XLabelRange>::get(); // must be suitable for getByIndex
1211 :
1212 : }
1213 :
1214 1 : sal_Bool SAL_CALL ScLabelRangesObj::hasElements() throw(uno::RuntimeException, std::exception)
1215 : {
1216 1 : SolarMutexGuard aGuard;
1217 1 : return ( getCount() != 0 );
1218 156 : }
1219 :
1220 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
