LCOV - code coverage report
Current view: top level - libreoffice/sw/source/ui/utlui - content.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 1 1643 0.1 %
Date: 2012-12-27 Functions: 2 82 2.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10