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