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