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