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