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, getBooleanCppuType(), 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, getBooleanCppuType(), 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 552 : static bool lcl_UserVisibleName(const ScRangeData& rData)
78 : {
79 : //! as method to ScRangeData
80 :
81 552 : return !rData.HasType(RT_DATABASE);
82 : }
83 :
84 336 : 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 336 : mxSheet( xSheet )
89 : {
90 336 : pDocShell->GetDocument().AddUnoObject(*this);
91 336 : }
92 :
93 1008 : ScNamedRangeObj::~ScNamedRangeObj()
94 : {
95 336 : SolarMutexGuard g;
96 :
97 336 : if (pDocShell)
98 324 : pDocShell->GetDocument().RemoveUnoObject(*this);
99 672 : }
100 :
101 54 : void ScNamedRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
102 : {
103 : // reference update is of no interest
104 :
105 54 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
106 54 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
107 12 : pDocShell = NULL; // became invalid
108 54 : }
109 :
110 : // Helper functions
111 :
112 324 : ScRangeData* ScNamedRangeObj::GetRangeData_Impl()
113 : {
114 324 : ScRangeData* pRet = NULL;
115 324 : if (pDocShell)
116 : {
117 : ScRangeName* pNames;
118 324 : SCTAB nTab = GetTab_Impl();
119 324 : if (nTab >= 0)
120 0 : pNames = pDocShell->GetDocument().GetRangeName(nTab);
121 : else
122 324 : pNames = pDocShell->GetDocument().GetRangeName();
123 324 : if (pNames)
124 : {
125 324 : pRet = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
126 324 : if (pRet)
127 324 : pRet->ValidateTabRefs(); // adjust relative tab refs to valid tables
128 : }
129 : }
130 324 : return pRet;
131 : }
132 :
133 346 : SCTAB ScNamedRangeObj::GetTab_Impl()
134 : {
135 346 : 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 346 : return -1;//global range name
148 : }
149 :
150 : // sheet::XNamedRange
151 :
152 22 : 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 22 : if (!pDocShell)
157 0 : return;
158 :
159 22 : ScDocument& rDoc = pDocShell->GetDocument();
160 : ScRangeName* pNames;
161 22 : SCTAB nTab = GetTab_Impl();
162 22 : if (nTab >= 0)
163 0 : pNames = rDoc.GetRangeName(nTab);
164 : else
165 22 : pNames = rDoc.GetRangeName();
166 22 : if (!pNames)
167 0 : return;
168 :
169 22 : const ScRangeData* pOld = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
170 22 : if (!pOld)
171 0 : return;
172 :
173 22 : ScRangeName* pNewRanges = new ScRangeName(*pNames);
174 :
175 22 : OUString aInsName = pOld->GetName();
176 22 : if (pNewName)
177 4 : aInsName = *pNewName;
178 :
179 44 : OUString aContent; // Content string based =>
180 22 : pOld->GetSymbol( aContent, eGrammar); // no problems with changed positions and such.
181 22 : if (pNewContent)
182 6 : aContent = *pNewContent;
183 :
184 22 : ScAddress aPos = pOld->GetPos();
185 22 : if (pNewPos)
186 2 : aPos = *pNewPos;
187 :
188 22 : sal_uInt16 nType = pOld->GetType();
189 22 : if (pNewType)
190 10 : nType = *pNewType;
191 :
192 22 : ScRangeData* pNew = NULL;
193 22 : if (pNewTokens)
194 0 : pNew = new ScRangeData( &rDoc, aInsName, *pNewTokens, aPos, nType );
195 : else
196 22 : pNew = new ScRangeData( &rDoc, aInsName, aContent, aPos, nType, eGrammar );
197 :
198 22 : pNew->SetIndex( pOld->GetIndex() );
199 :
200 22 : pNewRanges->erase(*pOld);
201 22 : if (pNewRanges->insert(pNew))
202 : {
203 22 : pDocShell->GetDocFunc().SetNewRangeNames(pNewRanges, mxParent->IsModifyAndBroadcast(), nTab);
204 :
205 22 : aName = aInsName; //! broadcast?
206 : }
207 : else
208 : {
209 0 : pNew = NULL; //! uno::Exception/Error or something
210 0 : delete pNewRanges;
211 22 : }
212 : }
213 :
214 28 : OUString SAL_CALL ScNamedRangeObj::getName() throw(uno::RuntimeException, std::exception)
215 : {
216 28 : SolarMutexGuard aGuard;
217 28 : return aName;
218 : }
219 :
220 4 : void SAL_CALL ScNamedRangeObj::setName( const OUString& aNewName )
221 : throw (uno::RuntimeException, std::exception)
222 : {
223 4 : SolarMutexGuard aGuard;
224 : //! adapt formulas ?????
225 :
226 8 : OUString aNewStr(aNewName);
227 : // GRAM_PODF_A1 for API compatibility.
228 4 : Modify_Impl( &aNewStr, NULL, NULL, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
229 :
230 4 : if ( aName != aNewStr ) // some error occurred...
231 4 : throw uno::RuntimeException(); // no other exceptions specified
232 4 : }
233 :
234 54 : OUString SAL_CALL ScNamedRangeObj::getContent() throw(uno::RuntimeException, std::exception)
235 : {
236 54 : SolarMutexGuard aGuard;
237 54 : OUString aContent;
238 54 : ScRangeData* pData = GetRangeData_Impl();
239 54 : if (pData)
240 : // GRAM_PODF_A1 for API compatibility.
241 54 : pData->GetSymbol( aContent,formula::FormulaGrammar::GRAM_PODF_A1);
242 54 : return aContent;
243 : }
244 :
245 6 : void SAL_CALL ScNamedRangeObj::setContent( const OUString& aContent )
246 : throw (uno::RuntimeException, std::exception)
247 : {
248 6 : SolarMutexGuard aGuard;
249 12 : OUString aContStr(aContent);
250 : // GRAM_PODF_A1 for API compatibility.
251 12 : Modify_Impl( NULL, NULL, &aContStr, NULL, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
252 6 : }
253 :
254 4 : table::CellAddress SAL_CALL ScNamedRangeObj::getReferencePosition()
255 : throw(uno::RuntimeException, std::exception)
256 : {
257 4 : SolarMutexGuard aGuard;
258 4 : ScAddress aPos;
259 4 : ScRangeData* pData = GetRangeData_Impl();
260 4 : if (pData)
261 4 : aPos = pData->GetPos();
262 4 : table::CellAddress aAddress;
263 4 : aAddress.Column = aPos.Col();
264 4 : aAddress.Row = aPos.Row();
265 4 : aAddress.Sheet = aPos.Tab();
266 4 : if (pDocShell)
267 : {
268 4 : SCTAB nDocTabs = pDocShell->GetDocument().GetTableCount();
269 4 : 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 4 : return aAddress;
278 : }
279 :
280 2 : void SAL_CALL ScNamedRangeObj::setReferencePosition( const table::CellAddress& aReferencePosition )
281 : throw (uno::RuntimeException, std::exception)
282 : {
283 2 : SolarMutexGuard aGuard;
284 2 : ScAddress aPos( (SCCOL)aReferencePosition.Column, (SCROW)aReferencePosition.Row, aReferencePosition.Sheet );
285 : // GRAM_PODF_A1 for API compatibility.
286 2 : Modify_Impl( NULL, NULL, NULL, &aPos, NULL,formula::FormulaGrammar::GRAM_PODF_A1 );
287 2 : }
288 :
289 12 : sal_Int32 SAL_CALL ScNamedRangeObj::getType() throw(uno::RuntimeException, std::exception)
290 : {
291 12 : SolarMutexGuard aGuard;
292 12 : sal_Int32 nType=0;
293 12 : ScRangeData* pData = GetRangeData_Impl();
294 12 : if (pData)
295 : {
296 : // do not return internal RT_* flags
297 : // see property 'IsSharedFormula' for RT_SHARED
298 12 : if ( pData->HasType(RT_CRITERIA) ) nType |= sheet::NamedRangeFlag::FILTER_CRITERIA;
299 12 : if ( pData->HasType(RT_PRINTAREA) ) nType |= sheet::NamedRangeFlag::PRINT_AREA;
300 12 : if ( pData->HasType(RT_COLHEADER) ) nType |= sheet::NamedRangeFlag::COLUMN_HEADER;
301 12 : if ( pData->HasType(RT_ROWHEADER) ) nType |= sheet::NamedRangeFlag::ROW_HEADER;
302 : }
303 12 : return nType;
304 : }
305 :
306 10 : void SAL_CALL ScNamedRangeObj::setType( sal_Int32 nUnoType )
307 : throw (uno::RuntimeException, std::exception)
308 : {
309 : // see property 'IsSharedFormula' for RT_SHARED
310 10 : SolarMutexGuard aGuard;
311 10 : sal_uInt16 nNewType = RT_NAME;
312 10 : if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= RT_CRITERIA;
313 10 : if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= RT_PRINTAREA;
314 10 : if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= RT_COLHEADER;
315 10 : if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= RT_ROWHEADER;
316 :
317 : // GRAM_PODF_A1 for API compatibility.
318 10 : Modify_Impl( NULL, NULL, NULL, NULL, &nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
319 10 : }
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 238 : uno::Reference<table::XCellRange> SAL_CALL ScNamedRangeObj::getReferredCells()
354 : throw(uno::RuntimeException, std::exception)
355 : {
356 238 : SolarMutexGuard aGuard;
357 238 : ScRange aRange;
358 238 : ScRangeData* pData = GetRangeData_Impl();
359 238 : if ( pData && pData->IsValidReference( aRange ) )
360 : {
361 : //! static function to create ScCellObj/ScCellRangeObj at ScCellRangeObj ???
362 :
363 226 : if ( aRange.aStart == aRange.aEnd )
364 214 : return new ScCellObj( pDocShell, aRange.aStart );
365 : else
366 12 : return new ScCellRangeObj( pDocShell, aRange );
367 : }
368 12 : 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] = OUString( SCNAMEDRANGEOBJ_SERVICE );
442 0 : aRet[1] = OUString( 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 2826 : ScNamedRangesObj::ScNamedRangesObj(ScDocShell* pDocSh) :
471 : mbModifyAndBroadcast(true),
472 2826 : pDocShell( pDocSh )
473 : {
474 2826 : pDocShell->GetDocument().AddUnoObject(*this);
475 2826 : }
476 :
477 5652 : ScNamedRangesObj::~ScNamedRangesObj()
478 : {
479 2826 : SolarMutexGuard g;
480 :
481 2826 : if (pDocShell)
482 2812 : pDocShell->GetDocument().RemoveUnoObject(*this);
483 2826 : }
484 :
485 402 : void ScNamedRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
486 : {
487 : // reference update is of no interest
488 :
489 402 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
490 402 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
491 : {
492 14 : pDocShell = NULL; // became invalid
493 : }
494 402 : }
495 :
496 : // sheet::XNamedRanges
497 :
498 26 : 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 26 : SolarMutexGuard aGuard;
504 26 : ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, aPosition.Sheet );
505 :
506 26 : sal_uInt16 nNewType = RT_NAME;
507 26 : if ( nUnoType & sheet::NamedRangeFlag::FILTER_CRITERIA ) nNewType |= RT_CRITERIA;
508 26 : if ( nUnoType & sheet::NamedRangeFlag::PRINT_AREA ) nNewType |= RT_PRINTAREA;
509 26 : if ( nUnoType & sheet::NamedRangeFlag::COLUMN_HEADER ) nNewType |= RT_COLHEADER;
510 26 : if ( nUnoType & sheet::NamedRangeFlag::ROW_HEADER ) nNewType |= RT_ROWHEADER;
511 :
512 26 : bool bDone = false;
513 26 : if (pDocShell)
514 : {
515 26 : ScDocument& rDoc = pDocShell->GetDocument();
516 26 : ScRangeName* pNames = GetRangeName_Impl();
517 26 : if (pNames && !pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName)))
518 : {
519 26 : ScRangeName* pNewRanges = new ScRangeName( *pNames );
520 : // GRAM_PODF_A1 for API compatibility.
521 : ScRangeData* pNew = new ScRangeData( &rDoc, aName, aContent,
522 26 : aPos, nNewType,formula::FormulaGrammar::GRAM_PODF_A1 );
523 26 : if ( pNewRanges->insert(pNew) )
524 : {
525 26 : pDocShell->GetDocFunc().SetNewRangeNames(pNewRanges, mbModifyAndBroadcast, GetTab_Impl());
526 26 : bDone = true;
527 : }
528 : else
529 : {
530 0 : pNew = NULL;
531 0 : delete pNewRanges;
532 : }
533 : }
534 : }
535 :
536 26 : if (!bDone)
537 0 : throw uno::RuntimeException(); // no other exceptions specified
538 26 : }
539 :
540 4 : void SAL_CALL ScNamedRangesObj::addNewFromTitles( const table::CellRangeAddress& aSource,
541 : sheet::Border aBorder ) throw(uno::RuntimeException, std::exception)
542 : {
543 4 : SolarMutexGuard aGuard;
544 : //! this cannot be an enum, because multiple bits can be set !!!
545 :
546 4 : bool bTop = ( aBorder == sheet::Border_TOP );
547 4 : bool bLeft = ( aBorder == sheet::Border_LEFT );
548 4 : bool bBottom = ( aBorder == sheet::Border_BOTTOM );
549 4 : bool bRight = ( aBorder == sheet::Border_RIGHT );
550 :
551 4 : ScRange aRange;
552 4 : ScUnoConversion::FillScRange( aRange, aSource );
553 :
554 4 : sal_uInt16 nFlags = 0;
555 4 : if (bTop) nFlags |= NAME_TOP;
556 4 : if (bLeft) nFlags |= NAME_LEFT;
557 4 : if (bBottom) nFlags |= NAME_BOTTOM;
558 4 : if (bRight) nFlags |= NAME_RIGHT;
559 :
560 4 : if (nFlags)
561 4 : pDocShell->GetDocFunc().CreateNames( aRange, nFlags, true, GetTab_Impl() );
562 4 : }
563 :
564 10 : void SAL_CALL ScNamedRangesObj::removeByName( const OUString& aName )
565 : throw(uno::RuntimeException, std::exception)
566 : {
567 10 : SolarMutexGuard aGuard;
568 10 : bool bDone = false;
569 10 : if (pDocShell)
570 : {
571 10 : ScRangeName* pNames = GetRangeName_Impl();
572 10 : if (pNames)
573 : {
574 10 : const ScRangeData* pData = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
575 10 : if (pData && lcl_UserVisibleName(*pData))
576 : {
577 10 : ScRangeName* pNewRanges = new ScRangeName(*pNames);
578 10 : pNewRanges->erase(*pData);
579 10 : pDocShell->GetDocFunc().SetNewRangeNames( pNewRanges, mbModifyAndBroadcast, GetTab_Impl());
580 10 : bDone = true;
581 : }
582 : }
583 : }
584 :
585 10 : if (!bDone)
586 0 : throw uno::RuntimeException(); // no other exceptions specified
587 10 : }
588 :
589 8 : void SAL_CALL ScNamedRangesObj::outputList( const table::CellAddress& aOutputPosition )
590 : throw(uno::RuntimeException, std::exception)
591 : {
592 8 : SolarMutexGuard aGuard;
593 8 : ScAddress aPos( (SCCOL)aOutputPosition.Column, (SCROW)aOutputPosition.Row, aOutputPosition.Sheet );
594 8 : if (pDocShell)
595 8 : pDocShell->GetDocFunc().InsertNameList( aPos, true );
596 8 : }
597 :
598 : // container::XEnumerationAccess
599 :
600 4 : uno::Reference<container::XEnumeration> SAL_CALL ScNamedRangesObj::createEnumeration()
601 : throw(uno::RuntimeException, std::exception)
602 : {
603 4 : SolarMutexGuard aGuard;
604 4 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.NamedRangesEnumeration"));
605 : }
606 :
607 : // container::XIndexAccess
608 :
609 32 : sal_Int32 SAL_CALL ScNamedRangesObj::getCount() throw(uno::RuntimeException, std::exception)
610 : {
611 32 : SolarMutexGuard aGuard;
612 32 : long nRet = 0;
613 32 : if (pDocShell)
614 : {
615 32 : ScRangeName* pNames = GetRangeName_Impl();
616 32 : if (pNames)
617 : {
618 32 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
619 96 : for (; itr != itrEnd; ++itr)
620 64 : if (lcl_UserVisibleName(*itr->second))
621 64 : ++nRet;
622 : }
623 : }
624 32 : return nRet;
625 : }
626 :
627 24 : uno::Any SAL_CALL ScNamedRangesObj::getByIndex( sal_Int32 nIndex )
628 : throw(lang::IndexOutOfBoundsException,
629 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
630 : {
631 24 : SolarMutexGuard aGuard;
632 48 : uno::Reference< sheet::XNamedRange > xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
633 24 : if ( xRange.is() )
634 40 : return uno::makeAny(xRange);
635 : else
636 28 : throw lang::IndexOutOfBoundsException();
637 : }
638 :
639 2 : uno::Type SAL_CALL ScNamedRangesObj::getElementType() throw(uno::RuntimeException, std::exception)
640 : {
641 2 : SolarMutexGuard aGuard;
642 2 : return cppu::UnoType<sheet::XNamedRange>::get(); // must be suitable for getByIndex
643 : }
644 :
645 2 : sal_Bool SAL_CALL ScNamedRangesObj::hasElements() throw(uno::RuntimeException, std::exception)
646 : {
647 2 : SolarMutexGuard aGuard;
648 2 : 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 1434 : uno::Any SAL_CALL ScNamedRangesObj::getByName( const OUString& aName )
687 : throw(container::NoSuchElementException,
688 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
689 : {
690 1434 : SolarMutexGuard aGuard;
691 2868 : uno::Reference< sheet::XNamedRange > xRange(GetObjectByName_Impl(aName));
692 1434 : if ( xRange.is() )
693 632 : return uno::makeAny(xRange);
694 : else
695 2552 : throw container::NoSuchElementException();
696 : }
697 :
698 2 : uno::Sequence<OUString> SAL_CALL ScNamedRangesObj::getElementNames()
699 : throw(uno::RuntimeException, std::exception)
700 : {
701 2 : SolarMutexGuard aGuard;
702 2 : if (pDocShell)
703 : {
704 2 : ScRangeName* pNames = GetRangeName_Impl();
705 2 : if (pNames)
706 : {
707 2 : long nVisCount = getCount(); // names with lcl_UserVisibleName
708 2 : uno::Sequence<OUString> aSeq(nVisCount);
709 2 : OUString* pAry = aSeq.getArray();
710 2 : sal_uInt16 nVisPos = 0;
711 2 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
712 4 : for (; itr != itrEnd; ++itr)
713 : {
714 2 : if (lcl_UserVisibleName(*itr->second))
715 2 : pAry[nVisPos++] = itr->second->GetName();
716 : }
717 2 : return aSeq;
718 : }
719 : }
720 0 : return uno::Sequence<OUString>(0);
721 : }
722 :
723 4448 : sal_Bool SAL_CALL ScNamedRangesObj::hasByName( const OUString& aName )
724 : throw(uno::RuntimeException, std::exception)
725 : {
726 4448 : SolarMutexGuard aGuard;
727 4448 : if (pDocShell)
728 : {
729 4448 : ScRangeName* pNames = GetRangeName_Impl();
730 4448 : if (pNames)
731 : {
732 4448 : const ScRangeData* pData = pNames->findByUpperName(ScGlobal::pCharClass->uppercase(aName));
733 4448 : if (pData && lcl_UserVisibleName(*pData))
734 452 : return sal_True;
735 : }
736 : }
737 3996 : 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 2826 : ScGlobalNamedRangesObj::ScGlobalNamedRangesObj(ScDocShell* pDocSh)
822 2826 : : ScNamedRangesObj(pDocSh)
823 : {
824 :
825 2826 : }
826 :
827 5652 : ScGlobalNamedRangesObj::~ScGlobalNamedRangesObj()
828 : {
829 :
830 5652 : }
831 :
832 24 : ScNamedRangeObj* ScGlobalNamedRangesObj::GetObjectByIndex_Impl(sal_uInt16 nIndex)
833 : {
834 24 : if (!pDocShell)
835 0 : return NULL;
836 :
837 24 : ScRangeName* pNames = pDocShell->GetDocument().GetRangeName();
838 24 : if (!pNames)
839 0 : return NULL;
840 :
841 24 : ScRangeName::const_iterator itr = pNames->begin(), itrEnd = pNames->end();
842 24 : sal_uInt16 nPos = 0;
843 28 : for (; itr != itrEnd; ++itr)
844 : {
845 24 : if (lcl_UserVisibleName(*itr->second))
846 : {
847 24 : if (nPos == nIndex)
848 20 : return new ScNamedRangeObj(this, pDocShell, itr->second->GetName());
849 : }
850 4 : ++nPos;
851 : }
852 4 : return NULL;
853 : }
854 :
855 1434 : ScNamedRangeObj* ScGlobalNamedRangesObj::GetObjectByName_Impl(const OUString& aName)
856 : {
857 1434 : if ( pDocShell && hasByName(aName) )
858 316 : return new ScNamedRangeObj(this, pDocShell, aName);
859 1118 : return NULL;
860 : }
861 :
862 4518 : ScRangeName* ScGlobalNamedRangesObj::GetRangeName_Impl()
863 : {
864 4518 : return pDocShell->GetDocument().GetRangeName();
865 : }
866 :
867 40 : SCTAB ScGlobalNamedRangesObj::GetTab_Impl()
868 : {
869 40 : 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 10 : ScLabelRangeObj::ScLabelRangeObj(ScDocShell* pDocSh, bool bCol, const ScRange& rR) :
935 : pDocShell( pDocSh ),
936 : bColumn( bCol ),
937 10 : aRange( rR )
938 : {
939 10 : pDocShell->GetDocument().AddUnoObject(*this);
940 10 : }
941 :
942 30 : ScLabelRangeObj::~ScLabelRangeObj()
943 : {
944 10 : SolarMutexGuard g;
945 :
946 10 : if (pDocShell)
947 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
948 20 : }
949 :
950 26 : void ScLabelRangeObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
951 : {
952 : //! Ref-Update !!!
953 :
954 26 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
955 26 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
956 10 : pDocShell = NULL; // became invalid
957 26 : }
958 :
959 : // Helper functions
960 :
961 4 : ScRangePair* ScLabelRangeObj::GetData_Impl()
962 : {
963 4 : ScRangePair* pRet = NULL;
964 4 : if (pDocShell)
965 : {
966 4 : ScDocument& rDoc = pDocShell->GetDocument();
967 4 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
968 4 : if (pList)
969 4 : pRet = pList->Find( aRange );
970 : }
971 4 : return pRet;
972 : }
973 :
974 4 : void ScLabelRangeObj::Modify_Impl( const ScRange* pLabel, const ScRange* pData )
975 : {
976 4 : if (pDocShell)
977 : {
978 4 : ScDocument& rDoc = pDocShell->GetDocument();
979 4 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
980 4 : if (pOldList)
981 : {
982 4 : ScRangePairListRef xNewList(pOldList->Clone());
983 4 : ScRangePair* pEntry = xNewList->Find( aRange );
984 4 : if (pEntry)
985 : {
986 4 : xNewList->Remove( pEntry ); // only removed from list, not deleted
987 :
988 4 : if ( pLabel )
989 2 : pEntry->GetRange(0) = *pLabel;
990 4 : if ( pData )
991 2 : pEntry->GetRange(1) = *pData;
992 :
993 4 : xNewList->Join( *pEntry );
994 4 : delete pEntry;
995 :
996 4 : if (bColumn)
997 4 : rDoc.GetColNameRangesRef() = xNewList;
998 : else
999 0 : rDoc.GetRowNameRangesRef() = xNewList;
1000 :
1001 4 : rDoc.CompileColRowNameFormula();
1002 4 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1003 4 : pDocShell->SetDocumentModified();
1004 :
1005 : //! Undo ?!?! (here and from dialog)
1006 :
1007 4 : if ( pLabel )
1008 2 : aRange = *pLabel; // adapt object to find range again
1009 4 : }
1010 : }
1011 : }
1012 4 : }
1013 :
1014 : // sheet::XLabelRange
1015 :
1016 2 : table::CellRangeAddress SAL_CALL ScLabelRangeObj::getLabelArea()
1017 : throw(uno::RuntimeException, std::exception)
1018 : {
1019 2 : SolarMutexGuard aGuard;
1020 2 : table::CellRangeAddress aRet;
1021 2 : ScRangePair* pData = GetData_Impl();
1022 2 : if (pData)
1023 2 : ScUnoConversion::FillApiRange( aRet, pData->GetRange(0) );
1024 2 : return aRet;
1025 : }
1026 :
1027 2 : void SAL_CALL ScLabelRangeObj::setLabelArea( const table::CellRangeAddress& aLabelArea )
1028 : throw(uno::RuntimeException, std::exception)
1029 : {
1030 2 : SolarMutexGuard aGuard;
1031 2 : ScRange aLabelRange;
1032 2 : ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
1033 2 : Modify_Impl( &aLabelRange, NULL );
1034 2 : }
1035 :
1036 2 : table::CellRangeAddress SAL_CALL ScLabelRangeObj::getDataArea()
1037 : throw(uno::RuntimeException, std::exception)
1038 : {
1039 2 : SolarMutexGuard aGuard;
1040 2 : table::CellRangeAddress aRet;
1041 2 : ScRangePair* pData = GetData_Impl();
1042 2 : if (pData)
1043 2 : ScUnoConversion::FillApiRange( aRet, pData->GetRange(1) );
1044 2 : return aRet;
1045 : }
1046 :
1047 2 : void SAL_CALL ScLabelRangeObj::setDataArea( const table::CellRangeAddress& aDataArea )
1048 : throw(uno::RuntimeException, std::exception)
1049 : {
1050 2 : SolarMutexGuard aGuard;
1051 2 : ScRange aDataRange;
1052 2 : ScUnoConversion::FillScRange( aDataRange, aDataArea );
1053 2 : Modify_Impl( NULL, &aDataRange );
1054 2 : }
1055 :
1056 118 : ScLabelRangesObj::ScLabelRangesObj(ScDocShell* pDocSh, bool bCol) :
1057 : pDocShell( pDocSh ),
1058 118 : bColumn( bCol )
1059 : {
1060 118 : pDocShell->GetDocument().AddUnoObject(*this);
1061 118 : }
1062 :
1063 354 : ScLabelRangesObj::~ScLabelRangesObj()
1064 : {
1065 118 : SolarMutexGuard g;
1066 :
1067 118 : if (pDocShell)
1068 96 : pDocShell->GetDocument().RemoveUnoObject(*this);
1069 236 : }
1070 :
1071 664 : void ScLabelRangesObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
1072 : {
1073 : // reference update is of no interest
1074 :
1075 664 : const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
1076 664 : if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
1077 : {
1078 22 : pDocShell = NULL; // became invalid
1079 : }
1080 664 : }
1081 :
1082 : // sheet::XLabelRanges
1083 :
1084 14 : ScLabelRangeObj* ScLabelRangesObj::GetObjectByIndex_Impl(size_t nIndex)
1085 : {
1086 14 : if (pDocShell)
1087 : {
1088 14 : ScDocument& rDoc = pDocShell->GetDocument();
1089 14 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1090 14 : if ( pList && nIndex < pList->size() )
1091 : {
1092 10 : ScRangePair* pData = (*pList)[nIndex];
1093 10 : if (pData)
1094 10 : return new ScLabelRangeObj( pDocShell, bColumn, pData->GetRange(0) );
1095 : }
1096 : }
1097 4 : return NULL;
1098 : }
1099 :
1100 8 : void SAL_CALL ScLabelRangesObj::addNew( const table::CellRangeAddress& aLabelArea,
1101 : const table::CellRangeAddress& aDataArea )
1102 : throw(uno::RuntimeException, std::exception)
1103 : {
1104 8 : SolarMutexGuard aGuard;
1105 8 : if (pDocShell)
1106 : {
1107 8 : ScDocument& rDoc = pDocShell->GetDocument();
1108 8 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1109 8 : if (pOldList)
1110 : {
1111 8 : ScRangePairListRef xNewList(pOldList->Clone());
1112 :
1113 8 : ScRange aLabelRange;
1114 8 : ScRange aDataRange;
1115 8 : ScUnoConversion::FillScRange( aLabelRange, aLabelArea );
1116 8 : ScUnoConversion::FillScRange( aDataRange, aDataArea );
1117 8 : xNewList->Join( ScRangePair( aLabelRange, aDataRange ) );
1118 :
1119 8 : if (bColumn)
1120 8 : rDoc.GetColNameRangesRef() = xNewList;
1121 : else
1122 0 : rDoc.GetRowNameRangesRef() = xNewList;
1123 :
1124 8 : rDoc.CompileColRowNameFormula();
1125 8 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1126 8 : pDocShell->SetDocumentModified();
1127 :
1128 : //! Undo ?!?! (here and from dialog)
1129 : }
1130 8 : }
1131 8 : }
1132 :
1133 4 : void SAL_CALL ScLabelRangesObj::removeByIndex( sal_Int32 nIndex )
1134 : throw(uno::RuntimeException, std::exception)
1135 : {
1136 4 : SolarMutexGuard aGuard;
1137 4 : bool bDone = false;
1138 4 : if (pDocShell)
1139 : {
1140 4 : ScDocument& rDoc = pDocShell->GetDocument();
1141 4 : ScRangePairList* pOldList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1142 :
1143 4 : if ( pOldList && nIndex >= 0 && nIndex < (sal_Int32)pOldList->size() )
1144 : {
1145 2 : ScRangePairListRef xNewList(pOldList->Clone());
1146 :
1147 2 : ScRangePair* pEntry = (*xNewList)[nIndex];
1148 2 : if (pEntry)
1149 : {
1150 2 : xNewList->Remove( pEntry );
1151 2 : delete pEntry;
1152 :
1153 2 : if (bColumn)
1154 2 : rDoc.GetColNameRangesRef() = xNewList;
1155 : else
1156 0 : rDoc.GetRowNameRangesRef() = xNewList;
1157 :
1158 2 : rDoc.CompileColRowNameFormula();
1159 2 : pDocShell->PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
1160 2 : pDocShell->SetDocumentModified();
1161 2 : bDone = true;
1162 :
1163 : //! Undo ?!?! (here and from dialog)
1164 2 : }
1165 : }
1166 : }
1167 4 : if (!bDone)
1168 2 : throw uno::RuntimeException(); // no other exceptions specified
1169 2 : }
1170 :
1171 : // container::XEnumerationAccess
1172 :
1173 4 : uno::Reference<container::XEnumeration> SAL_CALL ScLabelRangesObj::createEnumeration()
1174 : throw(uno::RuntimeException, std::exception)
1175 : {
1176 4 : SolarMutexGuard aGuard;
1177 4 : return new ScIndexEnumeration(this, OUString("com.sun.star.sheet.LabelRangesEnumeration"));
1178 : }
1179 :
1180 : // container::XIndexAccess
1181 :
1182 112 : sal_Int32 SAL_CALL ScLabelRangesObj::getCount() throw(uno::RuntimeException, std::exception)
1183 : {
1184 112 : SolarMutexGuard aGuard;
1185 112 : if (pDocShell)
1186 : {
1187 112 : ScDocument& rDoc = pDocShell->GetDocument();
1188 112 : ScRangePairList* pList = bColumn ? rDoc.GetColNameRanges() : rDoc.GetRowNameRanges();
1189 112 : if (pList)
1190 112 : return pList->size();
1191 : }
1192 0 : return 0;
1193 : }
1194 :
1195 14 : uno::Any SAL_CALL ScLabelRangesObj::getByIndex( sal_Int32 nIndex )
1196 : throw(lang::IndexOutOfBoundsException,
1197 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
1198 : {
1199 14 : SolarMutexGuard aGuard;
1200 28 : uno::Reference< sheet::XLabelRange > xRange(GetObjectByIndex_Impl((sal_uInt16)nIndex));
1201 14 : if ( xRange.is() )
1202 20 : return uno::makeAny(xRange);
1203 : else
1204 18 : throw lang::IndexOutOfBoundsException();
1205 : }
1206 :
1207 2 : uno::Type SAL_CALL ScLabelRangesObj::getElementType() throw(uno::RuntimeException, std::exception)
1208 : {
1209 2 : SolarMutexGuard aGuard;
1210 2 : return cppu::UnoType<sheet::XLabelRange>::get(); // must be suitable for getByIndex
1211 :
1212 : }
1213 :
1214 2 : sal_Bool SAL_CALL ScLabelRangesObj::hasElements() throw(uno::RuntimeException, std::exception)
1215 : {
1216 2 : SolarMutexGuard aGuard;
1217 2 : return ( getCount() != 0 );
1218 228 : }
1219 :
1220 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
