xref: /aoo42x/main/sfx2/source/dialog/splitwin.cxx (revision 01e38eab)
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_sfx2.hxx"
26 
27 #ifdef SOLARIS
28 // HACK: prevent conflict between STLPORT and Workshop headers on Solaris 8
29 #include <ctime>
30 #endif
31 
32 #include <string> // HACK: prevent conflict between STLPORT and Workshop headers
33 
34 #ifndef _WRKWIN_HXX //autogen
35 #include <vcl/wrkwin.hxx>
36 #endif
37 #include <unotools/viewoptions.hxx>
38 #ifndef GCC
39 #endif
40 
41 #include <vcl/timer.hxx>
42 
43 #include "splitwin.hxx"
44 #include "workwin.hxx"
45 #include <sfx2/dockwin.hxx>
46 #include <sfx2/app.hxx>
47 #include "dialog.hrc"
48 #include "sfx2/sfxresid.hxx"
49 #include <sfx2/mnumgr.hxx>
50 #include "virtmenu.hxx"
51 #include <sfx2/msgpool.hxx>
52 #include <sfx2/viewfrm.hxx>
53 
54 #include <vector>
55 #include <utility>
56 
57 using namespace ::com::sun::star::uno;
58 using namespace ::rtl;
59 
60 #define VERSION	1
61 #define nPixel	30L
62 #define USERITEM_NAME			OUString::createFromAscii( "UserItem" )
63 
64 namespace {
65     // helper class to deactivate UpdateMode, if needed, for the life time of an instance
66     class DeactivateUpdateMode
67     {
68     public:
DeactivateUpdateMode(SfxSplitWindow & rSplitWindow)69         explicit DeactivateUpdateMode( SfxSplitWindow& rSplitWindow )
70             : mrSplitWindow( rSplitWindow )
71             , mbUpdateMode( rSplitWindow.IsUpdateMode() )
72         {
73             if ( mbUpdateMode )
74             {
75                 mrSplitWindow.SetUpdateMode( sal_False );
76             }
77         }
78 
~DeactivateUpdateMode(void)79         ~DeactivateUpdateMode( void )
80         {
81             if ( mbUpdateMode )
82             {
83                 mrSplitWindow.SetUpdateMode( sal_True );
84             }
85         }
86 
87     private:
88         SfxSplitWindow& mrSplitWindow;
89         const sal_Bool mbUpdateMode;
90     };
91 }
92 
93 struct SfxDock_Impl
94 {
95 	sal_uInt16 				nType;
96 	SfxDockingWindow*	pWin;			// SplitWindow hat dieses Fenster
97 	sal_Bool				bNewLine;
98 	sal_Bool				bHide;			// SplitWindow hatte dieses Fenster
99 	long				nSize;
100 };
101 
102 typedef SfxDock_Impl* SfxDockPtr;
103 SV_DECL_PTRARR_DEL( SfxDockArr_Impl, SfxDockPtr, 4, 4)
104 SV_IMPL_PTRARR( SfxDockArr_Impl, SfxDockPtr);
105 
106 class SfxEmptySplitWin_Impl : public SplitWindow
107 {
108 /*  [Beschreibung]
109 
110 	Das SfxEmptySplitWin_Impldow ist ein leeres SplitWindow, das das SfxSplitWindow
111 	im AutoHide-Modus ersetzt. Es dient nur als Platzhalter, um MouseMoves
112 	zu empfangen und ggf. das eigentlichte SplitWindow einzublenden
113 */
114 friend class SfxSplitWindow;
115 
116 	SfxSplitWindow* 	pOwner;
117 	sal_Bool				bFadeIn;
118 	sal_Bool				bAutoHide;
119 	sal_Bool				bSplit;
120 	sal_Bool				bEndAutoHide;
121 	Timer				aTimer;
122 	Point				aLastPos;
123 	sal_uInt16				nState;
124 
SfxEmptySplitWin_Impl(SfxSplitWindow * pParent)125 						SfxEmptySplitWin_Impl( SfxSplitWindow *pParent )
126 							: SplitWindow( pParent->GetParent(), WinBits( WB_BORDER | WB_3DLOOK ) )
127 							, pOwner( pParent )
128 							, bFadeIn( sal_False )
129 							, bAutoHide( sal_False )
130 							, bSplit( sal_False )
131 							, bEndAutoHide( sal_False )
132 							, nState( 1 )
133 						{
134 							aTimer.SetTimeoutHdl(
135 								LINK(pOwner, SfxSplitWindow, TimerHdl ) );
136 							aTimer.SetTimeout( 200 );
137 //                            EnableDrop( sal_True );
138 							SetAlign( pOwner->GetAlign() );
139 							Actualize();
140 							ShowAutoHideButton( pOwner->IsAutoHideButtonVisible() );
141 							ShowFadeInHideButton( sal_True );
142 						}
143 
~SfxEmptySplitWin_Impl()144 						~SfxEmptySplitWin_Impl()
145 						{
146 							aTimer.Stop();
147 						}
148 
149 	virtual void		MouseMove( const MouseEvent& );
150 	virtual void		AutoHide();
151 	virtual void		FadeIn();
152 	void				Actualize();
153 };
154 
Actualize()155 void SfxEmptySplitWin_Impl::Actualize()
156 {
157 	Size aSize( pOwner->GetSizePixel() );
158 	switch ( pOwner->GetAlign() )
159 	{
160 		case WINDOWALIGN_LEFT:
161 		case WINDOWALIGN_RIGHT:
162 			aSize.Width() = GetFadeInSize();
163 			break;
164 		case WINDOWALIGN_TOP:
165 		case WINDOWALIGN_BOTTOM:
166 			aSize.Height() = GetFadeInSize();
167 			break;
168 	}
169 
170 	SetSizePixel( aSize );
171 }
172 
AutoHide()173 void SfxEmptySplitWin_Impl::AutoHide()
174 {
175 	pOwner->SetPinned_Impl( !pOwner->bPinned );
176 	pOwner->SaveConfig_Impl();
177 	bAutoHide = sal_True;
178 	FadeIn();
179 }
180 
FadeIn()181 void SfxEmptySplitWin_Impl::FadeIn()
182 {
183 	if (!bAutoHide )
184 		bAutoHide = IsFadeNoButtonMode();
185 	pOwner->SetFadeIn_Impl( sal_True );
186 	pOwner->Show_Impl();
187 	if ( bAutoHide )
188 	{
189 		// Timer zum Schlie\sen aufsetzen; der Aufrufer mu\s selbst sicherstellen,
190 		// da\s das Window nicht gleich wieder zu geht ( z.B. durch Setzen des
191 		// Focus oder einen modal mode )
192 		aLastPos = GetPointerPosPixel();
193 		aTimer.Start();
194 	}
195 	else
196 		pOwner->SaveConfig_Impl();
197 }
198 
199 //-------------------------------------------------------------------------
200 
MouseButtonDown(const MouseEvent & rMEvt)201 void SfxSplitWindow::MouseButtonDown( const MouseEvent& rMEvt )
202 {
203 	if ( rMEvt.GetClicks() != 2 )
204 		SplitWindow::MouseButtonDown( rMEvt );
205 }
206 
MouseMove(const MouseEvent & rMEvt)207 void SfxEmptySplitWin_Impl::MouseMove( const MouseEvent& rMEvt )
208 {
209 	SplitWindow::MouseMove( rMEvt );
210 }
211 
212 //-------------------------------------------------------------------------
213 
SfxSplitWindow(Window * pParent,SfxChildAlignment eAl,SfxWorkWindow * pW,sal_Bool bWithButtons,WinBits nBits)214 SfxSplitWindow::SfxSplitWindow( Window* pParent, SfxChildAlignment eAl,
215 		SfxWorkWindow *pW, sal_Bool bWithButtons, WinBits nBits )
216 
217 /*  [Beschreibung]
218 
219 	Ein SfxSplitWindow verbirgt die rekursive Struktur des SV-Splitwindows
220 	nach au\sen, indem es einen tabellenartigen Aufbau mit Zeilen und Spalten
221 	( also maximale Rekursionstiefe 2 ) simuliert.
222 	Au\erdem sichert es die Persistenz der Anordnung der SfxDockingWindows.
223 */
224 
225 :	SplitWindow ( pParent, nBits | WB_HIDE ),
226 	eAlign(eAl),
227 	pWorkWin(pW),
228 	pDockArr( new SfxDockArr_Impl ),
229 	bLocked(sal_False),
230 	bPinned(sal_True),
231 	pEmptyWin(NULL),
232 	pActive(NULL)
233 {
234 	if ( bWithButtons )
235 	{
236 		ShowAutoHideButton( sal_False );    // no autohide button (pin) anymore
237 		ShowFadeOutButton( sal_True );
238 	}
239 
240 	// SV-Alignment setzen
241 	WindowAlign eTbxAlign;
242 	switch ( eAlign )
243 	{
244 		case SFX_ALIGN_LEFT:
245 			eTbxAlign = WINDOWALIGN_LEFT;
246 			break;
247 		case SFX_ALIGN_RIGHT:
248 			eTbxAlign = WINDOWALIGN_RIGHT;
249 			break;
250 		case SFX_ALIGN_TOP:
251 			eTbxAlign = WINDOWALIGN_TOP;
252 			break;
253 		case SFX_ALIGN_BOTTOM:
254 			eTbxAlign = WINDOWALIGN_BOTTOM;
255 			bPinned = sal_True;
256 			break;
257 		default:
258 			eTbxAlign = WINDOWALIGN_TOP;  // some sort of default...
259 			break;  // -Wall lots not handled..
260 	}
261 
262 	SetAlign (eTbxAlign);
263 	pEmptyWin = new SfxEmptySplitWin_Impl( this );
264 	if ( bPinned )
265 	{
266 		pEmptyWin->bFadeIn = sal_True;
267 		pEmptyWin->nState = 2;
268 	}
269 
270 	if ( bWithButtons )
271 	{
272 		// Konfiguration einlesen
273         String aWindowId = String::CreateFromAscii("SplitWindow");
274         aWindowId += String::CreateFromInt32( (sal_Int32) eTbxAlign );
275         SvtViewOptions aWinOpt( E_WINDOW, aWindowId );
276         String aWinData;
277 		Any aUserItem = aWinOpt.GetUserItem( USERITEM_NAME );
278 		OUString aTemp;
279 		if ( aUserItem >>= aTemp )
280 			aWinData = String( aTemp );
281         if ( aWinData.Len() && aWinData.GetChar( (sal_uInt16) 0 ) == 'V' )
282         {
283             pEmptyWin->nState = (sal_uInt16) aWinData.GetToken( 1, ',' ).ToInt32();
284             if ( pEmptyWin->nState & 2 )
285                 pEmptyWin->bFadeIn = sal_True;
286             //bPinned = !( pEmptyWin->nState & 1 );
287             bPinned = sal_True; // always assume pinned - floating mode not used anymore
288 
289             sal_uInt16 i=2;
290             sal_uInt16 nCount = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
291             for ( sal_uInt16 n=0; n<nCount; n++ )
292             {
293                 SfxDock_Impl *pDock = new SfxDock_Impl;
294                 pDock->pWin = 0;
295                 pDock->bNewLine = sal_False;
296                 pDock->bHide = sal_True;
297                 pDock->nType = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
298                 if ( !pDock->nType )
299                 {
300                     // K"onnte NewLine bedeuten
301                     pDock->nType = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
302                     if ( !pDock->nType )
303                     {
304                         // Lesefehler
305                         delete pDock;
306                         break;
307                     }
308                     else
309                         pDock->bNewLine = sal_True;
310                 }
311 
312                 pDockArr->Insert(pDock,n);
313             }
314         }
315 	}
316 	else
317 	{
318 		bPinned = sal_True;
319 		pEmptyWin->bFadeIn = sal_True;
320 		pEmptyWin->nState = 2;
321 	}
322 
323 	SetAutoHideState( !bPinned );
324 	pEmptyWin->SetAutoHideState( !bPinned );
325 }
326 
327 //-------------------------------------------------------------------------
328 
~SfxSplitWindow()329 SfxSplitWindow::~SfxSplitWindow()
330 {
331 	if ( !pWorkWin->GetParent_Impl() )
332 		SaveConfig_Impl();
333 
334 	if ( pEmptyWin )
335 	{
336 		// pOwner auf NULL setzen, sonst versucht pEmptyWin, nochmal zu
337 		// l"oschen; es wird n"amlich von au\sen immer das Fenster deleted,
338 		// das gerade angedockt ist
339 		pEmptyWin->pOwner = NULL;
340 		delete pEmptyWin;
341 	}
342 
343 	delete pDockArr;
344 }
345 
SaveConfig_Impl()346 void SfxSplitWindow::SaveConfig_Impl()
347 {
348 	// Konfiguration abspeichern
349 	String aWinData('V');
350     aWinData += String::CreateFromInt32( VERSION );
351 	aWinData += ',';
352     aWinData += String::CreateFromInt32( pEmptyWin->nState );
353 	aWinData += ',';
354 
355 	sal_uInt16 nCount = 0;
356 	sal_uInt16 n;
357 	for ( n=0; n<pDockArr->Count(); n++ )
358 	{
359 		SfxDock_Impl *pDock = (*pDockArr)[n];
360 		if ( pDock->bHide || pDock->pWin )
361 			nCount++;
362 	}
363 
364     aWinData += String::CreateFromInt32( nCount );
365 
366 	for ( n=0; n<pDockArr->Count(); n++ )
367 	{
368 		SfxDock_Impl *pDock = (*pDockArr)[n];
369 		if ( !pDock->bHide && !pDock->pWin )
370 			continue;
371 		if ( pDock->bNewLine )
372 			aWinData += DEFINE_CONST_UNICODE(",0");
373 		aWinData += ',';
374         aWinData += String::CreateFromInt32( pDock->nType);
375 	}
376 
377     String aWindowId = String::CreateFromAscii("SplitWindow");
378     aWindowId += String::CreateFromInt32( (sal_Int32) GetAlign() );
379     SvtViewOptions aWinOpt( E_WINDOW, aWindowId );
380 	aWinOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aWinData ) ) );
381 }
382 
383 //-------------------------------------------------------------------------
384 
StartSplit()385 void SfxSplitWindow::StartSplit()
386 {
387 	long nSize = 0;
388 	Size aSize = GetSizePixel();
389 
390 	if ( pEmptyWin )
391 	{
392 		pEmptyWin->bFadeIn = sal_True;
393 		pEmptyWin->bSplit = sal_True;
394 	}
395 
396 	Rectangle aRect = pWorkWin->GetFreeArea( !bPinned );
397 	switch ( GetAlign() )
398 	{
399 		case WINDOWALIGN_LEFT:
400 		case WINDOWALIGN_RIGHT:
401 			nSize = aSize.Width() + aRect.GetWidth();
402 			break;
403 		case WINDOWALIGN_TOP:
404 		case WINDOWALIGN_BOTTOM:
405 			nSize = aSize.Height() + aRect.GetHeight();
406 			break;
407 	}
408 
409 	SetMaxSizePixel( nSize );
410 }
411 
412 //-------------------------------------------------------------------------
413 
SplitResize()414 void SfxSplitWindow::SplitResize()
415 {
416 	if ( bPinned )
417 	{
418 		pWorkWin->ArrangeChilds_Impl();
419 		pWorkWin->ShowChilds_Impl();
420 	}
421 	else
422 		pWorkWin->ArrangeAutoHideWindows( this );
423 }
424 
425 //-------------------------------------------------------------------------
426 
Split()427 void SfxSplitWindow::Split()
428 {
429     if ( pEmptyWin )
430         pEmptyWin->bSplit = sal_False;
431 
432     SplitWindow::Split();
433 
434     std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;
435 
436     sal_uInt16 nCount = pDockArr->Count();
437     for ( sal_uInt16 n=0; n<nCount; n++ )
438     {
439         SfxDock_Impl *pD = (*pDockArr)[n];
440         if ( pD->pWin )
441         {
442             const sal_uInt16 nId = pD->nType;
443             const long nSize    = GetItemSize( nId, SWIB_FIXED );
444             const long nSetSize = GetItemSize( GetSet( nId ) );
445             Size aSize;
446 
447             if ( IsHorizontal() )
448             {
449                 aSize.Width()  = nSize;
450                 aSize.Height() = nSetSize;
451             }
452             else
453             {
454                 aSize.Width()  = nSetSize;
455                 aSize.Height() = nSize;
456             }
457 
458             pD->pWin->SetItemSize_Impl( aSize );
459 
460             aNewOrgSizes.push_back( std::pair< sal_uInt16, long >( nId, nSize ) );
461         }
462     }
463 
464     // workaround insuffiency of <SplitWindow> regarding dock layouting:
465     // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
466     {
467         DeactivateUpdateMode aDeactivateUpdateMode( *this );
468         for ( sal_uInt16 i = 0; i < aNewOrgSizes.size(); ++i )
469         {
470             SetItemSize( aNewOrgSizes[i].first, aNewOrgSizes[i].second );
471         }
472     }
473 
474     SaveConfig_Impl();
475 }
476 
477 //-------------------------------------------------------------------------
478 
InsertWindow(SfxDockingWindow * pDockWin,const Size & rSize)479 void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize)
480 
481 /*  [Beschreibung]
482 
483 	Zum Einf"ugen von SfxDockingWindows kann auch keine Position "ubergeben
484 	werden. Das SfxSplitWindow sucht dann die zuletzt gemerkte zu dem
485 	"ubergebenen SfxDockingWindow heraus oder h"angt es als letztes neu an.
486 
487 */
488 {
489 	short nLine = -1;    	// damit erstes Fenster nLine auf 0 hochsetzen kann
490 	sal_uInt16 nL;
491 	sal_uInt16 nPos = 0;
492 	sal_Bool bNewLine = sal_True;
493 	sal_Bool bSaveConfig = sal_False;
494 	SfxDock_Impl *pFoundDock=0;
495 	sal_uInt16 nCount = pDockArr->Count();
496 	for ( sal_uInt16 n=0; n<nCount; n++ )
497 	{
498 		SfxDock_Impl *pDock = (*pDockArr)[n];
499 		if ( pDock->bNewLine )
500 		{
501 			// Das Fenster er"offnet eine neue Zeile
502 			if ( pFoundDock )
503 				// Aber hinter dem gerade eingef"ugten Fenster
504 				break;
505 
506 			// Neue Zeile
507 			nPos = 0;
508 			bNewLine = sal_True;
509 		}
510 
511 		if ( pDock->pWin )
512 		{
513 			// Es gibt an dieser Stelle gerade ein Fenster
514 			if ( bNewLine && !pFoundDock )
515 			{
516 				// Bisher ist nicht bekannt, in welcher realen Zeile es liegt
517 				GetWindowPos( pDock->pWin, nL, nPos );
518 				nLine = (short) nL;
519 			}
520 
521 			if ( !pFoundDock )
522 			{
523 				// Fenster liegt vor dem eingef"ugten
524 				nPos++;
525 			}
526 
527 			// Zeile ist schon er"offnet
528 			bNewLine = sal_False;
529 			if ( pFoundDock )
530 				break;
531 		}
532 
533 		if ( pDock->nType == pDockWin->GetType() )
534 		{
535 			DBG_ASSERT( !pFoundDock && !pDock->pWin, "Fenster ist schon vorhanden!");
536 			pFoundDock = pDock;
537 			if ( !bNewLine )
538 				break;
539 			else
540 			{
541 				// Es wurde zuletzt eine neue Reihe gestartet, aber noch kein
542 				// darin liegendes Fenster gefunden; daher weitersuchen, ob noch
543 				// ein Fenster in dieser Zeile folgt, um bNewLine korrekt zu setzen.
544 				// Dabei darf aber nLine oder nPos nicht mehr ver"andert werden!
545 				nLine++;
546 			}
547 		}
548 	}
549 
550 	if ( !pFoundDock )
551 	{
552 		// Nicht gefunden, am Ende einf"ugen
553 		pFoundDock = new SfxDock_Impl;
554 		pFoundDock->bHide = sal_True;
555 		pDockArr->Insert( pFoundDock, nCount );
556 		pFoundDock->nType = pDockWin->GetType();
557 		nLine++;
558 		nPos = 0;
559 		bNewLine = sal_True;
560 		pFoundDock->bNewLine = bNewLine;
561 		bSaveConfig = sal_True;
562 	}
563 
564 	pFoundDock->pWin = pDockWin;
565 	pFoundDock->bHide = sal_False;
566 	InsertWindow_Impl( pFoundDock, rSize, nLine, nPos, bNewLine );
567 	if ( bSaveConfig )
568 		SaveConfig_Impl();
569 }
570 
571 //-------------------------------------------------------------------------
572 
ReleaseWindow_Impl(SfxDockingWindow * pDockWin,sal_Bool bSave)573 void SfxSplitWindow::ReleaseWindow_Impl(SfxDockingWindow *pDockWin, sal_Bool bSave)
574 
575 /*  [Beschreibung]
576 
577 	Das DockingWindow wird nicht mehr in den internen Daten gespeichert.
578 */
579 
580 {
581 	SfxDock_Impl *pDock=0;
582 	sal_uInt16 nCount = pDockArr->Count();
583 	sal_Bool bFound = sal_False;
584 	for ( sal_uInt16 n=0; n<nCount; n++ )
585 	{
586 		pDock = (*pDockArr)[n];
587 		if ( pDock->nType == pDockWin->GetType() )
588 		{
589 			if ( pDock->bNewLine && n<nCount-1 )
590 				(*pDockArr)[n+1]->bNewLine = sal_True;
591 
592 			// Fenster hat schon eine Position, die vergessen wir
593 			bFound = sal_True;
594 			pDockArr->Remove(n);
595 			break;
596 		}
597 	}
598 
599 	if ( bFound )
600 		delete pDock;
601 
602 	if ( bSave )
603 		SaveConfig_Impl();
604 }
605 
606 //-------------------------------------------------------------------------
607 
MoveWindow(SfxDockingWindow * pDockWin,const Size & rSize,sal_uInt16 nLine,sal_uInt16 nPos,sal_Bool bNewLine)608 void SfxSplitWindow::MoveWindow( SfxDockingWindow* pDockWin, const Size& rSize,
609 						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)
610 
611 /*  [Beschreibung]
612 
613 	Das DockingWindow wird innerhalb des Splitwindows verschoben.
614 
615 */
616 
617 {
618 	sal_uInt16 nL, nP;
619 	GetWindowPos( pDockWin, nL, nP );
620 
621 	if ( nLine > nL && GetItemCount( GetItemId( nL, 0 ) ) == 1 )
622 	{
623 		// Wenn das letzte Fenster aus seiner Zeile entfernt wird, rutscht
624 		// alles eine Zeile nach vorne!
625 		nLine--;
626 	}
627 /*
628 	else if ( nLine == nL && nPos > nP )
629 	{
630 		nPos--;
631 	}
632 */
633 	RemoveWindow( pDockWin );
634 	InsertWindow( pDockWin, rSize, nLine, nPos, bNewLine );
635 }
636 
637 //-------------------------------------------------------------------------
638 
InsertWindow(SfxDockingWindow * pDockWin,const Size & rSize,sal_uInt16 nLine,sal_uInt16 nPos,sal_Bool bNewLine)639 void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize,
640 						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)
641 
642 /*  [Beschreibung]
643 
644 	Das DockingWindow wird in dieses Splitwindow geschoben und soll die
645 	"ubergebene Position und Gr"o\se haben.
646 
647 */
648 {
649 	ReleaseWindow_Impl( pDockWin, sal_False );
650 	SfxDock_Impl *pDock = new SfxDock_Impl;
651 	pDock->bHide = sal_False;
652 	pDock->nType = pDockWin->GetType();
653 	pDock->bNewLine = bNewLine;
654 	pDock->pWin = pDockWin;
655 
656 	DBG_ASSERT( nPos==0 || !bNewLine, "Falsche Paramenter!");
657 	if ( bNewLine )
658 		nPos = 0;
659 
660 	// Das Fenster mu\s vor dem ersten Fenster eingef"ugt werden, das die
661 	// gleiche oder eine gr"o\sere Position hat als pDockWin.
662 	sal_uInt16 nCount = pDockArr->Count();
663 
664 	// Wenn gar kein Fenster gefunden wird, wird als erstes eingef"ugt
665 	sal_uInt16 nInsertPos = 0;
666 	for ( sal_uInt16 n=0; n<nCount; n++ )
667 	{
668 		SfxDock_Impl *pD = (*pDockArr)[n];
669 
670 		if (pD->pWin)
671 		{
672 			// Ein angedocktes Fenster wurde gefunden
673 			// Wenn kein geeignetes Fenster hinter der gew"unschten Einf"ugeposition
674 			// gefunden wird, wird am Ende eingef"ugt
675 			nInsertPos = nCount;
676 			sal_uInt16 nL=0, nP=0;
677 			GetWindowPos( pD->pWin, nL, nP );
678 
679 			if ( (nL == nLine && nP == nPos) || nL > nLine )
680 			{
681 				DBG_ASSERT( nL == nLine || bNewLine || nPos > 0, "Falsche Parameter!" );
682 				if ( nL == nLine && nPos == 0 && !bNewLine )
683 				{
684 					DBG_ASSERT(pD->bNewLine, "Keine neue Zeile?");
685 
686 					// Das Fenster wird auf nPos==0 eingeschoben
687 					pD->bNewLine = sal_False;
688 					pDock->bNewLine = sal_True;
689 				}
690 
691 				nInsertPos = n;
692 				break;
693 			}
694 		}
695 	}
696 
697 	pDockArr->Insert(pDock, nInsertPos);
698 	InsertWindow_Impl( pDock, rSize, nLine, nPos, bNewLine );
699 	SaveConfig_Impl();
700 }
701 
702 //-------------------------------------------------------------------------
703 
InsertWindow_Impl(SfxDock_Impl * pDock,const Size & rSize,sal_uInt16 nLine,sal_uInt16 nPos,sal_Bool bNewLine)704 void SfxSplitWindow::InsertWindow_Impl( SfxDock_Impl* pDock,
705 						const Size& rSize,
706 						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)
707 
708 /*  [Beschreibung]
709 
710 	F"ugt ein DockingWindow ein und veranla\st die Neuberechnung der Gr"o\se
711 	des Splitwindows.
712 */
713 
714 {
715 	SfxDockingWindow* pDockWin = pDock->pWin;
716 
717 	sal_uInt16 nItemBits = pDockWin->GetWinBits_Impl();
718 
719 	long nWinSize, nSetSize;
720 	if ( IsHorizontal() )
721 	{
722 		nWinSize = rSize.Width();
723 		nSetSize = rSize.Height();
724 	}
725 	else
726 	{
727 		nSetSize = rSize.Width();
728 		nWinSize = rSize.Height();
729 	}
730 
731 	pDock->nSize = nWinSize;
732 
733     DeactivateUpdateMode* pDeactivateUpdateMode = new DeactivateUpdateMode( *this );
734 
735 	if ( bNewLine || nLine == GetItemCount( 0 ) )
736 	{
737 		// Es soll nicht in eine vorhandene Zeile eingef"ugt werden, sondern
738 		// eine neue erzeugt werden
739 
740 		sal_uInt16 nId = 1;
741 		for ( sal_uInt16 n=0; n<GetItemCount(0); n++ )
742 		{
743 			if ( GetItemId(n) >= nId )
744 				nId = GetItemId(n)+1;
745 		}
746 
747 		// Eine neue nLine-te Zeile erzeugen
748 		sal_uInt16 nBits = nItemBits;
749 		if ( GetAlign() == WINDOWALIGN_TOP || GetAlign() == WINDOWALIGN_BOTTOM )
750 			nBits |= SWIB_COLSET;
751 		InsertItem( nId, nSetSize, nLine, 0, nBits );
752 	}
753 
754 	// In Zeile mit Position nLine das Fenster einf"ugen
755 	// ItemWindowSize auf "Prozentual" setzen, da SV dann das Umgr"o\sern
756 	// so macht, wie man erwartet; "Pixel" macht eigentlich nur Sinn, wenn
757 	// auch Items mit prozentualen oder relativen Gr"o\sen dabei sind.
758 	nItemBits |= SWIB_PERCENTSIZE;
759 	bLocked = sal_True;
760 	sal_uInt16 nSet = GetItemId( nLine );
761 	InsertItem( pDockWin->GetType(), pDockWin, nWinSize, nPos, nSet, nItemBits );
762 
763 	// Splitwindows werden im SFX einmal angelegt und beim Einf"ugen des ersten
764 	// DockingWindows sichtbar gemacht.
765 	if ( GetItemCount( 0 ) == 1 && GetItemCount( 1 ) == 1 )
766 	{
767 		// Das Neuarrangieren am WorkWindow und ein Show() auf das SplitWindow
768 		// wird vom SfxDockingwindow veranla\st (->SfxWorkWindow::ConfigChild_Impl)
769 		if ( !bPinned && !IsFloatingMode() )
770 		{
771 			bPinned = sal_True;
772 			sal_Bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
773 			pEmptyWin->bFadeIn = sal_False;
774 			SetPinned_Impl( sal_False );
775 			pEmptyWin->Actualize();
776             DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
777 			pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign, sal_True )->nVisible = CHILD_VISIBLE;
778 			pWorkWin->ArrangeChilds_Impl();
779 			if ( bFadeIn )
780 				FadeIn();
781 		}
782 		else
783 		{
784 			sal_Bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
785 			pEmptyWin->bFadeIn = sal_False;
786 			pEmptyWin->Actualize();
787 #ifdef DBG_UTIL
788             if ( !bPinned || !pEmptyWin->bFadeIn )
789             {
790                 DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
791             }
792             else
793             {
794                 DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering real Splitwindow" );
795             }
796 #endif
797 			pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign, sal_True )->nVisible = CHILD_VISIBLE;
798 			pWorkWin->ArrangeChilds_Impl();
799 			if ( bFadeIn )
800 				FadeIn();
801 		}
802 
803 		pWorkWin->ShowChilds_Impl();
804 	}
805 
806     delete pDeactivateUpdateMode;
807     bLocked = sal_False;
808 
809     // workaround insuffiency of <SplitWindow> regarding dock layouting:
810     // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
811     {
812         std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;
813         // get FIXED item sizes
814         sal_uInt16 nCount = pDockArr->Count();
815         for ( sal_uInt16 n=0; n<nCount; n++ )
816         {
817             SfxDock_Impl *pD = (*pDockArr)[n];
818             if ( pD->pWin )
819             {
820                 const sal_uInt16 nId = pD->nType;
821                 const long nSize    = GetItemSize( nId, SWIB_FIXED );
822                 aNewOrgSizes.push_back( std::pair< sal_uInt16, long >( nId, nSize ) );
823             }
824         }
825         // apply new item sizes
826         DeactivateUpdateMode aDeactivateUpdateMode( *this );
827         for ( sal_uInt16 i = 0; i < aNewOrgSizes.size(); ++i )
828         {
829             SetItemSize( aNewOrgSizes[i].first, aNewOrgSizes[i].second );
830         }
831     }
832 }
833 
834 //-------------------------------------------------------------------------
835 
RemoveWindow(SfxDockingWindow * pDockWin,sal_Bool bHide)836 void SfxSplitWindow::RemoveWindow( SfxDockingWindow* pDockWin, sal_Bool bHide )
837 
838 /*  [Beschreibung]
839 
840 	Entfernt ein DockingWindow. Wenn es das letzte war, wird das SplitWindow
841 	gehidet.
842 */
843 {
844 	sal_uInt16 nSet = GetSet( pDockWin->GetType() );
845 
846 	// Splitwindows werden im SFX einmal angelegt und nach dem Entfernen
847 	// des letzten DockingWindows unsichtbar gemacht.
848 	if ( GetItemCount( nSet ) == 1 && GetItemCount( 0 ) == 1 )
849 	{
850 		// Das Neuarrangieren am WorkWindow wird vom SfxDockingwindow
851 		// veranla\st!
852 		Hide();
853 		pEmptyWin->aTimer.Stop();
854         sal_uInt16 nRealState = pEmptyWin->nState;
855 		FadeOut_Impl();
856 		pEmptyWin->Hide();
857 #ifdef DBG_UTIL
858         if ( !bPinned || !pEmptyWin->bFadeIn )
859         {
860             DBG_TRACE( "SfxSplitWindow::RemoveWindow - releasing empty Splitwindow" );
861         }
862         else
863         {
864             DBG_TRACE( "SfxSplitWindow::RemoveWindow - releasing real Splitwindow" );
865         }
866 #endif
867 		pWorkWin->ReleaseChild_Impl( *GetSplitWindow() );
868 		pEmptyWin->nState = nRealState;
869 		pWorkWin->ArrangeAutoHideWindows( this );
870 	}
871 
872 	SfxDock_Impl *pDock=0;
873 	sal_uInt16 nCount = pDockArr->Count();
874 	for ( sal_uInt16 n=0; n<nCount; n++ )
875 	{
876 		pDock = (*pDockArr)[n];
877 		if ( pDock->nType == pDockWin->GetType() )
878 		{
879 			pDock->pWin = 0;
880 			pDock->bHide = bHide;
881 			break;
882 		}
883 	}
884 
885 	// Fenster removen, und wenn es das letzte der Zeile war, auch die Zeile
886 	// ( Zeile = ItemSet )
887     DeactivateUpdateMode* pDeactivateUpdateMode = new DeactivateUpdateMode( *this );
888     bLocked = sal_True;
889 
890 	RemoveItem( pDockWin->GetType() );
891 
892 	if ( nSet && !GetItemCount( nSet ) )
893 		RemoveItem( nSet );
894 
895     delete pDeactivateUpdateMode;
896     bLocked = sal_False;
897 };
898 
899 //-------------------------------------------------------------------------
900 
GetWindowPos(const SfxDockingWindow * pWindow,sal_uInt16 & rLine,sal_uInt16 & rPos) const901 sal_Bool SfxSplitWindow::GetWindowPos( const SfxDockingWindow* pWindow,
902 										sal_uInt16& rLine, sal_uInt16& rPos ) const
903 /*  [Beschreibung]
904 
905 	Liefert die Id des Itemsets und die des Items f"ur das "ubergebene
906 	DockingWindow in der alten Zeilen/Spalten-Bezeichnung zur"uck.
907 */
908 
909 {
910 	sal_uInt16 nSet = GetSet ( pWindow->GetType() );
911 	if ( nSet == SPLITWINDOW_ITEM_NOTFOUND )
912 		return sal_False;
913 
914 	rPos  = GetItemPos( pWindow->GetType(), nSet );
915 	rLine = GetItemPos( nSet );
916 	return sal_True;
917 }
918 
919 //-------------------------------------------------------------------------
920 
GetWindowPos(const Point & rTestPos,sal_uInt16 & rLine,sal_uInt16 & rPos) const921 sal_Bool SfxSplitWindow::GetWindowPos( const Point& rTestPos,
922 									  sal_uInt16& rLine, sal_uInt16& rPos ) const
923 /*  [Beschreibung]
924 
925 	Liefert die Id des Itemsets und die des Items f"ur das DockingWindow
926 	an der "ubergebenen Position in der alten Zeilen/Spalten-Bezeichnung
927 	zur"uck.
928 */
929 
930 {
931 	sal_uInt16 nId = GetItemId( rTestPos );
932 	if ( nId == 0 )
933 		return sal_False;
934 
935 	sal_uInt16 nSet = GetSet ( nId );
936 	rPos  = GetItemPos( nId, nSet );
937 	rLine = GetItemPos( nSet );
938 	return sal_True;
939 }
940 
941 //-------------------------------------------------------------------------
942 
GetLineCount() const943 sal_uInt16 SfxSplitWindow::GetLineCount() const
944 
945 /*  [Beschreibung]
946 
947 	Liefert die Zeilenzahl = Zahl der Sub-Itemsets im Root-Set.
948 */
949 {
950 	return GetItemCount( 0 );
951 }
952 
953 //-------------------------------------------------------------------------
954 
GetLineSize(sal_uInt16 nLine) const955 long SfxSplitWindow::GetLineSize( sal_uInt16 nLine ) const
956 
957 /*  [Beschreibung]
958 
959 	Liefert die "Zeilenh"ohe" des nLine-ten Itemsets.
960 */
961 {
962 	sal_uInt16 nId = GetItemId( nLine );
963 	return GetItemSize( nId );
964 }
965 
966 //-------------------------------------------------------------------------
967 
GetWindowCount(sal_uInt16 nLine) const968 sal_uInt16 SfxSplitWindow::GetWindowCount( sal_uInt16 nLine ) const
969 
970 /*  [Beschreibung]
971 
972 	Liefert die
973 */
974 {
975 	sal_uInt16 nId = GetItemId( nLine );
976 	return GetItemCount( nId );
977 }
978 
979 //-------------------------------------------------------------------------
980 
GetWindowCount() const981 sal_uInt16 SfxSplitWindow::GetWindowCount() const
982 
983 /*  [Beschreibung]
984 
985 	Liefert die Gesamtzahl aller Fenstert
986 */
987 {
988 	return GetItemCount( 0 );
989 }
990 
991 //-------------------------------------------------------------------------
992 
Command(const CommandEvent & rCEvt)993 void SfxSplitWindow::Command( const CommandEvent& rCEvt )
994 {
995 	SplitWindow::Command( rCEvt );
996 }
997 
998 //-------------------------------------------------------------------------
999 
IMPL_LINK(SfxSplitWindow,TimerHdl,Timer *,pTimer)1000 IMPL_LINK( SfxSplitWindow, TimerHdl, Timer*, pTimer)
1001 {
1002 	if ( pTimer )
1003 		pTimer->Stop();
1004 
1005 	if ( CursorIsOverRect( sal_False ) || !pTimer )
1006 	{
1007 		// Wenn der Mauszeiger innerhalb des Fensters liegt, SplitWindow anzeigen
1008 		// und Timer zum Schlie\sen aufsetzen
1009 		pEmptyWin->bAutoHide = sal_True;
1010 		if ( !IsVisible() )
1011 			pEmptyWin->FadeIn();
1012 
1013 		pEmptyWin->aLastPos = GetPointerPosPixel();
1014 		pEmptyWin->aTimer.Start();
1015 	}
1016 	else if ( pEmptyWin->bAutoHide )
1017 	{
1018 		if ( GetPointerPosPixel() != pEmptyWin->aLastPos )
1019 		{
1020 			// Die Maus wurd innerhalb der Timerlaugzeit bewegt, also erst einmal
1021 			// nichts tun
1022 			pEmptyWin->aLastPos = GetPointerPosPixel();
1023 			pEmptyWin->aTimer.Start();
1024 			return 0L;
1025 		}
1026 
1027 		// Speziell f"ur TF_AUTOSHOW_ON_MOUSEMOVE :
1028 		// Wenn das Fenster nicht sichtbar ist, gibt es nichts zu tun
1029 		// (Benutzer ist einfach mit der Maus "uber pEmptyWin gefahren)
1030 		if ( IsVisible() )
1031 		{
1032 			pEmptyWin->bEndAutoHide = sal_False;
1033 			if ( !Application::IsInModalMode() &&
1034 				  !PopupMenu::IsInExecute() &&
1035 				  !pEmptyWin->bSplit && !HasChildPathFocus( sal_True ) )
1036 			{
1037 				// W"ahrend ein modaler Dialog oder ein Popupmenu offen sind
1038 				// oder w"ahrend des Splittens auf keinen Fall zumachen; auch
1039 				// solange eines der Children den Focus hat, bleibt das
1040 				// das Fenster offen
1041 				pEmptyWin->bEndAutoHide = sal_True;
1042 			}
1043 
1044 			if ( pEmptyWin->bEndAutoHide )
1045 			{
1046 				// Von mir aus kann Schlu\s sein mit AutoShow
1047 				// Aber vielleicht will noch ein anderes SfxSplitWindow offen bleiben,
1048 				// dann bleiben auch alle anderen offen
1049 				if ( !pWorkWin->IsAutoHideMode( this ) )
1050 				{
1051 					FadeOut_Impl();
1052 					pWorkWin->ArrangeAutoHideWindows( this );
1053 				}
1054 				else
1055 				{
1056 					pEmptyWin->aLastPos = GetPointerPosPixel();
1057 					pEmptyWin->aTimer.Start();
1058 				}
1059 			}
1060 			else
1061 			{
1062 				pEmptyWin->aLastPos = GetPointerPosPixel();
1063 				pEmptyWin->aTimer.Start();
1064 			}
1065 		}
1066 	}
1067 
1068 	return 0L;
1069 }
1070 
1071 //-------------------------------------------------------------------------
1072 
CursorIsOverRect(sal_Bool bForceAdding) const1073 sal_Bool SfxSplitWindow::CursorIsOverRect( sal_Bool bForceAdding ) const
1074 {
1075 	sal_Bool bVisible = IsVisible();
1076 
1077 	// Auch das kollabierte SplitWindow ber"ucksichtigen
1078 	Point aPos = pEmptyWin->GetParent()->OutputToScreenPixel( pEmptyWin->GetPosPixel() );
1079 	Size aSize = pEmptyWin->GetSizePixel();
1080 
1081 	if ( bForceAdding )
1082 	{
1083 		// Um +/- ein paar Pixel erweitern, sonst ist es zu nerv"os
1084 		aPos.X() -= nPixel;
1085 		aPos.Y() -= nPixel;
1086 		aSize.Width() += 2 * nPixel;
1087 		aSize.Height() += 2 * nPixel;
1088 	}
1089 
1090 	Rectangle aRect( aPos, aSize );
1091 
1092 	if ( bVisible )
1093 	{
1094 		Point aVisPos = GetPosPixel();
1095 		Size aVisSize = GetSizePixel();
1096 
1097 		// Um +/- ein paar Pixel erweitern, sonst ist es zu nerv"os
1098 		aVisPos.X() -= nPixel;
1099 		aVisPos.Y() -= nPixel;
1100 		aVisSize.Width() += 2 * nPixel;
1101 		aVisSize.Height() += 2 * nPixel;
1102 
1103 		Rectangle aVisRect( aVisPos, aVisSize );
1104 		aRect = aRect.GetUnion( aVisRect );
1105 	}
1106 
1107 	if ( aRect.IsInside( OutputToScreenPixel( ((Window*)this)->GetPointerPosPixel() ) ) )
1108 		return sal_True;
1109 	return sal_False;
1110 }
1111 
1112 //-------------------------------------------------------------------------
1113 
GetSplitWindow()1114 SplitWindow* SfxSplitWindow::GetSplitWindow()
1115 {
1116 	if ( !bPinned || !pEmptyWin->bFadeIn )
1117 		return pEmptyWin;
1118 	return this;
1119 }
1120 
1121 //-------------------------------------------------------------------------
IsFadeIn() const1122 sal_Bool SfxSplitWindow::IsFadeIn() const
1123 {
1124 	return pEmptyWin->bFadeIn;
1125 }
1126 
IsAutoHide(sal_Bool bSelf) const1127 sal_Bool SfxSplitWindow::IsAutoHide( sal_Bool bSelf ) const
1128 {
1129 	return bSelf ? pEmptyWin->bAutoHide && !pEmptyWin->bEndAutoHide : pEmptyWin->bAutoHide;
1130 }
1131 
1132 //-------------------------------------------------------------------------
1133 
SetPinned_Impl(sal_Bool bOn)1134 void SfxSplitWindow::SetPinned_Impl( sal_Bool bOn )
1135 {
1136 	if ( bPinned == bOn )
1137 		return;
1138 
1139 	bPinned = bOn;
1140 	if ( GetItemCount( 0 ) == 0 )
1141 		return;
1142 
1143 	if ( !bOn )
1144 	{
1145 		pEmptyWin->nState |= 1;
1146 		if ( pEmptyWin->bFadeIn )
1147 		{
1148 			// Ersatzfenster anmelden
1149             DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - releasing real Splitwindow" );
1150 			pWorkWin->ReleaseChild_Impl( *this );
1151 			Hide();
1152 			pEmptyWin->Actualize();
1153             DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - registering empty Splitwindow" );
1154 			pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
1155 		}
1156 
1157 		Point aPos( GetPosPixel() );
1158 		aPos = GetParent()->OutputToScreenPixel( aPos );
1159 		SetFloatingPos( aPos );
1160 		SetFloatingMode( sal_True );
1161 		GetFloatingWindow()->SetOutputSizePixel( GetOutputSizePixel() );
1162 
1163 		if ( pEmptyWin->bFadeIn )
1164 			Show();
1165 	}
1166 	else
1167 	{
1168 		pEmptyWin->nState &= ~1;
1169 		SetOutputSizePixel( GetFloatingWindow()->GetOutputSizePixel() );
1170 		SetFloatingMode( sal_False );
1171 
1172 		if ( pEmptyWin->bFadeIn )
1173 		{
1174 			// Ersatzfenster abmelden
1175             DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - releasing empty Splitwindow" );
1176 			pWorkWin->ReleaseChild_Impl( *pEmptyWin );
1177 			pEmptyWin->Hide();
1178             DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - registering real Splitwindow" );
1179 			pWorkWin->RegisterChild_Impl( *this, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
1180 		}
1181 	}
1182 
1183 	SetAutoHideState( !bPinned );
1184 	pEmptyWin->SetAutoHideState( !bPinned );
1185 }
1186 
1187 //-------------------------------------------------------------------------
1188 
SetFadeIn_Impl(sal_Bool bOn)1189 void SfxSplitWindow::SetFadeIn_Impl( sal_Bool bOn )
1190 {
1191 	if ( bOn == pEmptyWin->bFadeIn )
1192 		return;
1193 
1194 	if ( GetItemCount( 0 ) == 0 )
1195 		return;
1196 
1197 	pEmptyWin->bFadeIn = bOn;
1198 	if ( bOn )
1199 	{
1200 		pEmptyWin->nState |= 2;
1201 		if ( IsFloatingMode() )
1202 		{
1203 			// FloatingWindow ist nicht sichtbar, also anzeigen
1204 			pWorkWin->ArrangeAutoHideWindows( this );
1205 			Show();
1206 		}
1207 		else
1208 		{
1209             DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - releasing empty Splitwindow" );
1210 			pWorkWin->ReleaseChild_Impl( *pEmptyWin );
1211 			pEmptyWin->Hide();
1212             DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - registering real Splitwindow" );
1213 			pWorkWin->RegisterChild_Impl( *this, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
1214 			pWorkWin->ArrangeChilds_Impl();
1215 			pWorkWin->ShowChilds_Impl();
1216 		}
1217 	}
1218 	else
1219 	{
1220 		pEmptyWin->bAutoHide = sal_False;
1221 		pEmptyWin->nState &= ~2;
1222 		if ( !IsFloatingMode() )
1223 		{
1224 			// Das Fenster "schwebt" nicht, soll aber ausgeblendet werden,
1225             DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - releasing real Splitwindow" );
1226 			pWorkWin->ReleaseChild_Impl( *this );
1227 			Hide();
1228 			pEmptyWin->Actualize();
1229             DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - registering empty Splitwindow" );
1230 			pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
1231 			pWorkWin->ArrangeChilds_Impl();
1232 			pWorkWin->ShowChilds_Impl();
1233 			pWorkWin->ArrangeAutoHideWindows( this );
1234 		}
1235 		else
1236 		{
1237 			Hide();
1238 			pWorkWin->ArrangeAutoHideWindows( this );
1239 		}
1240 	}
1241 }
1242 
AutoHide()1243 void SfxSplitWindow::AutoHide()
1244 {
1245 	// Wenn dieser Handler am "echten" SplitWindow aufgerufen wird, ist es
1246 	// entweder angedockt und soll "schwebend" angezeigt werden oder umgekehrt
1247 	if ( !bPinned )
1248 	{
1249 		// Es "schwebt", also wieder andocken
1250 		SetPinned_Impl( sal_True );
1251 		pWorkWin->ArrangeChilds_Impl();
1252 	}
1253 	else
1254 	{
1255 		// In den "Schwebezustand" bringen
1256 		SetPinned_Impl( sal_False );
1257 		pWorkWin->ArrangeChilds_Impl();
1258 		pWorkWin->ArrangeAutoHideWindows( this );
1259 	}
1260 
1261 	pWorkWin->ShowChilds_Impl();
1262 	SaveConfig_Impl();
1263 }
1264 
FadeOut_Impl()1265 void SfxSplitWindow::FadeOut_Impl()
1266 {
1267     if ( pEmptyWin->aTimer.IsActive() )
1268     {
1269         pEmptyWin->bAutoHide = sal_False;
1270         pEmptyWin->aTimer.Stop();
1271     }
1272 
1273 	SetFadeIn_Impl( sal_False );
1274 	Show_Impl();
1275 }
1276 
FadeOut()1277 void SfxSplitWindow::FadeOut()
1278 {
1279 	FadeOut_Impl();
1280 	SaveConfig_Impl();
1281 }
1282 
FadeIn()1283 void SfxSplitWindow::FadeIn()
1284 {
1285 	SetFadeIn_Impl( sal_True );
1286 	Show_Impl();
1287 }
1288 
Show_Impl()1289 void SfxSplitWindow::Show_Impl()
1290 {
1291 	sal_uInt16 nCount = pDockArr->Count();
1292 	for ( sal_uInt16 n=0; n<nCount; n++ )
1293 	{
1294 		SfxDock_Impl *pDock = (*pDockArr)[n];
1295 		if ( pDock->pWin )
1296 			pDock->pWin->FadeIn( pEmptyWin->bFadeIn );
1297 	}
1298 }
1299 /*
1300 void SfxSplitWindow::Pin_Impl( sal_Bool bPin )
1301 {
1302 	if ( bPinned != bPin )
1303 		AutoHide();
1304 }
1305 */
ActivateNextChild_Impl(sal_Bool bForward)1306 sal_Bool SfxSplitWindow::ActivateNextChild_Impl( sal_Bool bForward )
1307 {
1308 	// Wenn kein pActive, auf erstes bzw. letztes Fenster gehen ( bei !bForward wird erst in der loop dekrementiert )
1309 	sal_uInt16 nCount = pDockArr->Count();
1310 	sal_uInt16 n = bForward ? 0 : nCount;
1311 
1312 	// Wenn Focus innerhalb, dann ein Fenster vor oder zur"uck, wenn m"oglich
1313 	if ( pActive )
1314 	{
1315 		// Aktives Fenster ermitteln
1316 		for ( n=0; n<nCount; n++ )
1317 		{
1318 			SfxDock_Impl *pD = (*pDockArr)[n];
1319 			if ( pD->pWin && pD->pWin->HasChildPathFocus() )
1320 				break;
1321 		}
1322 
1323 		if ( bForward )
1324 			// ein Fenster weiter ( wenn dann n>nCount, wird die Schleife unten gar nicht durchlaufen )
1325 			n++;
1326 	}
1327 
1328 	if ( bForward )
1329 	{
1330 		// N"achstes Fenster suchen
1331 		for ( sal_uInt16 nNext=n; nNext<nCount; nNext++ )
1332 		{
1333 			SfxDock_Impl *pD = (*pDockArr)[nNext];
1334 			if ( pD->pWin )
1335 			{
1336 				pD->pWin->GrabFocus();
1337 				return sal_True;
1338 			}
1339 		}
1340 	}
1341 	else
1342 	{
1343 		// Vorheriges Fenster suchen
1344 		for ( sal_uInt16 nNext=n; nNext--; )
1345 		{
1346 			SfxDock_Impl *pD = (*pDockArr)[nNext];
1347 			if ( pD->pWin )
1348 			{
1349 				pD->pWin->GrabFocus();
1350 				return sal_True;
1351 			}
1352 		}
1353 	}
1354 
1355 	return sal_False;
1356 }
1357 
SetActiveWindow_Impl(SfxDockingWindow * pWin)1358 void SfxSplitWindow::SetActiveWindow_Impl( SfxDockingWindow* pWin )
1359 {
1360 	pActive = pWin;
1361 	pWorkWin->SetActiveChild_Impl( this );
1362 }
1363 
1364 
1365