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