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