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