xref: /aoo41x/main/sfx2/source/appl/workwin.cxx (revision d119d52d)
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 #ifndef GCC
28 #endif
29 
30 #include <stdio.h>
31 #include <hash_map>
32 
33 #include <sfx2/docfile.hxx>
34 #include <sfx2/objsh.hxx>
35 #include <sfx2/app.hxx>
36 #include "workwin.hxx"
37 #include <sfx2/viewfrm.hxx>
38 #include "arrdecl.hxx"
39 #include <sfx2/viewfrm.hxx>
40 #include <sfx2/module.hxx>
41 #include <sfx2/dispatch.hxx>
42 #include <sfx2/dockwin.hxx>
43 #include <sfx2/viewsh.hxx>
44 #include "splitwin.hxx"
45 #include <sfx2/msgpool.hxx>
46 #include "sfx2/sfxresid.hxx"
47 #include <sfx2/objsh.hxx>
48 #include <sfx2/request.hxx>      // SFX_ITEMSET_SET
49 #include <vcl/taskpanelist.hxx>
50 #include <vcl/toolbox.hxx>
51 #include <tools/rcid.h>
52 #include <tools/diagnose_ex.h>
53 #include <toolkit/helper/vclunohelper.hxx>
54 #include <svl/itempool.hxx>
55 #include <svl/itemiter.hxx>
56 #include <svl/whiter.hxx>
57 #include <svl/intitem.hxx>
58 #ifndef _SFXEITEM_HXX //autogen
59 #include <svl/eitem.hxx>
60 #endif
61 #include <com/sun/star/ui/XUIElement.hpp>
62 #include <com/sun/star/frame/XLayoutManager.hpp>
63 #include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp>
64 #include <com/sun/star/frame/LayoutManagerEvents.hpp>
65 #include <com/sun/star/beans/XPropertySet.hpp>
66 #include <com/sun/star/awt/XWindow.hpp>
67 #include <com/sun/star/lang/DisposedException.hpp>
68 
69 using namespace ::com::sun::star;
70 using namespace ::com::sun::star::uno;
71 namespace css = ::com::sun::star;
72 
73 struct ResIdToResName
74 {
75     sal_uInt16      nId;
76     const char* pName;
77 };
78 
79 static const ResIdToResName pToolBarResToName[] =
80 {
81     { 558,      "fullscreenbar"        },
82     { 560,      "standardbar",         },
83     { 18001,    "formsnavigationbar"   },
84     { 18002,    "formsfilterbar"       },
85     { 18003,    "formtextobjectbar"    },
86     { 18004,    "formcontrols"         },
87     { 18005,    "moreformcontrols"     },
88     { 18006,    "formdesign"           },
89     { 20050,    "toolbar"              },      //math
90     { 30001,    "objectbar"            },      //chart
91     { 30513,    "toolbar"              },      //chart
92     { 25005,    "textobjectbar"        },      //calc
93     { 25053,    "drawobjectbar"        },
94     { 25054,    "graphicobjectbar"     },
95     { 25001,    "formatobjectbar"      },
96     { 25006,    "previewbar"           },
97     { 25035,    "toolbar"              },      //calc
98     { 23015,    "bezierobjectbar"      },      //draw/impress
99     { 23019,    "gluepointsobjectbar"  },
100     { 23030,    "graphicobjectbar"     },
101     { 23013,    "drawingobjectbar"     },      //impress
102     { 23016,    "textobjectbar"        },      //impress
103     { 23028,    "textobjectbar"        },      //draw
104     { 23011,    "toolbar"              },      //impress
105     { 23020,    "optionsbar"           },
106     { 23021,    "commontaskbar"        },
107     { 23025,    "toolbar"              },      //draw
108     { 23026,    "optionsbar"           },
109     { 23027,    "drawingobjectbar"     },      //draw
110     { 23017,    "outlinetoolbar"       },      //impress
111     { 23012,    "slideviewtoolbar"     },
112     { 23014,    "slideviewobjectbar"   },
113     { 23283,    "bezierobjectbar"      },      //writer
114     { 23269,    "drawingobjectbar"     },
115     { 23270,    "drawtextobjectbar"    },
116     { 23267,    "frameobjectbar"       },
117     { 23268,    "graphicobjectbar"     },
118     { 23271,    "numobjectbar"         },
119     { 23272,    "oleobjectbar"         },
120     { 23266,    "tableobjectbar"       },
121     { 23265,    "textobjectbar"        },
122     { 20631,    "previewobjectbar"     },      //writer
123     { 20402,    "toolbar"              },      //web
124     { 20403,    "textobjectbar"        },
125     { 23273,    "toolbar"              },      //writer
126     { 20408,    "frameobjectbar"       },      //web
127     { 20410,    "graphicobjectbar"     },
128     { 20411,    "oleobjectbar"         },
129     { 14850,    "macrobar"             },
130     { 10987,    "fontworkobjectbar"    },      //global
131     { 10986,    "extrusionobjectbar"   },
132     { 23022,    "formsobjectbar"       },
133     { 23310,    "viewerbar"            },      //writer (plugin)
134     { 25000,    "viewerbar"            },      //calc   (plugin)
135     { 23023,    "viewerbar"            },      //impress(plugin)
136     { 23024,    "viewerbar"            },      //draw   (plugin)
137     { 23031,    "mediaobjectbar"       },      //draw/impress
138     { 25060,    "mediaobjectbar"       },      //calc
139     { 23311,    "mediaobjectbar"       },      //writer
140     { 0,        ""                     }
141 };
142 
143 DBG_NAME(SfxWorkWindow)
144 
145 //SV_IMPL_OBJARR( SfxObjectBarArr_Impl, SfxObjectBar_Impl );
146 
147 //====================================================================
148 // Sortiert die Children nach ihrem Alignment
149 // Reihenfolge entspricht der im enum SfxChildAlignment (->CHILDWIN.HXX).
150 //
151 
152 // Hilfe, um die "Anderungen am Alignment kompatibal zu machen!
153 
154 
SFX_IMPL_XINTERFACE_3(LayoutManagerListener,OWeakObject,::com::sun::star::frame::XLayoutManagerListener,::com::sun::star::lang::XEventListener,::com::sun::star::lang::XComponent)155 SFX_IMPL_XINTERFACE_3( LayoutManagerListener, OWeakObject, ::com::sun::star::frame::XLayoutManagerListener, ::com::sun::star::lang::XEventListener, ::com::sun::star::lang::XComponent )
156 SFX_IMPL_XTYPEPROVIDER_3( LayoutManagerListener, ::com::sun::star::frame::XLayoutManagerListener, ::com::sun::star::lang::XEventListener, ::com::sun::star::lang::XComponent )
157 
158 LayoutManagerListener::LayoutManagerListener(
159     SfxWorkWindow* pWrkWin ) :
160     m_bHasFrame( sal_False ),
161     m_pWrkWin( pWrkWin ),
162     m_aLayoutManagerPropName( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ))
163 {
164 }
165 
~LayoutManagerListener()166 LayoutManagerListener::~LayoutManagerListener()
167 {
168 }
169 
setFrame(const css::uno::Reference<css::frame::XFrame> & xFrame)170 void LayoutManagerListener::setFrame( const css::uno::Reference< css::frame::XFrame >& xFrame )
171 {
172     ::vos::OGuard aGuard( Application::GetSolarMutex() );
173     if ( m_pWrkWin && !m_bHasFrame )
174     {
175         m_xFrame    = xFrame;
176         m_bHasFrame = sal_True;
177 
178         if ( xFrame.is() )
179         {
180             css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
181             css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager;
182             if ( xPropSet.is() )
183             {
184                 try
185                 {
186                     Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
187 	                aValue >>= xLayoutManager;
188 
189                     if ( xLayoutManager.is() )
190                         xLayoutManager->addLayoutManagerEventListener(
191                             css::uno::Reference< css::frame::XLayoutManagerListener >(
192                                 static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY ));
193 
194                     xPropSet = css::uno::Reference< css::beans::XPropertySet >( xLayoutManager, UNO_QUERY );
195                     if ( xPropSet.is() )
196                     {
197                         aValue = xPropSet->getPropertyValue(
198                             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LockCount" )) );
199                         aValue >>= m_pWrkWin->m_nLock;
200                     }
201                 }
202                 catch ( css::lang::DisposedException& )
203                 {
204                 }
205                 catch ( css::uno::RuntimeException& e )
206                 {
207                     throw e;
208                 }
209                 catch ( css::uno::Exception& )
210                 {
211                 }
212             }
213         }
214     }
215 }
216 
217 //---------------------------------------------------------------------------------------------------------
218 //  XComponent
219 //---------------------------------------------------------------------------------------------------------
addEventListener(const css::uno::Reference<css::lang::XEventListener> &)220 void SAL_CALL LayoutManagerListener::addEventListener(
221     const css::uno::Reference< css::lang::XEventListener >& )
222 throw (::com::sun::star::uno::RuntimeException)
223 {
224     // do nothing, only internal class
225 }
226 
removeEventListener(const css::uno::Reference<css::lang::XEventListener> &)227 void SAL_CALL LayoutManagerListener::removeEventListener(
228     const css::uno::Reference< css::lang::XEventListener >& )
229 throw (::com::sun::star::uno::RuntimeException)
230 {
231     // do nothing, only internal class
232 }
233 
dispose()234 void SAL_CALL LayoutManagerListener::dispose()
235 throw( css::uno::RuntimeException )
236 {
237     ::vos::OGuard aGuard( Application::GetSolarMutex() );
238 
239     // reset member
240     m_pWrkWin = 0;
241 
242     css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame.get(), css::uno::UNO_QUERY );
243     if ( xFrame.is() )
244     {
245         m_xFrame = css::uno::Reference< css::frame::XFrame >();
246         m_bHasFrame = sal_False;
247 
248         css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, css::uno::UNO_QUERY );
249         css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager;
250         if ( xPropSet.is() )
251         {
252             try
253             {
254                 css::uno::Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
255 	            aValue >>= xLayoutManager;
256 
257                 // remove as listener from layout manager
258                 if ( xLayoutManager.is() )
259                     xLayoutManager->removeLayoutManagerEventListener(
260                         css::uno::Reference< css::frame::XLayoutManagerListener >(
261                             static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY ));
262             }
263             catch ( css::lang::DisposedException& )
264             {
265             }
266             catch ( css::uno::RuntimeException& e )
267             {
268                 throw e;
269             }
270             catch ( css::uno::Exception& )
271             {
272             }
273         }
274     }
275 }
276 
277 //---------------------------------------------------------------------------------------------------------
278 //  XEventListener
279 //---------------------------------------------------------------------------------------------------------
disposing(const css::lang::EventObject &)280 void SAL_CALL LayoutManagerListener::disposing(
281     const css::lang::EventObject& )
282 throw( css::uno::RuntimeException )
283 {
284     ::vos::OGuard aGuard( Application::GetSolarMutex() );
285     m_pWrkWin = 0;
286     m_bHasFrame = sal_False;
287     m_xFrame = css::uno::Reference< css::frame::XFrame >();
288 }
289 
290 //---------------------------------------------------------------------------------------------------------
291 // XLayoutManagerEventListener
292 //---------------------------------------------------------------------------------------------------------
layoutEvent(const css::lang::EventObject &,::sal_Int16 eLayoutEvent,const css::uno::Any &)293 void SAL_CALL LayoutManagerListener::layoutEvent(
294     const css::lang::EventObject&,
295     ::sal_Int16                   eLayoutEvent,
296     const css::uno::Any&                        )
297 throw (css::uno::RuntimeException)
298 {
299     ::vos::OGuard aGuard( Application::GetSolarMutex() );
300     if ( m_pWrkWin )
301     {
302         if ( eLayoutEvent == css::frame::LayoutManagerEvents::VISIBLE )
303         {
304             m_pWrkWin->MakeVisible_Impl( sal_True );
305             m_pWrkWin->ShowChilds_Impl();
306             m_pWrkWin->ArrangeChilds_Impl( sal_True );
307         }
308         else if ( eLayoutEvent == css::frame::LayoutManagerEvents::INVISIBLE )
309         {
310             m_pWrkWin->MakeVisible_Impl( sal_False );
311             m_pWrkWin->HideChilds_Impl();
312             m_pWrkWin->ArrangeChilds_Impl( sal_True );
313         }
314         else if ( eLayoutEvent == css::frame::LayoutManagerEvents::LOCK )
315         {
316             m_pWrkWin->Lock_Impl( sal_True );
317         }
318         else if ( eLayoutEvent == css::frame::LayoutManagerEvents::UNLOCK )
319         {
320             m_pWrkWin->Lock_Impl( sal_False );
321         }
322     }
323 }
324 
325 //====================================================================
326 
327 typedef std::hash_map< sal_Int32, rtl::OUString > ToolBarResIdToResourceURLMap;
328 
329 static sal_Bool bMapInitialized = sal_False;
330 static ToolBarResIdToResourceURLMap aResIdToResourceURLMap;
331 
GetResourceURLFromResId(sal_uInt16 nResId)332 static rtl::OUString GetResourceURLFromResId( sal_uInt16 nResId )
333 {
334     if ( !bMapInitialized )
335     {
336         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
337         if ( !bMapInitialized )
338         {
339             sal_Int32 nIndex( 0 );
340             while ( pToolBarResToName[nIndex].nId != 0 )
341             {
342                 rtl::OUString aResourceURL( rtl::OUString::createFromAscii( pToolBarResToName[nIndex].pName ));
343                 aResIdToResourceURLMap.insert( ToolBarResIdToResourceURLMap::value_type(
344                                                     sal_Int32( pToolBarResToName[nIndex].nId ), aResourceURL ));
345                 ++nIndex;
346             }
347             bMapInitialized = sal_True;
348         }
349     }
350 
351     ToolBarResIdToResourceURLMap::const_iterator pIter = aResIdToResourceURLMap.find( nResId );
352     if ( pIter != aResIdToResourceURLMap.end() )
353         return pIter->second;
354     else
355         return rtl::OUString();
356 }
357 
IsAppWorkWinToolbox_Impl(sal_uInt16 nPos)358 sal_Bool IsAppWorkWinToolbox_Impl( sal_uInt16 nPos )
359 {
360 	switch ( nPos )
361 	{
362 		case SFX_OBJECTBAR_APPLICATION :
363 		case SFX_OBJECTBAR_MACRO:
364 		case SFX_OBJECTBAR_FULLSCREEN:
365 			return sal_True;
366 		default:
367 			return sal_False;
368 	}
369 }
370 
TbxMatch(sal_uInt16 nPos)371 sal_uInt16 TbxMatch( sal_uInt16 nPos )
372 {
373     switch ( nPos )
374     {
375         case SFX_OBJECTBAR_APPLICATION :
376             return 0;
377         case SFX_OBJECTBAR_OPTIONS:
378             return 1;
379         case SFX_OBJECTBAR_MACRO:
380             return 2;
381         case SFX_OBJECTBAR_OBJECT:
382             return 3;
383         case SFX_OBJECTBAR_TOOLS:
384             return 4;
385         case SFX_OBJECTBAR_FULLSCREEN:
386         case SFX_OBJECTBAR_COMMONTASK:
387         case SFX_OBJECTBAR_RECORDING:
388             return nPos+1;
389         default:
390             return nPos;
391     }
392 }
393 
ChildAlignValue(SfxChildAlignment eAlign)394 sal_uInt16 ChildAlignValue(SfxChildAlignment eAlign)
395 {
396 	sal_uInt16 ret = 17;
397 
398 	switch (eAlign)
399 	{
400 		case SFX_ALIGN_HIGHESTTOP:
401 			ret = 1;
402 			break;
403 		case SFX_ALIGN_LOWESTBOTTOM:
404 			ret = 2;
405 			break;
406 		case SFX_ALIGN_FIRSTLEFT:
407 			ret = 3;
408 			break;
409 		case SFX_ALIGN_LASTRIGHT:
410 			ret = 4;
411 			break;
412 		case SFX_ALIGN_LEFT:
413 			ret = 5;
414 			break;
415 		case SFX_ALIGN_RIGHT:
416 			ret = 6;
417 			break;
418 		case SFX_ALIGN_FIRSTRIGHT:
419 			ret = 7;
420 			break;
421 		case SFX_ALIGN_LASTLEFT:
422 			ret = 8;
423 			break;
424 		case SFX_ALIGN_TOP:
425 			ret = 9;
426 			break;
427 		case SFX_ALIGN_BOTTOM:
428 			ret = 10;
429 			break;
430 		case SFX_ALIGN_TOOLBOXTOP:
431 			ret = 11;
432 			break;
433 		case SFX_ALIGN_TOOLBOXBOTTOM:
434 			ret = 12;
435 			break;
436 		case SFX_ALIGN_LOWESTTOP:
437 			ret = 13;
438 			break;
439 		case SFX_ALIGN_HIGHESTBOTTOM:
440 			ret = 14;
441 			break;
442 		case SFX_ALIGN_TOOLBOXLEFT:
443 			ret = 15;
444 			break;
445 		case SFX_ALIGN_TOOLBOXRIGHT:
446 			ret = 16;
447 			break;
448 		case SFX_ALIGN_NOALIGNMENT:
449 			break;  // -Wall not handled...
450 	}
451 
452 	return ret;
453 }
454 
ChildTravelValue(SfxChildAlignment eAlign)455 sal_uInt16 ChildTravelValue( SfxChildAlignment eAlign )
456 {
457 	sal_uInt16 ret = 17;
458 
459 	switch (eAlign)
460 	{
461 		case SFX_ALIGN_FIRSTLEFT:
462 			ret = 1;
463 			break;
464 		case SFX_ALIGN_LEFT:
465 			ret = 2;
466 			break;
467 		case SFX_ALIGN_LASTLEFT:
468 			ret = 3;
469 			break;
470 		case SFX_ALIGN_TOOLBOXLEFT:
471 			ret = 4;
472 			break;
473 		case SFX_ALIGN_HIGHESTTOP:
474 			ret = 5;
475 			break;
476 		case SFX_ALIGN_TOP:
477 			ret = 6;
478 			break;
479 		case SFX_ALIGN_TOOLBOXTOP:
480 			ret = 7;
481 			break;
482 		case SFX_ALIGN_LOWESTTOP:
483 			ret = 8;
484 			break;
485 		case SFX_ALIGN_HIGHESTBOTTOM:
486 			ret = 9;
487 			break;
488 		case SFX_ALIGN_TOOLBOXBOTTOM:
489 			ret = 10;
490 			break;
491 		case SFX_ALIGN_BOTTOM:
492 			ret = 11;
493 			break;
494 		case SFX_ALIGN_LOWESTBOTTOM:
495 			ret = 12;
496 			break;
497 		case SFX_ALIGN_TOOLBOXRIGHT:
498 			ret = 13;
499 			break;
500 		case SFX_ALIGN_FIRSTRIGHT:
501 			ret = 14;
502 			break;
503 		case SFX_ALIGN_RIGHT:
504 			ret = 15;
505 			break;
506 		case SFX_ALIGN_LASTRIGHT:
507 			ret = 16;
508 			break;
509 		case SFX_ALIGN_NOALIGNMENT:
510 			break;  // -Wall not handled.
511 	}
512 
513 	return ret;
514 }
515 
Sort_Impl()516 void SfxWorkWindow::Sort_Impl()
517 {
518 	aSortedList.Remove(0, aSortedList.Count());
519 	for (sal_uInt16 i=0; i<pChilds->Count(); i++)
520 	{
521 		SfxChild_Impl *pCli = (*pChilds)[i];
522 		if (pCli)
523 		{
524 			sal_uInt16 k;
525 			for (k=0; k<aSortedList.Count(); k++)
526 //				if ( (*pChilds)[aSortedList[k]]->eAlign > pCli->eAlign )
527 				if (ChildAlignValue((*pChilds)[aSortedList[k]]->eAlign) >
528 					ChildAlignValue(pCli->eAlign))
529 					break;
530 			aSortedList.Insert (i,k);
531 		}
532 	}
533 
534 	bSorted = sal_True;
535 }
536 
537 
538 //====================================================================
539 // ctor f"ur workwin eines Frames
540 
SfxFrameWorkWin_Impl(Window * pWin,SfxFrame * pFrm,SfxFrame * pMaster)541 SfxFrameWorkWin_Impl::SfxFrameWorkWin_Impl( Window *pWin, SfxFrame *pFrm, SfxFrame* pMaster )
542     : SfxWorkWindow(
543         pWin,
544         pFrm->GetCurrentViewFrame()->GetBindings(),
545         pFrm->GetParentFrame() ? pFrm->GetParentFrame()->GetWorkWindow_Impl() : NULL )
546     , pMasterFrame( pMaster )
547     , pFrame( pFrm )
548 {
549 	pConfigShell = pFrm->GetCurrentViewFrame();
550 	if ( pConfigShell && pConfigShell->GetObjectShell() )
551 	{
552 		bShowStatusBar = ( !pConfigShell->GetObjectShell()->IsInPlaceActive() );
553 		bDockingAllowed = sal_True;
554         bInternalDockingAllowed = sal_True;
555 	}
556 
557 	// Die ben"otigten SplitWindows (je eins f"ur jede Seite) werden erzeugt
558 	for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
559 	{
560 		// Die SplitWindows sind direkte ChildWindows des WorkWindows und enthalten
561 		// die angedockten Fenster.
562 
563 		SfxChildAlignment eAlign =
564 						( n == SFX_SPLITWINDOWS_LEFT ? SFX_ALIGN_LEFT :
565 							n == SFX_SPLITWINDOWS_RIGHT ? SFX_ALIGN_RIGHT :
566 							n == SFX_SPLITWINDOWS_TOP ? SFX_ALIGN_TOP :
567 								SFX_ALIGN_BOTTOM );
568 		SfxSplitWindow *pSplitWin = new SfxSplitWindow(pWorkWin, eAlign, this, pParent==0 );
569 		pSplit[n] = pSplitWin;
570 	}
571 
572     //nOrigMode = SFX_VISIBILITY_CLIENT;
573     nOrigMode = SFX_VISIBILITY_STANDARD;
574 	nUpdateMode = SFX_VISIBILITY_STANDARD;
575 }
576 
577 //====================================================================
578 // ctor der Basisklasse
579 
SfxWorkWindow(Window * pWin,SfxBindings & rB,SfxWorkWindow * pParentWorkwin)580 SfxWorkWindow::SfxWorkWindow( Window *pWin, SfxBindings& rB, SfxWorkWindow* pParentWorkwin ) :
581 	pParent( pParentWorkwin ),
582 	pBindings(&rB),
583 	pWorkWin (pWin),
584 	pConfigShell( 0 ),
585     pActiveChild( 0 ),
586 	nChilds( 0 ),
587 	nOrigMode( 0 ),
588 	bSorted( sal_True ),
589 	bDockingAllowed(sal_True),
590     bInternalDockingAllowed(sal_True),
591 	bAllChildsVisible(sal_True),
592     bIsFullScreen( sal_False ),
593     bShowStatusBar( sal_True ),
594     m_nLock( 0 ),
595     m_aStatusBarResName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" )),
596     m_aLayoutManagerPropName( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )),
597     m_aTbxTypeName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/" )),
598     m_aProgressBarResName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/progressbar/progressbar" ))
599 {
600 	DBG_CTOR(SfxWorkWindow, 0);
601 	DBG_ASSERT (pBindings, "Keine Bindings!");
602 
603 	pBindings->SetWorkWindow_Impl( this );
604 
605 	pChildWins = new SfxChildWindows_Impl;
606 	pChilds = new SfxChildList_Impl;
607 
608 	// F"ur die ObjectBars wird ein fester Platz in der ChildList reserviert,
609 	// damit sie immer in einer definierten Reihenfolge kommen.
610 	SfxChild_Impl* pChild=0;
611 	for (sal_uInt16 n=0; n < SFX_OBJECTBAR_MAX; ++n)
612 		pChilds->Insert(0,pChild);
613 
614     // create and initialize layout manager listener
615     Reference< com::sun::star::frame::XFrame > xFrame = GetFrameInterface();
616     LayoutManagerListener* pLayoutManagerListener = new LayoutManagerListener( this );
617     m_xLayoutManagerListener = css::uno::Reference< css::lang::XComponent >(
618                                     static_cast< cppu::OWeakObject* >( pLayoutManagerListener ),
619                                         css::uno::UNO_QUERY );
620     pLayoutManagerListener->setFrame( xFrame );
621 }
622 
623 //====================================================================
624 // dtor
625 
~SfxWorkWindow()626 SfxWorkWindow::~SfxWorkWindow()
627 {
628 	DBG_DTOR(SfxWorkWindow, 0);
629 
630 	// SplitWindows l"oschen
631     for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
632 	{
633 		SfxSplitWindow *p = pSplit[n];
634 		if (p->GetWindowCount())
635 			ReleaseChild_Impl(*p);
636         delete p;
637 	}
638 
639 	// Hilfsstruktur f"ur Child-Windows l"oschen
640 	DBG_ASSERT( pChilds->Count() == 0, "dangling childs" );
641 	delete pChilds;
642 	delete pChildWins;
643 
644     if ( m_xLayoutManagerListener.is() )
645         m_xLayoutManagerListener->dispose();
646 }
647 
GetTopWindow() const648 SystemWindow* SfxWorkWindow::GetTopWindow() const
649 {
650     Window* pRet = pWorkWin;
651     while ( pRet && !pRet->IsSystemWindow() )
652         pRet = pRet->GetParent();
653     return (SystemWindow*) pRet;
654 }
655 
Lock_Impl(sal_Bool bLock)656 void SfxWorkWindow::Lock_Impl( sal_Bool bLock )
657 {
658     if ( bLock )
659         m_nLock++;
660     else
661         --m_nLock;
662     if ( m_nLock<0 )
663     {
664         DBG_ERROR("Lock count underflow!");
665         m_nLock = 0;
666     }
667 
668     if ( !m_nLock )
669         ArrangeChilds_Impl();
670 }
671 
ChangeWindow_Impl(Window * pNew)672 void SfxWorkWindow::ChangeWindow_Impl( Window *pNew )
673 {
674 	Window *pOld = pWorkWin;
675 	pWorkWin = pNew;
676 	for ( sal_uInt16 nPos = 0; nPos < pChilds->Count(); ++nPos )
677 	{
678 		SfxChild_Impl *pCli = (*pChilds)[nPos];
679 		if ( pCli && pCli->pWin && pCli->pWin->GetParent() == pOld )
680 		{
681 			pCli->pWin->SetParent( pNew );
682 		}
683 	}
684 }
685 
SaveStatus_Impl()686 void SfxWorkWindow::SaveStatus_Impl()
687 {
688 	sal_uInt16 nCount = pChildWins->Count();
689     for ( sal_uInt16 n=0; n<nCount; n++ )
690 	{
691 		SfxChildWin_Impl* pCW = (*pChildWins)[n];
692 		SfxChildWindow *pChild = pCW->pWin;
693 		if (pChild)
694 		{
695             sal_uInt16 nFlags = pCW->aInfo.nFlags;
696 			pCW->aInfo = pChild->GetInfo();
697             pCW->aInfo.nFlags |= nFlags;
698 			SaveStatus_Impl(pChild, pCW->aInfo);
699 		}
700 	}
701 }
702 
703 //--------------------------------------------------------------------
704 // Hilfsmethode zum Freigeben der Childlisten. Wenn danach nicht der dtor
705 // aufgerufen wird, sondern weiter gearbeitet wird, mu\s wie im ctor von
706 // SfxWorkWindow noch Platz f"ur die Objectbars und SplitWindows reserviert
707 // werden.
708 
DeleteControllers_Impl()709 void SfxWorkWindow::DeleteControllers_Impl()
710 {
711     DBG_CHKTHIS(SfxWorkWindow, 0);
712 
713     // SplitWindows locken (d.h. Resize-Reaktion an den
714     // DockingWindows unterdr"ucken)
715     sal_uInt16 n;
716     for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
717     {
718         SfxSplitWindow *p = pSplit[n];
719        	if (p->GetWindowCount())
720 	    p->Lock();
721     }
722 
723     // Child-Windows l"oschen
724     for ( n=0; n<pChildWins->Count(); )
725     {
726         SfxChildWin_Impl* pCW = (*pChildWins)[n];
727         pChildWins->Remove(n);
728        	SfxChildWindow *pChild = pCW->pWin;
729 	    if (pChild)
730 	    {
731 /*
732             sal_uInt16 nFlags = pCW->aInfo.nFlags;
733             pCW->aInfo = pChild->GetInfo();
734             pCW->aInfo.nFlags |= nFlags;
735             SaveStatus_Impl(pChild, pCW->aInfo);
736 */
737 	        pChild->Hide();
738 
739 	        // Wenn das ChildWindow ein direktes Childfenster ist und nicht
740 	        // in einem SplitWindow liegt, am WorkWindow abmelden.
741 	        // Nach TH ist eine Abmeldung am Splitwindow nicht erforderlich,
742 	        // wenn dieses auch gleich mit zerst"ort wird (s.u.).
743 	        if (pCW->pCli)
744 	            ReleaseChild_Impl(*pChild->GetWindow());
745 	        pCW->pWin = 0;
746 	        pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChild->GetWindow() );
747             pChild->Destroy();
748         }
749 
750 	    delete pCW;
751 
752         // ATTENTION: The array itself is cleared after this loop!!
753         // Therefore we have to set every array entry to zero as it could be
754         // accessed by calling pChild->Destroy().
755         // See task 128307 (Windows)
756         // Window::NotifyAllChilds() calls SfxWorkWindow::DataChanged_Impl for
757         // 8-bit displays (WM_QUERYPALETTECHANGED message due to focus change)!!
758         //(*pChildWins)[n] = 0;
759     }
760 
761     //pChildWins->Remove((sal_uInt16)0, nCount);
762 
763     Reference< com::sun::star::frame::XFrame > xFrame = GetFrameInterface();
764     Reference< com::sun::star::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
765     Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
766     if ( xPropSet.is() )
767     {
768         try
769         {
770 	        Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
771 	        aValue >>= xLayoutManager;
772         }
773         catch ( Exception& )
774         {
775         }
776     }
777 
778     if ( xLayoutManager.is() )
779     {
780         xLayoutManager->reset();
781 
782         // StatusBar l"oschen
783         ResetStatusBar_Impl();
784 
785         // ObjectBars l"oschen( zuletzt, damit pChilds nicht tote Pointer enh"alt )
786         for ( sal_uInt16 i = 0; i < aObjBarList.size(); i++ )
787         {
788             // Nicht jede Position mu\s belegt sein
789             sal_uInt16 nId = aObjBarList[i].nId;
790             if ( nId )
791                 aObjBarList[i].nId = 0;
792         }
793     }
794 
795     // ObjectBars werden alle auf einmal released, da sie einen
796     // festen zusammenh"angenden  Bereich im Array pChilds belegen
797     pChilds->Remove(0, SFX_OBJECTBAR_MAX);
798     bSorted = sal_False;
799 
800     nChilds = 0;
801 }
802 
803 //====================================================================
804 // Virtuelle Methode zum Anordnen der Childfenster.
805 
ArrangeChilds_Impl(sal_Bool)806 void SfxWorkWindow::ArrangeChilds_Impl( sal_Bool /*bForce*/)
807 {
808     Arrange_Impl();
809 }
810 
ArrangeChilds_Impl(sal_Bool bForce)811 void SfxFrameWorkWin_Impl::ArrangeChilds_Impl( sal_Bool bForce )
812 {
813     if ( pFrame->IsClosing_Impl() || ( m_nLock && !bForce ))
814 		return;
815 
816 	SfxInPlaceClient *pClient = 0;
817     SfxViewFrame *pF = pFrame->GetCurrentViewFrame();
818     if ( pF && pF->GetViewShell() )
819         pClient = pF->GetViewShell()->GetIPClient();
820 
821     if ( pClient )
822         return;
823 
824 	aClientArea = GetTopRect_Impl();
825     if ( aClientArea.IsEmpty() )
826         return;
827 
828 	SvBorder aBorder;
829 	if ( nChilds )
830     {
831         if ( IsVisible_Impl() )
832             aBorder = Arrange_Impl();
833     }
834 
835 	// Wenn das aktuelle Dokument der Applikation einen IPClient enth"alt, mu\s
836 	// dem dazugeh"origen Objekt durch SetTopToolFramePixel der zur Verf"ugung
837 	// stehende Platz zugeteilt werden. Das Objekt zeigt dann seine UITools an
838 	// und setzt den App-Border(->SfxInPlaceEnv_Impl::ArrangeChilds_Impl()).
839 	// Anderenfalls wird hier direkt der AppBorder gesetzt, um evtl. den Border
840 	// zu "uberschreiben, den bisher ein Objekt aus einem anderen Dokument
841 	// gesetzt hatte.
842 	// Das Objekt setzt, wenn es seine UI-Tools wegnimmt, den SetAppBorder nicht,
843 	// damit kein ObjectBar-Zappeln entsteht.
844 	// (->SfxInPlaceEnv_Impl::ArrangeChilds_Impl())
845 
846     pMasterFrame->SetToolSpaceBorderPixel_Impl( aBorder );
847 
848     ArrangeAutoHideWindows( NULL );
849 }
850 
851 //--------------------------------------------------------------------
852 
Arrange_Impl()853 SvBorder SfxWorkWindow::Arrange_Impl()
854 
855 /*	[Beschreibung]
856 
857 	Diese Methode ordnet alle sichtbaren ChildFenster so an, da\s die angedockten
858 	Fenster nach der Sorierreihenfolge von au\sen nach innen aneinander
859 	gesetzt werden. Wenn ein an sich sichtbares Fenster nicht mehr in die
860 	noch freie ClientArea pa\st, wird es auf "nicht sichtbar" gesetzt.
861 
862 */
863 {
864     DBG_CHKTHIS(SfxWorkWindow, 0);
865 
866     aClientArea = GetTopRect_Impl();
867     aUpperClientArea = aClientArea;
868 
869     SvBorder aBorder;
870     if ( !nChilds )
871         return aBorder;
872 
873     if (!bSorted)
874         Sort_Impl();
875 
876     Point aPos;
877     Size aSize;
878     Rectangle aTmp( aClientArea );
879 
880     for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n )
881     {
882         SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]];
883         if ( !pCli->pWin )
884             continue;
885 
886         // Zun"achst nehmen wir an, da\s das Fenster Platz hat
887         pCli->nVisible |= CHILD_FITS_IN;
888 
889         // Nicht sichtbare Fenster "uberspringen
890         if (pCli->nVisible != CHILD_VISIBLE)
891             continue;
892 
893         if ( pCli->bResize )
894             aSize = pCli->aSize;
895         else
896             aSize = pCli->pWin->GetSizePixel();
897 
898         SvBorder aTemp = aBorder;
899         sal_Bool bAllowHiding = sal_True;
900         switch ( pCli->eAlign )
901         {
902             case SFX_ALIGN_HIGHESTTOP:
903             case SFX_ALIGN_TOP:
904             case SFX_ALIGN_TOOLBOXTOP:
905             case SFX_ALIGN_LOWESTTOP:
906                 aSize.Width() = aTmp.GetWidth();
907                 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW )
908                     aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize );
909                 bAllowHiding = sal_False;
910                 aBorder.Top() += aSize.Height();
911                 aPos = aTmp.TopLeft();
912                 aTmp.Top() += aSize.Height();
913                 if ( pCli->eAlign == SFX_ALIGN_HIGHESTTOP )
914                     aUpperClientArea.Top() += aSize.Height();
915                 break;
916 
917             case SFX_ALIGN_LOWESTBOTTOM:
918             case SFX_ALIGN_BOTTOM:
919             case SFX_ALIGN_TOOLBOXBOTTOM:
920             case SFX_ALIGN_HIGHESTBOTTOM:
921                 aSize.Width() = aTmp.GetWidth();
922                 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW )
923                     aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize );
924                 aBorder.Bottom() += aSize.Height();
925                 aPos = aTmp.BottomLeft();
926                 aPos.Y() -= (aSize.Height()-1);
927                 aTmp.Bottom() -= aSize.Height();
928                 if ( pCli->eAlign == SFX_ALIGN_LOWESTBOTTOM )
929                     aUpperClientArea.Bottom() -= aSize.Height();
930                 break;
931 
932             case SFX_ALIGN_FIRSTLEFT:
933             case SFX_ALIGN_LEFT:
934             case SFX_ALIGN_LASTLEFT:
935             case SFX_ALIGN_TOOLBOXLEFT:
936                 aSize.Height() = aTmp.GetHeight();
937                 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW )
938                     aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize );
939                 bAllowHiding = sal_False;
940                 aBorder.Left() += aSize.Width();
941                 aPos = aTmp.TopLeft();
942                 aTmp.Left() += aSize.Width();
943                 if ( pCli->eAlign != SFX_ALIGN_TOOLBOXLEFT )
944                     aUpperClientArea.Left() += aSize.Width();
945                 break;
946 
947             case SFX_ALIGN_FIRSTRIGHT:
948             case SFX_ALIGN_RIGHT:
949             case SFX_ALIGN_LASTRIGHT:
950             case SFX_ALIGN_TOOLBOXRIGHT:
951                 aSize.Height() = aTmp.GetHeight();
952                 if ( pCli->pWin->GetType() == WINDOW_SPLITWINDOW )
953                     aSize = ((SplitWindow *)(pCli->pWin))->CalcLayoutSizePixel( aSize );
954                 aBorder.Right() += aSize.Width();
955                 aPos = aTmp.TopRight();
956                 aPos.X() -= (aSize.Width()-1);
957                 aTmp.Right() -= aSize.Width();
958                 if ( pCli->eAlign != SFX_ALIGN_TOOLBOXRIGHT )
959                     aUpperClientArea.Right() -= aSize.Width();
960                 break;
961 
962             default:
963                 pCli->aSize = pCli->pWin->GetSizePixel();
964                 pCli->bResize = sal_False;
965                 continue;
966         }
967 
968         pCli->pWin->SetPosSizePixel( aPos, aSize );
969         pCli->bResize = sal_False;
970         pCli->aSize = aSize;
971         if( bAllowHiding && !RequestTopToolSpacePixel_Impl( aBorder ) )
972         {
973             pCli->nVisible ^= CHILD_FITS_IN;
974             aBorder = aTemp;
975         }
976     }
977 
978     if ( aClientArea.GetWidth() >= aBorder.Left() + aBorder.Right() )
979     {
980         aClientArea.Left() += aBorder.Left();
981         aClientArea.Right() -= aBorder.Right();
982     }
983     else
984     {
985         aBorder.Left() = aClientArea.Left();
986         aBorder.Right() = aClientArea.Right();
987         aClientArea.Right() = aClientArea.Left() = aTmp.Left();
988     }
989 
990     if ( aClientArea.GetHeight() >= aBorder.Top() + aBorder.Bottom() )
991     {
992         aClientArea.Top() += aBorder.Top();
993         aClientArea.Bottom() -= aBorder.Bottom();
994     }
995     else
996     {
997         aBorder.Top() = aClientArea.Top();
998         aBorder.Bottom() = aClientArea.Bottom();
999         aClientArea.Top() = aClientArea.Bottom() = aTmp.Top();
1000     }
1001 
1002     return IsDockingAllowed() ? aBorder : SvBorder();
1003 }
1004 
1005 //--------------------------------------------------------------------
1006 // Close-Handler: die Konfiguration der ChildWindows wird gespeichert.
1007 //
1008 
Close_Impl()1009 void SfxWorkWindow::Close_Impl()
1010 {
1011 	for (sal_uInt16 n=0; n<pChildWins->Count(); n++)
1012 	{
1013 		SfxChildWin_Impl *pCW  = (*pChildWins)[n];
1014 		SfxChildWindow *pChild = pCW->pWin;
1015 		if (pChild)
1016 		{
1017             sal_uInt16 nFlags = pCW->aInfo.nFlags;
1018 			pCW->aInfo = pChild->GetInfo();
1019             pCW->aInfo.nFlags |= nFlags;
1020 			SaveStatus_Impl(pChild, pCW->aInfo);
1021 		}
1022 	}
1023 }
1024 
PrepareClose_Impl()1025 sal_Bool SfxWorkWindow::PrepareClose_Impl()
1026 {
1027 	for (sal_uInt16 n=0; n<pChildWins->Count(); n++)
1028 	{
1029 		SfxChildWin_Impl *pCW  = (*pChildWins)[n];
1030 		SfxChildWindow *pChild = pCW->pWin;
1031 		if ( pChild && !pChild->QueryClose() )
1032 			return sal_False;
1033 	}
1034 
1035 	return sal_True;
1036 }
1037 
1038 //--------------------------------------------------------------------
1039 
RegisterChild_Impl(Window & rWindow,SfxChildAlignment eAlign,sal_Bool bCanGetFocus)1040 SfxChild_Impl* SfxWorkWindow::RegisterChild_Impl( Window& rWindow,
1041 					SfxChildAlignment eAlign, sal_Bool bCanGetFocus )
1042 {
1043 	DBG_CHKTHIS(SfxWorkWindow, 0);
1044 	DBG_ASSERT( pChilds->Count() < 255, "too many childs" );
1045 	DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" );
1046 	DBG_ASSERT( !FindChild_Impl(rWindow), "child registered more than once" );
1047 
1048 
1049 	if ( rWindow.GetParent() != pWorkWin )
1050 		rWindow.SetParent( pWorkWin );
1051 
1052 	SfxChild_Impl *pChild = new SfxChild_Impl(rWindow, rWindow.GetSizePixel(),
1053 									eAlign, rWindow.IsVisible());
1054 	pChild->bCanGetFocus = bCanGetFocus;
1055 
1056 	pChilds->Insert(pChilds->Count(), pChild);
1057 	bSorted = sal_False;
1058 	nChilds++;
1059 	return (*pChilds)[pChilds->Count()-1];
1060 }
1061 
1062 //--------------------------------------------------------------------
1063 
AlignChild_Impl(Window & rWindow,const Size & rNewSize,SfxChildAlignment eAlign)1064 void SfxWorkWindow::AlignChild_Impl( Window& rWindow,
1065 											const Size& rNewSize,
1066 											SfxChildAlignment eAlign )
1067 {
1068 	DBG_CHKTHIS(SfxWorkWindow, 0);
1069 //	DBG_ASSERT( pChilds, "aligning unregistered child" );
1070 	DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" );
1071 
1072 	SfxChild_Impl *pChild = FindChild_Impl(rWindow);
1073 	if ( pChild )
1074 	{
1075 		if (pChild->eAlign != eAlign)
1076 			bSorted = sal_False;
1077 
1078 		pChild->eAlign = eAlign;
1079 		pChild->aSize = rNewSize;
1080 		pChild->bResize = sal_True;
1081 	}
1082 	else {
1083 		DBG_ERROR( "aligning unregistered child" );
1084     }
1085 }
1086 
1087 //--------------------------------------------------------------------
1088 
ReleaseChild_Impl(Window & rWindow)1089 void SfxWorkWindow::ReleaseChild_Impl( Window& rWindow )
1090 {
1091 	DBG_CHKTHIS(SfxWorkWindow, 0);
1092 //	DBG_ASSERT( pChilds, "releasing unregistered child" );
1093 
1094 	SfxChild_Impl *pChild = 0;
1095 	sal_uInt16 nPos;
1096     for ( nPos = 0; nPos < pChilds->Count(); ++nPos )
1097 	{
1098 		pChild = (*pChilds)[nPos];
1099 		if ( pChild )
1100 		  if ( pChild->pWin == &rWindow )
1101 			break;
1102 	}
1103 
1104     if ( nPos < pChilds->Count() )
1105 	{
1106 		bSorted = sal_False;
1107 		nChilds--;
1108 		pChilds->Remove(nPos);
1109 		delete pChild;
1110 	}
1111 	else {
1112 		DBG_ERROR( "releasing unregistered child" );
1113     }
1114 }
1115 
1116 //--------------------------------------------------------------------
1117 
FindChild_Impl(const Window & rWindow) const1118 SfxChild_Impl* SfxWorkWindow::FindChild_Impl( const Window& rWindow ) const
1119 {
1120 	DBG_CHKTHIS(SfxWorkWindow, 0);
1121 
1122 	SfxChild_Impl *pChild = 0;
1123 	sal_uInt16 nCount = pChilds->Count();
1124 	for ( sal_uInt16 nPos = 0; nPos < nCount; ++nPos )
1125 	{
1126 		pChild = (*pChilds)[nPos];
1127 		if ( pChild )
1128 		  if ( pChild->pWin == &rWindow )
1129 			return pChild;
1130 	}
1131 
1132 	return 0;
1133 }
1134 
1135 //--------------------------------------------------------------------
1136 
ShowChilds_Impl()1137 void SfxWorkWindow::ShowChilds_Impl()
1138 {
1139 	DBG_CHKTHIS(SfxWorkWindow, 0);
1140 
1141     bool bInvisible = ( !IsVisible_Impl() || ( !pWorkWin->IsReallyVisible() && !pWorkWin->IsReallyShown() ));
1142 
1143     SfxChild_Impl *pCli = 0;
1144 	for ( sal_uInt16 nPos = 0; nPos < pChilds->Count(); ++nPos )
1145 	{
1146         SfxChildWin_Impl* pCW = 0;
1147 		pCli = (*pChilds)[nPos];
1148 
1149         if ( pCli && pCli->pWin )
1150         {
1151             // We have to find the SfxChildWin_Impl to retrieve the
1152             // SFX_CHILDWIN flags that can influence visibility.
1153             for (sal_uInt16 n=0; n<pChildWins->Count(); n++)
1154 	        {
1155                 SfxChildWin_Impl* pCWin = (*pChildWins)[n];
1156                 SfxChild_Impl*    pChild  = pCWin->pCli;
1157                 if ( pChild == pCli )
1158                 {
1159                     pCW = pCWin;
1160                     break;
1161                 }
1162             }
1163 
1164             bool bVisible( !bInvisible );
1165             if ( pCW )
1166 		    {
1167                 // Check flag SFX_CHILDWIN_NEVERHIDE that forces us to show
1168                 // the child window even in situations where no child window is
1169                 // visible.
1170                 sal_uInt16 nFlags = pCW->aInfo.nFlags;
1171                 bVisible = !bInvisible || ( bInvisible & (( nFlags & SFX_CHILDWIN_NEVERHIDE ) != 0 ));
1172             }
1173 
1174             if ( CHILD_VISIBLE == (pCli->nVisible & CHILD_VISIBLE) && bVisible )
1175 		    {
1176 			    sal_uInt16 nFlags = pCli->bSetFocus ? 0 : SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE;
1177                 switch ( pCli->pWin->GetType() )
1178 			    {
1179 				    case RSC_DOCKINGWINDOW :
1180                         ((DockingWindow*)pCli->pWin)->Show( sal_True, nFlags );
1181 					    break;
1182 				    case RSC_SPLITWINDOW :
1183                         ((SplitWindow*)pCli->pWin)->Show( sal_True, nFlags );
1184 					    break;
1185 				    default:
1186                         pCli->pWin->Show( sal_True, nFlags );
1187 					    break;
1188 			    }
1189 
1190 			    pCli->bSetFocus = sal_False;
1191 		    }
1192 		    else
1193 		    {
1194 			    switch ( pCli->pWin->GetType() )
1195 			    {
1196 				    case RSC_DOCKINGWINDOW :
1197 					    ((DockingWindow*)pCli->pWin)->Hide();
1198 					    break;
1199 				    default:
1200 					    pCli->pWin->Hide();
1201 					    break;
1202 			    }
1203 		    }
1204         }
1205 	}
1206 }
1207 
1208 //--------------------------------------------------------------------
1209 
HideChilds_Impl()1210 void SfxWorkWindow::HideChilds_Impl()
1211 {
1212 	SfxChild_Impl *pChild = 0;
1213 	for ( sal_uInt16 nPos = pChilds->Count(); nPos > 0; --nPos )
1214 	{
1215 		pChild = (*pChilds)[nPos-1];
1216 		if (pChild && pChild->pWin)
1217 		{
1218 			switch ( pChild->pWin->GetType() )
1219 			{
1220 				case RSC_DOCKINGWINDOW :
1221 					((DockingWindow*)pChild->pWin)->Hide();
1222 					break;
1223 				default:
1224 					pChild->pWin->Hide();
1225 					break;
1226 			}
1227 		}
1228 	}
1229 }
1230 
1231 //------------------------------------------------------------------------
1232 
ResetObjectBars_Impl()1233 void SfxWorkWindow::ResetObjectBars_Impl()
1234 {
1235 	sal_uInt16 n;
1236     for ( n = 0; n < aObjBarList.size(); n++ )
1237         aObjBarList[n].bDestroy = sal_True;
1238 
1239 	for ( n = 0; n < pChildWins->Count(); ++n )
1240 		(*pChildWins)[n]->nId = 0;
1241 }
1242 
NextObjectBar_Impl(sal_uInt16)1243 void SfxWorkWindow::NextObjectBar_Impl( sal_uInt16 )
1244 {
1245 }
1246 
HasNextObjectBar_Impl(sal_uInt16,String *)1247 sal_uInt16 SfxWorkWindow::HasNextObjectBar_Impl( sal_uInt16, String* )
1248 {
1249 	return 0;
1250 }
1251 
1252 //------------------------------------------------------------------------
1253 
SetObjectBar_Impl(sal_uInt16 nPos,sal_uInt32 nResId,SfxInterface * pIFace,const String * pName)1254 void SfxWorkWindow::SetObjectBar_Impl( sal_uInt16 nPos, sal_uInt32 nResId,
1255 			SfxInterface* pIFace, const String *pName)
1256 {
1257 	DBG_ASSERT( (nPos & SFX_POSITION_MASK) < SFX_OBJECTBAR_MAX,
1258 				"object bar position overflow" );
1259 
1260 	sal_uInt16 nRealPos = nPos & SFX_POSITION_MASK;
1261 	if ( pParent && IsAppWorkWinToolbox_Impl( nRealPos ) )
1262 	{
1263 		pParent->SetObjectBar_Impl( nPos, nResId, pIFace, pName );
1264 		return;
1265 	}
1266 
1267 	SfxObjectBar_Impl aObjBar;
1268 	aObjBar.pIFace = pIFace;
1269 	aObjBar.nId = sal::static_int_cast<sal_uInt16>(nResId);
1270     aObjBar.nPos = nRealPos;
1271 	aObjBar.nMode = (nPos & SFX_VISIBILITY_MASK);
1272 	if (pName)
1273 		aObjBar.aName = *pName;
1274 	else
1275 		aObjBar.aName.Erase();
1276 
1277 	for ( sal_uInt16 n=0; n<aObjBarList.size(); n++ )
1278 	{
1279 		if ( aObjBarList[n].nId == aObjBar.nId )
1280 		{
1281             aObjBarList[n] = aObjBar;
1282 			return;
1283 		}
1284 	}
1285 
1286     aObjBarList.push_back( aObjBar );
1287 }
1288 
1289 //------------------------------------------------------------------------
1290 
KnowsObjectBar_Impl(sal_uInt16 nPos) const1291 bool SfxWorkWindow::KnowsObjectBar_Impl( sal_uInt16 nPos ) const
1292 
1293 /*	[Beschreibung]
1294 
1295 	Stellt fest, ob an der betreffenden Position "uberhaupt eine
1296 	Objektleiste zur Verf"ugung stehen w"urde. Ist unabh"agig davon,
1297 	ob diese tats"achlich ein- oder ausgeschaltet ist.
1298 */
1299 
1300 {
1301 	sal_uInt16 nRealPos = nPos & SFX_POSITION_MASK;
1302 	if ( pParent && IsAppWorkWinToolbox_Impl( nRealPos ) )
1303 		return pParent->KnowsObjectBar_Impl( nPos );
1304 
1305 	for ( sal_uInt16 n=0; n<aObjBarList.size(); n++ )
1306     {
1307         if ( aObjBarList[n].nPos == nRealPos )
1308             return true;
1309     }
1310 
1311     return false;
1312 }
1313 
1314 //------------------------------------------------------------------------
1315 
IsVisible_Impl(sal_uInt16 nMode) const1316 sal_Bool SfxWorkWindow::IsVisible_Impl( sal_uInt16 nMode ) const
1317 {
1318 	switch( nUpdateMode )
1319 	{
1320 		case SFX_VISIBILITY_STANDARD:
1321 			return sal_True;
1322 		case SFX_VISIBILITY_UNVISIBLE:
1323 			return sal_False;
1324 		case SFX_VISIBILITY_PLUGSERVER:
1325 		case SFX_VISIBILITY_PLUGCLIENT:
1326 		case SFX_VISIBILITY_CLIENT:
1327 		case SFX_VISIBILITY_SERVER:
1328 			return !!(nMode & nUpdateMode);
1329 		default:
1330 			return !!(nMode & nOrigMode ) ||
1331 				nOrigMode == SFX_VISIBILITY_STANDARD;
1332 	}
1333 }
1334 
GetObjectBar_Impl(sal_uInt16,sal_uInt32)1335 Window* SfxWorkWindow::GetObjectBar_Impl( sal_uInt16, sal_uInt32 )
1336 {
1337     return NULL;
1338 }
1339 
1340 //------------------------------------------------------------------------
UpdateObjectBars_Impl()1341 void SfxFrameWorkWin_Impl::UpdateObjectBars_Impl()
1342 {
1343     if ( pFrame->IsClosing_Impl() )
1344         return;
1345 
1346 	SfxWorkWindow *pWork = pParent;
1347 	while ( pWork )
1348 	{
1349 		pWork->SfxWorkWindow::UpdateObjectBars_Impl();
1350 		pWork = pWork->GetParent_Impl();
1351 	}
1352 
1353 	SfxWorkWindow::UpdateObjectBars_Impl();
1354 
1355 //	if ( pTask->IsActive() )
1356 	{
1357 		pWork = pParent;
1358 		while ( pWork )
1359 		{
1360 			pWork->ArrangeChilds_Impl();
1361 			pWork = pWork->GetParent_Impl();
1362 		}
1363 
1364 		ArrangeChilds_Impl( sal_False );
1365 
1366 		pWork = pParent;
1367 		while ( pWork )
1368 		{
1369 			pWork->ShowChilds_Impl();
1370 			pWork = pWork->GetParent_Impl();
1371 		}
1372 
1373 		ShowChilds_Impl();
1374 	}
1375 
1376     ShowChilds_Impl();
1377 }
1378 
GetStatusIndicator()1379 Reference< ::com::sun::star::task::XStatusIndicator > SfxWorkWindow::GetStatusIndicator()
1380 {
1381     Reference< com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
1382     Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
1383     Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
1384 
1385 	if ( xPropSet.is() )
1386 	{
1387 		Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
1388 		aValue >>= xLayoutManager;
1389         if ( xLayoutManager.is() )
1390         {
1391             xLayoutManager->createElement( m_aProgressBarResName );
1392             xLayoutManager->showElement( m_aProgressBarResName );
1393 
1394             Reference< ::com::sun::star::ui::XUIElement > xProgressBar =
1395                 xLayoutManager->getElement( m_aProgressBarResName );
1396             if ( xProgressBar.is() )
1397             {
1398                 xStatusIndicator = Reference< ::com::sun::star::task::XStatusIndicator >(
1399                     xProgressBar->getRealInterface(), UNO_QUERY );
1400             }
1401         }
1402     }
1403 
1404     return xStatusIndicator;
1405 }
1406 
1407 //------------------------------------------------------------------------
1408 
IsPluginMode(SfxObjectShell * pObjShell)1409 sal_Bool SfxWorkWindow::IsPluginMode( SfxObjectShell* pObjShell )
1410 {
1411     if ( pObjShell && pObjShell->GetMedium() )
1412     {
1413         SFX_ITEMSET_ARG( pObjShell->GetMedium()->GetItemSet(), pViewOnlyItem, SfxBoolItem, SID_VIEWONLY, sal_False );
1414         if ( pViewOnlyItem && pViewOnlyItem->GetValue() )
1415             return sal_True;
1416     }
1417 
1418     return sal_False;
1419 }
1420 
1421 //------------------------------------------------------------------------
1422 
GetFrameInterface()1423 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxWorkWindow::GetFrameInterface()
1424 {
1425     ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > xFrame;
1426 
1427     SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() );
1428     if ( pDispatcher )
1429     {
1430         SfxViewFrame* pFrame = pDispatcher->GetFrame();
1431         if ( pFrame )
1432            xFrame = pFrame->GetFrame().GetFrameInterface();
1433     }
1434 
1435     return xFrame;
1436 }
1437 
1438 //------------------------------------------------------------------------
1439 
UpdateObjectBars_Impl()1440 void SfxWorkWindow::UpdateObjectBars_Impl()
1441 {
1442 	// SplitWindows locken (d.h. Resize-Reaktion an den
1443 	// DockingWindows unterdr"ucken)
1444     sal_uInt16 n;
1445     for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
1446     {
1447         SfxSplitWindow *p = pSplit[n];
1448         if (p->GetWindowCount())
1449             p->Lock();
1450     }
1451 
1452     // was man so "ofters braucht, merkt man sich (spart Code und Laufzeit)
1453     SFX_APP();
1454 
1455     Reference< com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
1456     Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
1457 
1458 	if ( xPropSet.is() )
1459 	{
1460 		Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
1461 		aValue >>= xLayoutManager;
1462     }
1463 
1464     if ( !xLayoutManager.is() )
1465         return;
1466 
1467     sal_Bool       bPluginMode( sal_False );
1468     SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() );
1469 
1470     if ( pDispatcher )
1471     {
1472         SfxViewFrame* pFrame = pDispatcher->GetFrame();
1473         if ( pFrame )
1474            bPluginMode = IsPluginMode( pFrame->GetObjectShell() );
1475     }
1476 
1477     // "uber alle Toolboxen iterieren
1478     xLayoutManager->lock();
1479 	for ( n = 0; n < aObjBarList.size(); ++n )
1480 	{
1481         sal_uInt16      nId      = aObjBarList[n].nId;
1482         sal_Bool    bDestroy = aObjBarList[n].bDestroy;
1483 
1484         // die Modi bestimmen, f"ur die die ToolBox gilt
1485         sal_uInt16 nTbxMode = aObjBarList[n].nMode;
1486         bool bFullScreenTbx = SFX_VISIBILITY_FULLSCREEN ==
1487                                   ( nTbxMode & SFX_VISIBILITY_FULLSCREEN );
1488         nTbxMode &= ~SFX_VISIBILITY_FULLSCREEN;
1489 		nTbxMode &= ~SFX_VISIBILITY_VIEWER;
1490 
1491 		// wird in diesem Kontext eine ToolBox gefordert?
1492 		bool bModesMatching = ( nUpdateMode && ( nTbxMode & nUpdateMode) == nUpdateMode );
1493         if ( bDestroy )
1494         {
1495             rtl::OUString aTbxId( m_aTbxTypeName );
1496             aTbxId += GetResourceURLFromResId( aObjBarList[n].nId );
1497             xLayoutManager->destroyElement( aTbxId );
1498         }
1499 		else if ( nId != 0 && ( ( bModesMatching && !bIsFullScreen ) ||
1500                                 ( bIsFullScreen && bFullScreenTbx ) ) )
1501         {
1502             rtl::OUString aTbxId( m_aTbxTypeName );
1503             aTbxId += GetResourceURLFromResId( aObjBarList[n].nId );
1504             if ( !IsDockingAllowed() && !xLayoutManager->isElementFloating( aTbxId ))
1505                 xLayoutManager->destroyElement( aTbxId );
1506             else
1507             {
1508                 xLayoutManager->requestElement( aTbxId );
1509                 if ( bPluginMode )
1510                     xLayoutManager->lockWindow( aTbxId );
1511             }
1512         }
1513 		else if ( nId != 0 )
1514 		{
1515 		    // ggf. Toolbox an dieser Position l"oschen
1516             rtl::OUString aTbxId( m_aTbxTypeName );
1517             aTbxId += GetResourceURLFromResId( aObjBarList[n].nId );
1518             xLayoutManager->destroyElement( aTbxId );
1519         }
1520 	}
1521 
1522 	UpdateStatusBar_Impl();
1523 
1524     // unlocking automatically forces Layout
1525     xLayoutManager->unlock();
1526 
1527 	UpdateChildWindows_Impl();
1528 
1529 	// SplitWindows wieder ent-locken
1530 	for ( n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
1531 	{
1532 		SfxSplitWindow *p = pSplit[n];
1533 		if (p->GetWindowCount())
1534 			p->Lock(sal_False);
1535 	}
1536 }
1537 
AllowChildWindowCreation_Impl(const SfxChildWin_Impl & i_rCW) const1538 bool SfxWorkWindow::AllowChildWindowCreation_Impl( const SfxChildWin_Impl& i_rCW ) const
1539 {
1540     // or checking the availability of child windows, we need access to the module
1541     const SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
1542     const SfxObjectShell* pShell = pViewFrame ? pViewFrame->GetObjectShell() : NULL;
1543     const SfxModule* pModule = pShell ? pShell->GetModule() : NULL;
1544     ENSURE_OR_RETURN( pModule, "SfxWorkWindow::UpdateChildWindows_Impl: did not find an SfxModule to ask for the child win availability!", true );
1545     return pModule->IsChildWindowAvailable( i_rCW.nId, pViewFrame );
1546 }
1547 
UpdateChildWindows_Impl()1548 void SfxWorkWindow::UpdateChildWindows_Impl()
1549 {
1550 	// alle vorhandenen oder in den Kontext gekommenen ChildWindows
1551 	for ( sal_uInt16 n=0; n<pChildWins->Count(); n++ )
1552 	{
1553 		SfxChildWin_Impl *pCW = (*pChildWins)[n];
1554 		SfxChildWindow *pChildWin = pCW->pWin;
1555 		sal_Bool bCreate = sal_False;
1556         if ( pCW->nId && !pCW->bDisabled  && (pCW->aInfo.nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE || IsVisible_Impl( pCW->nVisibility ) ) )
1557 		{
1558 			// Im Kontext ist ein geeignetes ChildWindow erlaubt;
1559 			// ist es auch eingeschaltet ?
1560 			if ( pChildWin == NULL && pCW->bCreate )
1561 			{
1562                 // Internal docking is only used for embedding into another
1563                 // container. We force the floating state of all floatable
1564                 // child windows.
1565                 if ( !bInternalDockingAllowed )
1566                 {
1567                     // Special case for all non-floatable child windows. We have
1568                     // to prevent the creation here!
1569                     bCreate = !( pCW->aInfo.nFlags & SFX_CHILDWIN_FORCEDOCK );
1570                 }
1571                 else if ( !IsDockingAllowed() || bIsFullScreen ) // || !bInternalDocking )
1572 				{
1573                     // im PresentationMode oder FullScreen nur FloatingWindows
1574 					SfxChildAlignment eAlign;
1575 					if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) )
1576 						bCreate = ( eAlign == SFX_ALIGN_NOALIGNMENT );
1577 				}
1578 				else
1579 					bCreate = sal_True;
1580 
1581                 if ( bCreate )
1582                     bCreate = AllowChildWindowCreation_Impl( *pCW );
1583 
1584 				// Momentan kein Fenster da, aber es ist eingeschaltet; Fenster
1585 				// und ggf. Context erzeugen
1586 				if ( bCreate )
1587                     CreateChildWin_Impl( pCW, sal_False );
1588 
1589 				if ( !bAllChildsVisible )
1590 				{
1591 					if ( pCW->pCli )
1592 						pCW->pCli->nVisible &= ~CHILD_ACTIVE;
1593 				}
1594 			}
1595 			else if ( pChildWin )
1596 			{
1597 				// Fenster existiert schon; soll es auch sichtbar sein ?
1598                 if ( ( !bIsFullScreen || pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT ) && bAllChildsVisible )
1599 				{
1600 					// Updatemode ist kompatibel; auf jeden Fall wieder einschalten
1601                     bCreate = AllowChildWindowCreation_Impl( *pCW );
1602                     if ( bCreate )
1603                     {
1604 					    if ( pCW->pCli )
1605 					    {
1606 						    // Fenster ist direktes Child
1607                             if ( bAllChildsVisible && ( (IsDockingAllowed() && bInternalDockingAllowed) || pCW->pCli->eAlign == SFX_ALIGN_NOALIGNMENT ) )
1608                                 pCW->pCli->nVisible |= CHILD_NOT_HIDDEN;
1609 					    }
1610                         else
1611                         {
1612                             if ( pCW->bCreate && IsDockingAllowed() && bInternalDockingAllowed )
1613 						        // Fenster liegt in einem SplitWindow
1614 						        ((SfxDockingWindow*)pChildWin->GetWindow())->Reappear_Impl();
1615                         }
1616 
1617 					    if ( pCW->nInterfaceId != pChildWin->GetContextId() )
1618 						    pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() );
1619                     }
1620 				}
1621 			}
1622 		}
1623 
1624 		if ( pChildWin && !bCreate )
1625 		{
1626 			if ( !pChildWin->QueryClose() || pChildWin->IsHideNotDelete() || Application::IsUICaptured() )
1627 			{
1628 				if ( pCW->pCli )
1629 				{
1630 					if ( pCW->pCli->nVisible & CHILD_NOT_HIDDEN )
1631 						pCW->pCli->nVisible ^= CHILD_NOT_HIDDEN;
1632 				}
1633 				else
1634 					((SfxDockingWindow*)pChildWin->GetWindow())->Disappear_Impl();
1635 			}
1636 			else
1637 				RemoveChildWin_Impl( pCW );
1638 		}
1639 	}
1640 }
1641 
CreateChildWin_Impl(SfxChildWin_Impl * pCW,sal_Bool bSetFocus)1642 void SfxWorkWindow::CreateChildWin_Impl( SfxChildWin_Impl *pCW, sal_Bool bSetFocus )
1643 {
1644 	if ( pCW->aInfo.bVisible != 42 )
1645 		pCW->aInfo.bVisible = sal_True;
1646 
1647     SfxChildWindow *pChildWin = SfxChildWindow::CreateChildWindow( pCW->nId, pWorkWin, &GetBindings(), pCW->aInfo);
1648 	if (pChildWin)
1649 	{
1650 		if ( bSetFocus )
1651 			bSetFocus = pChildWin->WantsFocus();
1652 		pChildWin->SetWorkWindow_Impl( this );
1653 #if 0
1654 		// Enable-Status richtig setzen
1655 		pChildWin->GetWindow()->EnableInput( pCW->bEnable &&
1656             ( pWorkWin->IsInputEnabled() /* || pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT */ ) );
1657 #endif
1658 		// Zumindest der ExtraString wird beim Auswerten ver"andert, also neu holen
1659         SfxChildWinInfo aInfo = pChildWin->GetInfo();
1660         pCW->aInfo.aExtraString = aInfo.aExtraString;
1661         pCW->aInfo.bVisible = aInfo.bVisible;
1662         pCW->aInfo.nFlags |= aInfo.nFlags;
1663 
1664 		// Nein !! Sonst kann man keine Fenster defaultmaessig ausschalten ( Partwindow! )
1665 //		pCW->aInfo.bVisible = sal_True;
1666 
1667 		// Erzeugung war erfolgreich
1668 		GetBindings().Invalidate(pCW->nId);
1669 
1670 		sal_uInt16 nPos = pChildWin->GetPosition();
1671 		if (nPos != CHILDWIN_NOPOS)
1672 		{
1673 			DBG_ASSERT(nPos < SFX_OBJECTBAR_MAX, "Illegal objectbar position!");
1674 			if ((*pChilds)[TbxMatch(nPos)])// &&
1675 //							  pChildWin->GetAlignment() == (*pChilds)[nPos]->eAlign )
1676 			{
1677 				// ChildWindow ersetzt ObjectBar
1678 				(*pChilds)[TbxMatch(nPos)]->nVisible ^= CHILD_NOT_HIDDEN;
1679 			}
1680 		}
1681 
1682 		// make childwin keyboard accessible
1683 		pWorkWin->GetSystemWindow()->GetTaskPaneList()->AddWindow( pChildWin->GetWindow() );
1684 
1685 		pCW->pWin = pChildWin;
1686 
1687 		if ( pChildWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT || pChildWin->GetWindow()->GetParent() == pWorkWin)
1688 		{
1689 			// Das Fenster ist entweder nicht angedockt oder au\serhalb
1690 			// eines SplitWindows angedockt und mu\s daher explizit als
1691 			// Child registriert werden
1692 			pCW->pCli = RegisterChild_Impl(*(pChildWin->GetWindow()), pChildWin->GetAlignment(), pChildWin->CanGetFocus());
1693 			pCW->pCli->nVisible = CHILD_VISIBLE;
1694             if ( pChildWin->GetAlignment() != SFX_ALIGN_NOALIGNMENT && bIsFullScreen )
1695 				pCW->pCli->nVisible ^= CHILD_ACTIVE;
1696 			pCW->pCli->bSetFocus = bSetFocus;
1697 		}
1698 		else
1699 		{
1700 			// Ein angedocktes Fenster, dessen Parent nicht das WorkWindow ist,
1701 			// mu\s in einem SplitWindow liegen und daher nicht explizit
1702 			// registriert werden.
1703 			// Das passiert aber schon bei der Initialisierung des
1704 			// SfxDockingWindows!
1705 		}
1706 
1707 		if ( pCW->nInterfaceId != pChildWin->GetContextId() )
1708 			pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() );
1709 
1710 		// Information in der INI-Datei sichern
1711         SaveStatus_Impl(pChildWin, pCW->aInfo);
1712 	}
1713 }
1714 
RemoveChildWin_Impl(SfxChildWin_Impl * pCW)1715 void SfxWorkWindow::RemoveChildWin_Impl( SfxChildWin_Impl *pCW )
1716 {
1717 	sal_uInt16 nId = pCW->nSaveId;
1718 	SfxChildWindow *pChildWin = pCW->pWin;
1719 
1720 	// vorhandenes Fenster geht aus dem Kontext und wird daher entfernt
1721 	sal_uInt16 nPos = pChildWin->GetPosition();
1722 	if (nPos != CHILDWIN_NOPOS)
1723 	{
1724 /*
1725 		// ChildWindow "uberlagert einen ObjectBar
1726 		DBG_ASSERT(nPos < SFX_OBJECTBAR_MAX, "Illegal objectbar position!");
1727 		if ((*pChilds)[TbxMatch(nPos)] &&
1728 			(aObjBars[nPos].nMode & nUpdateMode) ) //&&
1729 //						   pChildWin->GetAlignment() == (*pChilds)[nPos]->eAlign )
1730 		{
1731 			// ObjectBar war "uberlagert; jetzt wieder anzeigen
1732 			(*pChilds)[TbxMatch(nPos)]->nVisible ^= CHILD_NOT_HIDDEN;
1733 		}
1734 */
1735 	}
1736 
1737 	// Information in der INI-Datei sichern
1738     sal_uInt16 nFlags = pCW->aInfo.nFlags;
1739     pCW->aInfo = pChildWin->GetInfo();
1740     pCW->aInfo.nFlags |= nFlags;
1741 	SaveStatus_Impl(pChildWin, pCW->aInfo);
1742 
1743 	pChildWin->Hide();
1744 
1745 	if ( pCW->pCli )
1746 	{
1747 		// ChildWindow ist ein direktes ChildWindow und mu\s sich daher
1748 		// beim WorkWindow abmelden
1749 		pCW->pCli = 0;
1750 		ReleaseChild_Impl(*pChildWin->GetWindow());
1751 	}
1752 	else
1753 	{
1754 		// ChildWindow liegt in einem SplitWindow und meldet sich
1755 		// selbst im dtor dort ab
1756 	}
1757 
1758 	pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChildWin->GetWindow() );
1759 	pCW->pWin = 0;
1760 	pChildWin->Destroy();
1761 
1762 	GetBindings().Invalidate( nId );
1763 }
1764 
ResetStatusBar_Impl()1765 void SfxWorkWindow::ResetStatusBar_Impl()
1766 {
1767 	aStatBar.nId = 0;
1768 }
1769 
1770 //--------------------------------------------------------------------
SetStatusBar_Impl(sal_uInt32 nResId,SfxShell *,SfxBindings &)1771 void SfxWorkWindow::SetStatusBar_Impl( sal_uInt32 nResId, SfxShell*, SfxBindings& )
1772 {
1773     if ( nResId && bShowStatusBar && IsVisible_Impl() )
1774 		aStatBar.nId = sal::static_int_cast<sal_uInt16>(nResId);
1775 }
1776 
1777 #define SFX_ITEMTYPE_STATBAR 4
1778 
SetTempStatusBar_Impl(sal_Bool bSet)1779 void SfxWorkWindow::SetTempStatusBar_Impl( sal_Bool bSet )
1780 {
1781     if ( aStatBar.bTemp != bSet && bShowStatusBar && IsVisible_Impl() )
1782 	{
1783 		sal_Bool bOn = sal_False;
1784         sal_Bool bReset = sal_False;
1785         if ( bSet && !aStatBar.nId )
1786         {
1787             bReset = sal_True;
1788             SetStatusBar_Impl( SFX_ITEMTYPE_STATBAR, SFX_APP(), GetBindings() );
1789         }
1790 
1791         if ( aStatBar.nId && aStatBar.bOn && !bIsFullScreen )
1792 			bOn = sal_True;
1793 
1794 		aStatBar.bTemp = bSet;
1795         if ( !bOn || bReset || (!bSet && aStatBar.nId ) )
1796 		{
1797 			// Nur was tun, wenn die Temp-Einstellung wirklich was bewirkt
1798 			UpdateStatusBar_Impl();
1799 			ArrangeChilds_Impl();
1800 			ShowChilds_Impl();
1801 		}
1802 
1803         if ( bReset )
1804             ResetStatusBar_Impl();
1805 	}
1806 }
1807 
UpdateStatusBar_Impl()1808 void SfxWorkWindow::UpdateStatusBar_Impl()
1809 {
1810     Reference< ::com::sun::star::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
1811     Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
1812 
1813 	Any aValue = xPropSet->getPropertyValue( m_aLayoutManagerPropName );
1814 	aValue >>= xLayoutManager;
1815 
1816 	// keine Statusleiste, wenn keine Id gew"unscht oder bei FullScreenView
1817 	// oder wenn ausgeschaltet
1818     if ( aStatBar.nId && IsDockingAllowed() && bInternalDockingAllowed && bShowStatusBar &&
1819          ( (aStatBar.bOn && !bIsFullScreen) || aStatBar.bTemp ) )
1820 	{
1821 		// Id hat sich ge"andert, also passenden Statusbarmanager erzeugen,
1822 		// dieser "ubernimmt die aktuelle Statusleiste;
1823         if ( xLayoutManager.is() )
1824             xLayoutManager->requestElement( m_aStatusBarResName );
1825 	}
1826 	else
1827 	{
1828 		// Aktuelle StatusBar vernichten
1829 		// Der Manager erzeugt die Statusleiste nur, er zerst"ort sie
1830 		// nicht !
1831         if ( xLayoutManager.is() )
1832             xLayoutManager->destroyElement( m_aStatusBarResName );
1833 	}
1834 }
1835 
1836 //------------------------------------------------------------------------
1837 /*
1838 void SfxWorkWindow::SetObjectBarVisibility_Impl( sal_uInt16 nMask )
1839 {
1840 	switch( nMask )
1841 	{
1842 		case SFX_VISIBILITY_UNVISIBLE:
1843 		case SFX_VISIBILITY_STANDARD:
1844 		case SFX_VISIBILITY_CLIENT:
1845 		case SFX_VISIBILITY_SERVER:
1846 			nOrigMode = nMask;
1847 	}
1848 	if (nMask != nUpdateMode)
1849 		nUpdateMode = nMask;
1850 }*/
1851 
MakeVisible_Impl(sal_Bool bVis)1852 void SfxWorkWindow::MakeVisible_Impl( sal_Bool bVis )
1853 {
1854     if ( bVis )
1855         nOrigMode = SFX_VISIBILITY_STANDARD;
1856     else
1857         nOrigMode = SFX_VISIBILITY_UNVISIBLE;
1858 
1859     if ( nOrigMode != nUpdateMode)
1860         nUpdateMode = nOrigMode;
1861 }
1862 
IsVisible_Impl()1863 sal_Bool SfxWorkWindow::IsVisible_Impl()
1864 {
1865     return nOrigMode != SFX_VISIBILITY_UNVISIBLE;
1866 }
1867 
1868 //------------------------------------------------------------------------
HidePopups_Impl(sal_Bool bHide,sal_Bool bParent,sal_uInt16 nId)1869 void SfxWorkWindow::HidePopups_Impl(sal_Bool bHide, sal_Bool bParent, sal_uInt16 nId )
1870 {
1871 	for ( sal_uInt16 n = 0; n < pChildWins->Count(); ++n )
1872 	{
1873 		SfxChildWindow *pCW = (*pChildWins)[n]->pWin;
1874 		if (pCW && pCW->GetAlignment() == SFX_ALIGN_NOALIGNMENT && pCW->GetType() != nId)
1875 		{
1876 			Window *pWin = pCW->GetWindow();
1877 			SfxChild_Impl *pChild = FindChild_Impl(*pWin);
1878 			if (bHide)
1879 			{
1880 				pChild->nVisible &= ~CHILD_ACTIVE;
1881 				pCW->Hide();
1882 			}
1883 			else
1884 			{
1885 				pChild->nVisible |= CHILD_ACTIVE;
1886 				if ( CHILD_VISIBLE == (pChild->nVisible & CHILD_VISIBLE) )
1887                     pCW->Show( SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1888 			}
1889 		}
1890 	}
1891 
1892 	if ( bParent && pParent )
1893 		pParent->HidePopups_Impl( bHide, bParent, nId );
1894 }
1895 
1896 //------------------------------------------------------------------------
1897 
ConfigChild_Impl(SfxChildIdentifier eChild,SfxDockingConfig eConfig,sal_uInt16 nId)1898 void SfxWorkWindow::ConfigChild_Impl(SfxChildIdentifier eChild,
1899 			SfxDockingConfig eConfig, sal_uInt16 nId)
1900 {
1901 	SfxDockingWindow* pDockWin=0;
1902 	sal_uInt16 nPos = USHRT_MAX;
1903 	Window *pWin=0;
1904 	SfxChildWin_Impl *pCW = 0;
1905 
1906     if ( eChild == SFX_CHILDWIN_OBJECTBAR )
1907 	{
1908         return;
1909 	}
1910 	else
1911 	{
1912         // configure direct childwindow
1913 		for (sal_uInt16 n=0; n<pChildWins->Count(); n++)
1914 		{
1915 			pCW = (*pChildWins)[n];
1916 			SfxChildWindow *pChild = pCW->pWin;
1917             if ( pChild )
1918 			{
1919                 if ( pChild->GetType() == nId )
1920 				{
1921                     if ( pChild->GetWindow()->GetType() == RSC_DOCKINGWINDOW )
1922                         // it's a DockingWindow
1923                         pDockWin = (SfxDockingWindow*) pChild->GetWindow();
1924                     else
1925                         // FloatingWindow or ModelessDialog
1926                         pWin = pChild->GetWindow();
1927 					break;
1928 				}
1929 			}
1930 		}
1931 
1932 		if ( pDockWin )
1933 		{
1934             if ( eChild == SFX_CHILDWIN_DOCKINGWINDOW || pDockWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT )
1935 			{
1936 				if ( eChild == SFX_CHILDWIN_SPLITWINDOW && eConfig == SFX_TOGGLEFLOATMODE)
1937 				{
1938                     // DockingWindow was dragged out of a SplitWindow
1939                     pCW->pCli = RegisterChild_Impl(*pDockWin, pDockWin->GetAlignment(), pCW->pWin->CanGetFocus());
1940 					pCW->pCli->nVisible = CHILD_VISIBLE;
1941 				}
1942 
1943 				pWin = pDockWin;
1944 			}
1945 			else
1946 			{
1947 				SfxSplitWindow *pSplitWin = GetSplitWindow_Impl(pDockWin->GetAlignment());
1948 
1949                 // configure DockingWindow inside a SplitWindow
1950 				if ( eConfig == SFX_TOGGLEFLOATMODE)
1951 				{
1952                     // DockingWindow was dragged into a SplitWindow
1953 					pCW->pCli = 0;
1954 					ReleaseChild_Impl(*pDockWin);
1955 				}
1956 
1957 				pWin = pSplitWin->GetSplitWindow();
1958 				if ( pSplitWin->GetWindowCount() == 1 )
1959                     ((SplitWindow*)pWin)->Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
1960 			}
1961 		}
1962 
1963         DBG_ASSERT( pCW, "Unknown window!" );
1964         if ( !pCW && pParent )
1965 		{
1966 			pParent->ConfigChild_Impl( eChild, eConfig, nId );
1967 			return;
1968 		}
1969 	}
1970 
1971     if ( !bSorted )
1972         // windows may have been registered and released without an update until now
1973 		Sort_Impl();
1974 
1975 	SfxChild_Impl *pChild = 0;
1976 	sal_uInt16 n;
1977 	for ( n=0; n<aSortedList.Count(); ++n )
1978 	{
1979 		pChild = (*pChilds)[aSortedList[n]];
1980 		if ( pChild )
1981 			if ( pChild->pWin == pWin )
1982 			break;
1983 	}
1984 
1985     if ( n < aSortedList.Count() )
1986         // sometimes called while toggeling float mode
1987         nPos = aSortedList[n];
1988 
1989 	switch ( eConfig )
1990 	{
1991 		case SFX_SETDOCKINGRECTS :
1992 		{
1993             if ( nPos == USHRT_MAX )
1994                 return;
1995 
1996 //			SfxChild_Impl *pChild = (*pChilds)[nPos];
1997 			Rectangle aOuterRect( GetTopRect_Impl() );
1998             aOuterRect.SetPos( pWorkWin->OutputToScreenPixel( aOuterRect.TopLeft() ));
1999             Rectangle aInnerRect( aOuterRect );
2000 			sal_Bool bTbx = (eChild == SFX_CHILDWIN_OBJECTBAR);
2001 
2002 			// Das gerade betroffene Fenster wird bei der Berechnung des
2003 			// inneren Rechtecks mit eingeschlossen!
2004 			for ( sal_uInt16 m=0; m<aSortedList.Count(); ++m )
2005 			{
2006 				sal_uInt16 i=aSortedList[m];
2007 				SfxChild_Impl* pCli = (*pChilds)[i];
2008 
2009                 if ( pCli && pCli->nVisible == CHILD_VISIBLE && pCli->pWin )
2010 				{
2011 					switch ( pCli->eAlign )
2012 					{
2013 						case SFX_ALIGN_TOP:
2014 							// Objekt-Toolboxen kommen immer zuletzt
2015 							//if ( bTbx || i <= nPos)
2016 								aInnerRect.Top() += pCli->aSize.Height();
2017 							break;
2018 
2019 						case SFX_ALIGN_TOOLBOXTOP:
2020 							// Toolbox geht nur vor, wenn nicht h"ohere Position
2021 							if ( bTbx && i <= nPos)
2022 								aInnerRect.Top() += pCli->aSize.Height();
2023 							break;
2024 
2025 						case SFX_ALIGN_HIGHESTTOP:
2026 							// Geht immer vor
2027 							aInnerRect.Top() += pCli->aSize.Height();
2028 							break;
2029 
2030 						case SFX_ALIGN_LOWESTTOP:
2031 							// Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist
2032 							if ( i == nPos )
2033 								aInnerRect.Top() += pCli->aSize.Height();
2034 							break;
2035 
2036 						case SFX_ALIGN_BOTTOM:
2037 							// Objekt-Toolboxen kommen immer zuletzt
2038 							//if ( bTbx || i <= nPos)
2039 								aInnerRect.Bottom() -= pCli->aSize.Height();
2040 							break;
2041 
2042 						case SFX_ALIGN_TOOLBOXBOTTOM:
2043 							// Toolbox geht nur vor, wenn nicht h"ohere Position
2044 							if ( bTbx && i <= nPos)
2045 								aInnerRect.Bottom() -= pCli->aSize.Height();
2046 							break;
2047 
2048 						case SFX_ALIGN_LOWESTBOTTOM:
2049 							// Geht immer vor
2050 							aInnerRect.Bottom() -= pCli->aSize.Height();
2051 							break;
2052 
2053 						case SFX_ALIGN_HIGHESTBOTTOM:
2054 							// Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist
2055 							if ( i == nPos )
2056 								aInnerRect.Bottom() -= pCli->aSize.Height();
2057 							break;
2058 
2059 						case SFX_ALIGN_LEFT:
2060 							// Toolboxen kommen immer zuletzt
2061 							//if (bTbx || i <= nPos)
2062 								aInnerRect.Left() += pCli->aSize.Width();
2063 							break;
2064 
2065 						case SFX_ALIGN_TOOLBOXLEFT:
2066 							// Toolboxen kommen immer zuletzt
2067 							if (bTbx && i <= nPos)
2068 								aInnerRect.Left() += pCli->aSize.Width();
2069 							break;
2070 
2071 						case SFX_ALIGN_FIRSTLEFT:
2072 							// Geht immer vor
2073 							aInnerRect.Left() += pCli->aSize.Width();
2074 							break;
2075 
2076 						case SFX_ALIGN_LASTLEFT:
2077 							// Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist
2078 							if (i == nPos)
2079 								aInnerRect.Left() += pCli->aSize.Width();
2080 
2081 						case SFX_ALIGN_RIGHT:
2082 							// Toolboxen kommen immer zuletzt
2083 							//if (bTbx || i <= nPos)
2084 								aInnerRect.Right() -= pCli->aSize.Width();
2085 							break;
2086 
2087 						case SFX_ALIGN_TOOLBOXRIGHT:
2088 							// Toolboxen kommen immer zuletzt
2089 							if (bTbx && i <= nPos)
2090 								aInnerRect.Right() -= pCli->aSize.Width();
2091 							break;
2092 
2093 						case SFX_ALIGN_FIRSTRIGHT:
2094 							// Wird nur mitgez"ahlt, wenn es das aktuelle Fenster ist
2095 							if (i == nPos)
2096 								aInnerRect.Right() -= pCli->aSize.Width();
2097 							break;
2098 
2099 						case SFX_ALIGN_LASTRIGHT:
2100 							// Geht immer vor
2101 							aInnerRect.Right() -= pCli->aSize.Width();
2102 							break;
2103 
2104 						default:
2105 							break;
2106 					}
2107 				}
2108 			}
2109 
2110             pDockWin->SetDockingRects(aOuterRect, aInnerRect);
2111 			break;
2112 		}
2113 
2114 		case SFX_MOVEDOCKINGWINDOW :
2115 		case SFX_ALIGNDOCKINGWINDOW :
2116 		case SFX_TOGGLEFLOATMODE:
2117 		{
2118             if ( nPos == USHRT_MAX && !pCW )
2119                 return;
2120 
2121             SfxChildAlignment eAlign = SFX_ALIGN_NOALIGNMENT;
2122             SfxChild_Impl *pCli = ( nPos != USHRT_MAX ) ? (*pChilds)[nPos] : 0;
2123             if ( pCli && pDockWin )
2124 			{
2125 				eAlign = pDockWin->GetAlignment();
2126                 if ( eChild == SFX_CHILDWIN_DOCKINGWINDOW || eAlign == SFX_ALIGN_NOALIGNMENT)
2127 				{
2128                     // configuration inside the SplitWindow, no change for the SplitWindows' configuration
2129 					pCli->bResize = sal_True;
2130 					pCli->aSize = pDockWin->GetSizePixel();
2131 				}
2132 			}
2133 
2134             if ( pCli )
2135             {
2136                 if( pCli->eAlign != eAlign )
2137                 {
2138                     bSorted = sal_False;
2139                     pCli->eAlign = eAlign;
2140                 }
2141 
2142                 ArrangeChilds_Impl();
2143                 ShowChilds_Impl();
2144             }
2145 
2146             if ( pCW && pCW->pWin )
2147 			{
2148                 // store changed configuration
2149                 sal_uInt16 nFlags = pCW->aInfo.nFlags;
2150                 pCW->aInfo = pCW->pWin->GetInfo();
2151                 pCW->aInfo.nFlags |= nFlags;
2152 				if ( eConfig != SFX_MOVEDOCKINGWINDOW )
2153 					SaveStatus_Impl( pCW->pWin, pCW->aInfo);
2154 			}
2155 
2156 			break;
2157 		}
2158 	}
2159 }
2160 
2161 
2162 //--------------------------------------------------------------------
2163 
SetChildWindowVisible_Impl(sal_uInt32 lId,sal_Bool bEnabled,sal_uInt16 nMode)2164 void SfxWorkWindow::SetChildWindowVisible_Impl( sal_uInt32 lId, sal_Bool bEnabled, sal_uInt16 nMode )
2165 {
2166 	sal_uInt16 nInter = (sal_uInt16) ( lId >> 16 );
2167 	sal_uInt16 nId = (sal_uInt16) ( lId & 0xFFFF );
2168 
2169 	SfxChildWin_Impl *pCW=NULL;
2170 	SfxWorkWindow *pWork = pParent;
2171 
2172 	// Den obersten parent nehmen; ChildWindows werden immer am WorkWindow
2173 	// der Task bzw. des Frames oder am AppWorkWindow angemeldet
2174 	while ( pWork && pWork->pParent )
2175 		pWork = pWork->pParent;
2176 
2177 	if ( pWork )
2178 	{
2179 		// Dem Parent schon bekannt ?
2180 		sal_uInt16 nCount = pWork->pChildWins->Count();
2181 		for (sal_uInt16 n=0; n<nCount; n++)
2182 			if ((*pWork->pChildWins)[n]->nSaveId == nId)
2183 			{
2184 				pCW = (*pWork->pChildWins)[n];
2185 				break;
2186 			}
2187 	}
2188 
2189 	if ( !pCW )
2190 	{
2191 		// Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen
2192 		sal_uInt16 nCount = pChildWins->Count();
2193 		for (sal_uInt16 n=0; n<nCount; n++)
2194 			if ((*pChildWins)[n]->nSaveId == nId)
2195 			{
2196 				pCW = (*pChildWins)[n];
2197 				break;
2198 			}
2199 	}
2200 
2201 	if ( !pCW )
2202 	{
2203 		// Ist neu, also initialisieren; je nach Flag beim Parent oder bei
2204 		// mir eintragen
2205 		pCW = new SfxChildWin_Impl( lId );
2206 		pCW->nId = nId;
2207 		InitializeChild_Impl( pCW );
2208 		if ( pWork && !( pCW->aInfo.nFlags & SFX_CHILDWIN_TASK ) )
2209 			pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW );
2210 		else
2211 			pChildWins->Insert( pChildWins->Count(), pCW );
2212 	}
2213 
2214 	pCW->nId = nId;
2215 	if ( nInter )
2216 		pCW->nInterfaceId = nInter;
2217 	pCW->nVisibility = nMode;
2218 	pCW->bEnable = bEnabled;
2219 #if 0
2220 	if ( pCW->pWin )
2221 		pCW->pWin->GetWindow()->EnableInput( bEnabled &&
2222             ( pWorkWin->IsInputEnabled() /* || pCW->pWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT */ ) );
2223 #endif
2224 	pCW->nVisibility = nMode;
2225 }
2226 
2227 //--------------------------------------------------------------------
2228 // Der An/Aus-Status eines ChildWindows wird umgeschaltet.
2229 
ToggleChildWindow_Impl(sal_uInt16 nId,sal_Bool bSetFocus)2230 void SfxWorkWindow::ToggleChildWindow_Impl(sal_uInt16 nId, sal_Bool bSetFocus)
2231 {
2232 	sal_uInt16 nCount = pChildWins->Count();
2233 	sal_uInt16 n;
2234 	for (n=0; n<nCount; n++)
2235 		if ((*pChildWins)[n]->nId == nId)
2236 			break;
2237 
2238 	if ( n<nCount )
2239 	{
2240 		// Das Fenster ist schon bekannt
2241 		SfxChildWin_Impl *pCW = (*pChildWins)[n];
2242 		SfxChildWindow *pChild = pCW->pWin;
2243 
2244         bool bCreationAllowed( true );
2245         if ( !bInternalDockingAllowed )
2246         {
2247             // Special case for all non-floatable child windows. We have
2248             // to prevent the creation here!
2249             bCreationAllowed = !( pCW->aInfo.nFlags & SFX_CHILDWIN_FORCEDOCK );
2250         }
2251 
2252         if ( bCreationAllowed )
2253         {
2254             if ( pCW->bCreate )
2255             {
2256                 if ( pChild )
2257 		        {
2258 			        if ( pChild->QueryClose() )
2259 			        {
2260 				        pCW->bCreate = sal_False;
2261 				        if ( pChild->IsHideAtToggle() )
2262 				        {
2263                             ShowChildWindow_Impl( nId, sal_False, bSetFocus );
2264 				        }
2265 				        else
2266 				        {
2267 					        // Fenster soll ausgeschaltet werdem
2268 					        pChild->SetVisible_Impl( sal_False );
2269 					        RemoveChildWin_Impl( pCW );
2270 				        }
2271 			        }
2272 		        }
2273                 else
2274                 {
2275                     // no actual Window exists, yet => just remember the "switched off" state
2276                     pCW->bCreate = sal_False;
2277                 }
2278             }
2279             else
2280 		    {
2281 			    pCW->bCreate = AllowChildWindowCreation_Impl( *pCW );
2282                 if ( pCW->bCreate )
2283                 {
2284 			        if ( pChild )
2285 			        {
2286                         ShowChildWindow_Impl( nId, sal_True, bSetFocus );
2287 			        }
2288 			        else
2289 			        {
2290 				        // create actual Window
2291 				        CreateChildWin_Impl( pCW, bSetFocus );
2292 				        if ( !pCW->pWin )
2293 					        // no success
2294 					        pCW->bCreate = sal_False;
2295 			        }
2296                 }
2297 		    }
2298         }
2299 
2300 		ArrangeChilds_Impl();
2301 		ShowChilds_Impl();
2302 
2303 		if ( pCW->bCreate && bCreationAllowed )
2304 		{
2305 			if ( !pCW->pCli )
2306 			{
2307 				SfxDockingWindow *pDock =
2308 					(SfxDockingWindow*) pCW->pWin->GetWindow();
2309                 if ( pDock->IsAutoHide_Impl() )
2310 					pDock->AutoShow_Impl();
2311 			}
2312 		}
2313 
2314 		return;
2315 	}
2316 	else if ( pParent )
2317 	{
2318         pParent->ToggleChildWindow_Impl( nId, bSetFocus );
2319 		return;
2320 	}
2321 
2322 #ifdef DBG_UTIL
2323 	nCount = pChildWins->Count();
2324 	for (n=0; n<nCount; n++)
2325 		if ((*pChildWins)[n]->nSaveId == nId)
2326 			break;
2327 
2328 	if ( n < nCount )
2329 	{
2330 		DBG_ERROR("ChildWindow ist nicht im Kontext!");
2331 	}
2332 	else
2333 	{
2334 		DBG_ERROR("ChildWindow ist nicht registriert!");
2335 	}
2336 #endif
2337 }
2338 
2339 //--------------------------------------------------------------------
2340 
HasChildWindow_Impl(sal_uInt16 nId)2341 sal_Bool SfxWorkWindow::HasChildWindow_Impl(sal_uInt16 nId)
2342 {
2343 	sal_uInt16 nCount = pChildWins->Count();
2344 	sal_uInt16 n;
2345 	for (n=0; n<nCount; n++)
2346 		if ((*pChildWins)[n]->nSaveId == nId)
2347 			break;
2348 
2349 	if (n<nCount)
2350 	{
2351 		SfxChildWin_Impl *pCW = (*pChildWins)[n];
2352 		SfxChildWindow *pChild = pCW->pWin;
2353 		return ( pChild && pCW->bCreate );
2354 	}
2355 
2356 	if ( pParent )
2357 		return pParent->HasChildWindow_Impl( nId );
2358 
2359 	return sal_False;
2360 }
2361 
IsFloating(sal_uInt16 nId)2362 sal_Bool SfxWorkWindow::IsFloating( sal_uInt16 nId )
2363 {
2364 	SfxChildWin_Impl *pCW=NULL;
2365 	SfxWorkWindow *pWork = pParent;
2366 
2367 	// Den obersten parent nehmen; ChildWindows werden immer am WorkWindow
2368 	// der Task bzw. des Frames oder am AppWorkWindow angemeldet
2369 	while ( pWork && pWork->pParent )
2370 		pWork = pWork->pParent;
2371 
2372 	if ( pWork )
2373 	{
2374 		// Dem Parent schon bekannt ?
2375 		sal_uInt16 nCount = pWork->pChildWins->Count();
2376 		for (sal_uInt16 n=0; n<nCount; n++)
2377 			if ((*pWork->pChildWins)[n]->nSaveId == nId)
2378 			{
2379 				pCW = (*pWork->pChildWins)[n];
2380 				break;
2381 			}
2382 	}
2383 
2384 	if ( !pCW )
2385 	{
2386 		// Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen
2387 		sal_uInt16 nCount = pChildWins->Count();
2388 		for (sal_uInt16 n=0; n<nCount; n++)
2389 			if ((*pChildWins)[n]->nSaveId == nId)
2390 			{
2391 				pCW = (*pChildWins)[n];
2392 				break;
2393 			}
2394 	}
2395 
2396 	if ( !pCW )
2397 	{
2398 		// Ist neu, also initialisieren; je nach Flag beim Parent oder bei
2399 		// mir eintragen
2400 		pCW = new SfxChildWin_Impl( nId );
2401 		pCW->bEnable = sal_False;
2402 		pCW->nId = 0;
2403 		pCW->nVisibility = 0;
2404 		InitializeChild_Impl( pCW );
2405 		if ( pWork && !( pCW->aInfo.nFlags & SFX_CHILDWIN_TASK ) )
2406 			pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW );
2407 		else
2408 			pChildWins->Insert( pChildWins->Count(), pCW );
2409 	}
2410 
2411 	SfxChildAlignment eAlign;
2412 	if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) )
2413 		return( eAlign == SFX_ALIGN_NOALIGNMENT );
2414 	else
2415 		return sal_True;
2416 }
2417 
2418 //--------------------------------------------------------------------
2419 
KnowsChildWindow_Impl(sal_uInt16 nId)2420 sal_Bool SfxWorkWindow::KnowsChildWindow_Impl(sal_uInt16 nId)
2421 {
2422 	SfxChildWin_Impl *pCW=0;
2423 	sal_uInt16 nCount = pChildWins->Count();
2424 	sal_uInt16 n;
2425 	for (n=0; n<nCount; n++)
2426 	{
2427 		pCW = (*pChildWins)[n];
2428 		if ( pCW->nSaveId == nId)
2429 			 break;
2430 	}
2431 
2432 	if (n<nCount)
2433 	{
2434         if ( !(pCW->aInfo.nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE) && !IsVisible_Impl(  pCW->nVisibility ) )
2435 			return sal_False;
2436 		return pCW->bEnable;
2437 	}
2438 	else if ( pParent )
2439 		return pParent->KnowsChildWindow_Impl( nId );
2440 	else
2441 		return sal_False;
2442 }
2443 
2444 //--------------------------------------------------------------------
2445 
SetChildWindow_Impl(sal_uInt16 nId,sal_Bool bOn,sal_Bool bSetFocus)2446 void SfxWorkWindow::SetChildWindow_Impl(sal_uInt16 nId, sal_Bool bOn, sal_Bool bSetFocus)
2447 {
2448 	SfxChildWin_Impl *pCW=NULL;
2449 	SfxWorkWindow *pWork = pParent;
2450 
2451 	// Den obersten parent nehmen; ChildWindows werden immer am WorkWindow
2452 	// der Task bzw. des Frames oder am AppWorkWindow angemeldet
2453 	while ( pWork && pWork->pParent )
2454 		pWork = pWork->pParent;
2455 
2456 	if ( pWork )
2457 	{
2458 		// Dem Parent schon bekannt ?
2459 		sal_uInt16 nCount = pWork->pChildWins->Count();
2460 		for (sal_uInt16 n=0; n<nCount; n++)
2461 			if ((*pWork->pChildWins)[n]->nSaveId == nId)
2462 			{
2463 				pCW = (*pWork->pChildWins)[n];
2464 				break;
2465 			}
2466 	}
2467 
2468 	if ( !pCW )
2469 	{
2470 		// Kein Parent oder dem Parent noch unbekannt, dann bei mir suchen
2471 		sal_uInt16 nCount = pChildWins->Count();
2472 		for (sal_uInt16 n=0; n<nCount; n++)
2473 			if ((*pChildWins)[n]->nSaveId == nId)
2474 			{
2475 				pCW = (*pChildWins)[n];
2476 				pWork = this;
2477 				break;
2478 			}
2479 	}
2480 
2481 	if ( !pCW )
2482 	{
2483 		// Ist neu, also initialisieren; je nach Flag beim Parent oder bei
2484 		// mir eintragen
2485 		pCW = new SfxChildWin_Impl( nId );
2486 		InitializeChild_Impl( pCW );
2487 		if ( !pWork || pCW->aInfo.nFlags & SFX_CHILDWIN_TASK )
2488 			pWork = this;
2489 		pWork->pChildWins->Insert( pWork->pChildWins->Count(), pCW );
2490 	}
2491 
2492     if ( pCW->bCreate != bOn )
2493         pWork->ToggleChildWindow_Impl(nId,bSetFocus);
2494 }
2495 
2496 //--------------------------------------------------------------------
2497 
ShowChildWindow_Impl(sal_uInt16 nId,sal_Bool bVisible,sal_Bool bSetFocus)2498 void SfxWorkWindow::ShowChildWindow_Impl(sal_uInt16 nId, sal_Bool bVisible, sal_Bool bSetFocus)
2499 {
2500 	sal_uInt16 nCount = pChildWins->Count();
2501 	SfxChildWin_Impl* pCW=0;
2502 	sal_uInt16 n;
2503 	for (n=0; n<nCount; n++)
2504 	{
2505 		pCW = (*pChildWins)[n];
2506 		if (pCW->nId == nId)
2507 			break;
2508 	}
2509 
2510 	if ( n<nCount )
2511 	{
2512 		SfxChildWindow *pChildWin = pCW->pWin;
2513 		if ( pChildWin )
2514 		{
2515 			if ( bVisible )
2516 			{
2517 				if ( pCW->pCli )
2518 				{
2519 					pCW->pCli->bSetFocus = bSetFocus;
2520 					pCW->pCli->nVisible = CHILD_VISIBLE;
2521                     pChildWin->Show( bSetFocus && pChildWin->WantsFocus() ? 0 : SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
2522 				}
2523 				else
2524 					((SfxDockingWindow*)pChildWin->GetWindow())->Reappear_Impl();
2525 
2526 			}
2527 			else
2528 			{
2529 				if ( pCW->pCli )
2530 				{
2531 					pCW->pCli->nVisible = CHILD_VISIBLE ^ CHILD_NOT_HIDDEN;
2532 					pCW->pWin->Hide();
2533 				}
2534 				else
2535 					((SfxDockingWindow*)pChildWin->GetWindow())->Disappear_Impl();
2536 
2537 			}
2538 
2539 			ArrangeChilds_Impl();
2540 			ShowChilds_Impl();
2541 		}
2542 		else if ( bVisible )
2543 		{
2544             SetChildWindow_Impl( nId, sal_True, bSetFocus );
2545 			pChildWin = pCW->pWin;
2546 		}
2547 
2548 		if ( pChildWin )
2549 		{
2550 			pChildWin->SetVisible_Impl( bVisible );
2551             sal_uInt16 nFlags = pCW->aInfo.nFlags;
2552             pCW->aInfo = pChildWin->GetInfo();
2553             pCW->aInfo.nFlags |= nFlags;
2554 			if ( !pCW->bCreate )
2555 				SaveStatus_Impl( pChildWin, pCW->aInfo );
2556 		}
2557 
2558 		return;
2559 	}
2560 
2561 	if ( pParent )
2562 	{
2563         pParent->ShowChildWindow_Impl( nId, bVisible, bSetFocus );
2564 		return;
2565 	}
2566 
2567 #ifdef DBG_UTIL
2568 	nCount = pChildWins->Count();
2569 	for (n=0; n<nCount; n++)
2570 		if ((*pChildWins)[n]->nSaveId == nId)
2571 			break;
2572 
2573 	if ( n<nCount )
2574 	{
2575 		DBG_ERROR("ChildWindow ist nicht im Kontext!");
2576 	}
2577 	else
2578 	{
2579 		DBG_ERROR("ChildWindow ist nicht registriert!");
2580 	}
2581 #endif
2582 }
2583 
2584 //--------------------------------------------------------------------
2585 
GetChildWindow_Impl(sal_uInt16 nId)2586 SfxChildWindow* SfxWorkWindow::GetChildWindow_Impl(sal_uInt16 nId)
2587 {
2588 	sal_uInt16 nCount = pChildWins->Count();
2589 	sal_uInt16 n;
2590 	for (n=0; n<nCount; n++)
2591 		if ((*pChildWins)[n]->nSaveId == nId)
2592 			 break;
2593 
2594 	if (n<nCount)
2595 		return (*pChildWins)[n]->pWin;
2596 	else if ( pParent )
2597 		return pParent->GetChildWindow_Impl( nId );
2598 	return 0;
2599 }
2600 
2601 //------------------------------------------------------------------------
2602 
ResetChildWindows_Impl()2603 void SfxWorkWindow::ResetChildWindows_Impl()
2604 {
2605 //	if ( pParent )
2606 //		pParent->ResetChildWindows_Impl();
2607 
2608 	for ( sal_uInt16 n = 0; n < pChildWins->Count(); ++n )
2609 	{
2610 		(*pChildWins)[n]->nId = 0;
2611 		(*pChildWins)[n]->bEnable = sal_False;
2612 	}
2613 }
2614 
2615 //------------------------------------------------------------------------
2616 // Virtuelle Methode, die die Gr"o\se der Fl"ache (client area) des parent
2617 // windows liefert, in der Child-Fenster angeordnet werden k"onnen.
2618 // in der ClientArea des parent findet.
2619 
GetTopRect_Impl()2620 Rectangle SfxWorkWindow::GetTopRect_Impl()
2621 {
2622 	return Rectangle (Point(), pWorkWin->GetOutputSizePixel() );
2623 }
2624 
2625 //------------------------------------------------------------------------
2626 // Virtuelle Methode, die die Gr"o\se der Fl"ache (client area) des parent
2627 // windows liefert, in der Child-Fenster angeordnet werden k"onnen.
2628 // in der ClientArea des parent findet.
2629 
GetTopRect_Impl()2630 Rectangle SfxFrameWorkWin_Impl::GetTopRect_Impl()
2631 {
2632     return pMasterFrame->GetTopOuterRectPixel_Impl();
2633 }
2634 
2635 //------------------------------------------------------------------------
2636 // Virtuelle Methode, um herauszufinden, ob ein Child-Fenster noch Platz
2637 // in der ClientArea des parent findet.
2638 
RequestTopToolSpacePixel_Impl(SvBorder aBorder)2639 sal_Bool SfxWorkWindow::RequestTopToolSpacePixel_Impl( SvBorder aBorder )
2640 {
2641 	if ( !IsDockingAllowed() ||
2642 			aClientArea.GetWidth() < aBorder.Left() + aBorder.Right() ||
2643 			aClientArea.GetHeight() < aBorder.Top() + aBorder.Bottom() )
2644 		return sal_False;
2645 	else
2646 		return sal_True;;
2647 }
2648 
SaveStatus_Impl(SfxChildWindow * pChild,const SfxChildWinInfo & rInfo)2649 void SfxWorkWindow::SaveStatus_Impl(SfxChildWindow *pChild, const SfxChildWinInfo &rInfo)
2650 {
2651 	// Den Status vom Presentation mode wollen wir nicht sichern
2652     if ( IsDockingAllowed() && bInternalDockingAllowed )
2653 		pChild->SaveStatus(rInfo);
2654 }
2655 
InitializeChild_Impl(SfxChildWin_Impl * pCW)2656 void SfxWorkWindow::InitializeChild_Impl(SfxChildWin_Impl *pCW)
2657 {
2658 	SfxChildWinFactory* pFact=0;
2659 	SfxApplication *pApp = SFX_APP();
2660     {
2661 	    SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
2662 	    for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
2663 	    {
2664 		    pFact = rFactories[nFactory];
2665 		    if ( pFact->nId == pCW->nSaveId )
2666 		    {
2667 			    pCW->aInfo   = pFact->aInfo;
2668 			    SfxChildWindow::InitializeChildWinFactory_Impl(
2669 										    pCW->nSaveId, pCW->aInfo);
2670                 pCW->bCreate = pCW->aInfo.bVisible;
2671 			    sal_uInt16 nFlags = pFact->aInfo.nFlags;
2672 			    if ( nFlags & SFX_CHILDWIN_TASK )
2673 				    pCW->aInfo.nFlags |= SFX_CHILDWIN_TASK;
2674 			    if ( nFlags & SFX_CHILDWIN_CANTGETFOCUS )
2675 				    pCW->aInfo.nFlags |= SFX_CHILDWIN_CANTGETFOCUS;
2676                 if ( nFlags & SFX_CHILDWIN_FORCEDOCK )
2677                     pCW->aInfo.nFlags |= SFX_CHILDWIN_FORCEDOCK;
2678 			    pFact->aInfo = pCW->aInfo;
2679 			    return;
2680 		    }
2681 	    }
2682     }
2683 
2684 	SfxDispatcher *pDisp = pBindings->GetDispatcher_Impl();
2685     SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0;
2686 	if ( pMod )
2687 	{
2688 		SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
2689 		if ( pFactories )
2690 		{
2691 			SfxChildWinFactArr_Impl &rFactories = *pFactories;
2692 			for ( sal_uInt16 nFactory = 0; nFactory < rFactories.Count(); ++nFactory )
2693 			{
2694 				pFact = rFactories[nFactory];
2695 				if ( pFact->nId == pCW->nSaveId )
2696 				{
2697 					pCW->aInfo   = pFact->aInfo;
2698 					SfxChildWindow::InitializeChildWinFactory_Impl(
2699 												pCW->nSaveId, pCW->aInfo);
2700 					pCW->bCreate = pCW->aInfo.bVisible;
2701 					sal_uInt16 nFlags = pFact->aInfo.nFlags;
2702 					if ( nFlags & SFX_CHILDWIN_TASK )
2703 						pCW->aInfo.nFlags |= SFX_CHILDWIN_TASK;
2704 					if ( nFlags & SFX_CHILDWIN_CANTGETFOCUS )
2705 						pCW->aInfo.nFlags |= SFX_CHILDWIN_CANTGETFOCUS;
2706                     if ( nFlags & SFX_CHILDWIN_FORCEDOCK )
2707                         pCW->aInfo.nFlags |= SFX_CHILDWIN_FORCEDOCK;
2708                     if ( nFlags & SFX_CHILDWIN_ALWAYSAVAILABLE )
2709                         pCW->aInfo.nFlags |= SFX_CHILDWIN_ALWAYSAVAILABLE;
2710 					pFact->aInfo = pCW->aInfo;
2711 					return;
2712 				}
2713 			}
2714 		}
2715 	}
2716 }
2717 /*
2718 SfxStatBar_Impl* SfxWorkWindow::GetStatusBar_Impl()
2719 {
2720     return &aStatBar;
2721 } */
2722 
GetSplitWindow_Impl(SfxChildAlignment eAlign)2723 SfxSplitWindow* SfxWorkWindow::GetSplitWindow_Impl( SfxChildAlignment eAlign )
2724 {
2725 	switch ( eAlign )
2726 	{
2727 		case SFX_ALIGN_TOP:
2728 			return pSplit[2];
2729 
2730 		case SFX_ALIGN_BOTTOM:
2731 			return pSplit[3];
2732 
2733 		case SFX_ALIGN_LEFT:
2734 			return pSplit[0];
2735 
2736 		case SFX_ALIGN_RIGHT:
2737 			return pSplit[1];
2738 
2739 		default:
2740 			return 0;
2741 	}
2742 }
2743 
MakeChildsVisible_Impl(sal_Bool bVis)2744 void SfxWorkWindow::MakeChildsVisible_Impl( sal_Bool bVis )
2745 {
2746 	if ( pParent )
2747 		pParent->MakeChildsVisible_Impl( bVis );
2748 
2749 	bAllChildsVisible = bVis;
2750 	if ( bVis )
2751 	{
2752 		if ( !bSorted )
2753 			Sort_Impl();
2754 		for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n )
2755 		{
2756 			SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]];
2757             if ( (pCli->eAlign == SFX_ALIGN_NOALIGNMENT) || (IsDockingAllowed() && bInternalDockingAllowed) )
2758 				pCli->nVisible |= CHILD_ACTIVE;
2759 		}
2760 	}
2761 	else
2762 	{
2763 		if ( !bSorted )
2764 			Sort_Impl();
2765 		for ( sal_uInt16 n=0; n<aSortedList.Count(); ++n )
2766 		{
2767 			SfxChild_Impl* pCli = (*pChilds)[aSortedList[n]];
2768 			pCli->nVisible &= ~CHILD_ACTIVE;
2769 		}
2770 	}
2771 }
2772 
IsAutoHideMode(const SfxSplitWindow * pSplitWin)2773 sal_Bool SfxWorkWindow::IsAutoHideMode( const SfxSplitWindow *pSplitWin )
2774 {
2775 	for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
2776 	{
2777 		if ( pSplit[n] != pSplitWin && pSplit[n]->IsAutoHide( sal_True ) )
2778 			return sal_True;
2779 	}
2780 	return sal_False;
2781 }
2782 
2783 
EndAutoShow_Impl(Point aPos)2784 void SfxWorkWindow::EndAutoShow_Impl( Point aPos )
2785 {
2786 	if ( pParent )
2787         pParent->EndAutoShow_Impl( aPos );
2788 
2789 	for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
2790 	{
2791 		SfxSplitWindow *p = pSplit[n];
2792 		if ( p && p->IsAutoHide() )
2793         {
2794             Point aLocalPos = p->ScreenToOutputPixel( aPos );
2795 	    Point aEmptyPoint = Point();
2796             Rectangle aRect( aEmptyPoint, p->GetSizePixel() );
2797             if ( !aRect.IsInside( aLocalPos ) )
2798                 p->FadeOut();
2799         }
2800 	}
2801 }
2802 
ArrangeAutoHideWindows(SfxSplitWindow * pActSplitWin)2803 void SfxWorkWindow::ArrangeAutoHideWindows( SfxSplitWindow *pActSplitWin )
2804 {
2805     if ( m_nLock )
2806         return;
2807 
2808 	if ( pParent )
2809 		pParent->ArrangeAutoHideWindows( pActSplitWin );
2810 
2811     Rectangle aArea( aUpperClientArea );
2812 	for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
2813 	{
2814 		// Es werden entweder Dummyfenster oder Fenster im AutoShow-Modus
2815 		// ( nicht gepinned, FadeIn ) behandelt.
2816 		// Nur das "ubergebene Fenster darf unsichtbar sein, denn vielleicht
2817 		// soll daf"ur gerade die Gr"o\se berechnet werden, bevor es angezeigt
2818 		// wird.
2819 		SfxSplitWindow* pSplitWin = pSplit[n];
2820 		sal_Bool bDummyWindow = !pSplitWin->IsFadeIn();
2821 		Window *pDummy = pSplitWin->GetSplitWindow();
2822 		Window *pWin = bDummyWindow ? pDummy : pSplitWin;
2823 		if ( (pSplitWin->IsPinned() && !bDummyWindow) || (!pWin->IsVisible() && pActSplitWin != pSplitWin) )
2824 			continue;
2825 
2826 		// Breite und Position des Dummy-Fensters als Ausgangspunkt
2827 		Size aSize = pDummy->GetSizePixel();
2828 		Point aPos = pDummy->GetPosPixel();
2829 
2830 		switch ( n )
2831 		{
2832 			case ( 0 ) :
2833 			{
2834 				// Linkes SplitWindow
2835 				// Breite vom Fenster selbst holen, wenn nicht das DummyWindow
2836 				if ( !bDummyWindow )
2837 					aSize.Width() = pSplitWin->GetSizePixel().Width();
2838 
2839 				// Wenn links ein Window sichtbar ist, beginnt der freie
2840 				// Bereich rechts davon bzw. bei der Client area
2841 				long nLeft = aPos.X() + aSize.Width();
2842 				if ( nLeft > aArea.Left() )
2843 					aArea.Left() = nLeft;
2844 				break;
2845 			}
2846 			case ( 1 ) :
2847 			{
2848 				// Rechtes SplitWindow
2849 				// Position um Differenz der Breiten korrigieren
2850 				aPos.X() += aSize.Width();
2851 
2852 				// Breite vom Fenster selbst holen, wenn nicht das DummyWindow
2853 				if ( !bDummyWindow )
2854 					aSize.Width() = pSplitWin->GetSizePixel().Width();
2855 
2856 				aPos.X() -= aSize.Width();
2857 
2858 				// Wenn links schon ein Fenster aufgeklappt ist, darf
2859 				// das rechte nicht dar"uber gehen
2860 				if ( aPos.X() < aArea.Left() )
2861 				{
2862 					aPos.X() = aArea.Left();
2863 					aSize.Width() = aArea.GetWidth();
2864 				}
2865 
2866 				// Wenn rechts ein Window sichtbar ist, endet der freie
2867 				// Bereich links davon bzw. bei der Client area
2868 				long nRight = aPos.X();
2869 				if ( nRight < aArea.Right() )
2870 					aArea.Right() = nRight;
2871 				break;
2872 			}
2873 			case ( 2 ) :
2874 			{
2875 				// Oberes SplitWindow
2876 				// H"ohe vom Fenster selbst holen, wenn nicht das DummyWindow
2877 				if ( !bDummyWindow )
2878 					aSize.Height() = pSplitWin->GetSizePixel().Height();
2879 
2880 				// Breite anpassen, je nachdem ob links oder rechts
2881 				// schon ein Fenster aufgeklappt ist
2882 				aPos.X() = aArea.Left();
2883 				aSize.Width() = aArea.GetWidth();
2884 
2885 				// Wenn oben ein Window sichtbar ist, beginnt der freie
2886 				// Bereich darunter bzw. bei der Client Area
2887 				long nTop = aPos.Y() + aSize.Height();
2888 				if ( nTop > aArea.Top() )
2889 					aArea.Top() = nTop;
2890 				break;
2891 			}
2892 			case ( 3 ) :
2893 			{
2894 				// Das untere SplitWindow
2895 				// Position um Differenz der H"ohen korrigieren
2896 				aPos.Y() += aSize.Height();
2897 
2898 				// H"ohe vom Fenster selbst holen, wenn nicht das DummmyWindow
2899 				if ( !bDummyWindow )
2900 					aSize.Height() = pSplitWin->GetSizePixel().Height();
2901 
2902 				aPos.Y() -= aSize.Height();
2903 
2904 				// Breite anpassen, je nachdem ob links oder rechts
2905 				// schon ein Fenster aufgeklappt ist
2906 				aPos.X() = aArea.Left();
2907 				aSize.Width() = aArea.GetWidth();
2908 
2909 				// Wenn oben schon ein Fenster aufgeklappt ist, darf
2910 				// das untere nicht dar"uber gehen
2911 				if ( aPos.Y() < aArea.Top() )
2912 				{
2913 					aPos.Y() = aArea.Top();
2914 					aSize.Height() = aArea.GetHeight();
2915 				}
2916 
2917 				break;
2918 			}
2919 		}
2920 
2921 		if ( !bDummyWindow )
2922 			// Das FadeIn-Window ist ein Float, dessen Koordinaten in
2923 			// Screenkoordinaten gesetzt werden
2924 			pSplitWin->SetPosSizePixel( pWorkWin->OutputToScreenPixel(aPos), aSize );
2925 		else
2926 			// Das angedockte DummyWindow
2927 			pDummy->SetPosSizePixel( aPos, aSize );
2928 	}
2929 }
2930 
GetFreeArea(sal_Bool bAutoHide) const2931 Rectangle SfxWorkWindow::GetFreeArea( sal_Bool bAutoHide ) const
2932 {
2933 	if ( bAutoHide )
2934 	{
2935 		Rectangle aArea( aClientArea );
2936 		for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
2937 		{
2938 			if ( pSplit[n]->IsPinned() || !pSplit[n]->IsVisible() )
2939 				continue;
2940 
2941 			Size aSize = pSplit[n]->GetSizePixel();
2942 			switch ( n )
2943 			{
2944 				case ( 0 ) :
2945 					aArea.Left() += aSize.Width();
2946 					break;
2947 				case ( 1 ) :
2948 					aArea.Right() -= aSize.Width();
2949 					break;
2950 				case ( 2 ) :
2951 					aArea.Top() += aSize.Height();
2952 					break;
2953 				case ( 3 ) :
2954 					aArea.Bottom() -= aSize.Height();
2955 					break;
2956 			}
2957 		}
2958 
2959 		return aArea;
2960 	}
2961 	else
2962 		return aClientArea;
2963 }
2964 
SfxChildWinController_Impl(sal_uInt16 nID,SfxWorkWindow * pWork)2965 SfxChildWinController_Impl::SfxChildWinController_Impl( sal_uInt16 nID, SfxWorkWindow *pWork )
2966 	: SfxControllerItem( nID, pWork->GetBindings() )
2967 	, pWorkwin( pWork )
2968 {}
2969 
CreateDispatch(const String &)2970 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch > SfxWorkWindow::CreateDispatch( const String& )
2971 {
2972 	return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XDispatch >();
2973 }
2974 
StateChanged(sal_uInt16 nSID,SfxItemState eState,const SfxPoolItem *)2975 void SfxChildWinController_Impl::StateChanged(
2976     sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* )
2977 {
2978 	pWorkwin->DisableChildWindow_Impl( nSID, eState == SFX_ITEM_DISABLED );
2979 }
2980 
DisableChildWindow_Impl(sal_uInt16 nId,sal_Bool bDisable)2981 void SfxWorkWindow::DisableChildWindow_Impl( sal_uInt16 nId, sal_Bool bDisable )
2982 {
2983 	sal_uInt16 nCount = pChildWins->Count();
2984 	sal_uInt16 n;
2985 	for (n=0; n<nCount; n++)
2986 		if ((*pChildWins)[n]->nSaveId == nId)
2987 			 break;
2988 	if ( n<nCount && (*pChildWins)[n]->bDisabled != bDisable )
2989 	{
2990 		(*pChildWins)[n]->bDisabled = bDisable;
2991 		UpdateChildWindows_Impl();
2992 		ArrangeChilds_Impl();
2993 		ShowChilds_Impl();
2994 	}
2995 }
2996 
SetActiveChild_Impl(Window * pChild)2997 void SfxWorkWindow::SetActiveChild_Impl( Window *pChild )
2998 {
2999 	pActiveChild = pChild;
3000 }
3001 
GetActiveChild_Impl()3002 Window*	SfxWorkWindow::GetActiveChild_Impl()
3003 {
3004 	return pActiveChild;
3005 }
3006 
ActivateNextChild_Impl(sal_Bool bForward)3007 sal_Bool SfxWorkWindow::ActivateNextChild_Impl( sal_Bool bForward )
3008 {
3009 	// Alle Kinder gem"a\s Liste sortieren
3010 	SvUShorts aList;
3011 	for ( sal_uInt16 i=SFX_OBJECTBAR_MAX; i<pChilds->Count(); i++)
3012 	{
3013 		SfxChild_Impl *pCli = (*pChilds)[i];
3014         if ( pCli && pCli->bCanGetFocus && pCli->pWin )
3015 		{
3016 			sal_uInt16 k;
3017 			for (k=0; k<aList.Count(); k++)
3018 				if ( ChildTravelValue((*pChilds)[aList[k]]->eAlign) > ChildTravelValue(pCli->eAlign) )
3019 					break;
3020 			aList.Insert(i,k);
3021 		}
3022 	}
3023 
3024     if ( aList.Count() == 0 )
3025         return sal_False;
3026 
3027 	sal_uInt16 nTopValue  = ChildTravelValue( SFX_ALIGN_LOWESTTOP );
3028 	for ( sal_uInt16 i=0; i<aList.Count(); i++ )
3029 	{
3030 		SfxChild_Impl* pCli = (*pChilds)[aList[i]];
3031         if ( pCli->pWin && ChildTravelValue( pCli->eAlign ) > nTopValue )
3032 			break;
3033 	}
3034 
3035 	sal_uInt16 n = bForward ? 0 : aList.Count()-1;
3036 	SfxChild_Impl *pAct=NULL;
3037     if ( pActiveChild )
3038 	{
3039 		// Das aktive Fenster suchen
3040 		for ( n=0; n<aList.Count(); n++ )
3041 		{
3042 			SfxChild_Impl* pCli = (*pChilds)[aList[n]];
3043 			if ( pCli && pCli->pWin && ( pCli->pWin == pActiveChild || !pActiveChild ) )
3044 			{
3045 				pAct = pCli;
3046 				break;
3047 			}
3048 		}
3049 	}
3050 
3051     // dummy entries for the container window
3052     aList.Insert( 0xFFFF, 0 );
3053     aList.Insert( 0xFFFF, aList.Count() );
3054     n = n + 1;
3055     if ( pAct )
3056 	{
3057 		for ( sal_uInt16 i=0; i<SFX_SPLITWINDOWS_MAX; i++ )
3058 		{
3059 			// Eventuell ist pAct ein Splitwindow
3060 			SfxSplitWindow *p = pSplit[i];
3061 			if ( pAct->pWin == p )
3062 			{
3063 				if( p->ActivateNextChild_Impl( bForward ) )
3064 					return sal_True;
3065 				break;
3066 			}
3067 		}
3068 
3069 		// pAct ist ein direktes ChildWindow
3070 		// mit dem Nachfolger bzw. Vorg"anger des aktiven Fensters weitermachen
3071 		if ( bForward )
3072             n = n+1;
3073 		else
3074             n = n-1;
3075 
3076         if ( n == 0 || n == aList.Count()-1 )
3077             return sal_False;
3078 	}
3079 
3080 	for( ;; )
3081 	{
3082         SfxChild_Impl* pCli = (*pChilds)[aList[n]];
3083         if ( pCli->pWin )
3084         {
3085             SfxChild_Impl* pNext = pCli;
3086             for ( sal_uInt16 i=0; n<SFX_SPLITWINDOWS_MAX; n++ )
3087             {
3088                 // Eventuell ist pNext ein Splitwindow
3089                 SfxSplitWindow *p = pSplit[i];
3090                 if ( pNext->pWin == p )
3091                 {
3092                     // Das erste/letzte Fenster dort aktivieren
3093                     p->SetActiveWindow_Impl( NULL );
3094                     pNext = NULL;
3095                     if( p->ActivateNextChild_Impl( bForward ) )
3096                         return sal_True;
3097                     break;
3098                 }
3099             }
3100 
3101             if ( pNext )
3102             {
3103                 pNext->pWin->GrabFocus();
3104                 pActiveChild = pNext->pWin;
3105                 return sal_True;
3106             }
3107         }
3108 
3109 		if ( bForward )
3110             n = n+1;
3111 		else
3112             n = n-1;
3113 
3114         if ( n == 0 || n == aList.Count()-1 )
3115 			break;
3116 	}
3117 
3118 	return sal_False;
3119 }
3120 
SetObjectBarCustomizeMode_Impl(sal_Bool)3121 void SfxWorkWindow::SetObjectBarCustomizeMode_Impl( sal_Bool )
3122 {
3123 }
3124 
DataChanged_Impl(const DataChangedEvent &)3125 void SfxWorkWindow::DataChanged_Impl( const DataChangedEvent& )
3126 {
3127 	sal_uInt16 n;
3128     sal_uInt16 nCount = pChildWins->Count();
3129 	for (n=0; n<nCount; n++)
3130 	{
3131         SfxChildWin_Impl*pCW = (*pChildWins)[n];
3132         if ( pCW && pCW->pWin )
3133             pCW->pWin->GetWindow()->UpdateSettings( Application::GetSettings() );
3134     }
3135 
3136     ArrangeChilds_Impl();
3137 }
3138 
3139