?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stop leaking all ScPostIt instances.
[LibreOffice.git] / sc / source / ui / navipi / content.cxx
blob69bcec78fa60e6599418e81dbb7f930353a4c887
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 <svx/svditer.hxx>
21 #include <svx/svdobj.hxx>
22 #include <svx/svdpage.hxx>
23 #include <svx/svdpagv.hxx>
24 #include <svx/svdview.hxx>
25 #include <svx/svdxcgv.hxx>
26 #include <sfx2/linkmgr.hxx>
27 #include <sfx2/docfile.hxx>
28 #include <sfx2/viewfrm.hxx>
29 #include <vcl/help.hxx>
30 #include <vcl/svapp.hxx>
31 #include <tools/urlobj.hxx>
32 #include <svl/urlbmk.hxx>
33 #include "svtools/svlbitm.hxx"
34 #include <stdlib.h>
35
36 #include "content.hxx"
37 #include "navipi.hxx"
38 #include "global.hxx"
39 #include "docsh.hxx"
40 #include "scmod.hxx"
41 #include "rangenam.hxx"
42 #include "dbdata.hxx"
43 #include "tablink.hxx"
44 #include "popmenu.hxx"
45 #include "drwlayer.hxx"
46 #include "transobj.hxx"
47 #include "drwtrans.hxx"
48 #include "lnktrans.hxx"
49 #include "formulacell.hxx"
50 #include "dociter.hxx"
51 #include "scresid.hxx"
52 #include "globstr.hrc"
53 #include "navipi.hrc"
54 #include "arealink.hxx"
55 #include "navicfg.hxx"
56 #include "navsett.hxx"
57 #include "postit.hxx"
58 #include "clipparam.hxx"
59 #include "markdata.hxx"
60
61 using namespace com::sun::star;
62
63 // Reihenfolge der Kategorien im Navigator -------------------------------------
64
65 static const sal_uInt16 pTypeList[SC_CONTENT_COUNT] =
66 {
67 SC_CONTENT_ROOT, // ROOT (0) muss vorne stehen
68 SC_CONTENT_TABLE,
69 SC_CONTENT_RANGENAME,
70 SC_CONTENT_DBAREA,
71 SC_CONTENT_AREALINK,
72 SC_CONTENT_GRAPHIC,
73 SC_CONTENT_OLEOBJECT,
74 SC_CONTENT_NOTE,
75 SC_CONTENT_DRAWING
76 };
77
78 sal_Bool ScContentTree::bIsInDrag = false;
79
80
81 ScDocShell* ScContentTree::GetManualOrCurrent()
82 {
83 ScDocShell* pSh = NULL;
84 if ( !aManualDoc.isEmpty() )
85 {
86 TypeId aScType = TYPE(ScDocShell);
87 SfxObjectShell* pObjSh = SfxObjectShell::GetFirst( &aScType );
88 while ( pObjSh && !pSh )
89 {
90 if ( pObjSh->GetTitle() == aManualDoc )
91 pSh = PTR_CAST( ScDocShell, pObjSh );
92 pObjSh = SfxObjectShell::GetNext( *pObjSh, &aScType );
93 }
94 }
95 else
96 {
97 // Current nur, wenn keine manuell eingestellt ist
98 // (damit erkannt wird, wenn das Dokument nicht mehr existiert)
99
100 SfxViewShell* pViewSh = SfxViewShell::Current();
101 if ( pViewSh )
102 {
103 SfxObjectShell* pObjSh = pViewSh->GetViewFrame()->GetObjectShell();
104 pSh = PTR_CAST( ScDocShell, pObjSh );
105 }
106 }
107
108 return pSh;
109 }
110
111 //
112 // ScContentTree
113 //
114
115 ScContentTree::ScContentTree( Window* pParent, const ResId& rResId ) :
116 SvTreeListBox ( pParent, rResId ),
117 aEntryImages ( ScResId( RID_IMAGELIST_NAVCONT ) ),
118 nRootType ( SC_CONTENT_ROOT ),
119 bHiddenDoc ( false ),
120 pHiddenDocument ( NULL )
121 {
122 sal_uInt16 i;
123 for (i=0; i<SC_CONTENT_COUNT; i++)
124 pPosList[pTypeList[i]] = i; // invers zum suchen
125
126 pParentWindow = (ScNavigatorDlg*)pParent;
127
128 pRootNodes[0] = NULL;
129 for (i=1; i<SC_CONTENT_COUNT; i++)
130 InitRoot(i);
131
132 SetNodeDefaultImages();
133
134 SetDoubleClickHdl( LINK( this, ScContentTree, ContentDoubleClickHdl ) );
135
136 SetStyle( GetStyle() | WB_QUICK_SEARCH );
137 }
138
139 ScContentTree::~ScContentTree()
140 {
141 }
142
143 void ScContentTree::InitRoot( sal_uInt16 nType )
144 {
145 if ( !nType )
146 return;
147
148 if ( nRootType && nRootType != nType ) // ausgeblendet ?
149 {
150 pRootNodes[nType] = NULL;
151 return;
152 }
153
154 const Image& rImage = aEntryImages.GetImage( nType );
155 OUString aName( ScResId( SCSTR_CONTENT_ROOT + nType ) );
156 // wieder an die richtige Position:
157 sal_uInt16 nPos = nRootType ? 0 : pPosList[nType]-1;
158 SvTreeListEntry* pNew = InsertEntry( aName, rImage, rImage, NULL, false, nPos );
159
160 pRootNodes[nType] = pNew;
161 }
162
163 void ScContentTree::ClearAll()
164 {
165 Clear();
166 for (sal_uInt16 i=1; i<SC_CONTENT_COUNT; i++)
167 InitRoot(i);
168 }
169
170 void ScContentTree::ClearType(sal_uInt16 nType)
171 {
172 if (!nType)
173 ClearAll();
174 else
175 {
176 SvTreeListEntry* pParent = pRootNodes[nType];
177 if ( !pParent || GetChildCount(pParent) ) // nicht, wenn ohne Children schon da
178 {
179 if (pParent)
180 GetModel()->Remove( pParent ); // mit allen Children
181 InitRoot( nType ); // ggf. neu eintragen
182 }
183 }
184 }
185
186 void ScContentTree::InsertContent( sal_uInt16 nType, const OUString& rValue )
187 {
188 if (nType >= SC_CONTENT_COUNT)
189 {
190 OSL_FAIL("ScContentTree::InsertContent mit falschem Typ");
191 return;
192 }
193
194 SvTreeListEntry* pParent = pRootNodes[nType];
195 if (pParent)
196 InsertEntry( rValue, pParent );
197 else
198 {
199 OSL_FAIL("InsertContent ohne Parent");
200 }
201 }
202
203 void ScContentTree::GetEntryIndexes( sal_uInt16& rnRootIndex, sal_uLong& rnChildIndex, SvTreeListEntry* pEntry ) const
204 {
205 rnRootIndex = SC_CONTENT_ROOT;
206 rnChildIndex = SC_CONTENT_NOCHILD;
207
208 if( !pEntry )
209 return;
210
211 SvTreeListEntry* pParent = GetParent( pEntry );
212 bool bFound = false;
213 for( sal_uInt16 nRoot = 1; !bFound && (nRoot < SC_CONTENT_COUNT); ++nRoot )
214 {
215 if( pEntry == pRootNodes[ nRoot ] )
216 {
217 rnRootIndex = nRoot;
218 rnChildIndex = ~0UL;
219 bFound = true;
220 }
221 else if( pParent && (pParent == pRootNodes[ nRoot ]) )
222 {
223 rnRootIndex = nRoot;
224
225 // search the entry in all child entries of the parent
226 sal_uLong nEntry = 0;
227 SvTreeListEntry* pIterEntry = FirstChild( pParent );
228 while( !bFound && pIterEntry )
229 {
230 if ( pEntry == pIterEntry )
231 {
232 rnChildIndex = nEntry;
233 bFound = true; // exit the while loop
234 }
235 pIterEntry = NextSibling( pIterEntry );
236 ++nEntry;
237 }
238
239 bFound = true; // exit the for loop
240 }
241 }
242 }
243
244 sal_uLong ScContentTree::GetChildIndex( SvTreeListEntry* pEntry ) const
245 {
246 sal_uInt16 nRoot;
247 sal_uLong nChild;
248 GetEntryIndexes( nRoot, nChild, pEntry );
249 return nChild;
250 }
251
252 static OUString lcl_GetDBAreaRange( ScDocument* pDoc, const OUString& rDBName )
253 {
254 OUString aRet;
255 if (pDoc)
256 {
257 ScDBCollection* pDbNames = pDoc->GetDBCollection();
258 const ScDBData* pData = pDbNames->getNamedDBs().findByUpperName(ScGlobal::pCharClass->uppercase(rDBName));
259 if (pData)
260 {
261 ScRange aRange;
262 pData->GetArea(aRange);
263 aRet = aRange.Format(SCR_ABS_3D, pDoc);
264 }
265 }
266 return aRet;
267 }
268
269 IMPL_LINK_NOARG(ScContentTree, ContentDoubleClickHdl)
270 {
271 sal_uInt16 nType;
272 sal_uLong nChild;
273 SvTreeListEntry* pEntry = GetCurEntry();
274 GetEntryIndexes( nType, nChild, pEntry );
275
276 if( pEntry && (nType != SC_CONTENT_ROOT) && (nChild != SC_CONTENT_NOCHILD) )
277 {
278 if ( bHiddenDoc )
279 return 0; //! spaeter...
280
281 OUString aText( GetEntryText( pEntry ) );
282
283 if ( !aManualDoc.isEmpty() )
284 pParentWindow->SetCurrentDoc( aManualDoc );
285
286 switch( nType )
287 {
288 case SC_CONTENT_TABLE:
289 pParentWindow->SetCurrentTableStr( aText );
290 break;
291
292 case SC_CONTENT_RANGENAME:
293 pParentWindow->SetCurrentCellStr( aText );
294 break;
295
296 case SC_CONTENT_DBAREA:
297 {
298 // Wenn gleiche Bereichs- und DB-Namen existieren, wird
299 // bei SID_CURRENTCELL der Bereichsname genommen.
300 // DB-Bereiche darum direkt ueber die Adresse anspringen.
301
302 OUString aRangeStr = lcl_GetDBAreaRange( GetSourceDocument(), aText );
303 if (!aRangeStr.isEmpty())
304 pParentWindow->SetCurrentCellStr( aRangeStr );
305 }
306 break;
307
308 case SC_CONTENT_OLEOBJECT:
309 case SC_CONTENT_GRAPHIC:
310 case SC_CONTENT_DRAWING:
311 pParentWindow->SetCurrentObject( aText );
312 break;
313
314 case SC_CONTENT_NOTE:
315 {
316 ScAddress aPos = GetNotePos( nChild );
317 pParentWindow->SetCurrentTable( aPos.Tab() );
318 pParentWindow->SetCurrentCell( aPos.Col(), aPos.Row() );
319 }
320 break;
321
322 case SC_CONTENT_AREALINK:
323 {
324 const ScAreaLink* pLink = GetLink( nChild );
325 if( pLink )
326 {
327 ScRange aRange = pLink->GetDestArea();
328 ScDocument* pSrcDoc = GetSourceDocument();
329 OUString aRangeStr(aRange.Format(SCR_ABS_3D, pSrcDoc, pSrcDoc->GetAddressConvention()));
330 pParentWindow->SetCurrentCellStr( aRangeStr );
331 }
332 }
333 break;
334 }
335
336 ScNavigatorDlg::ReleaseFocus(); // set focus into document
337 }
338
339 return 0;
340 }
341
342 void ScContentTree::MouseButtonDown( const MouseEvent& rMEvt )
343 {
344 SvTreeListBox::MouseButtonDown( rMEvt );
345 StoreSettings();
346 }
347
348 void ScContentTree::KeyInput( const KeyEvent& rKEvt )
349 {
350 bool bUsed = false;
351
352 const KeyCode aCode = rKEvt.GetKeyCode();
353 if (aCode.GetCode() == KEY_RETURN)
354 {
355 switch (aCode.GetModifier())
356 {
357 case KEY_MOD1:
358 ToggleRoot(); // toggle root mode (as in Writer)
359 bUsed = true;
360 break;
361 case 0:
362 {
363 SvTreeListEntry* pEntry = GetCurEntry();
364 if( pEntry )
365 {
366 sal_uInt16 nType;
367 sal_uLong nChild;
368 GetEntryIndexes( nType, nChild, pEntry );
369
370 if( (nType != SC_CONTENT_ROOT) && (nChild == SC_CONTENT_NOCHILD) )
371 {
372 if ( IsExpanded( pEntry ) )
373 Collapse( pEntry );
374 else
375 Expand( pEntry );
376 }
377 else
378 ContentDoubleClickHdl(0); // select content as if double clicked
379 }
380
381 bUsed = true;
382 }
383 break;
384 }
385 }
386 StoreSettings();
387
388 if( !bUsed )
389 SvTreeListBox::KeyInput(rKEvt);
390 }
391
392 sal_Int8 ScContentTree::AcceptDrop( const AcceptDropEvent& /* rEvt */ )
393 {
394 return DND_ACTION_NONE;
395 }
396
397 sal_Int8 ScContentTree::ExecuteDrop( const ExecuteDropEvent& /* rEvt */ )
398 {
399 return DND_ACTION_NONE;
400 }
401
402 void ScContentTree::StartDrag( sal_Int8 /* nAction */, const Point& /* rPosPixel */ )
403 {
404 DoDrag();
405 }
406
407 void ScContentTree::DragFinished( sal_Int8 /* nAction */ )
408 {
409 }
410
411 void ScContentTree::Command( const CommandEvent& rCEvt )
412 {
413 bool bDone = false;
414
415 switch ( rCEvt.GetCommand() )
416 {
417 case COMMAND_STARTDRAG:
418 // Aus dem ExecuteDrag heraus kann der Navigator geloescht werden
419 // (beim Umschalten auf einen anderen Dokument-Typ), das wuerde aber
420 // den StarView MouseMove-Handler, der Command() aufruft, umbringen.
421 // Deshalb Drag&Drop asynchron:
422
423 Application::PostUserEvent( STATIC_LINK( this, ScContentTree, ExecDragHdl ) );
424
425 bDone = true;
426 break;
427
428 case COMMAND_CONTEXTMENU:
429 {
430 // Drag-Drop Modus
431
432 PopupMenu aPop;
433 ScPopupMenu aDropMenu( ScResId( RID_POPUP_DROPMODE ) );
434 aDropMenu.CheckItem( RID_DROPMODE_URL + pParentWindow->GetDropMode() );
435 aPop.InsertItem( 1, pParentWindow->GetStrDragMode() );
436 aPop.SetPopupMenu( 1, &aDropMenu );
437
438 // angezeigtes Dokument
439
440 ScPopupMenu aDocMenu;
441 aDocMenu.SetMenuFlags( aDocMenu.GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
442 sal_uInt16 i=0;
443 sal_uInt16 nPos=0;
444 // geladene Dokumente
445 ScDocShell* pCurrentSh = PTR_CAST( ScDocShell, SfxObjectShell::Current() );
446 SfxObjectShell* pSh = SfxObjectShell::GetFirst();
447 while ( pSh )
448 {
449 if ( pSh->ISA(ScDocShell) )
450 {
451 OUString aName = pSh->GetTitle();
452 OUString aEntry = aName;
453 if ( pSh == pCurrentSh )
454 aEntry += pParentWindow->aStrActive;
455 else
456 aEntry += pParentWindow->aStrNotActive;
457 aDocMenu.InsertItem( ++i, aEntry );
458 if ( !bHiddenDoc && aName == aManualDoc )
459 nPos = i;
460 }
461 pSh = SfxObjectShell::GetNext( *pSh );
462 }
463 // "aktives Fenster"
464 aDocMenu.InsertItem( ++i, pParentWindow->aStrActiveWin );
465 if (!bHiddenDoc && aManualDoc.isEmpty())
466 nPos = i;
467 // verstecktes Dokument
468 if ( !aHiddenTitle.isEmpty() )
469 {
470 OUString aEntry = aHiddenTitle;
471 aEntry += pParentWindow->aStrHidden;
472 aDocMenu.InsertItem( ++i, aEntry );
473 if (bHiddenDoc)
474 nPos = i;
475 }
476 aDocMenu.CheckItem( nPos );
477 aPop.InsertItem( 2, pParentWindow->GetStrDisplay() );
478 aPop.SetPopupMenu( 2, &aDocMenu );
479
480 // ausfuehren
481
482 aPop.Execute( this, rCEvt.GetMousePosPixel() );
483
484 if ( aDropMenu.WasHit() ) // Drag-Drop Modus
485 {
486 sal_uInt16 nId = aDropMenu.GetSelected();
487 if ( nId >= RID_DROPMODE_URL && nId <= RID_DROPMODE_COPY )
488 pParentWindow->SetDropMode( nId - RID_DROPMODE_URL );
489 }
490 else if ( aDocMenu.WasHit() ) // angezeigtes Dokument
491 {
492 sal_uInt16 nId = aDocMenu.GetSelected();
493 OUString aName = aDocMenu.GetItemText(nId);
494 SelectDoc( aName );
495 }
496 }
497 break;
498 }
499
500 if (!bDone)
501 SvTreeListBox::Command(rCEvt);
502 }
503
504 void ScContentTree::RequestHelp( const HelpEvent& rHEvt )
505 {
506 bool bDone = false;
507 if( rHEvt.GetMode() & HELPMODE_QUICK )
508 {
509 Point aPos( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ));
510 SvTreeListEntry* pEntry = GetEntry( aPos );
511 if ( pEntry )
512 {
513 bool bRet = false;
514 OUString aHelpText;
515 SvTreeListEntry* pParent = GetParent(pEntry);
516 if ( !pParent ) // Top-Level ?
517 {
518 aHelpText = OUString::number( GetChildCount(pEntry) ) +
519 " " + GetEntryText(pEntry);
520 bRet = true;
521 }
522 else if ( pParent == pRootNodes[SC_CONTENT_NOTE] )
523 {
524 aHelpText = GetEntryText(pEntry); // Notizen als Help-Text
525 bRet = true;
526 }
527 else if ( pParent == pRootNodes[SC_CONTENT_AREALINK] )
528 {
529 sal_uLong nIndex = GetChildIndex(pEntry);
530 if( nIndex != SC_CONTENT_NOCHILD )
531 {
532 const ScAreaLink* pLink = GetLink(nIndex);
533 if (pLink)
534 {
535 aHelpText = pLink->GetFile(); // Source-Datei als Help-Text
536 bRet = true;
537 }
538 }
539 }
540
541 if (bRet)
542 {
543 SvLBoxTab* pTab;
544 SvLBoxString* pItem = (SvLBoxString*)(GetItem( pEntry, aPos.X(), &pTab ));
545 if( pItem )
546 {
547 aPos = GetEntryPosition( pEntry );
548 aPos.X() = GetTabPos( pEntry, pTab );
549 aPos = OutputToScreenPixel(aPos);
550 Size aSize( pItem->GetSize( this, pEntry ) );
551
552 Rectangle aItemRect( aPos, aSize );
553 Help::ShowQuickHelp( this, aItemRect, aHelpText );
554 bDone = true;
555 }
556 }
557 }
558 }
559 if (!bDone)
560 Window::RequestHelp( rHEvt );
561 }
562
563 ScDocument* ScContentTree::GetSourceDocument()
564 {
565 if (bHiddenDoc)
566 return pHiddenDocument;
567 else
568 {
569 ScDocShell* pSh = GetManualOrCurrent();
570 if (pSh)
571 return pSh->GetDocument();
572
573 }
574 return NULL;
575 }
576
577 void ScContentTree::Refresh( sal_uInt16 nType )
578 {
579 if ( bHiddenDoc && !pHiddenDocument )
580 return; // anderes Dokument angezeigt
581
582 // wenn sich nichts geaendert hat, gleich abbrechen (gegen Geflacker)
583
584 if ( nType == SC_CONTENT_NOTE )
585 if (!NoteStringsChanged())
586 return;
587 if ( nType == SC_CONTENT_GRAPHIC )
588 if (!DrawNamesChanged(SC_CONTENT_GRAPHIC))
589 return;
590 if ( nType == SC_CONTENT_OLEOBJECT )
591 if (!DrawNamesChanged(SC_CONTENT_OLEOBJECT))
592 return;
593 if ( nType == SC_CONTENT_DRAWING )
594 if (!DrawNamesChanged(SC_CONTENT_DRAWING))
595 return;
596
597 SetUpdateMode(false);
598
599 ClearType( nType );
600
601 if ( !nType || nType == SC_CONTENT_TABLE )
602 GetTableNames();
603 if ( !nType || nType == SC_CONTENT_RANGENAME )
604 GetAreaNames();
605 if ( !nType || nType == SC_CONTENT_DBAREA )
606 GetDbNames();
607 if ( !nType || nType == SC_CONTENT_GRAPHIC )
608 GetGraphicNames();
609 if ( !nType || nType == SC_CONTENT_OLEOBJECT )
610 GetOleNames();
611 if ( !nType || nType == SC_CONTENT_DRAWING )
612 GetDrawingNames();
613 if ( !nType || nType == SC_CONTENT_NOTE )
614 GetNoteStrings();
615 if ( !nType || nType == SC_CONTENT_AREALINK )
616 GetLinkNames();
617
618 ApplySettings();
619 SetUpdateMode(sal_True);
620 }
621
622 void ScContentTree::GetTableNames()
623 {
624 if ( nRootType && nRootType != SC_CONTENT_TABLE ) // ausgeblendet ?
625 return;
626
627 ScDocument* pDoc = GetSourceDocument();
628 if (!pDoc)
629 return;
630
631 OUString aName;
632 SCTAB nCount = pDoc->GetTableCount();
633 for ( SCTAB i=0; i<nCount; i++ )
634 {
635 pDoc->GetName( i, aName );
636 InsertContent( SC_CONTENT_TABLE, aName );
637 }
638 }
639
640 namespace {
641
642 OUString createLocalRangeName(const OUString& rName, const OUString& rTableName)
643 {
644 OUStringBuffer aString (rName);
645 aString.append(OUString(" ("));
646 aString.append(rTableName);
647 aString.append(OUString(")"));
648 return aString.makeStringAndClear();
649 }
650 }
651
652 void ScContentTree::GetAreaNames()
653 {
654 if ( nRootType && nRootType != SC_CONTENT_RANGENAME ) // ausgeblendet ?
655 return;
656
657 ScDocument* pDoc = GetSourceDocument();
658 if (!pDoc)
659 return;
660
661 ScRange aDummy;
662 std::set<OUString> aSet;
663 ScRangeName* pRangeNames = pDoc->GetRangeName();
664 if (!pRangeNames->empty())
665 {
666 ScRangeName::const_iterator itrBeg = pRangeNames->begin(), itrEnd = pRangeNames->end();
667 for (ScRangeName::const_iterator itr = itrBeg; itr != itrEnd; ++itr)
668 {
669 if (itr->second->IsValidReference(aDummy))
670 aSet.insert(itr->second->GetName());
671 }
672 }
673 for (SCTAB i = 0; i < pDoc->GetTableCount(); ++i)
674 {
675 ScRangeName* pLocalRangeName = pDoc->GetRangeName(i);
676 if (pLocalRangeName && !pLocalRangeName->empty())
677 {
678 OUString aTableName;
679 pDoc->GetName(i, aTableName);
680 for (ScRangeName::const_iterator itr = pLocalRangeName->begin(); itr != pLocalRangeName->end(); ++itr)
681 {
682 if (itr->second->IsValidReference(aDummy))
683 aSet.insert(createLocalRangeName(itr->second->GetName(), aTableName));
684 }
685 }
686 }
687
688 if (!aSet.empty())
689 {
690 for (std::set<OUString>::iterator itr = aSet.begin();
691 itr != aSet.end(); ++itr)
692 {
693 InsertContent(SC_CONTENT_RANGENAME, *itr);
694 }
695 }
696 }
697
698 void ScContentTree::GetDbNames()
699 {
700 if ( nRootType && nRootType != SC_CONTENT_DBAREA ) // ausgeblendet ?
701 return;
702
703 ScDocument* pDoc = GetSourceDocument();
704 if (!pDoc)
705 return;
706
707 ScDBCollection* pDbNames = pDoc->GetDBCollection();
708 const ScDBCollection::NamedDBs& rDBs = pDbNames->getNamedDBs();
709 ScDBCollection::NamedDBs::const_iterator itr = rDBs.begin(), itrEnd = rDBs.end();
710 for (; itr != itrEnd; ++itr)
711 {
712 const OUString& aStrName = itr->GetName();
713 InsertContent(SC_CONTENT_DBAREA, aStrName);
714 }
715 }
716
717 bool ScContentTree::IsPartOfType( sal_uInt16 nContentType, sal_uInt16 nObjIdentifier )
718 {
719 bool bRet = false;
720 switch ( nContentType )
721 {
722 case SC_CONTENT_GRAPHIC:
723 bRet = ( nObjIdentifier == OBJ_GRAF );
724 break;
725 case SC_CONTENT_OLEOBJECT:
726 bRet = ( nObjIdentifier == OBJ_OLE2 );
727 break;
728 case SC_CONTENT_DRAWING:
729 bRet = ( nObjIdentifier != OBJ_GRAF && nObjIdentifier != OBJ_OLE2 ); // everything else
730 break;
731 default:
732 OSL_FAIL("unknown content type");
733 }
734 return bRet;
735 }
736
737 void ScContentTree::GetDrawNames( sal_uInt16 nType )
738 {
739 if ( nRootType && nRootType != nType ) // ausgeblendet ?
740 return;
741
742 ScDocument* pDoc = GetSourceDocument();
743 if (!pDoc)
744 return;
745
746 // iterate in flat mode for groups
747 SdrIterMode eIter = ( nType == SC_CONTENT_DRAWING ) ? IM_FLAT : IM_DEEPNOGROUPS;
748
749 ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
750 SfxObjectShell* pShell = pDoc->GetDocumentShell();
751 if (pDrawLayer && pShell)
752 {
753 SCTAB nTabCount = pDoc->GetTableCount();
754 for (SCTAB nTab=0; nTab<nTabCount; nTab++)
755 {
756 SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
757 OSL_ENSURE(pPage,"Page ?");
758 if (pPage)
759 {
760 SdrObjListIter aIter( *pPage, eIter );
761 SdrObject* pObject = aIter.Next();
762 while (pObject)
763 {
764 if ( IsPartOfType( nType, pObject->GetObjIdentifier() ) )
765 {
766 OUString aName = ScDrawLayer::GetVisibleName( pObject );
767 if (!aName.isEmpty())
768 InsertContent( nType, aName );
769 }
770
771 pObject = aIter.Next();
772 }
773 }
774 }
775 }
776 }
777
778 void ScContentTree::GetGraphicNames()
779 {
780 GetDrawNames( SC_CONTENT_GRAPHIC );
781 }
782
783 void ScContentTree::GetOleNames()
784 {
785 GetDrawNames( SC_CONTENT_OLEOBJECT );
786 }
787
788 void ScContentTree::GetDrawingNames()
789 {
790 GetDrawNames( SC_CONTENT_DRAWING );
791 }
792
793 void ScContentTree::GetLinkNames()
794 {
795 if ( nRootType && nRootType != SC_CONTENT_AREALINK ) // ausgeblendet ?
796 return;
797
798 ScDocument* pDoc = GetSourceDocument();
799 if (!pDoc)
800 return;
801
802 sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
803 OSL_ENSURE(pLinkManager, "kein LinkManager am Dokument?");
804 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
805 sal_uInt16 nCount = rLinks.size();
806 for (sal_uInt16 i=0; i<nCount; i++)
807 {
808 ::sfx2::SvBaseLink* pBase = *rLinks[i];
809 if (pBase->ISA(ScAreaLink))
810 InsertContent( SC_CONTENT_AREALINK, ((ScAreaLink*)pBase)->GetSource() );
811
812 // in der Liste die Namen der Quellbereiche
813 }
814 }
815
816 const ScAreaLink* ScContentTree::GetLink( sal_uLong nIndex )
817 {
818 ScDocument* pDoc = GetSourceDocument();
819 if (!pDoc)
820 return NULL;
821
822 sal_uLong nFound = 0;
823 sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
824 OSL_ENSURE(pLinkManager, "kein LinkManager am Dokument?");
825 const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
826 sal_uInt16 nCount = rLinks.size();
827 for (sal_uInt16 i=0; i<nCount; i++)
828 {
829 ::sfx2::SvBaseLink* pBase = *rLinks[i];
830 if (pBase->ISA(ScAreaLink))
831 {
832 if (nFound == nIndex)
833 return (const ScAreaLink*) pBase;
834 ++nFound;
835 }
836 }
837
838 OSL_FAIL("link not found");
839 return NULL;
840 }
841
842 static OUString lcl_NoteString( const ScPostIt& rNote )
843 {
844 OUString aText = rNote.GetText();
845 sal_Int32 nAt;
846 while ( (nAt = aText.indexOf( '\n' )) != -1 )
847 aText = aText.replaceAt( nAt, 1, " " );
848 return aText;
849 }
850
851 void ScContentTree::GetNoteStrings()
852 {
853 if ( nRootType && nRootType != SC_CONTENT_NOTE ) // ausgeblendet ?
854 return;
855
856 ScDocument* pDoc = GetSourceDocument();
857 if (!pDoc)
858 return;
859
860 // loop over cell notes
861 std::vector<sc::NoteEntry> aEntries;
862 pDoc->GetAllNoteEntries(aEntries);
863 std::vector<sc::NoteEntry>::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
864 for (; it != itEnd; ++it)
865 InsertContent(SC_CONTENT_NOTE, lcl_NoteString(*it->mpNote));
866 }
867
868 ScAddress ScContentTree::GetNotePos( sal_uLong nIndex )
869 {
870 ScDocument* pDoc = GetSourceDocument();
871 if (!pDoc)
872 return ScAddress();
873
874 return pDoc->GetNotePosition(nIndex);
875 }
876
877 sal_Bool ScContentTree::NoteStringsChanged()
878 {
879 ScDocument* pDoc = GetSourceDocument();
880 if (!pDoc)
881 return false;
882
883 SvTreeListEntry* pParent = pRootNodes[SC_CONTENT_NOTE];
884 if (!pParent)
885 return false;
886
887 SvTreeListEntry* pEntry = FirstChild( pParent );
888
889 std::vector<sc::NoteEntry> aEntries;
890 pDoc->GetAllNoteEntries(aEntries);
891 std::vector<sc::NoteEntry>::const_iterator it = aEntries.begin(), itEnd = aEntries.end();
892 for (; it != itEnd; ++it)
893 {
894 const ScPostIt* pNote = it->mpNote;
895 if (!pEntry)
896 return true;
897
898 if (lcl_NoteString(*pNote) != GetEntryText(pEntry))
899 return true;
900
901 pEntry = NextSibling(pEntry);
902 }
903
904 if ( pEntry )
905 return true;
906
907 return false;
908 }
909
910 sal_Bool ScContentTree::DrawNamesChanged( sal_uInt16 nType )
911 {
912 ScDocument* pDoc = GetSourceDocument();
913 if (!pDoc)
914 return false;
915
916 SvTreeListEntry* pParent = pRootNodes[nType];
917 if (!pParent)
918 return false;
919
920 SvTreeListEntry* pEntry = FirstChild( pParent );
921
922 // iterate in flat mode for groups
923 SdrIterMode eIter = ( nType == SC_CONTENT_DRAWING ) ? IM_FLAT : IM_DEEPNOGROUPS;
924
925 sal_Bool bEqual = sal_True;
926 ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
927 SfxObjectShell* pShell = pDoc->GetDocumentShell();
928 if (pDrawLayer && pShell)
929 {
930 SCTAB nTabCount = pDoc->GetTableCount();
931 for (SCTAB nTab=0; nTab<nTabCount && bEqual; nTab++)
932 {
933 SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
934 OSL_ENSURE(pPage,"Page ?");
935 if (pPage)
936 {
937 SdrObjListIter aIter( *pPage, eIter );
938 SdrObject* pObject = aIter.Next();
939 while (pObject && bEqual)
940 {
941 if ( IsPartOfType( nType, pObject->GetObjIdentifier() ) )
942 {
943 if ( !pEntry )
944 bEqual = false;
945 else
946 {
947 if ( ScDrawLayer::GetVisibleName( pObject ) != GetEntryText(pEntry) )
948 bEqual = false;
949
950 pEntry = NextSibling( pEntry );
951 }
952 }
953 pObject = aIter.Next();
954 }
955 }
956 }
957 }
958
959 if ( pEntry )
960 bEqual = false; // kommt noch was
961
962 return !bEqual;
963 }
964
965 static bool lcl_GetRange( ScDocument* pDoc, sal_uInt16 nType, const OUString& rName, ScRange& rRange )
966 {
967 bool bFound = false;
968
969 if ( nType == SC_CONTENT_RANGENAME )
970 {
971 ScRangeName* pList = pDoc->GetRangeName();
972 if (pList)
973 {
974 const ScRangeData* p = pList->findByUpperName(ScGlobal::pCharClass->uppercase(rName));
975 if (p && p->IsValidReference(rRange))
976 bFound = true;
977 }
978 }
979 else if ( nType == SC_CONTENT_DBAREA )
980 {
981 ScDBCollection* pList = pDoc->GetDBCollection();
982 if (pList)
983 {
984 const ScDBData* p = pList->getNamedDBs().findByUpperName(ScGlobal::pCharClass->uppercase(rName));
985 if (p)
986 {
987 SCTAB nTab;
988 SCCOL nCol1, nCol2;
989 SCROW nRow1, nRow2;
990 p->GetArea(nTab, nCol1, nRow1, nCol2, nRow2);
991 rRange = ScRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
992 bFound = true;
993 }
994 }
995 }
996
997 return bFound;
998 }
999
1000 static void lcl_DoDragObject( ScDocShell* pSrcShell, const OUString& rName, sal_uInt16 nType, Window* pWin )
1001 {
1002 ScDocument* pSrcDoc = pSrcShell->GetDocument();
1003 ScDrawLayer* pModel = pSrcDoc->GetDrawLayer();
1004 if (pModel)
1005 {
1006 bool bOle = ( nType == SC_CONTENT_OLEOBJECT );
1007 bool bGraf = ( nType == SC_CONTENT_GRAPHIC );
1008 sal_uInt16 nDrawId = sal::static_int_cast<sal_uInt16>( bOle ? OBJ_OLE2 : ( bGraf ? OBJ_GRAF : OBJ_GRUP ) );
1009 SCTAB nTab = 0;
1010 SdrObject* pObject = pModel->GetNamedObject( rName, nDrawId, nTab );
1011 if (pObject)
1012 {
1013 SdrView aEditView( pModel );
1014 aEditView.ShowSdrPage(aEditView.GetModel()->GetPage(nTab));
1015 SdrPageView* pPV = aEditView.GetSdrPageView();
1016 aEditView.MarkObj(pObject, pPV);
1017
1018 SdrModel* pDragModel = aEditView.GetMarkedObjModel();
1019
1020 TransferableObjectDescriptor aObjDesc;
1021 pSrcShell->FillTransferableObjectDescriptor( aObjDesc );
1022 aObjDesc.maDisplayName = pSrcShell->GetMedium()->GetURLObject().GetURLNoPass();
1023 // maSize is set in ScDrawTransferObj ctor
1024
1025 ScDrawTransferObj* pTransferObj = new ScDrawTransferObj( pDragModel, pSrcShell, aObjDesc );
1026 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
1027
1028 pTransferObj->SetDragSourceObj( pObject, nTab );
1029 pTransferObj->SetDragSourceFlags( SC_DROP_NAVIGATOR );
1030
1031 SC_MOD()->SetDragObject( NULL, pTransferObj );
1032 pWin->ReleaseMouse();
1033 pTransferObj->StartDrag( pWin, DND_ACTION_COPYMOVE | DND_ACTION_LINK );
1034 }
1035 }
1036 }
1037
1038 static void lcl_DoDragCells( ScDocShell* pSrcShell, const ScRange& rRange, sal_uInt16 nFlags, Window* pWin )
1039 {
1040 ScMarkData aMark;
1041 aMark.SelectTable( rRange.aStart.Tab(), sal_True );
1042 aMark.SetMarkArea( rRange );
1043
1044 ScDocument* pSrcDoc = pSrcShell->GetDocument();
1045 if ( !pSrcDoc->HasSelectedBlockMatrixFragment( rRange.aStart.Col(), rRange.aStart.Row(),
1046 rRange.aEnd.Col(), rRange.aEnd.Row(),
1047 aMark ) )
1048 {
1049 ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
1050 ScClipParam aClipParam(rRange, false);
1051 pSrcDoc->CopyToClip(aClipParam, pClipDoc, &aMark);
1052 // pClipDoc->ExtendMerge( rRange, sal_True );
1053
1054 TransferableObjectDescriptor aObjDesc;
1055 pSrcShell->FillTransferableObjectDescriptor( aObjDesc );
1056 aObjDesc.maDisplayName = pSrcShell->GetMedium()->GetURLObject().GetURLNoPass();
1057 // maSize is set in ScTransferObj ctor
1058
1059 ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc );
1060 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
1061
1062 pTransferObj->SetDragSource( pSrcShell, aMark );
1063 pTransferObj->SetDragSourceFlags( nFlags );
1064
1065 SC_MOD()->SetDragObject( pTransferObj, NULL ); // for internal D&D
1066 pWin->ReleaseMouse();
1067 pTransferObj->StartDrag( pWin, DND_ACTION_COPYMOVE | DND_ACTION_LINK );
1068 }
1069 }
1070
1071 void ScContentTree::DoDrag()
1072 {
1073 ScDocumentLoader* pDocLoader = NULL;
1074 bIsInDrag = sal_True;
1075
1076 ScModule* pScMod = SC_MOD();
1077
1078 sal_uInt16 nType;
1079 sal_uLong nChild;
1080 SvTreeListEntry* pEntry = GetCurEntry();
1081 GetEntryIndexes( nType, nChild, pEntry );
1082
1083 if( pEntry &&
1084 (nChild != SC_CONTENT_NOCHILD) &&
1085 (nType != SC_CONTENT_ROOT) &&
1086 (nType != SC_CONTENT_NOTE) &&
1087 (nType != SC_CONTENT_AREALINK) )
1088 {
1089 OUString aText( GetEntryText( pEntry ) );
1090
1091 ScDocument* pLocalDoc = NULL; // fuer URL-Drop
1092 OUString aDocName;
1093 if (bHiddenDoc)
1094 aDocName = aHiddenName;
1095 else
1096 {
1097 ScDocShell* pDocSh = GetManualOrCurrent();
1098 if (pDocSh)
1099 {
1100 if (pDocSh->HasName())
1101 aDocName = pDocSh->GetMedium()->GetName();
1102 else
1103 pLocalDoc = pDocSh->GetDocument(); // Drop nur in dieses Dokument
1104 }
1105 }
1106
1107 bool bDoLinkTrans = false; // use ScLinkTransferObj
1108 OUString aLinkURL; // for ScLinkTransferObj
1109 OUString aLinkText;
1110
1111 sal_uInt16 nDropMode = pParentWindow->GetDropMode();
1112 switch ( nDropMode )
1113 {
1114 case SC_DROPMODE_URL:
1115 {
1116 OUString aUrl = aDocName + "#" + aText;
1117
1118 pScMod->SetDragJump( pLocalDoc, aUrl, aText );
1119
1120 if (!aDocName.isEmpty())
1121 {
1122 // provide URL to outside only if the document has a name
1123 // (without name, only internal D&D via SetDragJump)
1124
1125 aLinkURL = aUrl;
1126 aLinkText = aText;
1127 }
1128 bDoLinkTrans = true;
1129 }
1130 break;
1131 case SC_DROPMODE_LINK:
1132 {
1133 if ( !aDocName.isEmpty() ) // link only to named documents
1134 {
1135 // for internal D&D, set flag to insert a link
1136
1137 switch ( nType )
1138 {
1139 case SC_CONTENT_TABLE:
1140 pScMod->SetDragLink( aDocName, aText, EMPTY_OUSTRING );
1141 bDoLinkTrans = true;
1142 break;
1143 case SC_CONTENT_RANGENAME:
1144 case SC_CONTENT_DBAREA:
1145 pScMod->SetDragLink( aDocName, EMPTY_OUSTRING, aText );
1146 bDoLinkTrans = true;
1147 break;
1148
1149 // other types cannot be linked
1150 }
1151 }
1152 }
1153 break;
1154 case SC_DROPMODE_COPY:
1155 {
1156 ScDocShell* pSrcShell = NULL;
1157 if ( bHiddenDoc )
1158 {
1159 OUString aFilter, aOptions;
1160 OUString aURL = aHiddenName;
1161 pDocLoader = new ScDocumentLoader( aURL, aFilter, aOptions );
1162 if (!pDocLoader->IsError())
1163 pSrcShell = pDocLoader->GetDocShell();
1164 }
1165 else
1166 pSrcShell = GetManualOrCurrent();
1167
1168 if ( pSrcShell )
1169 {
1170 ScDocument* pSrcDoc = pSrcShell->GetDocument();
1171 if ( nType == SC_CONTENT_RANGENAME || nType == SC_CONTENT_DBAREA )
1172 {
1173 ScRange aRange;
1174 if ( lcl_GetRange( pSrcDoc, nType, aText, aRange ) )
1175 {
1176 lcl_DoDragCells( pSrcShell, aRange, SC_DROP_NAVIGATOR, this );
1177 }
1178 }
1179 else if ( nType == SC_CONTENT_TABLE )
1180 {
1181 SCTAB nTab;
1182 if ( pSrcDoc->GetTable( aText, nTab ) )
1183 {
1184 ScRange aRange( 0,0,nTab, MAXCOL,MAXROW,nTab );
1185 lcl_DoDragCells( pSrcShell, aRange, SC_DROP_NAVIGATOR | SC_DROP_TABLE, this );
1186 }
1187 }
1188 else if ( nType == SC_CONTENT_GRAPHIC || nType == SC_CONTENT_OLEOBJECT ||
1189 nType == SC_CONTENT_DRAWING )
1190 {
1191 lcl_DoDragObject( pSrcShell, aText, nType, this );
1192
1193 // in ExecuteDrag kann der Navigator geloescht worden sein
1194 // -> nicht mehr auf Member zugreifen !!!
1195 }
1196 }
1197 }
1198 break;
1199 }
1200
1201 if (bDoLinkTrans)
1202 {
1203 ScLinkTransferObj* pTransferObj = new ScLinkTransferObj;
1204 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
1205
1206 if ( !aLinkURL.isEmpty() )
1207 pTransferObj->SetLinkURL( aLinkURL, aLinkText );
1208
1209 // SetDragJump / SetDragLink has been done above
1210
1211 ReleaseMouse();
1212 pTransferObj->StartDrag( this, DND_ACTION_COPYMOVE | DND_ACTION_LINK );
1213 }
1214 }
1215
1216 bIsInDrag = false; // static Member
1217
1218 delete pDocLoader; // falls Dokument zum Draggen geladen wurde
1219 }
1220
1221 IMPL_STATIC_LINK(ScContentTree, ExecDragHdl, void*, EMPTYARG)
1222 {
1223 // als Link, damit asynchron ohne ImpMouseMoveMsg auf dem Stack auch der
1224 // Navigator geloescht werden darf
1225
1226 pThis->DoDrag();
1227 return 0;
1228 }
1229
1230 sal_Bool ScContentTree::LoadFile( const OUString& rUrl )
1231 {
1232 OUString aDocName = rUrl;
1233 sal_Int32 nPos = aDocName.indexOf('#');
1234 if ( nPos != -1 )
1235 aDocName = aDocName.copy(0, nPos); // nur der Name, ohne #...
1236
1237 sal_Bool bReturn = false;
1238 OUString aURL = aDocName;
1239 OUString aFilter, aOptions;
1240 ScDocumentLoader aLoader( aURL, aFilter, aOptions );
1241 if ( !aLoader.IsError() )
1242 {
1243 bHiddenDoc = sal_True;
1244 aHiddenName = aDocName;
1245 aHiddenTitle = aLoader.GetTitle();
1246 pHiddenDocument = aLoader.GetDocument();
1247
1248 Refresh(); // Inhalte aus geladenem Dokument holen
1249
1250 pHiddenDocument = NULL;
1251
1252 pParentWindow->GetDocNames( &aHiddenTitle ); // Liste fuellen
1253 }
1254
1255 // Dokument wird im dtor von ScDocumentLoader wieder geschlossen
1256
1257 return bReturn;
1258 }
1259
1260 void ScContentTree::InitWindowBits( sal_Bool bButtons )
1261 {
1262 WinBits nFlags = GetStyle()|WB_CLIPCHILDREN|WB_HSCROLL;
1263 if (bButtons)
1264 nFlags |= WB_HASBUTTONS|WB_HASBUTTONSATROOT;
1265
1266 SetStyle( nFlags );
1267 }
1268
1269 void ScContentTree::SetRootType( sal_uInt16 nNew )
1270 {
1271 if ( nNew != nRootType )
1272 {
1273 nRootType = nNew;
1274 InitWindowBits( nNew == 0 );
1275 Refresh();
1276
1277 ScNavipiCfg& rCfg = SC_MOD()->GetNavipiCfg();
1278 rCfg.SetRootType( nRootType );
1279 }
1280 }
1281
1282 void ScContentTree::ToggleRoot() // nach Selektion
1283 {
1284 sal_uInt16 nNew = SC_CONTENT_ROOT;
1285 if ( nRootType == SC_CONTENT_ROOT )
1286 {
1287 SvTreeListEntry* pEntry = GetCurEntry();
1288 if (pEntry)
1289 {
1290 SvTreeListEntry* pParent = GetParent(pEntry);
1291 for (sal_uInt16 i=1; i<SC_CONTENT_COUNT; i++)
1292 if ( pEntry == pRootNodes[i] || pParent == pRootNodes[i] )
1293 nNew = i;
1294 }
1295 }
1296
1297 SetRootType( nNew );
1298 }
1299
1300 void ScContentTree::ResetManualDoc()
1301 {
1302 aManualDoc = "";
1303 bHiddenDoc = false;
1304
1305 ActiveDocChanged();
1306 }
1307
1308 void ScContentTree::ActiveDocChanged()
1309 {
1310 if ( !bHiddenDoc && aManualDoc.isEmpty() )
1311 Refresh(); // Inhalte nur wenn automatisch
1312
1313 // Listbox muss immer geupdated werden, wegen aktiv-Flag
1314
1315 OUString aCurrent;
1316 if ( bHiddenDoc )
1317 aCurrent = aHiddenTitle;
1318 else
1319 {
1320 ScDocShell* pSh = GetManualOrCurrent();
1321 if (pSh)
1322 aCurrent = pSh->GetTitle();
1323 else
1324 {
1325 // eingestelltes Dokument existiert nicht mehr
1326
1327 aManualDoc = ""; // wieder automatisch
1328 Refresh();
1329 pSh = GetManualOrCurrent(); // sollte jetzt aktives sein
1330 if (pSh)
1331 aCurrent = pSh->GetTitle();
1332 }
1333 }
1334 pParentWindow->GetDocNames( &aCurrent ); // selektieren
1335 }
1336
1337 void ScContentTree::SetManualDoc(const OUString& rName)
1338 {
1339 aManualDoc = rName;
1340 if (!bHiddenDoc)
1341 {
1342 Refresh();
1343 pParentWindow->GetDocNames( &aManualDoc ); // selektieren
1344 }
1345 }
1346
1347 void ScContentTree::SelectDoc(const OUString& rName) // rName wie im Menue/Listbox angezeigt
1348 {
1349 if ( rName == pParentWindow->aStrActiveWin )
1350 {
1351 ResetManualDoc();
1352 return;
1353 }
1354
1355 // "aktiv" oder "inaktiv" weglassen
1356
1357 OUString aRealName = rName;
1358 sal_Int32 nLen = rName.getLength();
1359 sal_Int32 nActiveStart = nLen - pParentWindow->aStrActive.getLength();
1360 if ( rName.copy( nActiveStart ) == pParentWindow->aStrActive )
1361 aRealName = rName.copy( 0, nActiveStart );
1362 sal_Int32 nNotActiveStart = nLen - pParentWindow->aStrNotActive.getLength();
1363 if ( rName.copy( nNotActiveStart ) == pParentWindow->aStrNotActive )
1364 aRealName = rName.copy( 0, nNotActiveStart );
1365
1366 bool bLoaded = false;
1367
1368 // ist es ein normal geladenes Doc ?
1369
1370 SfxObjectShell* pSh = SfxObjectShell::GetFirst();
1371 while ( pSh && !bLoaded )
1372 {
1373 if ( pSh->ISA(ScDocShell) )
1374 if ( pSh->GetTitle() == aRealName )
1375 bLoaded = true;
1376 pSh = SfxObjectShell::GetNext( *pSh );
1377 }
1378
1379 if (bLoaded)
1380 {
1381 bHiddenDoc = false;
1382 SetManualDoc(aRealName);
1383 }
1384 else if (!aHiddenTitle.isEmpty()) // verstecktes ausgewaehlt
1385 {
1386 if (!bHiddenDoc)
1387 LoadFile(aHiddenName);
1388 }
1389 else
1390 {
1391 OSL_FAIL("SelectDoc: nicht gefunden");
1392 }
1393 }
1394
1395 void ScContentTree::ApplySettings()
1396 {
1397 const ScNavigatorSettings* pSettings = pParentWindow->GetNavigatorSettings();
1398 if( pSettings )
1399 {
1400 sal_uInt16 nRootSel = pSettings->GetRootSelected();
1401 sal_uLong nChildSel = pSettings->GetChildSelected();
1402
1403 for( sal_uInt16 nEntry = 1; nEntry < SC_CONTENT_COUNT; ++nEntry )
1404 {
1405 if( pRootNodes[ nEntry ] )
1406 {
1407 // expand
1408 sal_Bool bExp = pSettings->IsExpanded( nEntry );
1409 if( bExp != IsExpanded( pRootNodes[ nEntry ] ) )
1410 {
1411 if( bExp )
1412 Expand( pRootNodes[ nEntry ] );
1413 else
1414 Collapse( pRootNodes[ nEntry ] );
1415 }
1416
1417 // select
1418 if( nRootSel == nEntry )
1419 {
1420 SvTreeListEntry* pEntry = NULL;
1421 if( bExp && (nChildSel != SC_CONTENT_NOCHILD) )
1422 pEntry = GetEntry( pRootNodes[ nEntry ], nChildSel );
1423 Select( pEntry ? pEntry : pRootNodes[ nEntry ] );
1424 }
1425 }
1426 }
1427 }
1428 }
1429
1430 void ScContentTree::StoreSettings() const
1431 {
1432 ScNavigatorSettings* pSettings = pParentWindow->GetNavigatorSettings();
1433 if( pSettings )
1434 {
1435 for( sal_uInt16 nEntry = 1; nEntry < SC_CONTENT_COUNT; ++nEntry )
1436 {
1437 sal_Bool bExp = pRootNodes[ nEntry ] && IsExpanded( pRootNodes[ nEntry ] );
1438 pSettings->SetExpanded( nEntry, bExp );
1439 }
1440 sal_uInt16 nRoot;
1441 sal_uLong nChild;
1442 GetEntryIndexes( nRoot, nChild, GetCurEntry() );
1443 pSettings->SetRootSelected( nRoot );
1444 pSettings->SetChildSelected( nChild );
1445 }
1446 }
1447
1448
1449 //
1450 //------------------------------------------------------------------------
1451 //
1452
1453
1454
1455
1456
1457 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE