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