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