Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <boost/scoped_ptr.hpp>
21 : #include <vcl/toolbox.hxx>
22 : #include <tools/rcid.h>
23 : #include <unotools/moduleoptions.hxx>
24 : #include <unotools/viewoptions.hxx>
25 : #include <com/sun/star/frame/ModuleManager.hpp>
26 : #include <com/sun/star/frame/XController.hpp>
27 : #include <com/sun/star/frame/XFrame.hpp>
28 : #include <com/sun/star/util/XCloseable.hpp>
29 : #include <comphelper/processfactory.hxx>
30 : #include <comphelper/string.hxx>
31 : #include <cppuhelper/implbase1.hxx>
32 :
33 : #include <sfx2/childwin.hxx>
34 : #include <sfx2/app.hxx>
35 : #include <sfx2/bindings.hxx>
36 : #include <sfx2/module.hxx>
37 : #include <sfx2/dockwin.hxx>
38 : #include <sfx2/dispatch.hxx>
39 : #include "workwin.hxx"
40 :
41 : static const sal_uInt16 nVersion = 2;
42 :
43 21996 : struct SfxChildWindow_Impl
44 : {
45 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > xFrame;
46 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > xListener;
47 : SfxChildWinFactory* pFact;
48 : bool bHideNotDelete;
49 : bool bVisible;
50 : bool bHideAtToggle;
51 : bool bWantsFocus;
52 : SfxModule* pContextModule;
53 : SfxWorkWindow* pWorkWin;
54 : };
55 :
56 :
57 :
58 4 : class DisposeListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener >
59 : {
60 : public:
61 2 : DisposeListener( SfxChildWindow* pOwner ,
62 : SfxChildWindow_Impl* pData )
63 : : m_pOwner( pOwner )
64 2 : , m_pData ( pData )
65 2 : {}
66 :
67 2 : virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aSource ) throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE
68 : {
69 2 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > xSelfHold( this );
70 :
71 4 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComp( aSource.Source, ::com::sun::star::uno::UNO_QUERY );
72 2 : if( xComp.is() )
73 2 : xComp->removeEventListener( this );
74 :
75 2 : if( m_pOwner && m_pData )
76 : {
77 2 : m_pData->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >();
78 :
79 2 : if ( m_pData->pWorkWin )
80 : {
81 : // m_pOwner and m_pData will be killed
82 0 : m_pData->xFrame = ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >();
83 0 : m_pData->pWorkWin->GetBindings().Execute( m_pOwner->GetType() );
84 : }
85 : else
86 : {
87 2 : delete m_pOwner;
88 : }
89 :
90 2 : m_pOwner = NULL;
91 2 : m_pData = NULL;
92 2 : }
93 2 : }
94 :
95 : private:
96 : SfxChildWindow* m_pOwner;
97 : SfxChildWindow_Impl* m_pData ;
98 : };
99 :
100 :
101 :
102 4906 : bool GetPosSizeFromString( const OUString& rStr, Point& rPos, Size& rSize )
103 : {
104 4906 : if ( comphelper::string::getTokenCount(rStr, '/') != 4 )
105 0 : return false;
106 :
107 4906 : sal_Int32 nIdx = 0;
108 4906 : rPos.X() = rStr.getToken(0, '/', nIdx).toInt32();
109 4906 : rPos.Y() = rStr.getToken(0, '/', nIdx).toInt32();
110 4906 : rSize.Width() = rStr.getToken(0, '/', nIdx).toInt32();
111 4906 : rSize.Height() = rStr.getToken(0, '/', nIdx).toInt32();
112 :
113 : // negative sizes are invalid
114 4906 : if ( rSize.Width() < 0 || rSize.Height() < 0 )
115 0 : return false;
116 :
117 4906 : return true;
118 : }
119 :
120 4906 : bool GetSplitSizeFromString( const OUString& rStr, Size& rSize )
121 : {
122 4906 : sal_Int32 nIndex = rStr.indexOf( ',' );
123 4906 : if ( nIndex != -1 )
124 : {
125 4906 : OUString aStr = rStr.copy( nIndex+1 );
126 :
127 4906 : sal_Int32 nCount = comphelper::string::getTokenCount(aStr, ';');
128 4906 : if ( nCount != 2 )
129 0 : return false;
130 :
131 4906 : rSize.Width() = aStr.getToken(0, ';' ).toInt32();
132 4906 : rSize.Height() = aStr.getToken(1, ';' ).toInt32();
133 :
134 : // negative sizes are invalid
135 4906 : if ( rSize.Width() < 0 || rSize.Height() < 0 )
136 0 : return false;
137 :
138 4906 : return true;
139 : }
140 :
141 0 : return false;
142 : }
143 :
144 :
145 10998 : SfxChildWindow::SfxChildWindow(vcl::Window *pParentWindow, sal_uInt16 nId)
146 : : pParent(pParentWindow)
147 : , nType(nId)
148 : , eChildAlignment(SFX_ALIGN_NOALIGNMENT)
149 10998 : , pWindow(0L)
150 : {
151 10998 : pImp = new SfxChildWindow_Impl;
152 10998 : pImp->pFact = 0L;
153 10998 : pImp->bHideNotDelete = false;
154 10998 : pImp->bHideAtToggle = false;
155 10998 : pImp->bWantsFocus = true;
156 10998 : pImp->bVisible = true;
157 10998 : pImp->pContextModule = NULL;
158 10998 : pImp->pWorkWin = NULL;
159 :
160 10998 : pContext = 0L;
161 10998 : }
162 :
163 10998 : void SfxChildWindow::Destroy()
164 : {
165 10998 : if ( GetFrame().is() )
166 : {
167 2 : pImp->pWorkWin = NULL;
168 : try
169 : {
170 2 : ::com::sun::star::uno::Reference < ::com::sun::star::util::XCloseable > xClose( GetFrame(), ::com::sun::star::uno::UNO_QUERY );
171 2 : if ( xClose.is() )
172 2 : xClose->close( sal_True );
173 : else
174 0 : GetFrame()->dispose();
175 : }
176 0 : catch (const com::sun::star::uno::Exception&)
177 : {
178 : }
179 : }
180 : else
181 10996 : delete this;
182 10998 : }
183 :
184 :
185 10998 : SfxChildWindow::~SfxChildWindow()
186 : {
187 10998 : delete pContext;
188 10998 : delete pWindow;
189 10998 : delete pImp;
190 10998 : }
191 :
192 :
193 10998 : SfxChildWindow* SfxChildWindow::CreateChildWindow( sal_uInt16 nId,
194 : vcl::Window *pParent, SfxBindings* pBindings, SfxChildWinInfo& rInfo)
195 : {
196 10998 : SfxChildWindow *pChild=0;
197 10998 : SfxChildWinFactory* pFact=0;
198 10998 : sal_uInt16 nOldMode = Application::GetSystemWindowMode();
199 :
200 : // First search for ChildWindow in SDT; "Overloading has to be realized
201 : // by using ChildWindowContext
202 10998 : SfxApplication *pApp = SfxGetpApp();
203 : {
204 10998 : SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
205 188786 : for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
206 : {
207 183418 : pFact = &rFactories[nFactory];
208 183418 : if ( pFact->nId == nId )
209 : {
210 5630 : SfxChildWinInfo& rFactInfo = pFact->aInfo;
211 5630 : if ( rInfo.bVisible )
212 : {
213 5630 : if ( pBindings )
214 5630 : pBindings->ENTERREGISTRATIONS();
215 5630 : SfxChildWinInfo aInfo = rFactInfo;
216 5630 : Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE );
217 5630 : pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
218 5630 : Application::SetSystemWindowMode( nOldMode );
219 5630 : if ( pBindings )
220 5630 : pBindings->LEAVEREGISTRATIONS();
221 : }
222 :
223 5630 : break;
224 : }
225 : }
226 : }
227 :
228 10998 : SfxDispatcher *pDisp = pBindings ? pBindings->GetDispatcher_Impl() : NULL;
229 10998 : SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) : NULL;
230 10998 : if (!pChild && pMod)
231 : {
232 5368 : SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
233 5368 : if ( pFactories )
234 : {
235 5368 : SfxChildWinFactArr_Impl &rFactories = *pFactories;
236 92280 : for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
237 : {
238 92280 : pFact = &rFactories[nFactory];
239 92280 : if ( pFact->nId == nId )
240 : {
241 5368 : SfxChildWinInfo& rFactInfo = pFact->aInfo;
242 5368 : if ( rInfo.bVisible )
243 : {
244 5368 : if ( pBindings )
245 5368 : pBindings->ENTERREGISTRATIONS();
246 5368 : SfxChildWinInfo aInfo = rFactInfo;
247 5368 : Application::SetSystemWindowMode( SYSTEMWINDOW_MODE_NOAUTOMODE );
248 5368 : pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
249 5368 : Application::SetSystemWindowMode( nOldMode );
250 5368 : if ( pBindings )
251 5368 : pBindings->LEAVEREGISTRATIONS();
252 : }
253 :
254 5368 : break;
255 : }
256 : }
257 : }
258 : }
259 :
260 10998 : if ( pChild )
261 10998 : pChild->SetFactory_Impl( pFact );
262 :
263 : DBG_ASSERT(pFact && (pChild || !rInfo.bVisible), "ChildWindow-Typ not registered!");
264 :
265 10998 : if ( pChild && !pChild->pWindow )
266 : {
267 0 : DELETEZ(pChild);
268 : DBG_WARNING("ChildWindow has no Window!");
269 : }
270 :
271 10998 : return pChild;
272 : }
273 :
274 :
275 11165 : void SfxChildWindow::SaveStatus(const SfxChildWinInfo& rInfo)
276 : {
277 11165 : sal_uInt16 nID = GetType();
278 :
279 11165 : OUStringBuffer aWinData;
280 11165 : aWinData.append('V').append(static_cast<sal_Int32>(nVersion)).
281 22330 : append(',').append(rInfo.bVisible ? 'V' : 'H').append(',').
282 22330 : append(static_cast<sal_Int32>(rInfo.nFlags));
283 11165 : if ( !rInfo.aExtraString.isEmpty() )
284 : {
285 5142 : aWinData.append(',');
286 5142 : aWinData.append(rInfo.aExtraString);
287 : }
288 :
289 22330 : OUString sName(OUString::number(nID));
290 : //Try and save window state per-module, e.g. sidebar on in one application
291 : //but off in another
292 11165 : if (!rInfo.aModule.isEmpty())
293 10913 : sName = rInfo.aModule + "/" + sName;
294 22330 : SvtViewOptions aWinOpt(E_WINDOW, sName);
295 11165 : aWinOpt.SetWindowState(OStringToOUString(rInfo.aWinState, RTL_TEXTENCODING_UTF8));
296 :
297 22330 : ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq(1);
298 11165 : aSeq[0].Name = "Data";
299 11165 : aSeq[0].Value <<= aWinData.makeStringAndClear();
300 11165 : aWinOpt.SetUserData( aSeq );
301 :
302 : // ... but save status at runtime!
303 22330 : pImp->pFact->aInfo = rInfo;
304 11165 : }
305 :
306 :
307 4906 : void SfxChildWindow::SetAlignment(SfxChildAlignment eAlign)
308 : {
309 :
310 4906 : eChildAlignment = eAlign;
311 4906 : }
312 :
313 :
314 11167 : SfxChildWinInfo SfxChildWindow::GetInfo() const
315 : {
316 :
317 11167 : SfxChildWinInfo aInfo(pImp->pFact->aInfo);
318 11167 : aInfo.aPos = pWindow->GetPosPixel();
319 11167 : aInfo.aSize = pWindow->GetSizePixel();
320 11167 : if ( pWindow->IsSystemWindow() )
321 : {
322 43 : sal_uIntPtr nMask = WINDOWSTATE_MASK_POS | WINDOWSTATE_MASK_STATE;
323 43 : if ( pWindow->GetStyle() & WB_SIZEABLE )
324 0 : nMask |= ( WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT );
325 43 : aInfo.aWinState = static_cast<SystemWindow*>(pWindow)->GetWindowState( nMask );
326 : }
327 11124 : else if ( pWindow->GetType() == RSC_DOCKINGWINDOW )
328 : {
329 5142 : if (static_cast<DockingWindow*>(pWindow)->GetFloatingWindow() )
330 0 : aInfo.aWinState = static_cast<DockingWindow*>(pWindow)->GetFloatingWindow()->GetWindowState();
331 : else
332 : {
333 5142 : SfxChildWinInfo aTmpInfo;
334 5142 : static_cast<SfxDockingWindow*>(pWindow)->FillInfo( aTmpInfo );
335 5142 : aInfo.aExtraString = aTmpInfo.aExtraString;
336 : }
337 : }
338 :
339 11167 : aInfo.bVisible = pImp->bVisible;
340 11167 : aInfo.nFlags = 0;
341 11167 : return aInfo;
342 : }
343 :
344 :
345 10998 : sal_uInt16 SfxChildWindow::GetPosition()
346 : {
347 10998 : return pImp->pFact->nPos;
348 : }
349 :
350 :
351 173509 : void SfxChildWindow::InitializeChildWinFactory_Impl(sal_uInt16 nId, SfxChildWinInfo& rInfo)
352 : {
353 : // load configuration
354 :
355 173509 : boost::scoped_ptr<SvtViewOptions> xWinOpt;
356 : // first see if a module specific id exists
357 173509 : if (rInfo.aModule.getLength())
358 173297 : xWinOpt.reset(new SvtViewOptions(E_WINDOW, rInfo.aModule + "/" + OUString::number(nId)));
359 :
360 : // if not then try the generic id
361 173509 : if (!xWinOpt || !xWinOpt->Exists())
362 162859 : xWinOpt.reset(new SvtViewOptions(E_WINDOW, OUString::number(nId)));
363 :
364 173509 : if (xWinOpt->Exists() && xWinOpt->HasVisible() )
365 5406 : rInfo.bVisible = xWinOpt->IsVisible(); // set state from configuration. Can be overwritten by UserData, see below
366 :
367 347018 : ::com::sun::star::uno::Sequence < ::com::sun::star::beans::NamedValue > aSeq = xWinOpt->GetUserData();
368 :
369 347018 : OUString aTmp;
370 173509 : if ( aSeq.getLength() )
371 10680 : aSeq[0].Value >>= aTmp;
372 :
373 347018 : OUString aWinData( aTmp );
374 173509 : rInfo.aWinState = OUStringToOString(xWinOpt->GetWindowState(), RTL_TEXTENCODING_UTF8);
375 :
376 :
377 173509 : if ( !aWinData.isEmpty() )
378 : {
379 : // Search for version ID
380 10680 : if ( aWinData[0] != 0x0056 ) // 'V' = 56h
381 : // A version ID, so do not use
382 0 : return;
383 :
384 : // Delete 'V'
385 10680 : aWinData = aWinData.copy(1);
386 :
387 : // Read version
388 10680 : char cToken = ',';
389 10680 : sal_Int32 nPos = aWinData.indexOf( cToken );
390 10680 : sal_uInt16 nActVersion = (sal_uInt16)aWinData.copy( 0, nPos + 1 ).toInt32();
391 10680 : if ( nActVersion != nVersion )
392 0 : return;
393 :
394 10680 : aWinData = aWinData.copy(nPos+1);
395 :
396 : // Load Visibility: is coded as a char
397 10680 : rInfo.bVisible = (aWinData[0] == 0x0056); // 'V' = 56h
398 10680 : aWinData = aWinData.copy(1);
399 10680 : nPos = aWinData.indexOf( cToken );
400 10680 : if (nPos != -1)
401 : {
402 10680 : sal_Int32 nNextPos = aWinData.indexOf( cToken, 2 );
403 10680 : if ( nNextPos != -1 )
404 : {
405 : // there is extra information
406 4906 : rInfo.nFlags = (sal_uInt16)aWinData.copy( nPos+1, nNextPos - nPos - 1 ).toInt32();
407 4906 : aWinData = aWinData.replaceAt( nPos, nNextPos-nPos+1, "" );
408 4906 : rInfo.aExtraString = aWinData;
409 : }
410 : else
411 5774 : rInfo.nFlags = (sal_uInt16)aWinData.copy( nPos+1 ).toInt32();
412 : }
413 173509 : }
414 : }
415 :
416 120 : void SfxChildWindow::CreateContext( sal_uInt16 nContextId, SfxBindings& rBindings )
417 : {
418 120 : SfxChildWindowContext *pCon = NULL;
419 120 : SfxChildWinFactory* pFact=0;
420 120 : SfxApplication *pApp = SfxGetpApp();
421 120 : SfxDispatcher *pDisp = rBindings.GetDispatcher_Impl();
422 120 : SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :0;
423 120 : if ( pMod )
424 : {
425 120 : SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
426 120 : if ( pFactories )
427 : {
428 120 : SfxChildWinFactArr_Impl &rFactories = *pFactories;
429 948 : for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
430 : {
431 948 : pFact = &rFactories[nFactory];
432 948 : if ( pFact->nId == GetType() )
433 : {
434 : DBG_ASSERT( pFact->pArr, "No context registered!" );
435 120 : if ( !pFact->pArr )
436 0 : break;
437 :
438 242 : for ( sal_uInt16 n=0; n<pFact->pArr->size(); ++n )
439 : {
440 122 : SfxChildWinContextFactory *pConFact = &(*pFact->pArr)[n];
441 122 : rBindings.ENTERREGISTRATIONS();
442 122 : if ( pConFact->nContextId == nContextId )
443 : {
444 120 : SfxChildWinInfo aInfo = pFact->aInfo;
445 120 : pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
446 120 : pCon->nContextId = pConFact->nContextId;
447 120 : pImp->pContextModule = pMod;
448 : }
449 122 : rBindings.LEAVEREGISTRATIONS();
450 : }
451 120 : break;
452 : }
453 : }
454 : }
455 : }
456 :
457 120 : if ( !pCon )
458 : {
459 0 : SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
460 0 : for ( sal_uInt16 nFactory = 0; nFactory < rFactories.size(); ++nFactory )
461 : {
462 0 : pFact = &rFactories[nFactory];
463 0 : if ( pFact->nId == GetType() )
464 : {
465 : DBG_ASSERT( pFact->pArr, "No context registered!" );
466 0 : if ( !pFact->pArr )
467 0 : break;
468 :
469 0 : for ( sal_uInt16 n=0; n<pFact->pArr->size(); ++n )
470 : {
471 0 : SfxChildWinContextFactory *pConFact = &(*pFact->pArr)[n];
472 0 : rBindings.ENTERREGISTRATIONS();
473 0 : if ( pConFact->nContextId == nContextId )
474 : {
475 0 : SfxChildWinInfo aInfo = pFact->aInfo;
476 0 : pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
477 0 : pCon->nContextId = pConFact->nContextId;
478 0 : pImp->pContextModule = NULL;
479 : }
480 0 : rBindings.LEAVEREGISTRATIONS();
481 : }
482 0 : break;
483 : }
484 : }
485 : }
486 :
487 120 : if ( !pCon )
488 : {
489 : OSL_FAIL( "No suitable context found! ");
490 120 : return;
491 : }
492 :
493 120 : if ( pContext )
494 0 : delete( pContext );
495 120 : pContext = pCon;
496 120 : pContext->GetWindow()->SetSizePixel( pWindow->GetOutputSizePixel() );
497 120 : pContext->GetWindow()->Show();
498 : }
499 :
500 120 : SfxChildWindowContext::SfxChildWindowContext( sal_uInt16 nId )
501 : : pWindow( NULL )
502 120 : , nContextId( nId )
503 : {
504 120 : }
505 :
506 120 : SfxChildWindowContext::~SfxChildWindowContext()
507 : {
508 120 : delete pWindow;
509 120 : }
510 :
511 118 : FloatingWindow* SfxChildWindowContext::GetFloatingWindow() const
512 : {
513 118 : vcl::Window *pParent = pWindow->GetParent();
514 118 : if (pParent->GetType() == WINDOW_DOCKINGWINDOW || pParent->GetType() == WINDOW_TOOLBOX)
515 : {
516 118 : return static_cast<DockingWindow*>(pParent)->GetFloatingWindow();
517 : }
518 0 : else if (pParent->GetType() == WINDOW_FLOATINGWINDOW)
519 : {
520 0 : return static_cast<FloatingWindow*>(pParent);
521 : }
522 : else
523 : {
524 : OSL_FAIL("No FloatingWindow-Context!");
525 0 : return NULL;
526 : }
527 : }
528 :
529 0 : void SfxChildWindowContext::Resizing( Size& )
530 : {
531 0 : }
532 :
533 0 : bool SfxChildWindowContext::Close()
534 : {
535 0 : return true;
536 : }
537 :
538 10998 : void SfxChildWindow::SetFactory_Impl( SfxChildWinFactory *pF )
539 : {
540 10998 : pImp->pFact = pF;
541 10998 : }
542 :
543 4948 : void SfxChildWindow::SetHideNotDelete( bool bOn )
544 : {
545 4948 : pImp->bHideNotDelete = bOn;
546 4948 : }
547 :
548 32 : bool SfxChildWindow::IsHideNotDelete() const
549 : {
550 32 : return pImp->bHideNotDelete;
551 : }
552 :
553 126 : bool SfxChildWindow::IsHideAtToggle() const
554 : {
555 126 : return pImp->bHideAtToggle;
556 : }
557 :
558 0 : void SfxChildWindow::SetWantsFocus( bool bSet )
559 : {
560 0 : pImp->bWantsFocus = bSet;
561 0 : }
562 :
563 130 : bool SfxChildWindow::WantsFocus() const
564 : {
565 130 : return pImp->bWantsFocus;
566 : }
567 :
568 0 : bool SfxChildWinInfo::GetExtraData_Impl
569 : (
570 : SfxChildAlignment *pAlign,
571 : SfxChildAlignment *pLastAlign,
572 : Size *pSize,
573 : sal_uInt16 *pLine,
574 : sal_uInt16 *pPos
575 : ) const
576 : {
577 : // invalid?
578 0 : if ( aExtraString.isEmpty() )
579 0 : return false;
580 0 : OUString aStr;
581 0 : sal_Int32 nPos = aExtraString.indexOf("AL:");
582 0 : if ( nPos == -1 )
583 0 : return false;
584 :
585 : // Try to read the alignment string "ALIGN :(...)", but if
586 : // it is not present, then use an older version
587 0 : sal_Int32 n1 = aExtraString.indexOf('(', nPos);
588 0 : if ( n1 != -1 )
589 : {
590 0 : sal_Int32 n2 = aExtraString.indexOf(')', n1);
591 0 : if ( n2 != -1 )
592 : {
593 : // Cut out Alignment string
594 0 : aStr = aExtraString.copy(nPos, n2 - nPos + 1);
595 0 : aStr = aStr.replaceAt(nPos, n1-nPos+1, "");
596 : }
597 : }
598 :
599 : // First extract the Alignment
600 0 : if ( aStr.isEmpty() )
601 0 : return false;
602 0 : if ( pAlign )
603 0 : *pAlign = (SfxChildAlignment) (sal_uInt16) aStr.toInt32();
604 :
605 : // then the LastAlignment
606 0 : nPos = aStr.indexOf(',');
607 0 : if ( nPos == -1 )
608 0 : return false;
609 0 : aStr = aStr.copy(nPos+1);
610 0 : if ( pLastAlign )
611 0 : *pLastAlign = (SfxChildAlignment) (sal_uInt16) aStr.toInt32();
612 :
613 : // Then the splitting information
614 0 : nPos = aStr.indexOf(',');
615 0 : if ( nPos == -1 )
616 : // No docking in a Splitwindow
617 0 : return true;
618 0 : aStr = aStr.copy(nPos+1);
619 0 : Point aChildPos;
620 0 : Size aChildSize;
621 0 : if ( GetPosSizeFromString( aStr, aChildPos, aChildSize ) )
622 : {
623 0 : if ( pSize )
624 0 : *pSize = aChildSize;
625 0 : if ( pLine )
626 0 : *pLine = (sal_uInt16) aChildPos.X();
627 0 : if ( pPos )
628 0 : *pPos = (sal_uInt16) aChildPos.Y();
629 0 : return true;
630 : }
631 0 : return false;
632 : }
633 :
634 0 : bool SfxChildWindow::IsVisible() const
635 : {
636 0 : return pImp->bVisible;
637 : }
638 :
639 128 : void SfxChildWindow::SetVisible_Impl( bool bVis )
640 : {
641 128 : pImp->bVisible = bVis;
642 128 : }
643 :
644 10998 : void SfxChildWindow::Hide()
645 : {
646 10998 : switch ( pWindow->GetType() )
647 : {
648 : case RSC_DOCKINGWINDOW :
649 5016 : static_cast<DockingWindow*>(pWindow)->Hide();
650 5016 : break;
651 : case RSC_TOOLBOX :
652 542 : static_cast<ToolBox*>(pWindow)->Hide();
653 542 : break;
654 : default:
655 5440 : pWindow->Hide();
656 5440 : break;
657 : }
658 10998 : }
659 :
660 36 : void SfxChildWindow::Show( sal_uInt16 nFlags )
661 : {
662 36 : switch ( pWindow->GetType() )
663 : {
664 : case RSC_DOCKINGWINDOW :
665 0 : static_cast<DockingWindow*>(pWindow)->Show( true, nFlags );
666 0 : break;
667 : case RSC_TOOLBOX :
668 0 : static_cast<ToolBox*>(pWindow)->Show( true, nFlags );
669 0 : break;
670 : default:
671 36 : pWindow->Show( true, nFlags );
672 36 : break;
673 : }
674 36 : }
675 :
676 8 : vcl::Window* SfxChildWindow::GetContextWindow( SfxModule *pModule ) const
677 : {
678 8 : return pModule == pImp->pContextModule && pContext ? pContext->GetWindow(): 0;
679 : }
680 :
681 10998 : void SfxChildWindow::SetWorkWindow_Impl( SfxWorkWindow* pWin )
682 : {
683 10998 : pImp->pWorkWin = pWin;
684 10998 : if ( pWin && pWindow->HasChildPathFocus() )
685 0 : pImp->pWorkWin->SetActiveChild_Impl( pWindow );
686 10998 : }
687 :
688 0 : void SfxChildWindow::Activate_Impl()
689 : {
690 0 : if(pImp->pWorkWin!=NULL)
691 0 : pImp->pWorkWin->SetActiveChild_Impl( pWindow );
692 0 : }
693 :
694 20 : void SfxChildWindow::Deactivate_Impl()
695 : {
696 20 : }
697 :
698 170 : bool SfxChildWindow::QueryClose()
699 : {
700 170 : bool bAllow = true;
701 :
702 170 : if ( pImp->xFrame.is() )
703 : {
704 0 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XController > xCtrl = pImp->xFrame->getController();
705 0 : if ( xCtrl.is() )
706 0 : bAllow = xCtrl->suspend( sal_True );
707 : }
708 :
709 170 : if ( bAllow )
710 170 : bAllow = !GetWindow()->IsInModalMode();
711 :
712 170 : return bAllow;
713 : }
714 :
715 16548 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxChildWindow::GetFrame()
716 : {
717 16548 : return pImp->xFrame;
718 : }
719 :
720 2 : void SfxChildWindow::SetFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > & rFrame )
721 : {
722 : // Do nothing if nothing will be changed ...
723 2 : if( pImp->xFrame != rFrame )
724 : {
725 : // ... but stop listening on old frame, if connection exist!
726 2 : if( pImp->xFrame.is() )
727 0 : pImp->xFrame->removeEventListener( pImp->xListener );
728 :
729 : // If new frame isnt NULL -> we must guarantee valid listener for disposing events.
730 : // Use already existing or create new one.
731 2 : if( rFrame.is() )
732 2 : if( !pImp->xListener.is() )
733 2 : pImp->xListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >( new DisposeListener( this, pImp ) );
734 :
735 : // Set new frame in data container
736 : // and build new listener connection, if necessary.
737 2 : pImp->xFrame = rFrame;
738 2 : if( pImp->xFrame.is() )
739 2 : pImp->xFrame->addEventListener( pImp->xListener );
740 : }
741 2 : }
742 :
743 5982 : bool SfxChildWindow::CanGetFocus() const
744 : {
745 5982 : return !(pImp->pFact->aInfo.nFlags & SFX_CHILDWIN_CANTGETFOCUS);
746 : }
747 :
748 236 : void SfxChildWindowContext::RegisterChildWindowContext(SfxModule* pMod, sal_uInt16 nId, SfxChildWinContextFactory* pFact)
749 : {
750 236 : SfxGetpApp()->RegisterChildWindowContext_Impl( pMod, nId, pFact );
751 236 : }
752 :
753 10216 : void SfxChildWindow::RegisterChildWindow(SfxModule* pMod, SfxChildWinFactory* pFact)
754 : {
755 10216 : SfxGetpApp()->RegisterChildWindow_Impl( pMod, pFact );
756 11167 : }
757 :
758 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
