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_sw.hxx" 26 27 #ifndef _SVSTDARR_HXX 28 #define _SVSTDARR_STRINGSDTOR 29 #include <svl/svstdarr.hxx> 30 #endif 31 #include <svl/urlbmk.hxx> 32 #include <tools/urlobj.hxx> 33 #include <sfx2/docfile.hxx> 34 #include <sfx2/dispatch.hxx> 35 #include <vcl/help.hxx> 36 #include <sot/formats.hxx> 37 #include <vcl/sound.hxx> 38 #include <uiitems.hxx> 39 #include <fmtinfmt.hxx> 40 #include <txtinet.hxx> 41 #include <fmtfld.hxx> 42 #include <swmodule.hxx> 43 #include <wrtsh.hxx> 44 #include <view.hxx> 45 #include <errhdl.hxx> 46 #include <docsh.hxx> 47 #include <content.hxx> 48 #include <frmfmt.hxx> 49 #include <fldbas.hxx> 50 #include <txtatr.hxx> 51 #include <IMark.hxx> 52 #include <section.hxx> 53 #include <tox.hxx> 54 #define NAVIPI_CXX 55 #include <navipi.hxx> 56 #include <navicont.hxx> 57 #include <navicfg.hxx> 58 #include <edtwin.hxx> 59 #include <doc.hxx> 60 #include <unotools.hxx> 61 #include <crsskip.hxx> 62 #include <cmdid.h> 63 #include <helpid.h> 64 #include <navipi.hrc> 65 #include <utlui.hrc> 66 #include <misc.hrc> 67 #include <comcore.hrc> 68 #include <com/sun/star/text/XTextSectionsSupplier.hpp> 69 #include <com/sun/star/text/XTextGraphicObjectsSupplier.hpp> 70 #include <com/sun/star/text/XTextTablesSupplier.hpp> 71 #include <com/sun/star/text/XDocumentIndexesSupplier.hpp> 72 #include <com/sun/star/text/XDocumentIndex.hpp> 73 #include <com/sun/star/text/XBookmarksSupplier.hpp> 74 #include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp> 75 #include <com/sun/star/text/XTextFramesSupplier.hpp> 76 #include <dcontact.hxx> 77 #include <svx/svdogrp.hxx> 78 #include <svx/svdmodel.hxx> 79 #include <svx/svdpage.hxx> 80 #include <svx/svdview.hxx> 81 #include <vcl/scrbar.hxx> 82 #include <comcore.hrc> 83 #include <SwRewriter.hxx> 84 #include <hints.hxx> 85 #include <numrule.hxx> 86 #include <swundo.hxx> 87 #include <ndtxt.hxx> 88 //IAccessibility2 Implementation 2009----- 89 //#include <ndgrf.hxx> 90 #include <fmtcntnt.hxx> 91 #include <PostItMgr.hxx> 92 //#include <../../core/inc/flyfrm.hxx> 93 //#include <../../core/inc/cntfrm.hxx> 94 //#include <ndnotxt.hxx> 95 //-----IAccessibility2 Implementation 2009 96 //#include <postit.hxx> 97 #include <postithelper.hxx> 98 #include <redline.hxx> 99 #include <docary.hxx> 100 101 #include "swabstdlg.hxx" 102 #include "globals.hrc" 103 #include <unomid.h> 104 105 106 #define CTYPE_CNT 0 107 #define CTYPE_CTT 1 108 109 using namespace ::std; 110 using namespace ::com::sun::star; 111 using namespace ::com::sun::star::text; 112 using namespace ::com::sun::star::uno; 113 using namespace ::com::sun::star::container; 114 115 116 #define NAVI_BOOKMARK_DELIM (sal_Unicode)1 117 118 /*************************************************************************** 119 120 ***************************************************************************/ 121 122 typedef SwContent* SwContentPtr; 123 SV_DECL_PTRARR_SORT_DEL( SwContentArr, SwContentPtr, 0,4) 124 SV_IMPL_OP_PTRARR_SORT(SwContentArr, SwContentPtr) 125 126 sal_Bool SwContentTree::bIsInDrag = sal_False; 127 128 129 namespace 130 { 131 static sal_Bool lcl_IsContent(SvLBoxEntry* pEntry) 132 { 133 return ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId() == CTYPE_CNT; 134 } 135 136 137 static sal_Bool lcl_IsContentType(SvLBoxEntry* pEntry) 138 { 139 return ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId() == CTYPE_CTT; 140 } 141 142 143 static sal_Bool lcl_FindShell(SwWrtShell* pShell) 144 { 145 sal_Bool bFound = sal_False; 146 SwView *pView = SwModule::GetFirstView(); 147 while (pView) 148 { 149 if(pShell == &pView->GetWrtShell()) 150 { 151 bFound = sal_True; 152 break; 153 } 154 pView = SwModule::GetNextView(pView); 155 } 156 return bFound; 157 } 158 159 static bool lcl_IsUiVisibleBookmark(const IDocumentMarkAccess::pMark_t& rpMark) 160 { 161 return IDocumentMarkAccess::GetType(*rpMark) == IDocumentMarkAccess::BOOKMARK; 162 } 163 } 164 165 /*************************************************************************** 166 Beschreibung: Inhalt, enthaelt Namen und Verweis auf den Inhalstyp 167 ***************************************************************************/ 168 169 170 SwContent::SwContent(const SwContentType* pCnt, const String& rName, long nYPos) : 171 SwTypeNumber(CTYPE_CNT), 172 pParent(pCnt), 173 sContentName(rName), 174 nYPosition(nYPos), 175 bInvisible(sal_False) 176 { 177 } 178 179 180 sal_uInt8 SwTypeNumber::GetTypeId() 181 { 182 return nTypeId; 183 } 184 185 SwTypeNumber::~SwTypeNumber() 186 { 187 } 188 189 sal_Bool SwContent::IsProtect() const 190 { 191 return sal_False; 192 } 193 194 sal_Bool SwPostItContent::IsProtect() const 195 { 196 if (mbPostIt) 197 return pFld->IsProtect(); 198 else 199 return false; 200 } 201 202 sal_Bool SwURLFieldContent::IsProtect() const 203 { 204 return pINetAttr->IsProtect(); 205 } 206 207 SwGraphicContent::~SwGraphicContent() 208 { 209 } 210 SwTOXBaseContent::~SwTOXBaseContent() 211 { 212 } 213 214 /*************************************************************************** 215 Beschreibung: Inhaltstyp, kennt seine Inhalte und die WrtShell 216 ***************************************************************************/ 217 218 219 SwContentType::SwContentType(SwWrtShell* pShell, sal_uInt16 nType, sal_uInt8 nLevel) : 220 SwTypeNumber(CTYPE_CTT), 221 pWrtShell(pShell), 222 pMember(0), 223 sContentTypeName(SW_RES(STR_CONTENT_TYPE_FIRST + nType)), 224 sSingleContentTypeName(SW_RES(STR_CONTENT_TYPE_SINGLE_FIRST + nType)), 225 nMemberCount(0), 226 nContentType(nType), 227 nOutlineLevel(nLevel), 228 bMemberFilled(sal_False), 229 bDataValid(sal_False), 230 bEdit(sal_False), 231 bDelete(sal_True) 232 { 233 Init(); 234 } 235 236 /*************************************************************************** 237 Beschreibung: Initialisierung 238 ***************************************************************************/ 239 240 241 void SwContentType::Init(sal_Bool* pbInvalidateWindow) 242 { 243 // wenn sich der MemberCount aendert ... 244 sal_uInt16 nOldMemberCount = nMemberCount; 245 nMemberCount = 0; 246 switch(nContentType) 247 { 248 case CONTENT_TYPE_OUTLINE : 249 { 250 sTypeToken = C2S(pMarkToOutline); 251 sal_uInt16 nOutlineCount = nMemberCount = 252 static_cast<sal_uInt16>(pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount()); 253 if(nOutlineLevel < MAXLEVEL) 254 { 255 for(sal_uInt16 j = 0; j < nOutlineCount; j++) 256 { 257 if(pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineLevel(j) > nOutlineLevel ) 258 nMemberCount --; 259 } 260 } 261 bDelete = sal_False; 262 } 263 break; 264 265 case CONTENT_TYPE_TABLE : 266 sTypeToken = C2S(pMarkToTable); 267 nMemberCount = pWrtShell->GetTblFrmFmtCount(sal_True); 268 bEdit = sal_True; 269 break; 270 271 case CONTENT_TYPE_FRAME : 272 case CONTENT_TYPE_GRAPHIC : 273 case CONTENT_TYPE_OLE : 274 { 275 FlyCntType eType = FLYCNTTYPE_FRM; 276 sTypeToken = C2S(pMarkToFrame); 277 if(nContentType == CONTENT_TYPE_OLE) 278 { 279 eType = FLYCNTTYPE_OLE; 280 sTypeToken = C2S(pMarkToOLE); 281 } 282 else if(nContentType == CONTENT_TYPE_GRAPHIC) 283 { 284 eType = FLYCNTTYPE_GRF; 285 sTypeToken = C2S(pMarkToGraphic); 286 } 287 nMemberCount = pWrtShell->GetFlyCount(eType); 288 bEdit = sal_True; 289 } 290 break; 291 case CONTENT_TYPE_BOOKMARK: 292 { 293 IDocumentMarkAccess* const pMarkAccess = pWrtShell->getIDocumentMarkAccess(); 294 nMemberCount = static_cast<sal_uInt16>(count_if( 295 pMarkAccess->getBookmarksBegin(), 296 pMarkAccess->getBookmarksEnd(), 297 &lcl_IsUiVisibleBookmark)); 298 sTypeToken = aEmptyStr; 299 bEdit = sal_True; 300 } 301 break; 302 case CONTENT_TYPE_REGION : 303 { 304 SwContentArr* pOldMember = 0; 305 sal_uInt16 nOldRegionCount = 0; 306 sal_Bool bInvalidate = sal_False; 307 if(!pMember) 308 pMember = new SwContentArr; 309 else if(pMember->Count()) 310 { 311 pOldMember = pMember; 312 nOldRegionCount = pOldMember->Count(); 313 pMember = new SwContentArr; 314 } 315 const Point aNullPt; 316 nMemberCount = pWrtShell->GetSectionFmtCount(); 317 for(sal_uInt16 i = 0; i < nMemberCount; i++) 318 { 319 const SwSectionFmt* pFmt; 320 SectionType eTmpType; 321 if( (pFmt = &pWrtShell->GetSectionFmt(i))->IsInNodesArr() && 322 (eTmpType = pFmt->GetSection()->GetType()) != TOX_CONTENT_SECTION 323 && TOX_HEADER_SECTION != eTmpType ) 324 { 325 const String& rSectionName = 326 pFmt->GetSection()->GetSectionName(); 327 sal_uInt8 nLevel = 0; 328 SwSectionFmt* pParentFmt = pFmt->GetParent(); 329 while(pParentFmt) 330 { 331 nLevel++; 332 pParentFmt = pParentFmt->GetParent(); 333 } 334 335 SwContent* pCnt = new SwRegionContent(this, rSectionName, 336 nLevel, 337 pFmt->FindLayoutRect( sal_False, &aNullPt ).Top()); 338 339 SwPtrMsgPoolItem aAskItem( RES_CONTENT_VISIBLE, 0 ); 340 if( !pFmt->GetInfo( aAskItem ) && 341 !aAskItem.pObject ) // not visible 342 pCnt->SetInvisible(); 343 pMember->Insert(pCnt);//, pMember->Count()); 344 345 sal_uInt16 nPos = pMember->Count() - 1; 346 if(nOldRegionCount > nPos && 347 (pOldMember->GetObject(nPos))->IsInvisible() 348 != pCnt->IsInvisible()) 349 bInvalidate = sal_True; 350 } 351 } 352 nMemberCount = pMember->Count(); 353 sTypeToken = C2S(pMarkToRegion); 354 bEdit = sal_True; 355 bDelete = sal_False; 356 if(pOldMember) 357 { 358 pOldMember->DeleteAndDestroy(0, pOldMember->Count()); 359 delete pOldMember; 360 if(pbInvalidateWindow && bInvalidate) 361 *pbInvalidateWindow = sal_True; 362 } 363 } 364 break; 365 case CONTENT_TYPE_INDEX: 366 { 367 nMemberCount = pWrtShell->GetTOXCount(); 368 bEdit = sal_True; 369 bDelete = sal_False; 370 } 371 break; 372 case CONTENT_TYPE_REFERENCE: 373 { 374 nMemberCount = pWrtShell->GetRefMarks( 0 ); 375 bDelete = sal_False; 376 } 377 break; 378 case CONTENT_TYPE_URLFIELD: 379 { 380 nMemberCount = 0; 381 if(!pMember) 382 pMember = new SwContentArr; 383 else if(pMember->Count()) 384 pMember->DeleteAndDestroy(0, pMember->Count()); 385 386 SwGetINetAttrs aArr; 387 nMemberCount = pWrtShell->GetINetAttrs( aArr ); 388 for( sal_uInt16 n = 0; n < nMemberCount; ++n ) 389 { 390 SwGetINetAttr* p = aArr[ n ]; 391 SwURLFieldContent* pCnt = new SwURLFieldContent( 392 this, 393 p->sText, 394 INetURLObject::decode( 395 p->rINetAttr.GetINetFmt().GetValue(), 396 INET_HEX_ESCAPE, 397 INetURLObject::DECODE_UNAMBIGUOUS, 398 RTL_TEXTENCODING_UTF8 ), 399 &p->rINetAttr, 400 n ); 401 pMember->Insert( pCnt );//, n ); 402 } 403 bEdit = sal_True; 404 nOldMemberCount = nMemberCount; 405 bDelete = sal_False; 406 } 407 break; 408 case CONTENT_TYPE_POSTIT: 409 { 410 nMemberCount = 0; 411 if(!pMember) 412 pMember = new SwContentArr; 413 else if(pMember->Count()) 414 pMember->DeleteAndDestroy(0, pMember->Count()); 415 416 SwPostItMgr* aMgr = pWrtShell->GetView().GetPostItMgr(); 417 if (aMgr) 418 { 419 for(SwPostItMgr::const_iterator i = aMgr->begin(); i != aMgr->end(); ++i) 420 { 421 if ( (*i)->GetBroadCaster()->ISA(SwFmtFld)) // SwPostit 422 { 423 SwFmtFld* aFmtFld = static_cast<SwFmtFld*>((*i)->GetBroadCaster()); 424 if (aFmtFld->GetTxtFld() && aFmtFld->IsFldInDoc() && 425 (*i)->mLayoutStatus!=SwPostItHelper::INVISIBLE ) 426 { 427 String sEntry = aFmtFld->GetField()->GetPar2(); 428 RemoveNewline(sEntry); 429 SwPostItContent* pCnt = new SwPostItContent( 430 this, 431 sEntry, 432 (const SwFmtFld*)aFmtFld, 433 nMemberCount); 434 pMember->Insert(pCnt); 435 nMemberCount++; 436 } 437 } 438 } 439 } 440 // 441 sTypeToken = aEmptyStr; 442 bEdit = sal_True; 443 nOldMemberCount = nMemberCount; 444 } 445 break; 446 case CONTENT_TYPE_DRAWOBJECT: 447 { 448 sTypeToken = aEmptyStr; 449 nMemberCount = 0; 450 SdrModel* pModel = pWrtShell->getIDocumentDrawModelAccess()->GetDrawModel(); 451 if(pModel) 452 { 453 SdrPage* pPage = pModel->GetPage(0); 454 sal_uInt32 nCount = pPage->GetObjCount(); 455 for( sal_uInt32 i=0; i< nCount; i++ ) 456 { 457 SdrObject* pTemp = pPage->GetObj(i); 458 // --> OD 2006-03-09 #i51726# - all drawing objects can be named now 459 // if(pTemp->ISA(SdrObjGroup) && pTemp->GetName().Len()) 460 if ( pTemp->GetName().Len() ) 461 // <-- 462 nMemberCount++; 463 } 464 } 465 } 466 break; 467 } 468 // ... dann koennen die Daten auch nicht mehr gueltig sein 469 // abgesehen von denen, die schon korrigiert wurden, dann ist 470 // nOldMemberCount doch nicht so old 471 if( nOldMemberCount != nMemberCount ) 472 bDataValid = sal_False; 473 } 474 475 /*************************************************************************** 476 Beschreibung: 477 ***************************************************************************/ 478 479 480 SwContentType::~SwContentType() 481 { 482 delete pMember; 483 } 484 485 /*************************************************************************** 486 Beschreibung: Inhalt liefern, dazu gfs. die Liste fuellen 487 ***************************************************************************/ 488 489 490 const SwContent* SwContentType::GetMember(sal_uInt16 nIndex) 491 { 492 if(!bDataValid || !pMember) 493 { 494 FillMemberList(); 495 } 496 if(nIndex < pMember->Count()) 497 return pMember->GetObject(nIndex); 498 else 499 return 0; 500 501 } 502 503 504 /*************************************************************************** 505 Beschreibung: 506 ***************************************************************************/ 507 508 509 void SwContentType::Invalidate() 510 { 511 bDataValid = sal_False; 512 } 513 514 /*************************************************************************** 515 Beschreibung: Liste der Inhalte fuellen 516 ***************************************************************************/ 517 518 519 void SwContentType::FillMemberList(sal_Bool* pbLevelOrVisibiblityChanged) 520 { 521 SwContentArr* pOldMember = 0; 522 int nOldMemberCount = -1; 523 SwPtrMsgPoolItem aAskItem( RES_CONTENT_VISIBLE, 0 ); 524 if(pMember && pbLevelOrVisibiblityChanged) 525 { 526 pOldMember = pMember; 527 nOldMemberCount = pOldMember->Count(); 528 pMember = new SwContentArr; 529 *pbLevelOrVisibiblityChanged = sal_False; 530 } 531 else if(!pMember) 532 pMember = new SwContentArr; 533 else if(pMember->Count()) 534 pMember->DeleteAndDestroy(0, pMember->Count()); 535 switch(nContentType) 536 { 537 case CONTENT_TYPE_OUTLINE : 538 { 539 sal_uInt16 nOutlineCount = nMemberCount = 540 static_cast<sal_uInt16>(pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount()); 541 542 sal_uInt16 nPos = 0; 543 for (sal_uInt16 i = 0; i < nOutlineCount; ++i) 544 { 545 const sal_Int8 nLevel = (sal_Int8)pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineLevel(i); 546 if(nLevel >= nOutlineLevel ) 547 nMemberCount--; 548 else 549 { 550 String aEntry(pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(i)); 551 aEntry.EraseLeadingChars(); 552 SwNavigationPI::CleanEntry( aEntry ); 553 SwOutlineContent* pCnt = new SwOutlineContent(this, aEntry, i, nLevel, 554 pWrtShell->IsOutlineMovable( i ), nPos ); 555 pMember->Insert(pCnt);//, nPos); 556 // bei gleicher Anzahl und vorhandenem pOldMember wird die 557 // alte mit der neuen OutlinePos verglichen 558 // cast fuer Win16 559 if(nOldMemberCount > (int)nPos && 560 ((SwOutlineContent*)pOldMember->GetObject(nPos))->GetOutlineLevel() != nLevel) 561 *pbLevelOrVisibiblityChanged = sal_True; 562 563 nPos++; 564 } 565 } 566 567 } 568 break; 569 570 case CONTENT_TYPE_TABLE : 571 { 572 DBG_ASSERT(nMemberCount == 573 pWrtShell->GetTblFrmFmtCount(sal_True), 574 "MemberCount differiert"); 575 Point aNullPt; 576 nMemberCount = pWrtShell->GetTblFrmFmtCount(sal_True); 577 for(sal_uInt16 i = 0; i < nMemberCount; i++) 578 { 579 const SwFrmFmt& rTblFmt = pWrtShell->GetTblFrmFmt(i, sal_True); 580 String sTblName( rTblFmt.GetName() ); 581 582 SwContent* pCnt = new SwContent(this, sTblName, 583 rTblFmt.FindLayoutRect(sal_False, &aNullPt).Top() ); 584 if( !rTblFmt.GetInfo( aAskItem ) && 585 !aAskItem.pObject ) // not visible 586 pCnt->SetInvisible(); 587 588 pMember->Insert(pCnt);//, i); 589 590 if(nOldMemberCount > (int)i && 591 (pOldMember->GetObject(i))->IsInvisible() != pCnt->IsInvisible()) 592 *pbLevelOrVisibiblityChanged = sal_True; 593 } 594 } 595 break; 596 case CONTENT_TYPE_OLE : 597 case CONTENT_TYPE_FRAME : 598 case CONTENT_TYPE_GRAPHIC : 599 { 600 FlyCntType eType = FLYCNTTYPE_FRM; 601 if(nContentType == CONTENT_TYPE_OLE) 602 eType = FLYCNTTYPE_OLE; 603 else if(nContentType == CONTENT_TYPE_GRAPHIC) 604 eType = FLYCNTTYPE_GRF; 605 DBG_ASSERT(nMemberCount == pWrtShell->GetFlyCount(eType), 606 "MemberCount differiert"); 607 Point aNullPt; 608 nMemberCount = pWrtShell->GetFlyCount(eType); 609 for(sal_uInt16 i = 0; i < nMemberCount; i++) 610 { 611 const SwFrmFmt* pFrmFmt = pWrtShell->GetFlyNum(i,eType); 612 String sFrmName = pFrmFmt->GetName(); 613 614 SwContent* pCnt; 615 if(CONTENT_TYPE_GRAPHIC == nContentType) 616 { 617 String sLink; 618 pWrtShell->GetGrfNms( &sLink, 0, (SwFlyFrmFmt*) pFrmFmt); 619 pCnt = new SwGraphicContent(this, sFrmName, 620 INetURLObject::decode( sLink, INET_HEX_ESCAPE, 621 INetURLObject::DECODE_UNAMBIGUOUS, 622 RTL_TEXTENCODING_UTF8 ), 623 pFrmFmt->FindLayoutRect(sal_False, &aNullPt).Top()); 624 } 625 else 626 { 627 pCnt = new SwContent(this, sFrmName, 628 pFrmFmt->FindLayoutRect(sal_False, &aNullPt).Top() ); 629 } 630 if( !pFrmFmt->GetInfo( aAskItem ) && 631 !aAskItem.pObject ) // not visible 632 pCnt->SetInvisible(); 633 pMember->Insert(pCnt);//, i); 634 if(nOldMemberCount > (int)i && 635 (pOldMember->GetObject(i))->IsInvisible() != pCnt->IsInvisible()) 636 *pbLevelOrVisibiblityChanged = sal_True; 637 } 638 } 639 break; 640 case CONTENT_TYPE_BOOKMARK: 641 { 642 IDocumentMarkAccess* const pMarkAccess = pWrtShell->getIDocumentMarkAccess(); 643 for(IDocumentMarkAccess::const_iterator_t ppBookmark = pMarkAccess->getBookmarksBegin(); 644 ppBookmark != pMarkAccess->getBookmarksEnd(); 645 ppBookmark++) 646 { 647 if(lcl_IsUiVisibleBookmark(*ppBookmark)) 648 { 649 const String& rBkmName = ppBookmark->get()->GetName(); 650 //nYPos von 0 -> text::Bookmarks werden nach Alphabet sortiert 651 SwContent* pCnt = new SwContent(this, rBkmName, 0); 652 pMember->Insert(pCnt);//, pMember->Count()); 653 } 654 } 655 } 656 break; 657 case CONTENT_TYPE_REGION : 658 { 659 const Point aNullPt; 660 nMemberCount = pWrtShell->GetSectionFmtCount(); 661 for(sal_uInt16 i = 0; i < nMemberCount; i++) 662 { 663 const SwSectionFmt* pFmt; 664 SectionType eTmpType; 665 if( (pFmt = &pWrtShell->GetSectionFmt(i))->IsInNodesArr() && 666 (eTmpType = pFmt->GetSection()->GetType()) != TOX_CONTENT_SECTION 667 && TOX_HEADER_SECTION != eTmpType ) 668 { 669 String sSectionName = pFmt->GetSection()->GetSectionName(); 670 671 sal_uInt8 nLevel = 0; 672 SwSectionFmt* pParentFmt = pFmt->GetParent(); 673 while(pParentFmt) 674 { 675 nLevel++; 676 pParentFmt = pParentFmt->GetParent(); 677 } 678 679 SwContent* pCnt = new SwRegionContent(this, sSectionName, 680 nLevel, 681 pFmt->FindLayoutRect( sal_False, &aNullPt ).Top()); 682 if( !pFmt->GetInfo( aAskItem ) && 683 !aAskItem.pObject ) // not visible 684 pCnt->SetInvisible(); 685 pMember->Insert(pCnt);//, pMember->Count()); 686 687 sal_uInt16 nPos = pMember->Count() - 1; 688 if(nOldMemberCount > nPos && 689 (pOldMember->GetObject(nPos))->IsInvisible() 690 != pCnt->IsInvisible()) 691 *pbLevelOrVisibiblityChanged = sal_True; 692 } 693 } 694 nMemberCount = pMember->Count(); 695 } 696 break; 697 case CONTENT_TYPE_REFERENCE: 698 { 699 SvStringsDtor aRefMarks; 700 nMemberCount = pWrtShell->GetRefMarks( &aRefMarks ); 701 702 for(sal_uInt16 i=0; i<nMemberCount; i++) 703 { 704 //Referenzen nach Alphabet sortiert 705 SwContent* pCnt = new SwContent( 706 this, *aRefMarks.GetObject(i), 0); 707 pMember->Insert(pCnt);//, i); 708 } 709 } 710 break; 711 case CONTENT_TYPE_URLFIELD: 712 { 713 SwGetINetAttrs aArr; 714 nMemberCount = pWrtShell->GetINetAttrs( aArr ); 715 for( sal_uInt16 n = 0; n < nMemberCount; ++n ) 716 { 717 SwGetINetAttr* p = aArr[ n ]; 718 SwURLFieldContent* pCnt = new SwURLFieldContent( 719 this, 720 p->sText, 721 INetURLObject::decode( 722 p->rINetAttr.GetINetFmt().GetValue(), 723 INET_HEX_ESCAPE, 724 INetURLObject::DECODE_UNAMBIGUOUS, 725 RTL_TEXTENCODING_UTF8 ), 726 &p->rINetAttr, 727 n ); 728 pMember->Insert( pCnt );//, n ); 729 } 730 } 731 break; 732 case CONTENT_TYPE_INDEX: 733 { 734 735 sal_uInt16 nCount = nMemberCount = pWrtShell->GetTOXCount(); 736 for ( sal_uInt16 nTox = 0; nTox < nCount; nTox++ ) 737 { 738 const SwTOXBase* pBase = pWrtShell->GetTOX( nTox ); 739 String sTOXNm( pBase->GetTOXName() ); 740 741 SwContent* pCnt = new SwTOXBaseContent( 742 this, sTOXNm, nTox, *pBase); 743 744 if( !pBase->GetInfo( aAskItem ) && 745 !aAskItem.pObject ) // not visible 746 pCnt->SetInvisible(); 747 748 pMember->Insert( pCnt );//, nTox ); 749 sal_uInt16 nPos = pMember->Count() - 1; 750 if(nOldMemberCount > nPos && 751 (pOldMember->GetObject(nPos))->IsInvisible() 752 != pCnt->IsInvisible()) 753 *pbLevelOrVisibiblityChanged = sal_True; 754 } 755 } 756 break; 757 case CONTENT_TYPE_POSTIT: 758 { 759 nMemberCount = 0; 760 if(!pMember) 761 pMember = new SwContentArr; 762 else if(pMember->Count()) 763 pMember->DeleteAndDestroy(0, pMember->Count()); 764 SwPostItMgr* aMgr = pWrtShell->GetView().GetPostItMgr(); 765 if (aMgr) 766 { 767 for(SwPostItMgr::const_iterator i = aMgr->begin(); i != aMgr->end(); ++i) 768 { 769 if ( (*i)->GetBroadCaster()->ISA(SwFmtFld)) // SwPostit 770 { 771 SwFmtFld* aFmtFld = static_cast<SwFmtFld*>((*i)->GetBroadCaster()); 772 if (aFmtFld->GetTxtFld() && aFmtFld->IsFldInDoc() && 773 (*i)->mLayoutStatus!=SwPostItHelper::INVISIBLE ) 774 { 775 String sEntry = aFmtFld->GetField()->GetPar2(); 776 RemoveNewline(sEntry); 777 SwPostItContent* pCnt = new SwPostItContent( 778 this, 779 sEntry, 780 (const SwFmtFld*)aFmtFld, 781 nMemberCount); 782 pMember->Insert(pCnt); 783 nMemberCount++; 784 } 785 } 786 /* this code can be used once we want redline comments in the margin 787 else // redcomment 788 { 789 SwRedline* pRedline = static_cast<SwRedline*>((*i)->GetBroadCaster()); 790 if ( pRedline->GetComment() != String(::rtl::OUString::createFromAscii("")) ) 791 { 792 String sEntry = pRedline->GetComment(); 793 RemoveNewline(sEntry); 794 SwPostItContent* pCnt = new SwPostItContent( 795 this, 796 sEntry, 797 pRedline, 798 nMemberCount); 799 pMember->Insert(pCnt); 800 nMemberCount++; 801 } 802 } 803 */ 804 } 805 } 806 // 807 } 808 break; 809 case CONTENT_TYPE_DRAWOBJECT: 810 { 811 nMemberCount = 0; 812 if(!pMember) 813 pMember = new SwContentArr; 814 else if(pMember->Count()) 815 pMember->DeleteAndDestroy(0, pMember->Count()); 816 817 IDocumentDrawModelAccess* pIDDMA = pWrtShell->getIDocumentDrawModelAccess(); 818 SdrModel* pModel = pIDDMA->GetDrawModel(); 819 if(pModel) 820 { 821 SdrPage* pPage = pModel->GetPage(0); 822 sal_uInt32 nCount = pPage->GetObjCount(); 823 for( sal_uInt32 i=0; i< nCount; i++ ) 824 { 825 SdrObject* pTemp = pPage->GetObj(i); 826 // --> OD 2006-03-09 #i51726# - all drawing objects can be named now 827 // if(pTemp->ISA(SdrObjGroup) && pTemp->GetName().Len()) 828 if ( pTemp->GetName().Len() ) 829 // <-- 830 { 831 SwContact* pContact = (SwContact*)pTemp->GetUserCall(); 832 long nYPos = 0; 833 const Point aNullPt; 834 if(pContact && pContact->GetFmt()) 835 nYPos = pContact->GetFmt()->FindLayoutRect(sal_False, &aNullPt).Top(); 836 SwContent* pCnt = new SwContent( 837 this, 838 pTemp->GetName(), 839 nYPos); 840 if(!pIDDMA->IsVisibleLayerId(pTemp->GetLayer())) 841 pCnt->SetInvisible(); 842 pMember->Insert(pCnt); 843 nMemberCount++; 844 if(nOldMemberCount > (int)i && 845 (pOldMember->GetObject((sal_uInt16)i))->IsInvisible() != pCnt->IsInvisible()) 846 *pbLevelOrVisibiblityChanged = sal_True; 847 } 848 } 849 } 850 } 851 break; 852 } 853 bDataValid = sal_True; 854 if(pOldMember) 855 pOldMember->DeleteAndDestroy(0, pOldMember->Count()); 856 857 } 858 859 /*************************************************************************** 860 Beschreibung: TreeListBox fuer Inhaltsanzeige 861 ***************************************************************************/ 862 863 864 SwContentTree::SwContentTree(Window* pParent, const ResId& rResId) : 865 SvTreeListBox( pParent, rResId ), 866 867 sSpace(C2S(" ")), 868 869 sRemoveIdx(SW_RES(ST_REMOVE_INDEX)), 870 sUpdateIdx(SW_RES(ST_UPDATE)), 871 sUnprotTbl(SW_RES(ST_REMOVE_TBL_PROTECTION)), 872 sRename(SW_RES(ST_RENAME)), 873 sReadonlyIdx(SW_RES(ST_READONLY_IDX)), 874 sInvisible(SW_RES(ST_INVISIBLE)), 875 876 sPostItShow(SW_RES(ST_POSTIT_SHOW)), 877 sPostItHide(SW_RES(ST_POSTIT_HIDE)), 878 sPostItDelete(SW_RES(ST_POSTIT_DELETE)), 879 880 pHiddenShell(0), 881 pActiveShell(0), 882 pConfig(SW_MOD()->GetNavigationConfig()), 883 884 nActiveBlock(0), 885 nHiddenBlock(0), 886 887 nRootType(USHRT_MAX), 888 nLastSelType(USHRT_MAX), 889 nOutlineLevel(MAXLEVEL), 890 891 bIsActive(sal_True), 892 bIsConstant(sal_False), 893 bIsHidden(sal_False), 894 bDocChgdInDragging(sal_False), 895 bIsInternalDrag(sal_False), 896 bIsRoot(sal_False), 897 bIsIdleClear(sal_False), 898 bIsLastReadOnly(sal_False), 899 bIsOutlineMoveable(sal_True), 900 bViewHasChanged(sal_False), 901 bIsImageListInitialized(sal_False), 902 bIsKeySpace(sal_False) //IAccessibility2 Implementation 2009 903 { 904 sal_uInt16 i; 905 906 SetHelpId(HID_NAVIGATOR_TREELIST); 907 908 SetNodeDefaultImages(); 909 SetDoubleClickHdl(LINK(this, SwContentTree, ContentDoubleClickHdl)); 910 SetDragDropMode(SV_DRAGDROP_APP_COPY); 911 for( i = 0; i < CONTENT_TYPE_MAX; i++) 912 { 913 aActiveContentArr[i] = 0; 914 aHiddenContentArr[i] = 0; 915 } 916 for( i = 0; i < CONTEXT_COUNT; i++ ) 917 { 918 aContextStrings[i] = SW_RESSTR(i+ST_CONTEXT_FIRST); 919 } 920 nActiveBlock = pConfig->GetActiveBlock(); 921 aUpdTimer.SetTimeoutHdl(LINK(this, SwContentTree, TimerUpdate)); 922 aUpdTimer.SetTimeout(1000); 923 Clear(); 924 EnableContextMenuHandling(); 925 SetStyle( GetStyle() | WB_QUICK_SEARCH ); 926 } 927 928 /*************************************************************************** 929 Beschreibung: 930 ***************************************************************************/ 931 932 933 SwContentTree::~SwContentTree() 934 { 935 Clear(); // vorher gfs. Inhaltstypen loeschen 936 bIsInDrag = sal_False; 937 } 938 939 //IAccessibility2 Implementation 2009----- 940 String SwContentTree::GetEntryAltText( SvLBoxEntry* pEntry ) const 941 { 942 if( pEntry == NULL) 943 return String(); 944 945 SwContent* pCnt = (SwContent*)pEntry->GetUserData(); 946 if( pCnt == NULL || pCnt->GetParent() == NULL) 947 return String(); 948 949 sal_uInt16 nJumpType = pCnt->GetParent()->GetType(); 950 SdrObject* pTemp; 951 952 switch(nJumpType) 953 { 954 case CONTENT_TYPE_DRAWOBJECT: 955 { 956 SdrView* pDrawView = pActiveShell->GetDrawView(); 957 if (pDrawView) 958 { 959 SdrModel* pDrawModel = pActiveShell->GetDoc()->GetDrawModel(); 960 SdrPage* pPage = pDrawModel->GetPage(0); 961 const sal_uInt32 nCount = pPage->GetObjCount(); 962 for( sal_uInt32 i=0; i< nCount; i++ ) 963 { 964 pTemp = pPage->GetObj(i); 965 sal_uInt16 nCmpId; 966 switch( pTemp->GetObjIdentifier() ) 967 { 968 case OBJ_GRUP: 969 case OBJ_TEXT: 970 case OBJ_TEXTEXT: 971 case OBJ_wegFITTEXT: 972 case OBJ_LINE: 973 case OBJ_RECT: 974 //caoxueqin added custom shape 975 case OBJ_CUSTOMSHAPE: 976 //end 2005/08/05 977 case OBJ_CIRC: 978 case OBJ_SECT: 979 case OBJ_CARC: 980 case OBJ_CCUT: 981 case OBJ_POLY: 982 case OBJ_PLIN: 983 case OBJ_PATHLINE: 984 case OBJ_PATHFILL: 985 case OBJ_FREELINE: 986 case OBJ_FREEFILL: 987 case OBJ_PATHPOLY: 988 case OBJ_PATHPLIN: 989 case OBJ_CAPTION: 990 nCmpId = OBJ_GRUP; 991 break; 992 default: 993 nCmpId = pTemp->GetObjIdentifier(); 994 } 995 if(nCmpId == OBJ_GRUP /*pTemp->ISA(SdrObjGroup)*/ && pTemp->GetName() == pCnt->GetName()) 996 { 997 return pTemp->GetTitle(); 998 } 999 //Commented End 1000 } 1001 } 1002 } 1003 break; 1004 case CONTENT_TYPE_GRAPHIC : 1005 { 1006 if( pActiveShell && pActiveShell->GetDoc() ) 1007 { 1008 const SwFlyFrmFmt* pFrmFmt = pActiveShell->GetDoc()->FindFlyByName( pCnt->GetName(), 0); 1009 if( pFrmFmt ) 1010 { 1011 // SwNodeIndex aIdx( *(pFrmFmt->GetCntnt().GetCntntIdx()), 1 ); 1012 // const SwGrfNode* pGrfNd = aIdx.GetNode().GetGrfNode(); 1013 // if( pGrfNd ) 1014 // return pGrfNd->GetAlternateText(); 1015 return pFrmFmt->GetObjTitle(); 1016 } 1017 } 1018 } 1019 break; 1020 case CONTENT_TYPE_OLE : 1021 case CONTENT_TYPE_FRAME : 1022 { 1023 //Can't find the GetAlternateText function. Need to verify again. 1024 const SwFlyFrmFmt* pFlyFmt = pActiveShell->GetDoc()->FindFlyByName( pCnt->GetName(), 0); 1025 if( pFlyFmt ) 1026 return pFlyFmt->/*GetAlternateText*/GetName(); 1027 } 1028 break; 1029 } 1030 return String(); 1031 } 1032 1033 String SwContentTree::GetEntryLongDescription( SvLBoxEntry* pEntry ) const 1034 { 1035 if( pEntry == NULL) 1036 return String(); 1037 1038 SwContent* pCnt = (SwContent*)pEntry->GetUserData(); 1039 if( pCnt == NULL || pCnt->GetParent() == NULL) 1040 return String(); 1041 1042 sal_uInt16 nJumpType = pCnt->GetParent()->GetType(); 1043 SdrObject* pTemp; 1044 1045 switch(nJumpType) 1046 { 1047 case CONTENT_TYPE_DRAWOBJECT: 1048 { 1049 SdrView* pDrawView = pActiveShell->GetDrawView(); 1050 if (pDrawView) 1051 { 1052 SdrModel* pDrawModel = pActiveShell->GetDoc()->GetDrawModel(); 1053 SdrPage* pPage = pDrawModel->GetPage(0); 1054 sal_uInt32 nCount = pPage->GetObjCount(); 1055 for( sal_uInt32 i=0; i< nCount; i++ ) 1056 { 1057 pTemp = pPage->GetObj(i); 1058 sal_uInt16 nCmpId; 1059 switch( pTemp->GetObjIdentifier() ) 1060 { 1061 case OBJ_GRUP: 1062 case OBJ_TEXT: 1063 case OBJ_TEXTEXT: 1064 case OBJ_wegFITTEXT: 1065 case OBJ_LINE: 1066 case OBJ_RECT: 1067 //caoxueqin added custom shape 1068 case OBJ_CUSTOMSHAPE: 1069 //end 2005/08/05 1070 case OBJ_CIRC: 1071 case OBJ_SECT: 1072 case OBJ_CARC: 1073 case OBJ_CCUT: 1074 case OBJ_POLY: 1075 case OBJ_PLIN: 1076 case OBJ_PATHLINE: 1077 case OBJ_PATHFILL: 1078 case OBJ_FREELINE: 1079 case OBJ_FREEFILL: 1080 case OBJ_PATHPOLY: 1081 case OBJ_PATHPLIN: 1082 case OBJ_CAPTION: 1083 nCmpId = OBJ_GRUP; 1084 break; 1085 default: 1086 nCmpId = pTemp->GetObjIdentifier(); 1087 } 1088 if(nCmpId == OBJ_GRUP /*pTemp->ISA(SdrObjGroup)*/ && pTemp->GetName() == pCnt->GetName()) 1089 { 1090 return pTemp->GetDescription(); 1091 } 1092 //Commented End 1093 } 1094 } 1095 } 1096 break; 1097 case CONTENT_TYPE_GRAPHIC : 1098 case CONTENT_TYPE_OLE : 1099 case CONTENT_TYPE_FRAME : 1100 { 1101 //Can't find the function "GetLongDescription". Need to verify again. 1102 const SwFlyFrmFmt* pFlyFmt = pActiveShell->GetDoc()->FindFlyByName( pCnt->GetName(), 0); 1103 if( pFlyFmt ) 1104 return pFlyFmt->GetDescription(); 1105 } 1106 break; 1107 } 1108 return String(); 1109 } 1110 1111 //-----IAccessibility2 Implementation 2009 1112 /*************************************************************************** 1113 Drag&Drop methods 1114 ***************************************************************************/ 1115 1116 void SwContentTree::StartDrag( sal_Int8 nAction, const Point& rPosPixel ) 1117 { 1118 if( !bIsRoot || nRootType != CONTENT_TYPE_OUTLINE ) 1119 { 1120 ReleaseMouse(); 1121 1122 TransferDataContainer* pContainer = new TransferDataContainer; 1123 uno::Reference< 1124 datatransfer::XTransferable > xRef( pContainer ); 1125 1126 sal_Int8 nDragMode = DND_ACTION_COPYMOVE | DND_ACTION_LINK; 1127 if( FillTransferData( *pContainer, nDragMode )) 1128 { 1129 SwContentTree::SetInDrag(sal_True); 1130 pContainer->StartDrag( this, nDragMode, GetDragFinishedHdl() ); 1131 } 1132 } 1133 else 1134 SvTreeListBox::StartDrag( nAction, rPosPixel ); 1135 } 1136 1137 void SwContentTree::DragFinished( sal_Int8 nAction ) 1138 { 1139 //to prevent the removing of the selected entry in external drag and drop 1140 // the drag action mustn't be MOVE 1141 SvTreeListBox::DragFinished( bIsInternalDrag ? nAction : DND_ACTION_COPY ); 1142 SwContentTree::SetInDrag(sal_False); 1143 bIsInternalDrag = sal_False; 1144 } 1145 1146 /*************************************************************************** 1147 Beschreibung: QueryDrop wird im Navigator ausgefuehrt 1148 ***************************************************************************/ 1149 sal_Int8 SwContentTree::AcceptDrop( const AcceptDropEvent& rEvt ) 1150 { 1151 sal_Int8 nRet = DND_ACTION_NONE; 1152 if( bIsRoot ) 1153 { 1154 if( bIsOutlineMoveable ) 1155 nRet = SvTreeListBox::AcceptDrop( rEvt ); 1156 } 1157 else if( !bIsInDrag ) 1158 nRet = GetParentWindow()->AcceptDrop( rEvt ); 1159 return nRet; 1160 } 1161 1162 /*************************************************************************** 1163 Beschreibung: Drop wird im Navigator ausgefuehrt 1164 ***************************************************************************/ 1165 sal_Int8 SwContentTree::ExecuteDrop( const ExecuteDropEvent& rEvt ) 1166 { 1167 if( bIsRoot ) 1168 return SvTreeListBox::ExecuteDrop( rEvt ); 1169 return bIsInDrag ? DND_ACTION_NONE : GetParentWindow()->ExecuteDrop(rEvt); 1170 } 1171 1172 1173 /*************************************************************************** 1174 Beschreibung: Handler fuer Dragging und ContextMenu 1175 ***************************************************************************/ 1176 PopupMenu* SwContentTree::CreateContextMenu( void ) 1177 { 1178 PopupMenu* pPop = new PopupMenu; 1179 PopupMenu* pSubPop1 = new PopupMenu; 1180 PopupMenu* pSubPop2 = new PopupMenu; 1181 PopupMenu* pSubPop3 = new PopupMenu; 1182 PopupMenu* pSubPop4 = new PopupMenu; // Edit 1183 1184 sal_uInt16 i; 1185 for(i = 1; i <= MAXLEVEL; i++ ) 1186 { 1187 pSubPop1->InsertItem( i + 100, String::CreateFromInt32(i)); 1188 } 1189 pSubPop1->CheckItem(100 + nOutlineLevel); 1190 for(i=0; i < 3; i++ ) 1191 { 1192 pSubPop2->InsertItem( i + 201, aContextStrings[ 1193 ST_HYPERLINK - ST_CONTEXT_FIRST + i]); 1194 } 1195 pSubPop2->CheckItem( 201 + 1196 GetParentWindow()->GetRegionDropMode()); 1197 //Liste der offenen Dateien einfuegen 1198 sal_uInt16 nId = 301; 1199 const SwView* pActiveView = ::GetActiveView(); 1200 SwView *pView = SwModule::GetFirstView(); 1201 while (pView) 1202 { 1203 String sInsert = pView->GetDocShell()->GetTitle(); 1204 if(pView == pActiveView) 1205 { 1206 sInsert += '('; 1207 sInsert += aContextStrings[ ST_ACTIVE - ST_CONTEXT_FIRST]; 1208 sInsert += ')'; 1209 } 1210 pSubPop3->InsertItem(nId, sInsert); 1211 if(bIsConstant && pActiveShell == &pView->GetWrtShell()) 1212 pSubPop3->CheckItem(nId); 1213 pView = SwModule::GetNextView(pView); 1214 nId++; 1215 } 1216 pSubPop3->InsertItem(nId++, aContextStrings[ST_ACTIVE_VIEW - ST_CONTEXT_FIRST]); 1217 if(pHiddenShell) 1218 { 1219 String sHiddenEntry = pHiddenShell->GetView().GetDocShell()->GetTitle(); 1220 sHiddenEntry += C2S(" ( "); 1221 sHiddenEntry += aContextStrings[ ST_HIDDEN - ST_CONTEXT_FIRST]; 1222 sHiddenEntry += C2S(" )"); 1223 pSubPop3->InsertItem(nId, sHiddenEntry); 1224 } 1225 1226 if(bIsActive) 1227 pSubPop3->CheckItem( --nId ); 1228 else if(bIsHidden) 1229 pSubPop3->CheckItem( nId ); 1230 1231 pPop->InsertItem( 1, aContextStrings[ST_OUTLINE_LEVEL - ST_CONTEXT_FIRST]); 1232 pPop->InsertItem(2, aContextStrings[ST_DRAGMODE - ST_CONTEXT_FIRST]); 1233 pPop->InsertItem(3, aContextStrings[ST_DISPLAY - ST_CONTEXT_FIRST]); 1234 //jetzt noch bearbeiten 1235 SvLBoxEntry* pEntry = 0; 1236 //Bearbeiten nur, wenn die angezeigten Inhalte aus der aktiven View kommen 1237 if((bIsActive || pActiveShell == pActiveView->GetWrtShellPtr()) 1238 && 0 != (pEntry = FirstSelected()) && lcl_IsContent(pEntry)) 1239 { 1240 const SwContentType* pContType = ((SwContent*)pEntry->GetUserData())->GetParent(); 1241 const sal_uInt16 nContentType = pContType->GetType(); 1242 sal_Bool bReadonly = pActiveShell->GetView().GetDocShell()->IsReadOnly(); 1243 sal_Bool bVisible = !((SwContent*)pEntry->GetUserData())->IsInvisible(); 1244 sal_Bool bProtected = ((SwContent*)pEntry->GetUserData())->IsProtect(); 1245 sal_Bool bEditable = pContType->IsEditable() && 1246 ((bVisible && !bProtected) ||CONTENT_TYPE_REGION == nContentType); 1247 sal_Bool bDeletable = pContType->IsDeletable() && 1248 ((bVisible && !bProtected) ||CONTENT_TYPE_REGION == nContentType); 1249 sal_Bool bRenamable = bEditable && !bReadonly && 1250 (CONTENT_TYPE_TABLE == nContentType || 1251 CONTENT_TYPE_FRAME == nContentType || 1252 CONTENT_TYPE_GRAPHIC == nContentType || 1253 CONTENT_TYPE_OLE == nContentType || 1254 CONTENT_TYPE_BOOKMARK == nContentType || 1255 CONTENT_TYPE_REGION == nContentType|| 1256 CONTENT_TYPE_INDEX == nContentType); 1257 1258 if(!bReadonly && (bEditable || bDeletable)) 1259 { 1260 sal_Bool bSubPop4 = sal_False; 1261 if(CONTENT_TYPE_INDEX == nContentType) 1262 { 1263 bSubPop4 = sal_True; 1264 pSubPop4->InsertItem(401, sRemoveIdx); 1265 pSubPop4->InsertItem(402, sUpdateIdx); 1266 1267 const SwTOXBase* pBase = ((SwTOXBaseContent*)pEntry->GetUserData())->GetTOXBase(); 1268 if(!pBase->IsTOXBaseInReadonly()) 1269 pSubPop4->InsertItem(403, aContextStrings[ST_EDIT_ENTRY - ST_CONTEXT_FIRST]); 1270 pSubPop4->InsertItem(405, sReadonlyIdx); 1271 1272 pSubPop4->CheckItem( 405, pActiveShell->IsTOXBaseReadonly(*pBase)); 1273 pSubPop4->InsertItem(501, aContextStrings[ST_DELETE_ENTRY - ST_CONTEXT_FIRST]); 1274 } 1275 else if(CONTENT_TYPE_TABLE == nContentType && !bReadonly) 1276 { 1277 bSubPop4 = sal_True; 1278 pSubPop4->InsertItem(403, aContextStrings[ST_EDIT_ENTRY - ST_CONTEXT_FIRST]); 1279 pSubPop4->InsertItem(404, sUnprotTbl); 1280 sal_Bool bFull = sal_False; 1281 String sTblName = ((SwContent*)pEntry->GetUserData())->GetName(); 1282 sal_Bool bProt =pActiveShell->HasTblAnyProtection( &sTblName, &bFull ); 1283 pSubPop4->EnableItem(403, !bFull ); 1284 pSubPop4->EnableItem(404, bProt ); 1285 pSubPop4->InsertItem(501, aContextStrings[ST_DELETE_ENTRY - ST_CONTEXT_FIRST]); 1286 } 1287 else if(bEditable || bDeletable) 1288 { 1289 1290 if(bEditable && bDeletable) 1291 { 1292 pSubPop4->InsertItem(403, aContextStrings[ST_EDIT_ENTRY - ST_CONTEXT_FIRST]); 1293 pSubPop4->InsertItem(501, aContextStrings[ST_DELETE_ENTRY - ST_CONTEXT_FIRST]); 1294 bSubPop4 = sal_True; 1295 } 1296 else if(bEditable) 1297 pPop->InsertItem(403, aContextStrings[ST_EDIT_ENTRY - ST_CONTEXT_FIRST]); 1298 else if(bDeletable) 1299 { 1300 pSubPop4->InsertItem(501, aContextStrings[ST_DELETE_ENTRY - ST_CONTEXT_FIRST]); 1301 } 1302 } 1303 //Rename object 1304 if(bRenamable) 1305 { 1306 if(bSubPop4) 1307 pSubPop4->InsertItem(502, sRename); 1308 else 1309 pPop->InsertItem(502, sRename); 1310 } 1311 1312 if(bSubPop4) 1313 { 1314 pPop->InsertItem(4, pContType->GetSingleName()); 1315 pPop->SetPopupMenu(4, pSubPop4); 1316 } 1317 } 1318 } 1319 else if( pEntry ) 1320 { 1321 SwContentType* pType = (SwContentType*)pEntry->GetUserData(); 1322 if ( (pType->GetType() == CONTENT_TYPE_POSTIT) && (!pActiveShell->GetView().GetDocShell()->IsReadOnly()) && ( pType->GetMemberCount() > 0) ) 1323 { 1324 pSubPop4->InsertItem(600, sPostItShow ); 1325 pSubPop4->InsertItem(601, sPostItHide ); 1326 pSubPop4->InsertItem(602, sPostItDelete ); 1327 /* 1328 pSubPop4->InsertItem(603,rtl::OUString::createFromAscii("Sort")); 1329 PopupMenu* pMenuSort = new PopupMenu; 1330 pMenuSort->InsertItem(604,rtl::OUString::createFromAscii("By Position")); 1331 pMenuSort->InsertItem(605,rtl::OUString::createFromAscii("By Author")); 1332 pMenuSort->InsertItem(606,rtl::OUString::createFromAscii("By Date")); 1333 pSubPop4->SetPopupMenu(603, pMenuSort); 1334 */ 1335 pPop->InsertItem(4, pType->GetSingleName()); 1336 pPop->SetPopupMenu(4, pSubPop4); 1337 } 1338 } 1339 1340 pPop->SetPopupMenu( 1, pSubPop1 ); 1341 pPop->SetPopupMenu( 2, pSubPop2 ); 1342 pPop->SetPopupMenu( 3, pSubPop3 ); 1343 return pPop; 1344 1345 } 1346 /*************************************************************************** 1347 Beschreibung: Einrueckung fuer outlines (und sections) 1348 ***************************************************************************/ 1349 1350 1351 long SwContentTree::GetTabPos( SvLBoxEntry* pEntry, SvLBoxTab* pTab) 1352 { 1353 sal_uInt16 nLevel = 0; 1354 if(lcl_IsContent(pEntry)) 1355 { 1356 nLevel++; 1357 SwContent* pCnt = (SwContent *) pEntry->GetUserData(); 1358 const SwContentType* pParent; 1359 if(pCnt && 0 != (pParent = pCnt->GetParent())) 1360 { 1361 if(pParent->GetType() == CONTENT_TYPE_OUTLINE) 1362 nLevel = nLevel + ((SwOutlineContent*)pCnt)->GetOutlineLevel(); 1363 else if(pParent->GetType() == CONTENT_TYPE_REGION) 1364 nLevel = nLevel + ((SwRegionContent*)pCnt)->GetRegionLevel(); 1365 } 1366 } 1367 sal_uInt16 nBasis = bIsRoot ? 0 : 5; 1368 return nLevel * 10 + nBasis + pTab->GetPos(); //empirisch ermittelt 1369 } 1370 1371 /*************************************************************************** 1372 Beschreibung: Inhalte werden erst auf Anforderung in die Box eingefuegt 1373 ***************************************************************************/ 1374 1375 1376 void SwContentTree::RequestingChilds( SvLBoxEntry* pParent ) 1377 { 1378 // ist es ein Inhaltstyp? 1379 if(lcl_IsContentType(pParent)) 1380 { 1381 if(!pParent->HasChilds()) 1382 { 1383 DBG_ASSERT(pParent->GetUserData(), "keine UserData?"); 1384 SwContentType* pCntType = (SwContentType*)pParent->GetUserData(); 1385 1386 sal_uInt16 nCount = pCntType->GetMemberCount(); 1387 for(sal_uInt16 i = 0; i < nCount; i++) 1388 { 1389 const SwContent* pCnt = pCntType->GetMember(i); 1390 if(pCnt) 1391 { 1392 String sEntry = pCnt->GetName(); 1393 if(!sEntry.Len()) 1394 sEntry = sSpace; 1395 SvLBoxEntry* pChild = InsertEntry(sEntry, pParent, 1396 sal_False, LIST_APPEND, (void*)pCnt); 1397 //IAccessibility2 Implementation 2009----- 1398 //Solution: If object is marked , the corresponding entry is set true , 1399 //else the corresponding entry is set false . 1400 //================================================== 1401 SdrObject * pObj = GetDrawingObjectsByContent(pCnt); 1402 if(pChild) 1403 pChild->SetMarked(sal_False); 1404 if(pObj) 1405 { 1406 SdrView* pDrawView = pActiveShell->GetDrawView(); 1407 SdrPageView* pPV = pDrawView->/*GetPageViewPvNum*/GetSdrPageView(/*0*/); 1408 if( pPV ) 1409 { 1410 sal_Bool Marked = pDrawView->IsObjMarked(pObj); 1411 if(Marked) 1412 { 1413 //sEntry += String::CreateFromAscii(" *"); 1414 pChild->SetMarked(sal_True); 1415 } 1416 1417 } 1418 } 1419 //-----IAccessibility2 Implementation 2009 1420 } 1421 } 1422 } 1423 } 1424 } 1425 /*************************************************************************** 1426 Beschreibung: Expand - Zustand fuer Inhaltstypen merken 1427 ***************************************************************************/ 1428 1429 //IAccessibility2 Implementation 2009----- 1430 //Solution: Get drawing Objects by content . 1431 SdrObject* SwContentTree::GetDrawingObjectsByContent(const SwContent *pCnt) 1432 { 1433 SdrObject *pRetObj = NULL; 1434 sal_uInt16 nJumpType = pCnt->GetParent()->GetType(); 1435 switch(nJumpType) 1436 { 1437 case CONTENT_TYPE_DRAWOBJECT: 1438 { 1439 SdrView* pDrawView = pActiveShell->GetDrawView(); 1440 if (pDrawView) 1441 { 1442 SdrModel* pDrawModel = pActiveShell->GetDoc()->GetDrawModel(); 1443 SdrPage* pPage = pDrawModel->GetPage(0); 1444 sal_uInt32 nCount = pPage->GetObjCount(); 1445 1446 for( sal_uInt32 i=0; i< nCount; i++ ) 1447 { 1448 SdrObject* pTemp = pPage->GetObj(i); 1449 if( pTemp->GetName() == pCnt->GetName()) 1450 { 1451 pRetObj = pTemp; 1452 break; 1453 } 1454 } 1455 } 1456 break; 1457 } 1458 default: 1459 pRetObj = NULL; 1460 } 1461 return pRetObj; 1462 } 1463 //-----IAccessibility2 Implementation 2009 1464 1465 sal_Bool SwContentTree::Expand( SvLBoxEntry* pParent ) 1466 { 1467 if(!bIsRoot) 1468 { 1469 if(lcl_IsContentType(pParent)) 1470 { 1471 SwContentType* pCntType = (SwContentType*)pParent->GetUserData(); 1472 sal_uInt16 nOr = 1 << pCntType->GetType(); //linear -> Bitposition 1473 if(bIsActive || bIsConstant) 1474 { 1475 nActiveBlock |= nOr; 1476 pConfig->SetActiveBlock(nActiveBlock); 1477 } 1478 else 1479 nHiddenBlock |= nOr; 1480 } 1481 } 1482 return SvTreeListBox::Expand(pParent); 1483 } 1484 /*************************************************************************** 1485 Beschreibung: Collapse - Zustand fuer Inhaltstypen merken 1486 ***************************************************************************/ 1487 1488 1489 sal_Bool SwContentTree::Collapse( SvLBoxEntry* pParent ) 1490 { 1491 sal_Bool bRet; 1492 if(!bIsRoot) 1493 { 1494 if(lcl_IsContentType(pParent)) 1495 { 1496 SwContentType* pCntType = (SwContentType*)pParent->GetUserData(); 1497 sal_uInt16 nAnd = 1 << pCntType->GetType(); 1498 nAnd = ~nAnd; 1499 if(bIsActive || bIsConstant) 1500 { 1501 nActiveBlock &= nAnd; 1502 pConfig->SetActiveBlock(nActiveBlock); 1503 } 1504 else 1505 nHiddenBlock &= nAnd; 1506 } 1507 bRet = SvTreeListBox::Collapse(pParent); 1508 } 1509 else 1510 bRet = sal_False; 1511 return bRet; 1512 } 1513 1514 1515 /*************************************************************************** 1516 Beschreibung: Auch auf Doppelclick wird zunaechst nur aufgeklappt 1517 ***************************************************************************/ 1518 1519 1520 IMPL_LINK( SwContentTree, ContentDoubleClickHdl, SwContentTree *, EMPTYARG ) 1521 { 1522 SvLBoxEntry* pEntry = GetCurEntry(); 1523 // ist es ein Inhaltstyp? 1524 DBG_ASSERT(pEntry, "kein aktueller Eintrag!"); 1525 if(pEntry) 1526 { 1527 if(lcl_IsContentType(pEntry)) 1528 RequestingChilds(pEntry); 1529 else if(bIsActive || bIsConstant) 1530 { 1531 if(bIsConstant) 1532 { 1533 pActiveShell->GetView().GetViewFrame()->GetWindow().ToTop(); 1534 } 1535 //Inhaltstyp anspringen: 1536 SwContent* pCnt = (SwContent*)pEntry->GetUserData(); 1537 DBG_ASSERT( pCnt, "keine UserData"); 1538 GotoContent(pCnt); 1539 if(pCnt->GetParent()->GetType() == CONTENT_TYPE_FRAME) 1540 pActiveShell->EnterStdMode(); 1541 } 1542 } 1543 return 0; 1544 } 1545 1546 /*************************************************************************** 1547 Beschreibung: Anzeigen der Datei 1548 ***************************************************************************/ 1549 1550 1551 void SwContentTree::Display( sal_Bool bActive ) 1552 { 1553 if(!bIsImageListInitialized) 1554 { 1555 sal_uInt16 nResId = GetSettings().GetStyleSettings().GetHighContrastMode() ? IMG_NAVI_ENTRYBMPH : IMG_NAVI_ENTRYBMP; 1556 aEntryImages = ImageList(SW_RES(nResId)); 1557 bIsImageListInitialized = sal_True; 1558 } 1559 // erst den selektierten Eintrag auslesen, um ihn spaeter evtl. wieder 1560 // zu selektieren -> die UserDaten sind hier nicht mehr gueltig! 1561 SvLBoxEntry* pOldSelEntry = FirstSelected(); 1562 String sEntryName; // Name des Eintrags 1563 sal_uInt16 nEntryRelPos = 0; // rel. Pos zu seinem Parent 1564 sal_uInt32 nOldEntryCount = GetEntryCount(); 1565 sal_Int32 nOldScrollPos = 0; 1566 if(pOldSelEntry) 1567 { 1568 ScrollBar* pVScroll = GetVScroll(); 1569 if(pVScroll && pVScroll->IsVisible()) 1570 nOldScrollPos = pVScroll->GetThumbPos(); 1571 1572 sEntryName = GetEntryText(pOldSelEntry); 1573 if(GetParent(pOldSelEntry)) 1574 { 1575 nEntryRelPos = (sal_uInt16)(GetModel()->GetAbsPos(pOldSelEntry) - GetModel()->GetAbsPos(GetParent(pOldSelEntry))); 1576 } 1577 } 1578 Clear(); 1579 SetUpdateMode( sal_False ); 1580 if(bActive && !bIsConstant && !bIsActive) 1581 bIsActive = bActive; 1582 bIsHidden = !bActive; 1583 SwWrtShell* pShell = GetWrtShell(); 1584 sal_Bool bReadOnly = pShell ? pShell->GetView().GetDocShell()->IsReadOnly() : sal_True; 1585 if(bReadOnly != bIsLastReadOnly) 1586 { 1587 bIsLastReadOnly = bReadOnly; 1588 sal_Bool bDisable = pShell == 0 || bReadOnly; 1589 SwNavigationPI* pNavi = GetParentWindow(); 1590 pNavi->aContentToolBox.EnableItem(FN_ITEM_UP , !bDisable); 1591 pNavi->aContentToolBox.EnableItem(FN_ITEM_DOWN, !bDisable); 1592 pNavi->aContentToolBox.EnableItem(FN_ITEM_LEFT, !bDisable); 1593 pNavi->aContentToolBox.EnableItem(FN_ITEM_RIGHT, !bDisable); 1594 pNavi->aContentToolBox.EnableItem(FN_SELECT_SET_AUTO_BOOKMARK, !bDisable); 1595 } 1596 if(pShell) 1597 { 1598 SvLBoxEntry* pSelEntry = 0; 1599 if(nRootType == USHRT_MAX) 1600 { 1601 for(sal_uInt16 nCntType = CONTENT_TYPE_OUTLINE; 1602 nCntType <= CONTENT_TYPE_DRAWOBJECT; nCntType++ ) 1603 { 1604 SwContentType** ppContentT = bActive ? 1605 &aActiveContentArr[nCntType] : 1606 &aHiddenContentArr[nCntType]; 1607 if(!*ppContentT) 1608 (*ppContentT) = new SwContentType(pShell, nCntType, nOutlineLevel ); 1609 1610 1611 String sEntry = (*ppContentT)->GetName(); 1612 SvLBoxEntry* pEntry; 1613 const Image& rImage = aEntryImages.GetImage(SID_SW_START + nCntType); 1614 sal_Bool bChOnDemand = 0 != (*ppContentT)->GetMemberCount(); 1615 pEntry = InsertEntry(sEntry, rImage, rImage, 1616 0, bChOnDemand, LIST_APPEND, (*ppContentT)); 1617 if(nCntType == nLastSelType) 1618 pSelEntry = pEntry; 1619 sal_Int32 nExpandOptions = bIsActive || bIsConstant ? 1620 nActiveBlock : 1621 nHiddenBlock; 1622 if(nExpandOptions & (1 << nCntType)) 1623 { 1624 Expand(pEntry); 1625 if(nEntryRelPos && nCntType == nLastSelType) 1626 { 1627 // jetzt vielleicht noch ein Child selektieren 1628 SvLBoxEntry* pChild = pEntry; 1629 SvLBoxEntry* pTemp = 0; 1630 sal_uInt16 nPos = 1; 1631 while(0 != (pChild = Next(pChild))) 1632 { 1633 // der alte Text wird leicht bevorzugt 1634 if(sEntryName == GetEntryText(pChild) || 1635 nPos == nEntryRelPos ) 1636 { 1637 pSelEntry = pChild; 1638 break; 1639 } 1640 pTemp = pChild; 1641 nPos++; 1642 } 1643 if(!pSelEntry || lcl_IsContentType(pSelEntry)) 1644 pSelEntry = pTemp; 1645 } 1646 1647 } 1648 } 1649 if(pSelEntry) 1650 { 1651 MakeVisible(pSelEntry); 1652 Select(pSelEntry); 1653 } 1654 else 1655 nOldScrollPos = 0; 1656 } 1657 else 1658 { 1659 SwContentType** ppRootContentT = bActive ? 1660 &aActiveContentArr[nRootType] : 1661 &aHiddenContentArr[nRootType]; 1662 if(!(*ppRootContentT)) 1663 (*ppRootContentT) = new SwContentType(pShell, nRootType, nOutlineLevel ); 1664 const Image& rImage = aEntryImages.GetImage(20000 + nRootType); 1665 SvLBoxEntry* pParent = InsertEntry( 1666 (*ppRootContentT)->GetName(), rImage, rImage, 1667 0, sal_False, LIST_APPEND, *ppRootContentT); 1668 1669 for(sal_uInt16 i = 0; i < (*ppRootContentT)->GetMemberCount(); i++ ) 1670 { 1671 const SwContent* pCnt = (*ppRootContentT)->GetMember(i); 1672 if(pCnt) 1673 { 1674 String sEntry = pCnt->GetName(); 1675 if(!sEntry.Len()) 1676 sEntry = sSpace; 1677 InsertEntry( sEntry, pParent, 1678 sal_False, LIST_APPEND, (void*)pCnt); 1679 } 1680 } 1681 Expand(pParent); 1682 if( nRootType == CONTENT_TYPE_OUTLINE && bIsActive ) 1683 { 1684 //feststellen, wo der Cursor steht 1685 const sal_uInt16 nActPos = pShell->GetOutlinePos(MAXLEVEL); 1686 SvLBoxEntry* pEntry = First(); 1687 1688 while( 0 != (pEntry = Next(pEntry)) ) 1689 { 1690 if(((SwOutlineContent*)pEntry->GetUserData())->GetPos() == nActPos) 1691 { 1692 MakeVisible(pEntry); 1693 Select(pEntry); 1694 } 1695 } 1696 1697 } 1698 else 1699 { 1700 // jetzt vielleicht noch ein Child selektieren 1701 SvLBoxEntry* pChild = pParent; 1702 SvLBoxEntry* pTemp = 0; 1703 sal_uInt16 nPos = 1; 1704 while(0 != (pChild = Next(pChild))) 1705 { 1706 // der alte Text wird leicht bevorzugt 1707 if(sEntryName == GetEntryText(pChild) || 1708 nPos == nEntryRelPos ) 1709 { 1710 pSelEntry = pChild; 1711 break; 1712 } 1713 pTemp = pChild; 1714 nPos++; 1715 } 1716 if(!pSelEntry) 1717 pSelEntry = pTemp; 1718 if(pSelEntry) 1719 { 1720 MakeVisible(pSelEntry); 1721 Select(pSelEntry); 1722 } 1723 } 1724 } 1725 } 1726 SetUpdateMode( sal_True ); 1727 ScrollBar* pVScroll = GetVScroll(); 1728 if(GetEntryCount() == nOldEntryCount && 1729 nOldScrollPos && pVScroll && pVScroll->IsVisible() 1730 && pVScroll->GetThumbPos() != nOldScrollPos) 1731 { 1732 sal_Int32 nDelta = pVScroll->GetThumbPos() - nOldScrollPos; 1733 ScrollOutputArea( (short)nDelta ); 1734 } 1735 1736 } 1737 1738 /*************************************************************************** 1739 Beschreibung: Im Clear muessen auch die ContentTypes geloescht werden 1740 ***************************************************************************/ 1741 1742 1743 void SwContentTree::Clear() 1744 { 1745 SetUpdateMode(sal_False); 1746 SvTreeListBox::Clear(); 1747 SetUpdateMode(sal_True); 1748 } 1749 1750 /*************************************************************************** 1751 Beschreibung: 1752 ***************************************************************************/ 1753 1754 sal_Bool SwContentTree::FillTransferData( TransferDataContainer& rTransfer, 1755 sal_Int8& rDragMode ) 1756 { 1757 SwWrtShell* pWrtShell = GetWrtShell(); 1758 DBG_ASSERT(pWrtShell, "keine Shell!"); 1759 SvLBoxEntry* pEntry = GetCurEntry(); 1760 if(!pEntry || lcl_IsContentType(pEntry) || !pWrtShell) 1761 return sal_False; 1762 String sEntry; 1763 SwContent* pCnt = ((SwContent*)pEntry->GetUserData()); 1764 1765 sal_uInt16 nActType = pCnt->GetParent()->GetType(); 1766 String sUrl; 1767 sal_Bool bOutline = sal_False; 1768 String sOutlineText; 1769 switch( nActType ) 1770 { 1771 case CONTENT_TYPE_OUTLINE: 1772 { 1773 sal_uInt16 nPos = ((SwOutlineContent*)pCnt)->GetPos(); 1774 DBG_ASSERT(nPos < pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount(), 1775 "outlinecnt veraendert"); 1776 1777 // #100738# make sure outline may actually be copied 1778 if( pWrtShell->IsOutlineCopyable( nPos ) ) 1779 { 1780 const SwNumRule* pOutlRule = pWrtShell->GetOutlineNumRule(); 1781 const SwTxtNode* pTxtNd = 1782 pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNode(nPos); 1783 if( pTxtNd && pOutlRule && pTxtNd->IsNumbered()) 1784 { 1785 SwNumberTree::tNumberVector aNumVector = 1786 pTxtNd->GetNumberVector(); 1787 for( sal_Int8 nLevel = 0; 1788 nLevel <= pTxtNd->GetActualListLevel(); 1789 nLevel++ ) 1790 { 1791 sal_uInt16 nVal = (sal_uInt16)aNumVector[nLevel]; 1792 nVal ++; 1793 nVal = nVal - pOutlRule->Get(nLevel).GetStart(); 1794 sEntry += String::CreateFromInt32( nVal ); 1795 sEntry += '.'; 1796 } 1797 } 1798 sEntry += pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(nPos, false); 1799 sOutlineText = pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(nPos, true); 1800 bIsOutlineMoveable = ((SwOutlineContent*)pCnt)->IsMoveable(); 1801 bOutline = sal_True; 1802 } 1803 } 1804 break; 1805 case CONTENT_TYPE_POSTIT: 1806 case CONTENT_TYPE_INDEX: 1807 case CONTENT_TYPE_REFERENCE : 1808 // koennen weder als URL noch als Bereich eingefuegt werden 1809 break; 1810 case CONTENT_TYPE_URLFIELD: 1811 sUrl = ((SwURLFieldContent*)pCnt)->GetURL(); 1812 // kein break; 1813 case CONTENT_TYPE_OLE: 1814 case CONTENT_TYPE_GRAPHIC: 1815 if(GetParentWindow()->GetRegionDropMode() != REGION_MODE_NONE) 1816 break; 1817 else 1818 rDragMode &= ~( DND_ACTION_MOVE | DND_ACTION_LINK ); 1819 default: 1820 sEntry = GetEntryText(pEntry); 1821 } 1822 1823 sal_Bool bRet = sal_False; 1824 if(sEntry.Len()) 1825 { 1826 const SwDocShell* pDocShell = pWrtShell->GetView().GetDocShell(); 1827 if(!sUrl.Len()) 1828 { 1829 if(pDocShell->HasName()) 1830 { 1831 SfxMedium* pMedium = pDocShell->GetMedium(); 1832 sUrl = pMedium->GetURLObject().GetURLNoMark(); 1833 // nur, wenn primaer ein Link eingefuegt werden soll 1834 bRet = sal_True; 1835 } 1836 else if( nActType == CONTENT_TYPE_REGION || 1837 nActType == CONTENT_TYPE_BOOKMARK ) 1838 { 1839 // fuer Bereich und Textmarken ist ein Link auch ohne 1840 // Dateiname ins eigene Dokument erlaubt 1841 bRet = sal_True; 1842 } 1843 else if(bIsConstant && 1844 ( !::GetActiveView() || 1845 pActiveShell != ::GetActiveView()->GetWrtShellPtr())) 1846 { 1847 // Urls von inaktiven Views ohne Dateinamen koennen auch nicht 1848 // gedraggt werden 1849 bRet = sal_False; 1850 } 1851 else 1852 { 1853 bRet = GetParentWindow()->GetRegionDropMode() == REGION_MODE_NONE; 1854 rDragMode = DND_ACTION_MOVE; 1855 } 1856 1857 const String& rToken = pCnt->GetParent()->GetTypeToken(); 1858 sUrl += '#'; 1859 sUrl += sEntry; 1860 if(rToken.Len()) 1861 { 1862 sUrl += cMarkSeperator; 1863 sUrl += rToken; 1864 } 1865 } 1866 else 1867 bRet = sal_True; 1868 1869 if( bRet ) 1870 { 1871 //fuer Outlines muss in die Description der Ueberschrifttext mit der echten Nummer 1872 if(bOutline) 1873 sEntry = sOutlineText; 1874 1875 { 1876 NaviContentBookmark aBmk( sUrl, sEntry, 1877 GetParentWindow()->GetRegionDropMode(), 1878 pDocShell); 1879 aBmk.Copy( rTransfer ); 1880 } 1881 1882 // fuer fremde DocShells muss eine INetBookmark 1883 // dazugeliefert werden 1884 if( pDocShell->HasName() ) 1885 { 1886 INetBookmark aBkmk( sUrl, sEntry ); 1887 rTransfer.CopyINetBookmark( aBkmk ); 1888 } 1889 } 1890 } 1891 return bRet; 1892 } 1893 /*************************************************************************** 1894 Beschreibung: Umschalten der Anzeige auf Root 1895 ***************************************************************************/ 1896 1897 1898 sal_Bool SwContentTree::ToggleToRoot() 1899 { 1900 if(!bIsRoot) 1901 { 1902 SvLBoxEntry* pEntry = GetCurEntry(); 1903 const SwContentType* pCntType; 1904 if(pEntry) 1905 { 1906 if(lcl_IsContentType(pEntry)) 1907 pCntType = (SwContentType*)pEntry->GetUserData(); 1908 else 1909 pCntType = ((SwContent*)pEntry->GetUserData())->GetParent(); 1910 nRootType = pCntType->GetType(); 1911 bIsRoot = sal_True; 1912 Display(bIsActive || bIsConstant); 1913 } 1914 } 1915 else 1916 { 1917 nRootType = USHRT_MAX; 1918 bIsRoot = sal_False; 1919 FindActiveTypeAndRemoveUserData(); 1920 Display(bIsActive || bIsConstant); 1921 } 1922 pConfig->SetRootType( nRootType ); 1923 GetParentWindow()->aContentToolBox.CheckItem(FN_SHOW_ROOT, bIsRoot); 1924 return bIsRoot; 1925 } 1926 1927 /*************************************************************************** 1928 Beschreibung: Angezeigten Inhalt auf Gueltigkeit pruefen 1929 ***************************************************************************/ 1930 1931 1932 sal_Bool SwContentTree::HasContentChanged() 1933 { 1934 /* 1935 -Parallel durch das lokale Array und die Treelistbox laufen. 1936 -Sind die Eintraege nicht expandiert, werden sie nur im Array verworfen 1937 und der Contenttype wird als UserData neu gesetzt. 1938 - ist der Root-Modus aktiv, wird nur dieser aktualisiert, 1939 fuer die nicht angezeigten Inhaltstypen gilt: 1940 die Memberliste wird geloescht und der Membercount aktualisiert 1941 Wenn Inhalte ueberprueft werden, werden gleichzeitig die vorhanden 1942 Memberlisten aufgefuellt. Sobald ein Unterschied auftritt wird nur noch 1943 gefuellt und nicht mehr ueberprueft. Abschliessend wird die Box neu gefuellt. 1944 1945 */ 1946 1947 sal_Bool bRepaint = sal_False; 1948 sal_Bool bInvalidate = sal_False; 1949 1950 if(!bIsActive && ! bIsConstant) 1951 { 1952 for(sal_uInt16 i=0; i < CONTENT_TYPE_MAX; i++) 1953 { 1954 if(aActiveContentArr[i]) 1955 aActiveContentArr[i]->Invalidate(); 1956 } 1957 } 1958 else if(bIsRoot) 1959 { 1960 sal_Bool bOutline = sal_False; 1961 SvLBoxEntry* pEntry = First(); 1962 if(!pEntry) 1963 bRepaint = sal_True; 1964 else 1965 { 1966 sal_uInt16 nType = ((SwContentType*)pEntry->GetUserData())->GetType(); 1967 bOutline = nRootType == CONTENT_TYPE_OUTLINE; 1968 SwContentType* pArrType = aActiveContentArr[nType]; 1969 if(!pArrType) 1970 bRepaint = sal_True; 1971 else 1972 { 1973 sal_uInt16 nSelLevel = USHRT_MAX; 1974 1975 SvLBoxEntry* pFirstSel; 1976 if(bOutline && 1977 0 != ( pFirstSel = FirstSelected()) && 1978 lcl_IsContent(pFirstSel)) 1979 { 1980 nSelLevel = ((SwOutlineContent*)pFirstSel->GetUserData())->GetOutlineLevel(); 1981 SwWrtShell* pSh = GetWrtShell(); 1982 sal_uInt16 nOutlinePos = pSh->GetOutlinePos(MAXLEVEL); 1983 bRepaint |= nOutlinePos != USHRT_MAX && 1984 pSh->getIDocumentOutlineNodesAccess()->getOutlineLevel(nOutlinePos) != nSelLevel; 1985 } 1986 1987 pArrType->Init(&bInvalidate); 1988 pArrType->FillMemberList(); 1989 pEntry->SetUserData((void*)pArrType); 1990 if(!bRepaint) 1991 { 1992 if(GetChildCount(pEntry) != pArrType->GetMemberCount()) 1993 bRepaint = sal_True; 1994 else 1995 { 1996 sal_uInt16 nChildCount = (sal_uInt16)GetChildCount(pEntry); 1997 for(sal_uInt16 j = 0; j < nChildCount; j++) 1998 { 1999 pEntry = Next(pEntry); 2000 const SwContent* pCnt = pArrType->GetMember(j); 2001 pEntry->SetUserData((void*)pCnt); 2002 String sEntryText = GetEntryText(pEntry); 2003 if( sEntryText != pCnt->GetName() && 2004 !(sEntryText == sSpace && !pCnt->GetName().Len())) 2005 bRepaint = sal_True; 2006 } 2007 } 2008 } 2009 } 2010 } 2011 if( !bRepaint && bOutline ) 2012 { 2013 //feststellen, wo der Cursor steht 2014 const sal_uInt16 nActPos = GetWrtShell()->GetOutlinePos(MAXLEVEL); 2015 SvLBoxEntry* pFirstEntry = First(); 2016 2017 while( 0 != (pFirstEntry = Next(pFirstEntry)) ) 2018 { 2019 if(((SwOutlineContent*)pFirstEntry->GetUserData())->GetPos() == nActPos) 2020 { 2021 if(FirstSelected() != pFirstEntry) 2022 { 2023 Select(pFirstEntry); 2024 MakeVisible(pFirstEntry); 2025 } 2026 } 2027 } 2028 2029 } 2030 2031 } 2032 else 2033 { 2034 SvLBoxEntry* pEntry = First(); 2035 while ( pEntry ) 2036 { 2037 sal_Bool bNext = sal_True; // mindestens ein Next muss sein 2038 SwContentType* pTreeType = (SwContentType*)pEntry->GetUserData(); 2039 sal_uInt16 nType = pTreeType->GetType(); 2040 sal_uInt16 nTreeCount = pTreeType->GetMemberCount(); 2041 SwContentType* pArrType = aActiveContentArr[nType]; 2042 if(!pArrType) 2043 bRepaint = sal_True; 2044 else 2045 { 2046 pArrType->Init(&bInvalidate); 2047 pEntry->SetUserData((void*)pArrType); 2048 if(IsExpanded(pEntry)) 2049 { 2050 sal_Bool bLevelOrVisibiblityChanged = sal_False; 2051 // bLevelOrVisibiblityChanged is set if outlines have changed their level 2052 // or if the visibility of objects (frames, sections, tables) has changed 2053 // i.e. in header/footer 2054 pArrType->FillMemberList(&bLevelOrVisibiblityChanged); 2055 if(bLevelOrVisibiblityChanged) 2056 bInvalidate = sal_True; 2057 sal_uInt16 nChildCount = (sal_uInt16)GetChildCount(pEntry); 2058 if(bLevelOrVisibiblityChanged) 2059 bInvalidate = sal_True; 2060 2061 if(nChildCount != pArrType->GetMemberCount()) 2062 bRepaint = sal_True; 2063 else 2064 { 2065 for(sal_uInt16 j = 0; j < nChildCount; j++) 2066 { 2067 pEntry = Next(pEntry); 2068 bNext = sal_False; 2069 const SwContent* pCnt = pArrType->GetMember(j); 2070 pEntry->SetUserData((void*)pCnt); 2071 String sEntryText = GetEntryText(pEntry); 2072 if( sEntryText != pCnt->GetName() && 2073 !(sEntryText == sSpace && !pCnt->GetName().Len())) 2074 bRepaint = sal_True; 2075 } 2076 } 2077 2078 } 2079 else if(pEntry->HasChilds()) 2080 { 2081 //war der Eintrag einmal aufgeklappt, dann muessen auch 2082 // die unsichtbaren Eintraege geprueft werden. 2083 // zumindest muessen die Userdaten aktualisiert werden 2084 sal_Bool bLevelOrVisibiblityChanged = sal_False; 2085 // bLevelOrVisibiblityChanged is set if outlines have changed their level 2086 // or if the visibility of objects (frames, sections, tables) has changed 2087 // i.e. in header/footer 2088 pArrType->FillMemberList(&bLevelOrVisibiblityChanged); 2089 sal_Bool bRemoveChildren = sal_False; 2090 sal_uInt16 nChildCount = (sal_uInt16)GetChildCount(pEntry); 2091 if( nChildCount != pArrType->GetMemberCount() ) 2092 { 2093 bRemoveChildren = sal_True; 2094 } 2095 else 2096 { 2097 SvLBoxEntry* pChild = FirstChild(pEntry); 2098 for(sal_uInt16 j = 0; j < nChildCount; j++) 2099 { 2100 const SwContent* pCnt = pArrType->GetMember(j); 2101 pChild->SetUserData((void*)pCnt); 2102 String sEntryText = GetEntryText(pChild); 2103 if( sEntryText != pCnt->GetName() && 2104 !(sEntryText == sSpace && !pCnt->GetName().Len())) 2105 bRemoveChildren = sal_True; 2106 pChild = Next(pChild); 2107 } 2108 } 2109 if(bRemoveChildren) 2110 { 2111 SvLBoxEntry* pChild = FirstChild(pEntry); 2112 SvLBoxEntry* pRemove = pChild; 2113 for(sal_uInt16 j = 0; j < nChildCount; j++) 2114 { 2115 pChild = Next(pRemove); 2116 GetModel()->Remove(pRemove); 2117 pRemove = pChild; 2118 } 2119 } 2120 if(!nChildCount) 2121 { 2122 pEntry->EnableChildsOnDemand(sal_False); 2123 InvalidateEntry(pEntry); 2124 } 2125 2126 } 2127 else if((nTreeCount != 0) 2128 != (pArrType->GetMemberCount()!=0)) 2129 { 2130 bRepaint = sal_True; 2131 } 2132 } 2133 //hier muss noch der naechste Root-Entry gefunden werden 2134 while( pEntry && (bNext || GetParent(pEntry ) )) 2135 { 2136 pEntry = Next(pEntry); 2137 bNext = sal_False; 2138 } 2139 } 2140 } 2141 if(!bRepaint && bInvalidate) 2142 Invalidate(); 2143 return bRepaint; 2144 } 2145 2146 /*************************************************************************** 2147 Beschreibung: Bevor alle Daten geloescht werden, soll noch der letzte 2148 * aktive Eintrag festgestellt werden. Dann werden die 2149 * UserData geloescht 2150 ***************************************************************************/ 2151 void SwContentTree::FindActiveTypeAndRemoveUserData() 2152 { 2153 SvLBoxEntry* pEntry = FirstSelected(); 2154 if(pEntry) 2155 { 2156 // wird Clear ueber TimerUpdate gerufen, kann nur fuer die Root 2157 // die Gueltigkeit der UserData garantiert werden 2158 SvLBoxEntry* pParent; 2159 while(0 != (pParent = GetParent(pEntry))) 2160 pEntry = pParent; 2161 if(pEntry->GetUserData() && lcl_IsContentType(pEntry)) 2162 nLastSelType = ((SwContentType*)pEntry->GetUserData())->GetType(); 2163 } 2164 // else 2165 // nLastSelType = USHRT_MAX; 2166 pEntry = First(); 2167 while(pEntry) 2168 { 2169 pEntry->SetUserData(0); 2170 pEntry = Next(pEntry); 2171 } 2172 } 2173 2174 /*************************************************************************** 2175 Beschreibung: Nachdem ein File auf den Navigator gedroppt wurde, 2176 wird die neue Shell gesetzt 2177 ***************************************************************************/ 2178 2179 2180 void SwContentTree::SetHiddenShell(SwWrtShell* pSh) 2181 { 2182 pHiddenShell = pSh; 2183 bIsHidden = sal_True; 2184 bIsActive = bIsConstant = sal_False; 2185 FindActiveTypeAndRemoveUserData(); 2186 for(sal_uInt16 i=0; i < CONTENT_TYPE_MAX; i++) 2187 { 2188 DELETEZ(aHiddenContentArr[i]); 2189 } 2190 Display(bIsActive); 2191 2192 GetParentWindow()->UpdateListBox(); 2193 } 2194 /*************************************************************************** 2195 Beschreibung: Dokumentwechsel - neue Shell setzen 2196 ***************************************************************************/ 2197 2198 2199 void SwContentTree::SetActiveShell(SwWrtShell* pSh) 2200 { 2201 if(bIsInternalDrag) 2202 bDocChgdInDragging = sal_True; 2203 sal_Bool bClear = pActiveShell != pSh; 2204 if(bIsActive && bClear) 2205 { 2206 pActiveShell = pSh; 2207 FindActiveTypeAndRemoveUserData(); 2208 Clear(); 2209 } 2210 else if(bIsConstant) 2211 { 2212 if(!lcl_FindShell(pActiveShell)) 2213 { 2214 pActiveShell = pSh; 2215 bIsActive = sal_True; 2216 bIsConstant = sal_False; 2217 bClear = sal_True; 2218 } 2219 } 2220 // nur wenn es die aktive View ist, wird das Array geloescht und 2221 // die Anzeige neu gefuellt 2222 if(bIsActive && bClear) 2223 { 2224 FindActiveTypeAndRemoveUserData(); 2225 for(sal_uInt16 i=0; i < CONTENT_TYPE_MAX; i++) 2226 { 2227 DELETEZ(aActiveContentArr[i]); 2228 } 2229 Display(sal_True); 2230 } 2231 } 2232 2233 /*************************************************************************** 2234 Beschreibung: Eine offene View als aktiv festlegen 2235 ***************************************************************************/ 2236 2237 2238 void SwContentTree::SetConstantShell(SwWrtShell* pSh) 2239 { 2240 pActiveShell = pSh; 2241 bIsActive = sal_False; 2242 bIsConstant = sal_True; 2243 FindActiveTypeAndRemoveUserData(); 2244 for(sal_uInt16 i=0; i < CONTENT_TYPE_MAX; i++) 2245 { 2246 DELETEZ(aActiveContentArr[i]); 2247 } 2248 Display(sal_True); 2249 } 2250 /*************************************************************************** 2251 Beschreibung: Kommandos des Navigators ausfuehren 2252 ***************************************************************************/ 2253 2254 2255 void SwContentTree::ExecCommand(sal_uInt16 nCmd, sal_Bool bModifier) 2256 { 2257 sal_Bool nMove = sal_False; 2258 switch( nCmd ) 2259 { 2260 case FN_ITEM_DOWN: 2261 case FN_ITEM_UP: nMove = sal_True; 2262 case FN_ITEM_LEFT: 2263 case FN_ITEM_RIGHT: 2264 if( !GetWrtShell()->GetView().GetDocShell()->IsReadOnly() && 2265 (bIsActive || 2266 (bIsConstant && pActiveShell == GetParentWindow()->GetCreateView()->GetWrtShellPtr()))) 2267 { 2268 SwWrtShell* pShell = GetWrtShell(); 2269 sal_Int8 nActOutlineLevel = nOutlineLevel; 2270 sal_uInt16 nActPos = pShell->GetOutlinePos(nActOutlineLevel); 2271 SvLBoxEntry* pFirstEntry = FirstSelected(); 2272 if (pFirstEntry && lcl_IsContent(pFirstEntry)) 2273 { 2274 if((bIsRoot && nRootType == CONTENT_TYPE_OUTLINE) || 2275 ((SwContent*)pFirstEntry->GetUserData())->GetParent()->GetType() 2276 == CONTENT_TYPE_OUTLINE) 2277 { 2278 nActPos = ((SwOutlineContent*)pFirstEntry->GetUserData())->GetPos(); 2279 } 2280 } 2281 if ( nActPos < USHRT_MAX && 2282 ( !nMove || pShell->IsOutlineMovable( nActPos )) ) 2283 { 2284 pShell->StartAllAction(); 2285 pShell->GotoOutline( nActPos); // Falls Textselektion != BoxSelektion 2286 pShell->Push(); 2287 pShell->MakeOutlineSel( nActPos, nActPos, 2288 bModifier); 2289 if( nMove ) 2290 { 2291 short nDir = nCmd == FN_ITEM_UP ? -1 : 1; 2292 if( !bModifier && ((nDir == -1 && nActPos > 0) || 2293 (nDir == 1 && nActPos < GetEntryCount() - 2 )) ) 2294 { 2295 pShell->MoveOutlinePara( nDir ); 2296 //Cursor wieder an die aktuelle Position setzen 2297 pShell->GotoOutline( nActPos + nDir); 2298 } 2299 else if(bModifier) 2300 { 2301 sal_uInt16 nActEndPos = nActPos; 2302 SvLBoxEntry* pEntry = pFirstEntry; 2303 sal_uInt16 nActLevel = ((SwOutlineContent*) 2304 pFirstEntry->GetUserData())->GetOutlineLevel(); 2305 pEntry = Next(pEntry); 2306 while( pEntry && CONTENT_TYPE_OUTLINE == 2307 ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId() ) 2308 { 2309 if(nActLevel >= ((SwOutlineContent*) 2310 pEntry->GetUserData())->GetOutlineLevel()) 2311 break; 2312 pEntry = Next(pEntry); 2313 nActEndPos++; 2314 } 2315 sal_uInt16 nDest; 2316 if(nDir == 1) 2317 { 2318 //Wenn der letzte Eintrag bewegt werden soll 2319 //ist Schluss 2320 if(pEntry && CONTENT_TYPE_OUTLINE == 2321 ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId()) 2322 { 2323 // pEntry zeigt jetzt auf den 2324 // dem letzten sel. Eintrag folgenden E. 2325 nDest = nActEndPos; 2326 nDest++; 2327 //hier muss der uebernaechste Eintrag 2328 //gefunden werden. Die Selektion muss davor eingefuegt 2329 //werden 2330 while(pEntry ) 2331 { 2332 pEntry = Next(pEntry); 2333 // nDest++ darf nur ausgefuehrt werden, 2334 // wenn pEntry != 0 2335 if(pEntry && nDest++ && 2336 ( nActLevel >= ((SwOutlineContent*)pEntry->GetUserData())->GetOutlineLevel()|| 2337 CONTENT_TYPE_OUTLINE != ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId())) 2338 { 2339 nDest--; 2340 break; 2341 } 2342 } 2343 nDir = nDest - nActEndPos; 2344 //wenn kein Eintrag gefunden wurde, der der Bedingung 2345 //fuer das zuvor Einfuegen entspricht, muss etwas weniger 2346 //geschoben werden 2347 } 2348 else 2349 nDir = 0; 2350 } 2351 else 2352 { 2353 nDest = nActPos; 2354 pEntry = pFirstEntry; 2355 while(pEntry && nDest ) 2356 { 2357 nDest--; 2358 pEntry = Prev(pEntry); 2359 if(pEntry && 2360 (nActLevel >= ((SwOutlineContent*)pEntry->GetUserData())->GetOutlineLevel()|| 2361 CONTENT_TYPE_OUTLINE != 2362 ((SwTypeNumber*)pEntry->GetUserData())->GetTypeId())) 2363 { 2364 break; 2365 } 2366 } 2367 nDir = nDest - nActPos; 2368 } 2369 if(nDir) 2370 { 2371 pShell->MoveOutlinePara( nDir ); 2372 //Cursor wieder an die aktuelle Position setzen 2373 pShell->GotoOutline( nActPos + nDir); 2374 } 2375 } 2376 } 2377 else 2378 { 2379 if( pShell->IsProtectedOutlinePara() ) 2380 Sound::Beep(); //konnte nicht umgestuft werden 2381 else 2382 pShell->OutlineUpDown( nCmd == FN_ITEM_LEFT ? -1 : 1 ); 2383 } 2384 2385 pShell->ClearMark(); 2386 pShell->Pop(sal_False); //Cursor steht jetzt wieder an der akt. Ueberschrift 2387 pShell->EndAllAction(); 2388 if(aActiveContentArr[CONTENT_TYPE_OUTLINE]) 2389 aActiveContentArr[CONTENT_TYPE_OUTLINE]->Invalidate(); 2390 Display(sal_True); 2391 if(!bIsRoot) 2392 { 2393 const sal_uInt16 nCurrPos = pShell->GetOutlinePos(MAXLEVEL); 2394 SvLBoxEntry* pFirst = First(); 2395 2396 while( 0 != (pFirst = Next(pFirst)) && lcl_IsContent(pFirst)) 2397 { 2398 if(((SwOutlineContent*)pFirst->GetUserData())->GetPos() == nCurrPos) 2399 { 2400 Select(pFirst); 2401 MakeVisible(pFirst); 2402 } 2403 } 2404 } 2405 } 2406 else 2407 Sound::Beep(); //konnte nicht verschoben werden 2408 } 2409 } 2410 } 2411 /*************************************************************************** 2412 Beschreibung: 2413 ***************************************************************************/ 2414 2415 2416 void SwContentTree::ShowTree() 2417 { 2418 aUpdTimer.Start(); 2419 SvTreeListBox::Show(); 2420 } 2421 2422 /*************************************************************************** 2423 Beschreibung: zusammengefaltet wird nicht geidlet 2424 ***************************************************************************/ 2425 2426 2427 void SwContentTree::HideTree() 2428 { 2429 aUpdTimer.Stop(); 2430 SvTreeListBox::Hide(); 2431 } 2432 2433 /*************************************************************************** 2434 Beschreibung: Kein Idle mit Focus oder waehrend des Dragging 2435 ***************************************************************************/ 2436 2437 2438 IMPL_LINK( SwContentTree, TimerUpdate, Timer*, EMPTYARG) 2439 { 2440 // kein Update waehrend D&D 2441 // Viewabfrage, da der Navigator zu spaet abgeraeumt wird 2442 SwView* pView = GetParentWindow()->GetCreateView(); 2443 if( (!HasFocus() || bViewHasChanged) && 2444 !bIsInDrag && !bIsInternalDrag && pView && 2445 pView->GetWrtShellPtr() && !pView->GetWrtShellPtr()->ActionPend() ) 2446 { 2447 bViewHasChanged = sal_False; 2448 bIsIdleClear = sal_False; 2449 SwWrtShell* pActShell = pView->GetWrtShellPtr(); 2450 if( bIsConstant && !lcl_FindShell( pActiveShell ) ) 2451 { 2452 SetActiveShell(pActShell); 2453 GetParentWindow()->UpdateListBox(); 2454 } 2455 2456 if(bIsActive && pActShell != GetWrtShell()) 2457 SetActiveShell(pActShell); 2458 else if( (bIsActive || (bIsConstant && pActShell == GetWrtShell())) && 2459 HasContentChanged()) 2460 { 2461 FindActiveTypeAndRemoveUserData(); 2462 Display(sal_True); 2463 //IAccessibility2 Implementation 2009----- 2464 //Solution: Set focus 2465 if( bIsKeySpace ) 2466 { 2467 HideFocus(); 2468 ShowFocus( oldRectangle); 2469 bIsKeySpace = sal_False; 2470 } 2471 //-----IAccessibility2 Implementation 2009 2472 } 2473 } 2474 else if(!pView && bIsActive && !bIsIdleClear) 2475 { 2476 if(pActiveShell) 2477 SetActiveShell(0); 2478 Clear(); 2479 bIsIdleClear = sal_True; 2480 } 2481 return 0; 2482 } 2483 2484 /*************************************************************************** 2485 Beschreibung: 2486 ***************************************************************************/ 2487 2488 2489 DragDropMode SwContentTree::NotifyStartDrag( 2490 TransferDataContainer& rContainer, 2491 SvLBoxEntry* pEntry ) 2492 { 2493 DragDropMode eMode = (DragDropMode)0; 2494 if( bIsActive && nRootType == CONTENT_TYPE_OUTLINE && 2495 GetModel()->GetAbsPos( pEntry ) > 0 2496 && !GetWrtShell()->GetView().GetDocShell()->IsReadOnly()) 2497 eMode = GetDragDropMode(); 2498 else if(!bIsActive && GetWrtShell()->GetView().GetDocShell()->HasName()) 2499 eMode = SV_DRAGDROP_APP_COPY; 2500 2501 sal_Int8 nDragMode; 2502 FillTransferData( rContainer, nDragMode ); 2503 bDocChgdInDragging = sal_False; 2504 bIsInternalDrag = sal_True; 2505 return eMode; 2506 } 2507 2508 2509 /*************************************************************************** 2510 Beschreibung : Nach dem Drag wird der aktuelle Absatz m i t 2511 Childs verschoben 2512 ***************************************************************************/ 2513 2514 2515 sal_Bool SwContentTree::NotifyMoving( SvLBoxEntry* pTarget, 2516 SvLBoxEntry* pEntry, SvLBoxEntry*& , sal_uLong& ) 2517 { 2518 if(!bDocChgdInDragging) 2519 { 2520 sal_uInt16 nTargetPos = 0; 2521 sal_uInt16 nSourcePos = (( SwOutlineContent* )pEntry->GetUserData())->GetPos(); 2522 if(!lcl_IsContent(pTarget)) 2523 nTargetPos = USHRT_MAX; 2524 else 2525 nTargetPos = (( SwOutlineContent* )pTarget->GetUserData())->GetPos(); 2526 if( MAXLEVEL > nOutlineLevel && // werden nicht alle Ebenen angezeigt 2527 nTargetPos != USHRT_MAX) 2528 { 2529 SvLBoxEntry* pNext = Next(pTarget); 2530 if(pNext) 2531 nTargetPos = (( SwOutlineContent* )pNext->GetUserData())->GetPos() -1; 2532 else 2533 nTargetPos = static_cast<sal_uInt16>(GetWrtShell()->getIDocumentOutlineNodesAccess()->getOutlineNodesCount())- 1; 2534 2535 } 2536 2537 DBG_ASSERT( pEntry && 2538 lcl_IsContent(pEntry),"Source == 0 oder Source hat keinen Content" ); 2539 GetParentWindow()->MoveOutline( nSourcePos, 2540 nTargetPos, 2541 sal_True); 2542 2543 aActiveContentArr[CONTENT_TYPE_OUTLINE]->Invalidate(); 2544 Display(sal_True); 2545 } 2546 //TreeListBox wird aus dem Dokument neu geladen 2547 return sal_False; 2548 } 2549 /*************************************************************************** 2550 Beschreibung : Nach dem Drag wird der aktuelle Absatz o h n e 2551 Childs verschoben 2552 ***************************************************************************/ 2553 2554 2555 sal_Bool SwContentTree::NotifyCopying( SvLBoxEntry* pTarget, 2556 SvLBoxEntry* pEntry, SvLBoxEntry*& , sal_uLong& ) 2557 { 2558 if(!bDocChgdInDragging) 2559 { 2560 sal_uInt16 nTargetPos = 0; 2561 sal_uInt16 nSourcePos = (( SwOutlineContent* )pEntry->GetUserData())->GetPos(); 2562 if(!lcl_IsContent(pTarget)) 2563 nTargetPos = USHRT_MAX; 2564 else 2565 nTargetPos = (( SwOutlineContent* )pTarget->GetUserData())->GetPos(); 2566 2567 if( MAXLEVEL > nOutlineLevel && // werden nicht alle Ebenen angezeigt 2568 nTargetPos != USHRT_MAX) 2569 { 2570 SvLBoxEntry* pNext = Next(pTarget); 2571 if(pNext) 2572 nTargetPos = (( SwOutlineContent* )pNext->GetUserData())->GetPos() - 1; 2573 else 2574 nTargetPos = static_cast<sal_uInt16>(GetWrtShell()->getIDocumentOutlineNodesAccess()->getOutlineNodesCount()) - 1; 2575 2576 } 2577 2578 2579 DBG_ASSERT( pEntry && 2580 lcl_IsContent(pEntry),"Source == 0 oder Source hat keinen Content" ); 2581 GetParentWindow()->MoveOutline( nSourcePos, nTargetPos, sal_False); 2582 2583 //TreeListBox wird aus dem Dokument neu geladen 2584 aActiveContentArr[CONTENT_TYPE_OUTLINE]->Invalidate(); 2585 Display(sal_True); 2586 } 2587 return sal_False; 2588 } 2589 2590 /*************************************************************************** 2591 Beschreibung: Kein Drop vor den ersten Eintrag - es ist ein SwContentType 2592 ***************************************************************************/ 2593 2594 sal_Bool SwContentTree::NotifyAcceptDrop( SvLBoxEntry* pEntry) 2595 { 2596 return pEntry != 0; 2597 } 2598 2599 2600 /*************************************************************************** 2601 Beschreibung: Wird ein Ctrl+DoubleClick in einen freien Bereich ausgefuehrt, 2602 * dann soll die Basisfunktion des Controls gerufen werden 2603 ***************************************************************************/ 2604 void SwContentTree::MouseButtonDown( const MouseEvent& rMEvt ) 2605 { 2606 Point aPos( rMEvt.GetPosPixel()); 2607 SvLBoxEntry* pEntry = GetEntry( aPos, sal_True ); 2608 if( !pEntry && rMEvt.IsLeft() && rMEvt.IsMod1() && (rMEvt.GetClicks() % 2) == 0) 2609 Control::MouseButtonDown( rMEvt ); 2610 else 2611 SvTreeListBox::MouseButtonDown( rMEvt ); 2612 } 2613 2614 /*************************************************************************** 2615 Beschreibung: sofort aktualisieren 2616 ***************************************************************************/ 2617 2618 2619 void SwContentTree::GetFocus() 2620 { 2621 SwView* pActView = GetParentWindow()->GetCreateView(); 2622 if(pActView) 2623 { 2624 SwWrtShell* pActShell = pActView->GetWrtShellPtr(); 2625 if(bIsConstant && !lcl_FindShell(pActiveShell)) 2626 { 2627 SetActiveShell(pActShell); 2628 } 2629 2630 if(bIsActive && pActShell != GetWrtShell()) 2631 SetActiveShell(pActShell); 2632 else if( (bIsActive || (bIsConstant && pActShell == GetWrtShell())) && 2633 HasContentChanged()) 2634 { 2635 Display(sal_True); 2636 } 2637 } 2638 else if(bIsActive) 2639 Clear(); 2640 SvTreeListBox::GetFocus(); 2641 } 2642 2643 /*************************************************************************** 2644 Beschreibung: 2645 ***************************************************************************/ 2646 2647 2648 void SwContentTree::KeyInput(const KeyEvent& rEvent) 2649 { 2650 const KeyCode aCode = rEvent.GetKeyCode(); 2651 if(aCode.GetCode() == KEY_RETURN) 2652 { 2653 SvLBoxEntry* pEntry = FirstSelected(); 2654 if ( pEntry ) 2655 { 2656 switch(aCode.GetModifier()) 2657 { 2658 case KEY_MOD2: 2659 // Boxen umschalten 2660 GetParentWindow()->ToggleTree(); 2661 break; 2662 case KEY_MOD1: 2663 // RootModus umschalten 2664 ToggleToRoot(); 2665 break; 2666 case 0: 2667 if(lcl_IsContentType(pEntry)) 2668 { 2669 IsExpanded(pEntry) ? 2670 Collapse(pEntry) : 2671 Expand(pEntry); 2672 } 2673 else 2674 ContentDoubleClickHdl(0); 2675 break; 2676 } 2677 } 2678 } 2679 else if(aCode.GetCode() == KEY_DELETE && 0 == aCode.GetModifier()) 2680 { 2681 SvLBoxEntry* pEntry = FirstSelected(); 2682 if(pEntry && 2683 lcl_IsContent(pEntry) && 2684 ((SwContent*)pEntry->GetUserData())->GetParent()->IsDeletable() && 2685 !pActiveShell->GetView().GetDocShell()->IsReadOnly()) 2686 { 2687 EditEntry(pEntry, EDIT_MODE_DELETE); 2688 bViewHasChanged = sal_True; 2689 GetParentWindow()->UpdateListBox(); 2690 TimerUpdate(&aUpdTimer); 2691 GrabFocus(); 2692 } 2693 } 2694 //IAccessibility2 Implementation 2009----- 2695 //Solution: Make KEY_SPACE has same function as DoubleClick , 2696 //and realize multi-selection . 2697 else if(aCode.GetCode() == KEY_SPACE && 0 == aCode.GetModifier()) 2698 { 2699 2700 SvLBoxEntry* pEntry = GetCurEntry(); 2701 if( GetChildCount( pEntry ) == 0 ) 2702 bIsKeySpace = sal_True; 2703 Point tempPoint = GetEntryPosition( pEntry );//Change from "GetEntryPos" to "GetEntryPosition" for acc migration 2704 oldRectangle = GetFocusRect( pEntry,tempPoint.Y() ); 2705 2706 if(pEntry) 2707 { 2708 if(bIsActive || bIsConstant) 2709 { 2710 if(bIsConstant) 2711 { 2712 pActiveShell->GetView().GetViewFrame()->GetWindow().ToTop(); 2713 } 2714 2715 SwContent* pCnt = (SwContent*)pEntry->GetUserData(); 2716 2717 sal_Bool bSel = sal_False; 2718 sal_uInt16 nJumpType = pCnt->GetParent()->GetType(); 2719 switch(nJumpType) 2720 { 2721 case CONTENT_TYPE_DRAWOBJECT: 2722 { 2723 SdrView* pDrawView = pActiveShell->GetDrawView(); 2724 if (pDrawView) 2725 { 2726 pDrawView->SdrEndTextEdit();//Change from "EndTextEdit" to "SdrEndTextEdit" for acc migration 2727 2728 SdrModel* pDrawModel = pActiveShell->GetDoc()->GetDrawModel(); 2729 SdrPage* pPage = pDrawModel->GetPage(0); 2730 sal_uInt32 nCount = pPage->GetObjCount(); 2731 sal_Bool hasObjectMarked = sal_False; 2732 2733 SdrObject* pObject = NULL; 2734 pObject = GetDrawingObjectsByContent( pCnt ); 2735 if( pObject ) 2736 { 2737 SdrPageView* pPV = pDrawView->GetSdrPageView/*GetPageViewPvNum*/(/*0*/); 2738 if( pPV ) 2739 { 2740 sal_Bool bUnMark = pDrawView->IsObjMarked(pObject); 2741 pDrawView->MarkObj( pObject, pPV, bUnMark); 2742 2743 } 2744 } 2745 for( sal_uInt32 i=0; i< nCount; i++ ) 2746 { 2747 SdrObject* pTemp = pPage->GetObj(i); 2748 sal_uInt16 nCmpId; 2749 sal_Bool bMark = pDrawView->IsObjMarked(pTemp); 2750 switch( pTemp->GetObjIdentifier() ) 2751 { 2752 case OBJ_GRUP: 2753 case OBJ_TEXT: 2754 case OBJ_TEXTEXT: 2755 case OBJ_wegFITTEXT: 2756 case OBJ_LINE: 2757 case OBJ_RECT: 2758 case OBJ_CIRC: 2759 case OBJ_SECT: 2760 case OBJ_CARC: 2761 case OBJ_CCUT: 2762 case OBJ_POLY: 2763 case OBJ_PLIN: 2764 case OBJ_PATHLINE: 2765 case OBJ_PATHFILL: 2766 case OBJ_FREELINE: 2767 case OBJ_FREEFILL: 2768 case OBJ_PATHPOLY: 2769 case OBJ_PATHPLIN: 2770 case OBJ_CAPTION: 2771 case OBJ_CUSTOMSHAPE: 2772 nCmpId = OBJ_GRUP; 2773 if( bMark ) 2774 hasObjectMarked = sal_True; 2775 break; 2776 default: 2777 nCmpId = pTemp->GetObjIdentifier(); 2778 //IAccessibility2 Implementation 2009----- 2779 if ( bMark ) 2780 { 2781 SdrPageView* pPV = pDrawView->GetSdrPageView/*GetPageViewPvNum*/(/*0*/); 2782 if (pPV) 2783 { 2784 pDrawView->MarkObj(pTemp, pPV, sal_True); 2785 } 2786 } 2787 //-----IAccessibility2 Implementation 2009 2788 } 2789 //mod end 2790 } 2791 if ( pActiveShell && !hasObjectMarked ) 2792 { 2793 SwEditWin& pEditWindow = 2794 pActiveShell->GetView().GetEditWin(); 2795 if( &pEditWindow ) 2796 { 2797 KeyCode tempKeycode( KEY_ESCAPE ); 2798 KeyEvent rKEvt( 0 , tempKeycode ); 2799 ((Window*)&pEditWindow)->KeyInput( rKEvt ); 2800 2801 } 2802 //rView.GetEditWin().GrabFocus(); 2803 } 2804 } 2805 } 2806 break; 2807 } 2808 2809 2810 bViewHasChanged = sal_True; 2811 } 2812 } 2813 2814 } 2815 //-----IAccessibility2 Implementation 2009 2816 else 2817 SvTreeListBox::KeyInput(rEvent); 2818 2819 } 2820 2821 /*************************************************************************** 2822 Beschreibung: 2823 ***************************************************************************/ 2824 2825 2826 void SwContentTree::RequestHelp( const HelpEvent& rHEvt ) 2827 { 2828 sal_Bool bCallBase = sal_True; 2829 if( rHEvt.GetMode() & HELPMODE_QUICK ) 2830 { 2831 Point aPos( ScreenToOutputPixel( rHEvt.GetMousePosPixel() )); 2832 SvLBoxEntry* pEntry = GetEntry( aPos ); 2833 if( pEntry ) 2834 { 2835 sal_uInt16 nType; 2836 sal_Bool bBalloon = sal_False; 2837 sal_Bool bContent = sal_False; 2838 void* pUserData = pEntry->GetUserData(); 2839 if(lcl_IsContentType(pEntry)) 2840 nType = ((SwContentType*)pUserData)->GetType(); 2841 else 2842 { 2843 nType = ((SwContent*)pUserData)->GetParent()->GetType(); 2844 bContent = sal_True; 2845 } 2846 String sEntry; 2847 sal_Bool bRet = sal_False; 2848 if(bContent) 2849 { 2850 switch( nType ) 2851 { 2852 case CONTENT_TYPE_URLFIELD: 2853 sEntry = ((SwURLFieldContent*)pUserData)->GetURL(); 2854 bRet = sal_True; 2855 break; 2856 2857 case CONTENT_TYPE_POSTIT: 2858 sEntry = ((SwPostItContent*)pUserData)->GetName(); 2859 bRet = sal_True; 2860 if(Help::IsBalloonHelpEnabled()) 2861 bBalloon = sal_True; 2862 break; 2863 case CONTENT_TYPE_OUTLINE: 2864 sEntry = ((SwOutlineContent*)pUserData)->GetName(); 2865 bRet = sal_True; 2866 break; 2867 case CONTENT_TYPE_GRAPHIC: 2868 sEntry = ((SwGraphicContent*)pUserData)->GetLink(); 2869 #if OSL_DEBUG_LEVEL > 1 2870 sEntry += ' '; 2871 sEntry += String::CreateFromInt32( 2872 ((SwGraphicContent*)pUserData)->GetYPos()); 2873 #endif 2874 bRet = sal_True; 2875 break; 2876 #if OSL_DEBUG_LEVEL > 1 2877 case CONTENT_TYPE_TABLE: 2878 case CONTENT_TYPE_FRAME: 2879 sEntry = String::CreateFromInt32( 2880 ((SwContent*)pUserData)->GetYPos() ); 2881 bRet = sal_True; 2882 break; 2883 #endif 2884 } 2885 if(((SwContent*)pUserData)->IsInvisible()) 2886 { 2887 if(sEntry.Len()) 2888 sEntry += C2S(", "); 2889 sEntry += sInvisible; 2890 bRet = sal_True; 2891 } 2892 } 2893 else 2894 { 2895 sal_uInt16 nMemberCount = ((SwContentType*)pUserData)->GetMemberCount(); 2896 sEntry = String::CreateFromInt32(nMemberCount); 2897 sEntry += ' '; 2898 sEntry += nMemberCount == 1 2899 ? ((SwContentType*)pUserData)->GetSingleName() 2900 : ((SwContentType*)pUserData)->GetName(); 2901 bRet = sal_True; 2902 } 2903 if(bRet) 2904 { 2905 SvLBoxTab* pTab; 2906 SvLBoxItem* pItem = GetItem( pEntry, aPos.X(), &pTab ); 2907 if( pItem && SV_ITEM_ID_LBOXSTRING == pItem->IsA()) 2908 { 2909 aPos = GetEntryPosition( pEntry ); 2910 2911 aPos.X() = GetTabPos( pEntry, pTab ); 2912 Size aSize( pItem->GetSize( this, pEntry ) ); 2913 2914 if((aPos.X() + aSize.Width()) > GetSizePixel().Width()) 2915 aSize.Width() = GetSizePixel().Width() - aPos.X(); 2916 2917 aPos = OutputToScreenPixel(aPos); 2918 Rectangle aItemRect( aPos, aSize ); 2919 if(bBalloon) 2920 { 2921 aPos.X() += aSize.Width(); 2922 Help::ShowBalloon( this, aPos, aItemRect, sEntry ); 2923 } 2924 else 2925 Help::ShowQuickHelp( this, aItemRect, sEntry, 2926 QUICKHELP_LEFT|QUICKHELP_VCENTER ); 2927 bCallBase = sal_False; 2928 } 2929 } 2930 else 2931 { 2932 Help::ShowQuickHelp( this, Rectangle(), aEmptyStr, 0 ); 2933 bCallBase = sal_False; 2934 } 2935 } 2936 } 2937 if( bCallBase ) 2938 Window::RequestHelp( rHEvt ); 2939 } 2940 2941 /*************************************************************************** 2942 Beschreibung: 2943 ***************************************************************************/ 2944 2945 2946 void SwContentTree::ExcecuteContextMenuAction( sal_uInt16 nSelectedPopupEntry ) 2947 { 2948 SvLBoxEntry* pFirst = FirstSelected(); 2949 switch( nSelectedPopupEntry ) 2950 { 2951 //Outlinelevel 2952 case 101: 2953 case 102: 2954 case 103: 2955 case 104: 2956 case 105: 2957 case 106: 2958 case 107: 2959 case 108: 2960 case 109: 2961 case 110: 2962 nSelectedPopupEntry -= 100; 2963 if(nOutlineLevel != nSelectedPopupEntry ) 2964 SetOutlineLevel((sal_Int8)nSelectedPopupEntry); 2965 break; 2966 case 201: 2967 case 202: 2968 case 203: 2969 GetParentWindow()->SetRegionDropMode(nSelectedPopupEntry - 201); 2970 break; 2971 case 401: 2972 case 402: 2973 EditEntry(pFirst, nSelectedPopupEntry == 401 ? EDIT_MODE_RMV_IDX : EDIT_MODE_UPD_IDX); 2974 break; 2975 // Eintrag bearbeiten 2976 case 403: 2977 EditEntry(pFirst, EDIT_MODE_EDIT); 2978 break; 2979 case 404: 2980 EditEntry(pFirst, EDIT_UNPROTECT_TABLE); 2981 break; 2982 case 405 : 2983 { 2984 const SwTOXBase* pBase = ((SwTOXBaseContent*)pFirst->GetUserData()) 2985 ->GetTOXBase(); 2986 pActiveShell->SetTOXBaseReadonly(*pBase, !pActiveShell->IsTOXBaseReadonly(*pBase)); 2987 } 2988 break; 2989 case 4: 2990 break; 2991 case 501: 2992 EditEntry(pFirst, EDIT_MODE_DELETE); 2993 break; 2994 case 502 : 2995 EditEntry(pFirst, EDIT_MODE_RENAME); 2996 break; 2997 case 600: 2998 pActiveShell->GetView().GetPostItMgr()->Show(); 2999 break; 3000 case 601: 3001 pActiveShell->GetView().GetPostItMgr()->Hide(); 3002 break; 3003 case 602: 3004 { 3005 pActiveShell->GetView().GetPostItMgr()->SetActiveSidebarWin(0); 3006 pActiveShell->GetView().GetPostItMgr()->Delete(); 3007 break; 3008 } 3009 //Anzeige 3010 default: // nSelectedPopupEntry > 300 3011 if(nSelectedPopupEntry > 300 && nSelectedPopupEntry < 400) 3012 { 3013 nSelectedPopupEntry -= 300; 3014 SwView *pView = SwModule::GetFirstView(); 3015 while (pView) 3016 { 3017 nSelectedPopupEntry --; 3018 if(nSelectedPopupEntry == 0) 3019 { 3020 SetConstantShell(&pView->GetWrtShell()); 3021 break; 3022 } 3023 pView = SwModule::GetNextView(pView); 3024 } 3025 if(nSelectedPopupEntry) 3026 { 3027 bViewHasChanged = bIsActive = nSelectedPopupEntry == 1; 3028 bIsConstant = sal_False; 3029 Display(nSelectedPopupEntry == 1); 3030 } 3031 } 3032 } 3033 GetParentWindow()->UpdateListBox(); 3034 } 3035 3036 /*************************************************************************** 3037 Beschreibung: 3038 ***************************************************************************/ 3039 3040 3041 void SwContentTree::SetOutlineLevel(sal_uInt8 nSet) 3042 { 3043 nOutlineLevel = nSet; 3044 pConfig->SetOutlineLevel( nOutlineLevel ); 3045 SwContentType** ppContentT = bIsActive ? 3046 &aActiveContentArr[CONTENT_TYPE_OUTLINE] : 3047 &aHiddenContentArr[CONTENT_TYPE_OUTLINE]; 3048 if(*ppContentT) 3049 { 3050 (*ppContentT)->SetOutlineLevel(nOutlineLevel); 3051 (*ppContentT)->Init(); 3052 } 3053 Display(bIsActive); 3054 } 3055 3056 /*************************************************************************** 3057 Beschreibung: Moduswechsel: gedropptes Doc anzeigen 3058 ***************************************************************************/ 3059 3060 3061 void SwContentTree::ShowHiddenShell() 3062 { 3063 if(pHiddenShell) 3064 { 3065 bIsConstant = sal_False; 3066 bIsActive = sal_False; 3067 Display(sal_False); 3068 } 3069 } 3070 3071 /*************************************************************************** 3072 Beschreibung: Moduswechsel: aktive Sicht anzeigen 3073 ***************************************************************************/ 3074 3075 3076 void SwContentTree::ShowActualView() 3077 { 3078 bIsActive = sal_True; 3079 bIsConstant = sal_False; 3080 Display(sal_True); 3081 GetParentWindow()->UpdateListBox(); 3082 } 3083 3084 /*-----------------20.11.96 13.34------------------- 3085 Beschreibung: Hier sollen die Buttons zum Verschieben von 3086 Outlines en-/disabled werden 3087 --------------------------------------------------*/ 3088 3089 sal_Bool SwContentTree::Select( SvLBoxEntry* pEntry, sal_Bool bSelect ) 3090 { 3091 if(!pEntry) 3092 return sal_False; 3093 sal_Bool bEnable = sal_False; 3094 SvLBoxEntry* pParentEntry = GetParent(pEntry); 3095 if(!bIsLastReadOnly && (!IsVisible() || 3096 ((bIsRoot && nRootType == CONTENT_TYPE_OUTLINE && pParentEntry) || 3097 (lcl_IsContent(pEntry) && ((SwContentType*)pParentEntry->GetUserData())->GetType() == CONTENT_TYPE_OUTLINE)))) 3098 bEnable = sal_True; 3099 SwNavigationPI* pNavi = GetParentWindow(); 3100 pNavi->aContentToolBox.EnableItem(FN_ITEM_UP , bEnable); 3101 pNavi->aContentToolBox.EnableItem(FN_ITEM_DOWN, bEnable); 3102 pNavi->aContentToolBox.EnableItem(FN_ITEM_LEFT, bEnable); 3103 pNavi->aContentToolBox.EnableItem(FN_ITEM_RIGHT,bEnable); 3104 3105 return SvTreeListBox::Select(pEntry, bSelect); 3106 } 3107 3108 /*-----------------27.11.96 12.56------------------- 3109 3110 --------------------------------------------------*/ 3111 3112 void SwContentTree::SetRootType(sal_uInt16 nType) 3113 { 3114 nRootType = nType; 3115 bIsRoot = sal_True; 3116 pConfig->SetRootType( nRootType ); 3117 } 3118 3119 /*-----------------10.01.97 12.19------------------- 3120 3121 --------------------------------------------------*/ 3122 3123 void SwContentType::RemoveNewline(String& rEntry) 3124 { 3125 sal_Unicode* pStr = rEntry.GetBufferAccess(); 3126 for(xub_StrLen i = rEntry.Len(); i; --i, ++pStr ) 3127 { 3128 if( *pStr == 10 || *pStr == 13 ) 3129 *pStr = 0x20; 3130 } 3131 } 3132 3133 /*-----------------14.01.97 16.38------------------- 3134 3135 --------------------------------------------------*/ 3136 3137 void SwContentTree::EditEntry(SvLBoxEntry* pEntry, sal_uInt8 nMode) 3138 { 3139 SwContent* pCnt = (SwContent*)pEntry->GetUserData(); 3140 GotoContent(pCnt); 3141 sal_uInt16 nType = pCnt->GetParent()->GetType(); 3142 sal_uInt16 nSlot = 0; 3143 3144 uno::Reference< container::XNameAccess > xNameAccess, xSecond, xThird; 3145 switch(nType) 3146 { 3147 case CONTENT_TYPE_TABLE : 3148 if(nMode == EDIT_UNPROTECT_TABLE) 3149 { 3150 pActiveShell->GetView().GetDocShell()-> 3151 GetDoc()->UnProtectCells( pCnt->GetName()); 3152 } 3153 else if(nMode == EDIT_MODE_DELETE) 3154 { 3155 pActiveShell->StartAction(); 3156 String sTable = SW_RES(STR_TABLE_NAME); 3157 SwRewriter aRewriterTableName; 3158 aRewriterTableName.AddRule(UNDO_ARG1, SW_RES(STR_START_QUOTE)); 3159 aRewriterTableName.AddRule(UNDO_ARG2, pCnt->GetName()); 3160 aRewriterTableName.AddRule(UNDO_ARG3, SW_RES(STR_END_QUOTE)); 3161 sTable = aRewriterTableName.Apply(sTable); 3162 3163 SwRewriter aRewriter; 3164 aRewriter.AddRule(UNDO_ARG1, sTable); 3165 pActiveShell->StartUndo(UNDO_DELETE, &aRewriter); 3166 pActiveShell->GetView().GetViewFrame()->GetDispatcher()->Execute(FN_TABLE_SELECT_ALL); 3167 pActiveShell->DeleteRow(); 3168 pActiveShell->EndUndo(); 3169 pActiveShell->EndAction(); 3170 } 3171 else if(nMode == EDIT_MODE_RENAME) 3172 { 3173 uno::Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3174 uno::Reference< text::XTextTablesSupplier > xTables(xModel, uno::UNO_QUERY); 3175 xNameAccess = xTables->getTextTables(); 3176 } 3177 else 3178 nSlot = FN_FORMAT_TABLE_DLG; 3179 break; 3180 3181 case CONTENT_TYPE_GRAPHIC : 3182 if(nMode == EDIT_MODE_DELETE) 3183 { 3184 pActiveShell->DelRight(); 3185 } 3186 else if(nMode == EDIT_MODE_RENAME) 3187 { 3188 uno::Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3189 uno::Reference< text::XTextGraphicObjectsSupplier > xGraphics(xModel, uno::UNO_QUERY); 3190 xNameAccess = xGraphics->getGraphicObjects(); 3191 uno::Reference< text::XTextFramesSupplier > xFrms(xModel, uno::UNO_QUERY); 3192 xSecond = xFrms->getTextFrames(); 3193 uno::Reference< text::XTextEmbeddedObjectsSupplier > xObjs(xModel, uno::UNO_QUERY); 3194 xThird = xObjs->getEmbeddedObjects(); 3195 } 3196 else 3197 nSlot = FN_FORMAT_GRAFIC_DLG; 3198 break; 3199 3200 case CONTENT_TYPE_FRAME : 3201 case CONTENT_TYPE_OLE : 3202 if(nMode == EDIT_MODE_DELETE) 3203 { 3204 pActiveShell->DelRight(); 3205 } 3206 else if(nMode == EDIT_MODE_RENAME) 3207 { 3208 uno::Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3209 uno::Reference< text::XTextFramesSupplier > xFrms(xModel, uno::UNO_QUERY); 3210 uno::Reference< text::XTextEmbeddedObjectsSupplier > xObjs(xModel, uno::UNO_QUERY); 3211 if(CONTENT_TYPE_FRAME == nType) 3212 { 3213 xNameAccess = xFrms->getTextFrames(); 3214 xSecond = xObjs->getEmbeddedObjects(); 3215 } 3216 else 3217 { 3218 xNameAccess = xObjs->getEmbeddedObjects(); 3219 xSecond = xFrms->getTextFrames(); 3220 } 3221 uno::Reference< text::XTextGraphicObjectsSupplier > xGraphics(xModel, uno::UNO_QUERY); 3222 xThird = xGraphics->getGraphicObjects(); 3223 } 3224 else 3225 nSlot = FN_FORMAT_FRAME_DLG; 3226 break; 3227 case CONTENT_TYPE_BOOKMARK : 3228 if(nMode == EDIT_MODE_DELETE) 3229 { 3230 IDocumentMarkAccess* const pMarkAccess = pActiveShell->getIDocumentMarkAccess(); 3231 pMarkAccess->deleteMark( pMarkAccess->findMark(pCnt->GetName()) ); 3232 } 3233 else if(nMode == EDIT_MODE_RENAME) 3234 { 3235 uno::Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3236 uno::Reference< text::XBookmarksSupplier > xBkms(xModel, uno::UNO_QUERY); 3237 xNameAccess = xBkms->getBookmarks(); 3238 } 3239 else 3240 nSlot = FN_INSERT_BOOKMARK; 3241 break; 3242 3243 case CONTENT_TYPE_REGION : 3244 if(nMode == EDIT_MODE_RENAME) 3245 { 3246 uno::Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3247 uno::Reference< text::XTextSectionsSupplier > xSects(xModel, uno::UNO_QUERY); 3248 xNameAccess = xSects->getTextSections(); 3249 } 3250 else 3251 nSlot = FN_EDIT_REGION; 3252 break; 3253 3254 case CONTENT_TYPE_URLFIELD: 3255 nSlot = FN_EDIT_HYPERLINK; 3256 break; 3257 case CONTENT_TYPE_REFERENCE: 3258 nSlot = FN_EDIT_FIELD; 3259 break; 3260 3261 case CONTENT_TYPE_POSTIT: 3262 pActiveShell->GetView().GetPostItMgr()->AssureStdModeAtShell(); 3263 if(nMode == EDIT_MODE_DELETE) 3264 { 3265 if (((SwPostItContent*)pCnt)->IsPostIt()) 3266 { 3267 pActiveShell->GetView().GetPostItMgr()->SetActiveSidebarWin(0); 3268 pActiveShell->DelRight(); 3269 } 3270 /* 3271 // this code can be used once we want redline comments in the margin 3272 else 3273 { 3274 SwMarginWin* pComment = pActiveShell->GetView().GetPostItMgr()->GetPostIt(((SwPostItContent*)pCnt)->GetRedline()); 3275 if (pComment) 3276 pComment->Delete(); 3277 } 3278 */ 3279 } 3280 else 3281 { 3282 if (((SwPostItContent*)pCnt)->IsPostIt()) 3283 nSlot = FN_POSTIT; 3284 else 3285 nSlot = FN_REDLINE_COMMENT; 3286 } 3287 break; 3288 case CONTENT_TYPE_INDEX: 3289 { 3290 const SwTOXBase* pBase = ((SwTOXBaseContent*)pCnt)->GetTOXBase(); 3291 switch(nMode) 3292 { 3293 case EDIT_MODE_EDIT: 3294 if(pBase) 3295 { 3296 SwPtrItem aPtrItem( FN_INSERT_MULTI_TOX, (void*)pBase); 3297 pActiveShell->GetView().GetViewFrame()-> 3298 GetDispatcher()->Execute(FN_INSERT_MULTI_TOX, 3299 SFX_CALLMODE_ASYNCHRON, &aPtrItem, 0L); 3300 3301 } 3302 break; 3303 case EDIT_MODE_RMV_IDX: 3304 case EDIT_MODE_DELETE: 3305 { 3306 if( pBase ) 3307 pActiveShell->DeleteTOX(*pBase, EDIT_MODE_DELETE == nMode); 3308 } 3309 break; 3310 case EDIT_MODE_UPD_IDX: 3311 case EDIT_MODE_RENAME: 3312 { 3313 Reference< frame::XModel > xModel = pActiveShell->GetView().GetDocShell()->GetBaseModel(); 3314 Reference< XDocumentIndexesSupplier > xIndexes(xModel, UNO_QUERY); 3315 Reference< XIndexAccess> xIdxAcc(xIndexes->getDocumentIndexes()); 3316 Reference< XNameAccess >xLocalNameAccess(xIdxAcc, UNO_QUERY); 3317 if(EDIT_MODE_RENAME == nMode) 3318 xNameAccess = xLocalNameAccess; 3319 else if(xLocalNameAccess.is() && xLocalNameAccess->hasByName(pBase->GetTOXName())) 3320 { 3321 Any aIdx = xLocalNameAccess->getByName(pBase->GetTOXName()); 3322 Reference< XDocumentIndex> xIdx; 3323 if(aIdx >>= xIdx) 3324 xIdx->update(); 3325 } 3326 } 3327 break; 3328 } 3329 } 3330 break; 3331 case CONTENT_TYPE_DRAWOBJECT : 3332 if(EDIT_MODE_DELETE == nMode) 3333 nSlot = SID_DELETE; 3334 break; 3335 } 3336 if(nSlot) 3337 pActiveShell->GetView().GetViewFrame()-> 3338 GetDispatcher()->Execute(nSlot, SFX_CALLMODE_ASYNCHRON); 3339 else if(xNameAccess.is()) 3340 { 3341 uno::Any aObj = xNameAccess->getByName(pCnt->GetName()); 3342 uno::Reference< uno::XInterface > xTmp; 3343 aObj >>= xTmp; 3344 uno::Reference< container::XNamed > xNamed(xTmp, uno::UNO_QUERY); 3345 SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); 3346 DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!"); 3347 3348 AbstractSwRenameXNamedDlg* pDlg = pFact->CreateSwRenameXNamedDlg( this, xNamed, xNameAccess, DLG_RENAME_XNAMED ); 3349 DBG_ASSERT(pDlg, "Dialogdiet fail!"); 3350 if(xSecond.is()) 3351 pDlg->SetAlternativeAccess( xSecond, xThird); 3352 3353 String sForbiddenChars; 3354 if(CONTENT_TYPE_BOOKMARK == nType) 3355 { 3356 sForbiddenChars = C2S("/\\@:*?\";,.#"); 3357 } 3358 else if(CONTENT_TYPE_TABLE == nType) 3359 { 3360 sForbiddenChars = C2S(" .<>"); 3361 } 3362 pDlg->SetForbiddenChars(sForbiddenChars); 3363 pDlg->Execute(); 3364 delete pDlg; 3365 } 3366 } 3367 3368 /*-----------------14.01.97 16.53------------------- 3369 3370 --------------------------------------------------*/ 3371 3372 void SwContentTree::GotoContent(SwContent* pCnt) 3373 { 3374 pActiveShell->EnterStdMode(); 3375 3376 sal_Bool bSel = sal_False; 3377 sal_uInt16 nJumpType = pCnt->GetParent()->GetType(); 3378 switch(nJumpType) 3379 { 3380 case CONTENT_TYPE_OUTLINE : 3381 { 3382 pActiveShell->GotoOutline(((SwOutlineContent*)pCnt)->GetPos()); 3383 } 3384 break; 3385 case CONTENT_TYPE_TABLE : 3386 { 3387 pActiveShell->GotoTable(pCnt->GetName()); 3388 } 3389 break; 3390 case CONTENT_TYPE_FRAME : 3391 case CONTENT_TYPE_GRAPHIC : 3392 case CONTENT_TYPE_OLE : 3393 { 3394 if(pActiveShell->GotoFly(pCnt->GetName())) 3395 bSel = sal_True; 3396 } 3397 break; 3398 case CONTENT_TYPE_BOOKMARK: 3399 { 3400 pActiveShell->GotoMark(pCnt->GetName()); 3401 } 3402 break; 3403 case CONTENT_TYPE_REGION : 3404 { 3405 pActiveShell->GotoRegion(pCnt->GetName()); 3406 } 3407 break; 3408 case CONTENT_TYPE_URLFIELD: 3409 { 3410 if(pActiveShell->GotoINetAttr( 3411 *((SwURLFieldContent*)pCnt)->GetINetAttr() )) 3412 { 3413 pActiveShell->Right( CRSR_SKIP_CHARS, sal_True, 1, sal_False); 3414 pActiveShell->SwCrsrShell::SelectTxtAttr( RES_TXTATR_INETFMT, sal_True ); 3415 } 3416 3417 } 3418 break; 3419 case CONTENT_TYPE_REFERENCE: 3420 { 3421 pActiveShell->GotoRefMark(pCnt->GetName()); 3422 } 3423 break; 3424 case CONTENT_TYPE_INDEX: 3425 { 3426 if (!pActiveShell->GotoNextTOXBase(&pCnt->GetName())) 3427 pActiveShell->GotoPrevTOXBase(&pCnt->GetName()); 3428 } 3429 break; 3430 case CONTENT_TYPE_POSTIT: 3431 pActiveShell->GetView().GetPostItMgr()->AssureStdModeAtShell(); 3432 if (((SwPostItContent*)pCnt)->IsPostIt()) 3433 pActiveShell->GotoFld(*((SwPostItContent*)pCnt)->GetPostIt()); 3434 else 3435 pActiveShell->GetView().GetDocShell()->GetWrtShell()->GotoRedline( 3436 pActiveShell->GetView().GetDocShell()->GetWrtShell()->FindRedlineOfData(((SwPostItContent*)pCnt)->GetRedline()->GetRedlineData())); 3437 3438 break; 3439 case CONTENT_TYPE_DRAWOBJECT: 3440 { 3441 SdrView* pDrawView = pActiveShell->GetDrawView(); 3442 if (pDrawView) 3443 { 3444 pDrawView->SdrEndTextEdit(); 3445 pDrawView->UnmarkAll(); 3446 SdrModel* _pModel = pActiveShell->getIDocumentDrawModelAccess()->GetDrawModel(); 3447 SdrPage* pPage = _pModel->GetPage(0); 3448 sal_uInt32 nCount = pPage->GetObjCount(); 3449 for( sal_uInt32 i=0; i< nCount; i++ ) 3450 { 3451 SdrObject* pTemp = pPage->GetObj(i); 3452 // --> OD 2006-03-09 #i51726# - all drawing objects can be named now 3453 // if(pTemp->ISA(SdrObjGroup) && pTemp->GetName() == pCnt->GetName()) 3454 if ( pTemp->GetName() == pCnt->GetName() ) 3455 // <-- 3456 { 3457 SdrPageView* pPV = pDrawView->GetSdrPageView(); 3458 if( pPV ) 3459 { 3460 pDrawView->MarkObj( pTemp, pPV ); 3461 } 3462 } 3463 } 3464 } 3465 } 3466 break; 3467 } 3468 if(bSel) 3469 { 3470 pActiveShell->HideCrsr(); 3471 pActiveShell->EnterSelFrmMode(); 3472 } 3473 SwView& rView = pActiveShell->GetView(); 3474 rView.StopShellTimer(); 3475 rView.GetPostItMgr()->SetActiveSidebarWin(0); 3476 rView.GetEditWin().GrabFocus(); 3477 } 3478 /*-----------------06.02.97 19.14------------------- 3479 Jetzt nochtdie passende text::Bookmark 3480 --------------------------------------------------*/ 3481 3482 NaviContentBookmark::NaviContentBookmark() 3483 : 3484 nDocSh(0), 3485 nDefDrag( REGION_MODE_NONE ) 3486 { 3487 } 3488 3489 /*-----------------06.02.97 20.12------------------- 3490 3491 --------------------------------------------------*/ 3492 3493 NaviContentBookmark::NaviContentBookmark( const String &rUrl, 3494 const String& rDesc, 3495 sal_uInt16 nDragType, 3496 const SwDocShell* pDocSh ) : 3497 aUrl( rUrl ), 3498 aDescr(rDesc), 3499 nDocSh((long)pDocSh), 3500 nDefDrag( nDragType ) 3501 { 3502 } 3503 3504 void NaviContentBookmark::Copy( TransferDataContainer& rData ) const 3505 { 3506 rtl_TextEncoding eSysCSet = gsl_getSystemTextEncoding(); 3507 3508 ByteString sStr( aUrl, eSysCSet ); 3509 sStr += static_cast< char >(NAVI_BOOKMARK_DELIM); 3510 sStr += ByteString( aDescr, eSysCSet ); 3511 sStr += static_cast< char >(NAVI_BOOKMARK_DELIM); 3512 sStr += ByteString::CreateFromInt32( nDefDrag ); 3513 sStr += static_cast< char >(NAVI_BOOKMARK_DELIM); 3514 sStr += ByteString::CreateFromInt32( nDocSh ); 3515 rData.CopyByteString( SOT_FORMATSTR_ID_SONLK, sStr ); 3516 } 3517 3518 sal_Bool NaviContentBookmark::Paste( TransferableDataHelper& rData ) 3519 { 3520 String sStr; 3521 sal_Bool bRet = rData.GetString( SOT_FORMATSTR_ID_SONLK, sStr ); 3522 if( bRet ) 3523 { 3524 xub_StrLen nPos = 0; 3525 aUrl = sStr.GetToken(0, NAVI_BOOKMARK_DELIM, nPos ); 3526 aDescr = sStr.GetToken(0, NAVI_BOOKMARK_DELIM, nPos ); 3527 nDefDrag= (sal_uInt16)sStr.GetToken(0, NAVI_BOOKMARK_DELIM, nPos ).ToInt32(); 3528 nDocSh = sStr.GetToken(0, NAVI_BOOKMARK_DELIM, nPos ).ToInt32(); 3529 } 3530 return bRet; 3531 } 3532 3533 3534 /* -----------------------------09.12.99 13:50-------------------------------- 3535 3536 ---------------------------------------------------------------------------*/ 3537 class SwContentLBoxString : public SvLBoxString 3538 { 3539 public: 3540 SwContentLBoxString( SvLBoxEntry* pEntry, sal_uInt16 nFlags, 3541 const String& rStr ) : SvLBoxString(pEntry,nFlags,rStr) {} 3542 3543 virtual void Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 nFlags, 3544 SvLBoxEntry* pEntry); 3545 }; 3546 3547 /* -----------------------------09.12.99 13:49-------------------------------- 3548 3549 ---------------------------------------------------------------------------*/ 3550 void SwContentTree::InitEntry(SvLBoxEntry* pEntry, 3551 const XubString& rStr ,const Image& rImg1,const Image& rImg2, 3552 SvLBoxButtonKind eButtonKind) 3553 { 3554 sal_uInt16 nColToHilite = 1; //0==Bitmap;1=="Spalte1";2=="Spalte2" 3555 SvTreeListBox::InitEntry( pEntry, rStr, rImg1, rImg2, eButtonKind ); 3556 SvLBoxString* pCol = (SvLBoxString*)pEntry->GetItem( nColToHilite ); 3557 SwContentLBoxString* pStr = new SwContentLBoxString( pEntry, 0, pCol->GetText() ); 3558 pEntry->ReplaceItem( pStr, nColToHilite ); 3559 } 3560 /* -----------------------------09.12.99 13:49-------------------------------- 3561 3562 ---------------------------------------------------------------------------*/ 3563 void SwContentLBoxString::Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 nFlags, 3564 SvLBoxEntry* pEntry ) 3565 { 3566 if(lcl_IsContent(pEntry) && 3567 ((SwContent *)pEntry->GetUserData())->IsInvisible()) 3568 { 3569 //* pCont = (SwContent*)pEntry->GetUserData(); 3570 Font aOldFont( rDev.GetFont()); 3571 Font aFont(aOldFont); 3572 Color aCol( COL_LIGHTGRAY ); 3573 aFont.SetColor( aCol ); 3574 rDev.SetFont( aFont ); 3575 rDev.DrawText( rPos, GetText() ); 3576 rDev.SetFont( aOldFont ); 3577 } 3578 //IAccessibility2 Implementation 2009----- 3579 // IA2 CWS. MT: Removed for now (also in SvLBoxEntry) - only used in Sw/Sd/ScContentLBoxString, they should decide if they need this 3580 /* 3581 else if (pEntry->IsMarked()) 3582 { 3583 rDev.DrawText( rPos, GetText() ); 3584 XubString str; 3585 str = XubString::CreateFromAscii("*"); 3586 Point rPosStar(rPos.X()-6,rPos.Y()); 3587 Font aOldFont( rDev.GetFont()); 3588 Font aFont(aOldFont); 3589 Color aCol( aOldFont.GetColor() ); 3590 aCol.DecreaseLuminance( 200 ); 3591 aFont.SetColor( aCol ); 3592 rDev.SetFont( aFont ); 3593 rDev.DrawText( rPosStar, str); 3594 rDev.SetFont( aOldFont ); 3595 } 3596 //-----IAccessibility2 Implementation 2009 3597 */ 3598 else 3599 SvLBoxString::Paint( rPos, rDev, nFlags, pEntry); 3600 } 3601 /* -----------------------------06.05.2002 10:20------------------------------ 3602 3603 ---------------------------------------------------------------------------*/ 3604 void SwContentTree::DataChanged( const DataChangedEvent& rDCEvt ) 3605 { 3606 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && 3607 (rDCEvt.GetFlags() & SETTINGS_STYLE) ) 3608 { 3609 sal_uInt16 nResId = GetSettings().GetStyleSettings().GetHighContrastMode() ? IMG_NAVI_ENTRYBMPH : IMG_NAVI_ENTRYBMP; 3610 aEntryImages = ImageList(SW_RES(nResId)); 3611 FindActiveTypeAndRemoveUserData(); 3612 Display(sal_True); 3613 } 3614 SvTreeListBox::DataChanged( rDCEvt ); 3615 } 3616 3617 3618 //IAccessibility2 Implementation 2009----- 3619 sal_Int32 SwContentTree::GetEntryRealChildsNum( SvLBoxEntry* pParent ) const 3620 { 3621 // ist es ein Inhaltstyp? 3622 if(lcl_IsContentType(pParent)) 3623 { 3624 if(!pParent->HasChilds()) 3625 { 3626 SwContentType* pCntType = (SwContentType*)pParent->GetUserData(); 3627 return pCntType->GetMemberCount(); 3628 } 3629 } 3630 return 0; 3631 } 3632 //-----IAccessibility2 Implementation 2009 3633