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 :
21 : #include <vcl/svapp.hxx>
22 : #include <vcl/window.hxx>
23 : #include <vcl/wall.hxx>
24 : #include <osl/mutex.hxx>
25 : #include <toolkit/controls/dialogcontrol.hxx>
26 : #include <toolkit/controls/geometrycontrolmodel.hxx>
27 : #include <toolkit/helper/property.hxx>
28 : #include <toolkit/controls/stdtabcontroller.hxx>
29 : #include <com/sun/star/awt/PosSize.hpp>
30 : #include <com/sun/star/awt/WindowAttribute.hpp>
31 : #include <com/sun/star/resource/XStringResourceResolver.hpp>
32 : #include <com/sun/star/uno/XComponentContext.hpp>
33 : #include <com/sun/star/graphic/XGraphicProvider.hpp>
34 : #include <cppuhelper/supportsservice.hxx>
35 : #include <cppuhelper/typeprovider.hxx>
36 : #include <cppuhelper/queryinterface.hxx>
37 : #include <tools/debug.hxx>
38 : #include <tools/diagnose_ex.h>
39 : #include <comphelper/sequence.hxx>
40 : #include <vcl/outdev.hxx>
41 :
42 : #include <toolkit/helper/vclunohelper.hxx>
43 : #include <unotools/ucbstreamhelper.hxx>
44 : #include <vcl/graph.hxx>
45 : #include <vcl/image.hxx>
46 : #include <cppuhelper/implbase1.hxx>
47 : #include <algorithm>
48 : #include <functional>
49 : #include <map>
50 : #include <unordered_map>
51 : #include "osl/file.hxx"
52 :
53 : #include <vcl/tabctrl.hxx>
54 : #include <toolkit/awt/vclxwindows.hxx>
55 : #include "toolkit/controls/unocontrols.hxx"
56 :
57 : #include "helper/unopropertyarrayhelper.hxx"
58 : #include "controlmodelcontainerbase_internal.hxx"
59 :
60 : using namespace ::com::sun::star;
61 : using namespace ::com::sun::star::uno;
62 : using namespace ::com::sun::star::awt;
63 : using namespace ::com::sun::star::lang;
64 : using namespace ::com::sun::star::container;
65 : using namespace ::com::sun::star::beans;
66 : using namespace ::com::sun::star::util;
67 :
68 : #define PROPERTY_DIALOGSOURCEURL OUString( "DialogSourceURL" )
69 : #define PROPERTY_IMAGEURL OUString( "ImageURL" )
70 : #define PROPERTY_GRAPHIC OUString( "Graphic" )
71 :
72 :
73 : // we probably will need both a hash of control models and hash of controls
74 : // => use some template magic
75 :
76 : typedef ::cppu::WeakImplHelper1< container::XNameContainer > SimpleNameContainer_BASE;
77 :
78 : template< typename T >
79 30 : class SimpleNamedThingContainer : public SimpleNameContainer_BASE
80 : {
81 : typedef std::unordered_map< OUString, Reference< T >, OUStringHash,
82 : std::equal_to< OUString > > NamedThingsHash;
83 : NamedThingsHash things;
84 : ::osl::Mutex m_aMutex;
85 : public:
86 : // ::com::sun::star::container::XNameContainer, XNameReplace, XNameAccess
87 0 : virtual void SAL_CALL replaceByName( const OUString& aName, const Any& aElement ) throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE
88 : {
89 0 : ::osl::MutexGuard aGuard( m_aMutex );
90 0 : if ( !hasByName( aName ) )
91 0 : throw NoSuchElementException();
92 0 : Reference< T > xElement;
93 0 : if ( ! ( aElement >>= xElement ) )
94 0 : throw IllegalArgumentException();
95 0 : things[ aName ] = xElement;
96 0 : }
97 9 : virtual Any SAL_CALL getByName( const OUString& aName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE
98 : {
99 9 : ::osl::MutexGuard aGuard( m_aMutex );
100 9 : if ( !hasByName( aName ) )
101 0 : throw NoSuchElementException();
102 9 : return uno::makeAny( things[ aName ] );
103 : }
104 1 : virtual Sequence< OUString > SAL_CALL getElementNames( ) throw(RuntimeException, std::exception) SAL_OVERRIDE
105 : {
106 1 : ::osl::MutexGuard aGuard( m_aMutex );
107 1 : Sequence< OUString > aResult( things.size() );
108 1 : typename NamedThingsHash::iterator it = things.begin();
109 1 : typename NamedThingsHash::iterator it_end = things.end();
110 1 : OUString* pName = aResult.getArray();
111 3 : for (; it != it_end; ++it, ++pName )
112 2 : *pName = it->first;
113 1 : return aResult;
114 : }
115 62 : virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) throw(RuntimeException, std::exception) SAL_OVERRIDE
116 : {
117 62 : ::osl::MutexGuard aGuard( m_aMutex );
118 62 : return ( things.find( aName ) != things.end() );
119 : }
120 32 : virtual void SAL_CALL insertByName( const OUString& aName, const Any& aElement ) throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE
121 : {
122 32 : ::osl::MutexGuard aGuard( m_aMutex );
123 32 : if ( hasByName( aName ) )
124 0 : throw ElementExistException();
125 64 : Reference< T > xElement;
126 32 : if ( ! ( aElement >>= xElement ) )
127 0 : throw IllegalArgumentException();
128 64 : things[ aName ] = xElement;
129 32 : }
130 7 : virtual void SAL_CALL removeByName( const OUString& aName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE
131 : {
132 7 : ::osl::MutexGuard aGuard( m_aMutex );
133 7 : if ( !hasByName( aName ) )
134 0 : throw NoSuchElementException();
135 7 : things.erase( things.find( aName ) );
136 7 : }
137 0 : virtual Type SAL_CALL getElementType( ) throw (RuntimeException, std::exception) SAL_OVERRIDE
138 : {
139 0 : return cppu::UnoType<T>::get();
140 : }
141 0 : virtual sal_Bool SAL_CALL hasElements( ) throw (RuntimeException, std::exception) SAL_OVERRIDE
142 : {
143 0 : ::osl::MutexGuard aGuard( m_aMutex );
144 0 : return ( !things.empty() );
145 : }
146 : };
147 :
148 : namespace {
149 :
150 : class UnoControlDialogModel : public ControlModelContainerBase
151 : {
152 : protected:
153 : css::uno::Reference< css::graphic::XGraphicObject > mxGrfObj;
154 : css::uno::Any ImplGetDefaultValue( sal_uInt16 nPropId ) const SAL_OVERRIDE;
155 : ::cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() SAL_OVERRIDE;
156 : // ::cppu::OPropertySetHelper
157 : void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue ) throw (css::uno::Exception, std::exception) SAL_OVERRIDE;
158 : public:
159 : explicit UnoControlDialogModel( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
160 : UnoControlDialogModel( const UnoControlDialogModel& rModel );
161 : virtual ~UnoControlDialogModel();
162 :
163 : UnoControlModel* Clone() const SAL_OVERRIDE;
164 : // css::beans::XMultiPropertySet
165 : css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo( ) throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
166 :
167 : // css::io::XPersistObject
168 : OUString SAL_CALL getServiceName() throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
169 :
170 : // XServiceInfo
171 6 : OUString SAL_CALL getImplementationName()
172 : throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE
173 6 : { return OUString("stardiv.Toolkit.UnoControlDialogModel"); }
174 :
175 9 : css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames()
176 : throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE
177 : {
178 9 : auto s(ControlModelContainerBase::getSupportedServiceNames());
179 9 : s.realloc(s.getLength() + 2);
180 9 : s[s.getLength() - 2] = "com.sun.star.awt.UnoControlDialogModel";
181 9 : s[s.getLength() - 1] = "stardiv.vcl.controlmodel.Dialog";
182 9 : return s;
183 : }
184 : };
185 :
186 14 : UnoControlDialogModel::UnoControlDialogModel( const Reference< XComponentContext >& rxContext )
187 14 : :ControlModelContainerBase( rxContext )
188 : {
189 14 : ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
190 : // ImplRegisterProperty( BASEPROPERTY_BORDER );
191 14 : ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
192 14 : ImplRegisterProperty( BASEPROPERTY_ENABLED );
193 14 : ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
194 : // ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
195 14 : ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
196 14 : ImplRegisterProperty( BASEPROPERTY_HELPURL );
197 14 : ImplRegisterProperty( BASEPROPERTY_TITLE );
198 14 : ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
199 14 : ImplRegisterProperty( BASEPROPERTY_DESKTOP_AS_PARENT );
200 14 : ImplRegisterProperty( BASEPROPERTY_DECORATION );
201 14 : ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
202 14 : ImplRegisterProperty( BASEPROPERTY_GRAPHIC );
203 14 : ImplRegisterProperty( BASEPROPERTY_IMAGEURL );
204 14 : ImplRegisterProperty( BASEPROPERTY_HSCROLL );
205 14 : ImplRegisterProperty( BASEPROPERTY_VSCROLL );
206 14 : ImplRegisterProperty( BASEPROPERTY_SCROLLWIDTH );
207 14 : ImplRegisterProperty( BASEPROPERTY_SCROLLHEIGHT );
208 14 : ImplRegisterProperty( BASEPROPERTY_SCROLLTOP );
209 14 : ImplRegisterProperty( BASEPROPERTY_SCROLLLEFT );
210 :
211 14 : Any aBool;
212 14 : aBool <<= true;
213 14 : ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
214 14 : ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
215 : // #TODO separate class for 'UserForm' ( instead of re-using Dialog ? )
216 28 : uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >();
217 28 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
218 14 : }
219 :
220 1 : UnoControlDialogModel::UnoControlDialogModel( const UnoControlDialogModel& rModel )
221 1 : : ControlModelContainerBase( rModel )
222 : {
223 : // need to clone BASEPROPERTY_USERFORMCONTAINEES too
224 1 : Reference< XNameContainer > xSrcNameCont( const_cast< UnoControlDialogModel& >(rModel).getPropertyValue( GetPropertyName( BASEPROPERTY_USERFORMCONTAINEES ) ), UNO_QUERY );
225 2 : Reference<XNameContainer > xNameCont( new SimpleNamedThingContainer< XControlModel >() );
226 :
227 2 : uno::Sequence< OUString > sNames = xSrcNameCont->getElementNames();
228 1 : OUString* pName = sNames.getArray();
229 1 : OUString* pNamesEnd = pName + sNames.getLength();
230 3 : for ( ; pName != pNamesEnd; ++pName )
231 : {
232 2 : if ( xSrcNameCont->hasByName( *pName ) )
233 2 : xNameCont->insertByName( *pName, xSrcNameCont->getByName( *pName ) );
234 : }
235 2 : setFastPropertyValue_NoBroadcast( BASEPROPERTY_USERFORMCONTAINEES, makeAny( xNameCont ) );
236 1 : }
237 :
238 6 : UnoControlDialogModel::~UnoControlDialogModel()
239 : {
240 6 : }
241 :
242 1 : UnoControlModel* UnoControlDialogModel::Clone() const
243 : {
244 : // clone the container itself
245 1 : UnoControlDialogModel* pClone = new UnoControlDialogModel( *this );
246 :
247 1 : Clone_Impl(*pClone);
248 :
249 1 : return pClone;
250 : }
251 :
252 :
253 0 : OUString UnoControlDialogModel::getServiceName( ) throw(RuntimeException, std::exception)
254 : {
255 0 : return OUString("stardiv.vcl.controlmodel.Dialog");
256 : }
257 :
258 417 : Any UnoControlDialogModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
259 : {
260 417 : Any aAny;
261 :
262 417 : switch ( nPropId )
263 : {
264 : case BASEPROPERTY_DEFAULTCONTROL:
265 14 : aAny <<= OUString::createFromAscii( szServiceName_UnoControlDialog );
266 14 : break;
267 : case BASEPROPERTY_SCROLLWIDTH:
268 : case BASEPROPERTY_SCROLLHEIGHT:
269 : case BASEPROPERTY_SCROLLTOP:
270 : case BASEPROPERTY_SCROLLLEFT:
271 76 : aAny <<= sal_Int32(0);
272 76 : break;
273 : default:
274 327 : aAny = UnoControlModel::ImplGetDefaultValue( nPropId );
275 : }
276 :
277 417 : return aAny;
278 : }
279 :
280 3369 : ::cppu::IPropertyArrayHelper& UnoControlDialogModel::getInfoHelper()
281 : {
282 : static UnoPropertyArrayHelper* pHelper = NULL;
283 3369 : if ( !pHelper )
284 : {
285 7 : Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
286 7 : pHelper = new UnoPropertyArrayHelper( aIDs );
287 : }
288 3369 : return *pHelper;
289 : }
290 :
291 : // XMultiPropertySet
292 7 : Reference< XPropertySetInfo > UnoControlDialogModel::getPropertySetInfo( ) throw(RuntimeException, std::exception)
293 : {
294 7 : static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
295 7 : return xInfo;
296 : }
297 :
298 222 : void SAL_CALL UnoControlDialogModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const ::com::sun::star::uno::Any& rValue ) throw (::com::sun::star::uno::Exception, std::exception)
299 : {
300 222 : ControlModelContainerBase::setFastPropertyValue_NoBroadcast( nHandle, rValue );
301 : try
302 : {
303 222 : if ( nHandle == BASEPROPERTY_IMAGEURL && ImplHasProperty( BASEPROPERTY_GRAPHIC ) )
304 : {
305 2 : OUString sImageURL;
306 2 : OSL_VERIFY( rValue >>= sImageURL );
307 2 : setPropertyValue( GetPropertyName( BASEPROPERTY_GRAPHIC ), uno::makeAny( ImageHelper::getGraphicAndGraphicObjectFromURL_nothrow( mxGrfObj, sImageURL ) ) );
308 : }
309 : }
310 0 : catch( const ::com::sun::star::uno::Exception& )
311 : {
312 : OSL_ENSURE( false, "UnoControlDialogModel::setFastPropertyValue_NoBroadcast: caught an exception while setting ImageURL properties!" );
313 : }
314 222 : }
315 :
316 : }
317 :
318 :
319 : // = class UnoDialogControl
320 :
321 :
322 8 : UnoDialogControl::UnoDialogControl( const uno::Reference< uno::XComponentContext >& rxContext )
323 : :UnoDialogControl_Base( rxContext )
324 : ,maTopWindowListeners( *this )
325 8 : ,mbWindowListener(false)
326 : {
327 8 : maComponentInfos.nWidth = 300;
328 8 : maComponentInfos.nHeight = 450;
329 8 : }
330 :
331 4 : UnoDialogControl::~UnoDialogControl()
332 : {
333 4 : }
334 :
335 4 : OUString UnoDialogControl::GetComponentServiceName()
336 : {
337 :
338 4 : bool bDecoration( true );
339 4 : ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
340 4 : if ( bDecoration )
341 4 : return OUString("Dialog");
342 : else
343 0 : return OUString("TabPage");
344 : }
345 :
346 6 : void UnoDialogControl::dispose() throw(RuntimeException, std::exception)
347 : {
348 6 : SolarMutexGuard aGuard;
349 :
350 12 : EventObject aEvt;
351 6 : aEvt.Source = static_cast< ::cppu::OWeakObject* >( this );
352 6 : maTopWindowListeners.disposeAndClear( aEvt );
353 12 : ControlContainerBase::dispose();
354 6 : }
355 :
356 6 : void SAL_CALL UnoDialogControl::disposing(
357 : const EventObject& Source )
358 : throw(RuntimeException, std::exception)
359 : {
360 6 : ControlContainerBase::disposing( Source );
361 6 : }
362 :
363 13 : sal_Bool UnoDialogControl::setModel( const Reference< XControlModel >& rxModel ) throw(RuntimeException, std::exception)
364 : {
365 : // #Can we move all the Resource stuff to the ControlContainerBase ?
366 13 : SolarMutexGuard aGuard;
367 13 : bool bRet = ControlContainerBase::setModel( rxModel );
368 13 : ImplStartListingForResourceEvents();
369 13 : return bRet;
370 : }
371 :
372 4 : void UnoDialogControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) throw(RuntimeException, std::exception)
373 : {
374 4 : SolarMutexGuard aGuard;
375 :
376 4 : UnoControlContainer::createPeer( rxToolkit, rParentPeer );
377 :
378 8 : Reference < XTopWindow > xTW( getPeer(), UNO_QUERY );
379 4 : if ( xTW.is() )
380 : {
381 4 : xTW->setMenuBar( mxMenuBar );
382 :
383 4 : if ( !mbWindowListener )
384 : {
385 4 : Reference< XWindowListener > xWL( static_cast< cppu::OWeakObject*>( this ), UNO_QUERY );
386 4 : addWindowListener( xWL );
387 4 : mbWindowListener = true;
388 : }
389 :
390 4 : if ( maTopWindowListeners.getLength() )
391 0 : xTW->addTopWindowListener( &maTopWindowListeners );
392 : // there must be a better way than doing this, we can't
393 : // process the scrolltop & scrollleft in XDialog because
394 : // the children haven't been added when those props are applied
395 4 : ImplSetPeerProperty( GetPropertyName( BASEPROPERTY_SCROLLTOP ), ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_SCROLLTOP ) ) );
396 4 : ImplSetPeerProperty( GetPropertyName( BASEPROPERTY_SCROLLLEFT ), ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_SCROLLLEFT ) ) );
397 :
398 4 : }
399 4 : }
400 :
401 1 : OUString UnoDialogControl::getImplementationName()
402 : throw (css::uno::RuntimeException, std::exception)
403 : {
404 1 : return OUString("stardiv.Toolkit.UnoDialogControl");
405 : }
406 :
407 0 : sal_Bool UnoDialogControl::supportsService(OUString const & ServiceName)
408 : throw (css::uno::RuntimeException, std::exception)
409 : {
410 0 : return cppu::supportsService(this, ServiceName);
411 : }
412 :
413 1 : css::uno::Sequence<OUString> UnoDialogControl::getSupportedServiceNames()
414 : throw (css::uno::RuntimeException, std::exception)
415 : {
416 : return css::uno::Sequence<OUString>{
417 : OUString::createFromAscii(szServiceName2_UnoControlDialog),
418 1 : "stardiv.vcl.control.Dialog"};
419 : }
420 :
421 4 : void UnoDialogControl::PrepareWindowDescriptor( ::com::sun::star::awt::WindowDescriptor& rDesc )
422 : {
423 4 : UnoControlContainer::PrepareWindowDescriptor( rDesc );
424 4 : bool bDecoration( true );
425 4 : ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
426 4 : if ( !bDecoration )
427 : {
428 : // Now we have to manipulate the WindowDescriptor
429 0 : rDesc.WindowAttributes = rDesc.WindowAttributes | ::com::sun::star::awt::WindowAttribute::NODECORATION;
430 : }
431 :
432 : // We have to set the graphic property before the peer
433 : // will be created. Otherwise the properties will be copied
434 : // into the peer via propertiesChangeEvents. As the order of
435 : // can lead to overwrites we have to set the graphic property
436 : // before the propertiesChangeEvents are sent!
437 4 : OUString aImageURL;
438 8 : Reference< graphic::XGraphic > xGraphic;
439 8 : if (( ImplGetPropertyValue( PROPERTY_IMAGEURL ) >>= aImageURL ) &&
440 4 : ( !aImageURL.isEmpty() ))
441 : {
442 0 : OUString absoluteUrl = aImageURL;
443 0 : if ( !aImageURL.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
444 0 : absoluteUrl = getPhysicalLocation( ImplGetPropertyValue( PROPERTY_DIALOGSOURCEURL ),
445 0 : uno::makeAny( aImageURL ) );
446 :
447 0 : xGraphic = ImageHelper::getGraphicFromURL_nothrow( absoluteUrl );
448 0 : ImplSetPropertyValue( PROPERTY_GRAPHIC, uno::makeAny( xGraphic ), true );
449 4 : }
450 4 : }
451 :
452 2 : void UnoDialogControl::addTopWindowListener( const Reference< XTopWindowListener >& rxListener ) throw (RuntimeException, std::exception)
453 : {
454 2 : maTopWindowListeners.addInterface( rxListener );
455 2 : if( getPeer().is() && maTopWindowListeners.getLength() == 1 )
456 : {
457 2 : Reference < XTopWindow > xTW( getPeer(), UNO_QUERY );
458 2 : xTW->addTopWindowListener( &maTopWindowListeners );
459 : }
460 2 : }
461 :
462 2 : void UnoDialogControl::removeTopWindowListener( const Reference< XTopWindowListener >& rxListener ) throw (RuntimeException, std::exception)
463 : {
464 2 : if( getPeer().is() && maTopWindowListeners.getLength() == 1 )
465 : {
466 2 : Reference < XTopWindow > xTW( getPeer(), UNO_QUERY );
467 2 : xTW->removeTopWindowListener( &maTopWindowListeners );
468 : }
469 2 : maTopWindowListeners.removeInterface( rxListener );
470 2 : }
471 :
472 0 : void UnoDialogControl::toFront( ) throw (RuntimeException, std::exception)
473 : {
474 0 : SolarMutexGuard aGuard;
475 0 : if ( getPeer().is() )
476 : {
477 0 : Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
478 0 : if( xTW.is() )
479 0 : xTW->toFront();
480 0 : }
481 0 : }
482 :
483 0 : void UnoDialogControl::toBack( ) throw (RuntimeException, std::exception)
484 : {
485 0 : SolarMutexGuard aGuard;
486 0 : if ( getPeer().is() )
487 : {
488 0 : Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
489 0 : if( xTW.is() )
490 0 : xTW->toBack();
491 0 : }
492 0 : }
493 :
494 0 : void UnoDialogControl::setMenuBar( const Reference< XMenuBar >& rxMenuBar ) throw (RuntimeException, std::exception)
495 : {
496 0 : SolarMutexGuard aGuard;
497 0 : mxMenuBar = rxMenuBar;
498 0 : if ( getPeer().is() )
499 : {
500 0 : Reference< XTopWindow > xTW( getPeer(), UNO_QUERY );
501 0 : if( xTW.is() )
502 0 : xTW->setMenuBar( mxMenuBar );
503 0 : }
504 0 : }
505 2 : static ::Size ImplMapPixelToAppFont( OutputDevice* pOutDev, const ::Size& aSize )
506 : {
507 2 : ::Size aTmp = pOutDev->PixelToLogic( aSize, MAP_APPFONT );
508 2 : return aTmp;
509 : }
510 : // ::com::sun::star::awt::XWindowListener
511 2 : void SAL_CALL UnoDialogControl::windowResized( const ::com::sun::star::awt::WindowEvent& e )
512 : throw (::com::sun::star::uno::RuntimeException, std::exception)
513 : {
514 2 : OutputDevice*pOutDev = Application::GetDefaultDevice();
515 : DBG_ASSERT( pOutDev, "Missing Default Device!" );
516 2 : if ( pOutDev && !mbSizeModified )
517 : {
518 : // Currentley we are simply using MAP_APPFONT
519 2 : ::Size aAppFontSize( e.Width, e.Height );
520 :
521 2 : Reference< XControl > xDialogControl( *this, UNO_QUERY_THROW );
522 4 : Reference< XDevice > xDialogDevice( xDialogControl->getPeer(), UNO_QUERY );
523 : OSL_ENSURE( xDialogDevice.is(), "UnoDialogControl::windowResized: no peer, but a windowResized event?" );
524 :
525 : // #i87592 In design mode the drawing layer works with sizes with decoration.
526 : // Therefore we have to subtract them before writing back to the properties (model).
527 2 : if ( xDialogDevice.is() && mbDesignMode )
528 : {
529 0 : DeviceInfo aDeviceInfo( xDialogDevice->getInfo() );
530 0 : aAppFontSize.Width() -= aDeviceInfo.LeftInset + aDeviceInfo.RightInset;
531 0 : aAppFontSize.Height() -= aDeviceInfo.TopInset + aDeviceInfo.BottomInset;
532 : }
533 :
534 2 : aAppFontSize = ImplMapPixelToAppFont( pOutDev, aAppFontSize );
535 :
536 : // Remember that changes have been done by listener. No need to
537 : // update the position because of property change event.
538 2 : mbSizeModified = true;
539 4 : Sequence< OUString > aProps( 2 );
540 4 : Sequence< Any > aValues( 2 );
541 : // Properties in a sequence must be sorted!
542 2 : aProps[0] = "Height";
543 2 : aProps[1] = "Width";
544 2 : aValues[0] <<= aAppFontSize.Height();
545 2 : aValues[1] <<= aAppFontSize.Width();
546 :
547 2 : ImplSetPropertyValues( aProps, aValues, true );
548 4 : mbSizeModified = false;
549 : }
550 2 : }
551 :
552 0 : void SAL_CALL UnoDialogControl::windowMoved( const ::com::sun::star::awt::WindowEvent& e )
553 : throw (::com::sun::star::uno::RuntimeException, std::exception)
554 : {
555 0 : OutputDevice*pOutDev = Application::GetDefaultDevice();
556 : DBG_ASSERT( pOutDev, "Missing Default Device!" );
557 0 : if ( pOutDev && !mbPosModified )
558 : {
559 : // Currentley we are simply using MAP_APPFONT
560 0 : ::Size aTmp( e.X, e.Y );
561 0 : aTmp = ImplMapPixelToAppFont( pOutDev, aTmp );
562 :
563 : // Remember that changes have been done by listener. No need to
564 : // update the position because of property change event.
565 0 : mbPosModified = true;
566 0 : Sequence< OUString > aProps( 2 );
567 0 : Sequence< Any > aValues( 2 );
568 0 : aProps[0] = "PositionX";
569 0 : aProps[1] = "PositionY";
570 0 : aValues[0] <<= aTmp.Width();
571 0 : aValues[1] <<= aTmp.Height();
572 :
573 0 : ImplSetPropertyValues( aProps, aValues, true );
574 0 : mbPosModified = false;
575 : }
576 0 : }
577 :
578 0 : void SAL_CALL UnoDialogControl::windowShown( const EventObject& e ) throw (RuntimeException, std::exception)
579 : {
580 : (void)e;
581 0 : }
582 :
583 0 : void SAL_CALL UnoDialogControl::windowHidden( const EventObject& e ) throw (RuntimeException, std::exception)
584 : {
585 : (void)e;
586 0 : }
587 :
588 0 : void SAL_CALL UnoDialogControl::endDialog( ::sal_Int32 i_result ) throw (RuntimeException, std::exception)
589 : {
590 0 : Reference< XDialog2 > xPeerDialog( getPeer(), UNO_QUERY );
591 0 : if ( xPeerDialog.is() )
592 0 : xPeerDialog->endDialog( i_result );
593 0 : }
594 :
595 0 : void SAL_CALL UnoDialogControl::setHelpId( const OUString& i_id ) throw (RuntimeException, std::exception)
596 : {
597 0 : Reference< XDialog2 > xPeerDialog( getPeer(), UNO_QUERY );
598 0 : if ( xPeerDialog.is() )
599 0 : xPeerDialog->setHelpId( i_id );
600 0 : }
601 :
602 0 : void UnoDialogControl::setTitle( const OUString& Title ) throw(RuntimeException, std::exception)
603 : {
604 0 : SolarMutexGuard aGuard;
605 0 : Any aAny;
606 0 : aAny <<= Title;
607 0 : ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ), aAny, true );
608 0 : }
609 :
610 0 : OUString UnoDialogControl::getTitle() throw(RuntimeException, std::exception)
611 : {
612 0 : SolarMutexGuard aGuard;
613 0 : return ImplGetPropertyValue_UString( BASEPROPERTY_TITLE );
614 : }
615 :
616 0 : sal_Int16 UnoDialogControl::execute() throw(RuntimeException, std::exception)
617 : {
618 0 : SolarMutexGuard aGuard;
619 0 : sal_Int16 nDone = -1;
620 0 : if ( getPeer().is() )
621 : {
622 0 : Reference< XDialog > xDlg( getPeer(), UNO_QUERY );
623 0 : if( xDlg.is() )
624 : {
625 0 : GetComponentInfos().bVisible = true;
626 0 : nDone = xDlg->execute();
627 0 : GetComponentInfos().bVisible = false;
628 0 : }
629 : }
630 0 : return nDone;
631 : }
632 :
633 0 : void UnoDialogControl::endExecute() throw(RuntimeException, std::exception)
634 : {
635 0 : SolarMutexGuard aGuard;
636 0 : if ( getPeer().is() )
637 : {
638 0 : Reference< XDialog > xDlg( getPeer(), UNO_QUERY );
639 0 : if( xDlg.is() )
640 : {
641 0 : xDlg->endExecute();
642 0 : GetComponentInfos().bVisible = false;
643 0 : }
644 0 : }
645 0 : }
646 :
647 : // XModifyListener
648 0 : void SAL_CALL UnoDialogControl::modified(
649 : const lang::EventObject& /*rEvent*/ )
650 : throw (RuntimeException, std::exception)
651 : {
652 0 : ImplUpdateResourceResolver();
653 0 : }
654 :
655 246 : void UnoDialogControl::ImplModelPropertiesChanged( const Sequence< PropertyChangeEvent >& rEvents ) throw(RuntimeException)
656 : {
657 246 : sal_Int32 nLen = rEvents.getLength();
658 654 : for( sal_Int32 i = 0; i < nLen; i++ )
659 : {
660 414 : const PropertyChangeEvent& rEvt = rEvents.getConstArray()[i];
661 414 : Reference< XControlModel > xModel( rEvt.Source, UNO_QUERY );
662 414 : bool bOwnModel = xModel.get() == getModel().get();
663 414 : if ( bOwnModel && rEvt.PropertyName == "ImageURL" )
664 : {
665 6 : OUString aImageURL;
666 12 : Reference< graphic::XGraphic > xGraphic;
667 12 : if (( ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_IMAGEURL ) ) >>= aImageURL ) &&
668 6 : ( !aImageURL.isEmpty() ))
669 : {
670 2 : OUString absoluteUrl = aImageURL;
671 2 : if ( !aImageURL.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
672 :
673 4 : absoluteUrl = getPhysicalLocation( ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DIALOGSOURCEURL )),
674 2 : uno::makeAny(aImageURL));
675 :
676 2 : xGraphic = ImageHelper::getGraphicFromURL_nothrow( absoluteUrl );
677 : }
678 6 : ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_GRAPHIC), uno::makeAny( xGraphic ), true );
679 12 : break;
680 : }
681 408 : }
682 246 : ControlContainerBase::ImplModelPropertiesChanged(rEvents);
683 246 : }
684 :
685 :
686 : // class MultiPageControl
687 :
688 0 : UnoMultiPageControl::UnoMultiPageControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext), maTabListeners( *this )
689 : {
690 0 : maComponentInfos.nWidth = 280;
691 0 : maComponentInfos.nHeight = 400;
692 0 : }
693 :
694 0 : UnoMultiPageControl::~UnoMultiPageControl()
695 : {
696 0 : }
697 : // XTabListener
698 :
699 0 : void SAL_CALL UnoMultiPageControl::inserted( SAL_UNUSED_PARAMETER ::sal_Int32 ) throw (RuntimeException, std::exception)
700 : {
701 0 : }
702 0 : void SAL_CALL UnoMultiPageControl::removed( SAL_UNUSED_PARAMETER ::sal_Int32 ) throw (RuntimeException, std::exception)
703 : {
704 0 : }
705 0 : void SAL_CALL UnoMultiPageControl::changed( SAL_UNUSED_PARAMETER ::sal_Int32,
706 : SAL_UNUSED_PARAMETER const Sequence< NamedValue >& ) throw (RuntimeException, std::exception)
707 : {
708 0 : }
709 0 : void SAL_CALL UnoMultiPageControl::activated( ::sal_Int32 ID ) throw (RuntimeException, std::exception)
710 : {
711 0 : ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( ID ), false );
712 :
713 0 : }
714 0 : void SAL_CALL UnoMultiPageControl::deactivated( SAL_UNUSED_PARAMETER ::sal_Int32 ) throw (RuntimeException, std::exception)
715 : {
716 0 : }
717 0 : void SAL_CALL UnoMultiPageControl::disposing(const EventObject&) throw (RuntimeException, std::exception)
718 : {
719 0 : }
720 :
721 0 : void SAL_CALL UnoMultiPageControl::dispose() throw (RuntimeException, std::exception)
722 : {
723 0 : lang::EventObject aEvt;
724 0 : aEvt.Source = static_cast<cppu::OWeakObject*>(this);
725 0 : maTabListeners.disposeAndClear( aEvt );
726 0 : ControlContainerBase::dispose();
727 0 : }
728 :
729 : // com::sun::star::awt::XSimpleTabController
730 0 : ::sal_Int32 SAL_CALL UnoMultiPageControl::insertTab() throw (RuntimeException, std::exception)
731 : {
732 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
733 0 : if ( !xMultiPage.is() )
734 0 : throw RuntimeException();
735 0 : return xMultiPage->insertTab();
736 : }
737 :
738 0 : void SAL_CALL UnoMultiPageControl::removeTab( ::sal_Int32 ID ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
739 : {
740 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
741 0 : if ( !xMultiPage.is() )
742 0 : throw RuntimeException();
743 0 : xMultiPage->removeTab( ID );
744 0 : }
745 :
746 0 : void SAL_CALL UnoMultiPageControl::setTabProps( ::sal_Int32 ID, const Sequence< NamedValue >& Properties ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
747 : {
748 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
749 0 : if ( !xMultiPage.is() )
750 0 : throw RuntimeException();
751 0 : xMultiPage->setTabProps( ID, Properties );
752 0 : }
753 :
754 0 : Sequence< NamedValue > SAL_CALL UnoMultiPageControl::getTabProps( ::sal_Int32 ID ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
755 : {
756 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
757 0 : if ( !xMultiPage.is() )
758 0 : throw RuntimeException();
759 0 : return xMultiPage->getTabProps( ID );
760 : }
761 :
762 0 : void SAL_CALL UnoMultiPageControl::activateTab( ::sal_Int32 ID ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
763 : {
764 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
765 0 : if ( !xMultiPage.is() )
766 0 : throw RuntimeException();
767 0 : xMultiPage->activateTab( ID );
768 0 : ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( ID ), true );
769 :
770 0 : }
771 :
772 0 : ::sal_Int32 SAL_CALL UnoMultiPageControl::getActiveTabID() throw (RuntimeException, std::exception)
773 : {
774 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
775 0 : if ( !xMultiPage.is() )
776 0 : throw RuntimeException();
777 0 : return xMultiPage->getActiveTabID();
778 : }
779 :
780 0 : void SAL_CALL UnoMultiPageControl::addTabListener( const Reference< XTabListener >& Listener ) throw (RuntimeException, std::exception)
781 : {
782 0 : maTabListeners.addInterface( Listener );
783 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
784 0 : if ( xMultiPage.is() && maTabListeners.getLength() == 1 )
785 0 : xMultiPage->addTabListener( &maTabListeners );
786 0 : }
787 :
788 0 : void SAL_CALL UnoMultiPageControl::removeTabListener( const Reference< XTabListener >& Listener ) throw (RuntimeException, std::exception)
789 : {
790 0 : Reference< XSimpleTabController > xMultiPage( getPeer(), UNO_QUERY );
791 0 : if ( xMultiPage.is() && maTabListeners.getLength() == 1 )
792 0 : xMultiPage->removeTabListener( &maTabListeners );
793 0 : maTabListeners.removeInterface( Listener );
794 0 : }
795 :
796 :
797 : // lang::XTypeProvider
798 0 : IMPL_XTYPEPROVIDER_START( UnoMultiPageControl )
799 0 : cppu::UnoType<awt::XSimpleTabController>::get(),
800 0 : cppu::UnoType<awt::XTabListener>::get(),
801 : ControlContainerBase::getTypes()
802 0 : IMPL_XTYPEPROVIDER_END
803 :
804 : // uno::XInterface
805 0 : uno::Any UnoMultiPageControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
806 : {
807 : uno::Any aRet = ::cppu::queryInterface( rType,
808 0 : (static_cast< awt::XTabListener* >(this)), (static_cast< awt::XSimpleTabController* >(this)) );
809 0 : return (aRet.hasValue() ? aRet : ControlContainerBase::queryAggregation( rType ));
810 : }
811 :
812 0 : OUString UnoMultiPageControl::GetComponentServiceName()
813 : {
814 0 : bool bDecoration( true );
815 0 : ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_DECORATION )) >>= bDecoration;
816 0 : if ( bDecoration )
817 0 : return OUString("tabcontrol");
818 : // Hopefully we can tweak the tabcontrol to display without tabs
819 0 : return OUString("tabcontrolnotabs");
820 : }
821 :
822 0 : void UnoMultiPageControl::bindPage( const uno::Reference< awt::XControl >& _rxControl )
823 : {
824 0 : uno::Reference< awt::XWindowPeer > xPage( _rxControl->getPeer() );
825 0 : uno::Reference< awt::XSimpleTabController > xTabCntrl( getPeer(), uno::UNO_QUERY );
826 0 : uno::Reference< beans::XPropertySet > xProps( _rxControl->getModel(), uno::UNO_QUERY );
827 :
828 0 : VCLXTabPage* pXPage = dynamic_cast< VCLXTabPage* >( xPage.get() );
829 0 : TabPage* pPage = pXPage ? pXPage->getTabPage() : NULL;
830 0 : if ( xTabCntrl.is() && pPage )
831 : {
832 0 : VCLXMultiPage* pXTab = dynamic_cast< VCLXMultiPage* >( xTabCntrl.get() );
833 0 : if ( pXTab )
834 : {
835 0 : OUString sTitle;
836 0 : xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ) ) >>= sTitle;
837 0 : pXTab->insertTab( pPage, sTitle);
838 : }
839 0 : }
840 :
841 0 : }
842 :
843 0 : void UnoMultiPageControl::createPeer( const Reference< XToolkit > & rxToolkit, const Reference< XWindowPeer > & rParentPeer ) throw(RuntimeException, std::exception)
844 : {
845 0 : SolarMutexGuard aSolarGuard;
846 :
847 0 : UnoControlContainer::createPeer( rxToolkit, rParentPeer );
848 :
849 0 : uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
850 0 : sal_uInt32 nCtrls = aCtrls.getLength();
851 0 : for( sal_uInt32 n = 0; n < nCtrls; n++ )
852 0 : bindPage( aCtrls[ n ] );
853 0 : sal_Int32 nActiveTab(0);
854 0 : Reference< XPropertySet > xMultiProps( getModel(), UNO_QUERY );
855 0 : xMultiProps->getPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ) ) >>= nActiveTab;
856 :
857 0 : uno::Reference< awt::XSimpleTabController > xTabCntrl( getPeer(), uno::UNO_QUERY );
858 0 : if ( xTabCntrl.is() )
859 : {
860 0 : xTabCntrl->addTabListener( this );
861 0 : if ( nActiveTab && nCtrls ) // Ensure peer is initialise with correct activated tab
862 : {
863 0 : xTabCntrl->activateTab( nActiveTab );
864 0 : ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTIPAGEVALUE ), uno::makeAny( nActiveTab ), true );
865 : }
866 0 : }
867 0 : }
868 :
869 0 : void UnoMultiPageControl::impl_createControlPeerIfNecessary( const uno::Reference< awt::XControl >& _rxControl)
870 : {
871 : OSL_PRECOND( _rxControl.is(), "UnoMultiPageControl::impl_createControlPeerIfNecessary: invalid control, this will crash!" );
872 :
873 : // if the container already has a peer, then also create a peer for the control
874 0 : uno::Reference< awt::XWindowPeer > xMyPeer( getPeer() );
875 :
876 0 : if( xMyPeer.is() )
877 : {
878 0 : _rxControl->createPeer( NULL, xMyPeer );
879 0 : bindPage( _rxControl );
880 0 : ImplActivateTabControllers();
881 0 : }
882 :
883 0 : }
884 :
885 : // ------------- UnoMultiPageModel -----------------
886 :
887 1 : UnoMultiPageModel::UnoMultiPageModel( const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
888 : {
889 1 : ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
890 1 : ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
891 1 : ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
892 1 : ImplRegisterProperty( BASEPROPERTY_ENABLED );
893 :
894 1 : ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
895 1 : ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
896 1 : ImplRegisterProperty( BASEPROPERTY_HELPURL );
897 1 : ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
898 : //ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
899 1 : ImplRegisterProperty( BASEPROPERTY_MULTIPAGEVALUE );
900 1 : ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
901 1 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
902 :
903 1 : Any aBool;
904 1 : aBool <<= true;
905 1 : ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
906 1 : ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
907 1 : ImplRegisterProperty( BASEPROPERTY_DECORATION, aBool );
908 : // MultiPage Control has the tab stop property. And the default value is True.
909 1 : ImplRegisterProperty( BASEPROPERTY_TABSTOP, aBool );
910 :
911 2 : uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >();
912 2 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
913 1 : }
914 :
915 0 : UnoMultiPageModel::UnoMultiPageModel( const UnoMultiPageModel& rModel )
916 0 : : ControlModelContainerBase( rModel )
917 : {
918 0 : }
919 :
920 2 : UnoMultiPageModel::~UnoMultiPageModel()
921 : {
922 2 : }
923 :
924 : UnoControlModel*
925 0 : UnoMultiPageModel::Clone() const
926 : {
927 : // clone the container itself
928 0 : UnoMultiPageModel* pClone = new UnoMultiPageModel( *this );
929 0 : Clone_Impl( *pClone );
930 0 : return pClone;
931 : }
932 :
933 0 : OUString UnoMultiPageModel::getServiceName() throw(::com::sun::star::uno::RuntimeException, std::exception)
934 : {
935 0 : return OUString( "com.sun.star.awt.UnoMultiPageModel" );
936 : }
937 :
938 15 : uno::Any UnoMultiPageModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
939 : {
940 15 : if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
941 : {
942 1 : uno::Any aAny;
943 1 : aAny <<= OUString( "com.sun.star.awt.UnoControlMultiPage" );
944 1 : return aAny;
945 : }
946 14 : return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
947 : }
948 :
949 0 : ::cppu::IPropertyArrayHelper& UnoMultiPageModel::getInfoHelper()
950 : {
951 : static UnoPropertyArrayHelper* pHelper = NULL;
952 0 : if ( !pHelper )
953 : {
954 0 : uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
955 0 : pHelper = new UnoPropertyArrayHelper( aIDs );
956 : }
957 0 : return *pHelper;
958 : }
959 :
960 : // beans::XMultiPropertySet
961 0 : uno::Reference< beans::XPropertySetInfo > UnoMultiPageModel::getPropertySetInfo( ) throw(uno::RuntimeException, std::exception)
962 : {
963 0 : static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
964 0 : return xInfo;
965 : }
966 :
967 0 : void UnoMultiPageModel::insertByName( const OUString& aName, const Any& aElement ) throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException, std::exception)
968 : {
969 0 : Reference< XServiceInfo > xInfo;
970 0 : aElement >>= xInfo;
971 :
972 0 : if ( !xInfo.is() )
973 0 : throw IllegalArgumentException();
974 :
975 : // Only a Page model can be inserted into the multipage
976 0 : if ( !xInfo->supportsService( "com.sun.star.awt.UnoPageModel" ) )
977 0 : throw IllegalArgumentException();
978 :
979 0 : return ControlModelContainerBase::insertByName( aName, aElement );
980 : }
981 :
982 :
983 0 : sal_Bool SAL_CALL UnoMultiPageModel::getGroupControl( ) throw (RuntimeException, std::exception)
984 : {
985 0 : return sal_True;
986 : }
987 :
988 :
989 : // class UnoPageControl
990 :
991 0 : UnoPageControl::UnoPageControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext)
992 : {
993 0 : maComponentInfos.nWidth = 280;
994 0 : maComponentInfos.nHeight = 400;
995 0 : }
996 :
997 0 : UnoPageControl::~UnoPageControl()
998 : {
999 0 : }
1000 :
1001 0 : OUString UnoPageControl::GetComponentServiceName()
1002 : {
1003 0 : return OUString("tabpage");
1004 : }
1005 :
1006 :
1007 : // ------------- UnoPageModel -----------------
1008 :
1009 0 : UnoPageModel::UnoPageModel( const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
1010 : {
1011 0 : ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
1012 0 : ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
1013 0 : ImplRegisterProperty( BASEPROPERTY_ENABLED );
1014 0 : ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
1015 :
1016 0 : ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
1017 0 : ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
1018 0 : ImplRegisterProperty( BASEPROPERTY_HELPURL );
1019 0 : ImplRegisterProperty( BASEPROPERTY_TITLE );
1020 0 : ImplRegisterProperty( BASEPROPERTY_SIZEABLE );
1021 0 : ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
1022 0 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
1023 : // ImplRegisterProperty( BASEPROPERTY_DIALOGSOURCEURL );
1024 :
1025 0 : Any aBool;
1026 0 : aBool <<= true;
1027 0 : ImplRegisterProperty( BASEPROPERTY_MOVEABLE, aBool );
1028 0 : ImplRegisterProperty( BASEPROPERTY_CLOSEABLE, aBool );
1029 : //ImplRegisterProperty( BASEPROPERTY_TABSTOP, aBool );
1030 :
1031 0 : uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >();
1032 0 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
1033 0 : }
1034 :
1035 0 : UnoPageModel::UnoPageModel( const UnoPageModel& rModel )
1036 0 : : ControlModelContainerBase( rModel )
1037 : {
1038 0 : }
1039 :
1040 0 : UnoPageModel::~UnoPageModel()
1041 : {
1042 0 : }
1043 :
1044 : UnoControlModel*
1045 0 : UnoPageModel::Clone() const
1046 : {
1047 : // clone the container itself
1048 0 : UnoPageModel* pClone = new UnoPageModel( *this );
1049 0 : Clone_Impl( *pClone );
1050 0 : return pClone;
1051 : }
1052 :
1053 0 : OUString UnoPageModel::getServiceName() throw(::com::sun::star::uno::RuntimeException, std::exception)
1054 : {
1055 0 : return OUString( "com.sun.star.awt.UnoPageModel" );
1056 : }
1057 :
1058 0 : uno::Any UnoPageModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1059 : {
1060 0 : if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1061 : {
1062 0 : uno::Any aAny;
1063 0 : aAny <<= OUString( "com.sun.star.awt.UnoControlPage" );
1064 0 : return aAny;
1065 : }
1066 0 : return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
1067 : }
1068 :
1069 0 : ::cppu::IPropertyArrayHelper& UnoPageModel::getInfoHelper()
1070 : {
1071 : static UnoPropertyArrayHelper* pHelper = NULL;
1072 0 : if ( !pHelper )
1073 : {
1074 0 : uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1075 0 : pHelper = new UnoPropertyArrayHelper( aIDs );
1076 : }
1077 0 : return *pHelper;
1078 : }
1079 :
1080 : // beans::XMultiPropertySet
1081 0 : uno::Reference< beans::XPropertySetInfo > UnoPageModel::getPropertySetInfo( ) throw(uno::RuntimeException, std::exception)
1082 : {
1083 0 : static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1084 0 : return xInfo;
1085 : }
1086 :
1087 :
1088 0 : sal_Bool SAL_CALL UnoPageModel::getGroupControl( ) throw (RuntimeException, std::exception)
1089 : {
1090 0 : return sal_False;
1091 : }
1092 :
1093 : // Frame control
1094 :
1095 :
1096 : // class UnoFrameControl
1097 :
1098 0 : UnoFrameControl::UnoFrameControl( const uno::Reference< uno::XComponentContext >& rxContext ) : ControlContainerBase(rxContext)
1099 : {
1100 0 : maComponentInfos.nWidth = 280;
1101 0 : maComponentInfos.nHeight = 400;
1102 0 : }
1103 :
1104 0 : UnoFrameControl::~UnoFrameControl()
1105 : {
1106 0 : }
1107 :
1108 0 : OUString UnoFrameControl::GetComponentServiceName()
1109 : {
1110 0 : return OUString("frame");
1111 : }
1112 :
1113 0 : void UnoFrameControl::ImplSetPosSize( Reference< XControl >& rxCtrl )
1114 : {
1115 0 : bool bOwnCtrl = false;
1116 0 : OUString sTitle;
1117 0 : if ( rxCtrl.get() == Reference<XControl>( this ).get() )
1118 0 : bOwnCtrl = true;
1119 0 : Reference< XPropertySet > xProps( getModel(), UNO_QUERY );
1120 : //xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_TITLE ) ) >>= sTitle;
1121 0 : xProps->getPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ) ) >>= sTitle;
1122 :
1123 0 : ControlContainerBase::ImplSetPosSize( rxCtrl );
1124 0 : Reference < XWindow > xW( rxCtrl, UNO_QUERY );
1125 0 : if ( !bOwnCtrl && xW.is() && !sTitle.isEmpty() )
1126 : {
1127 0 : awt::Rectangle aSizePos = xW->getPosSize();
1128 :
1129 0 : sal_Int32 nX = aSizePos.X, nY = aSizePos.Y, nWidth = aSizePos.Width, nHeight = aSizePos.Height;
1130 : // Retrieve the values set by the base class
1131 0 : OutputDevice*pOutDev = Application::GetDefaultDevice();
1132 0 : if ( pOutDev )
1133 : {
1134 0 : if ( !bOwnCtrl && !sTitle.isEmpty() )
1135 : {
1136 : // Adjust Y based on height of Title
1137 0 : ::Rectangle aRect;
1138 0 : aRect = pOutDev->GetTextRect( aRect, sTitle );
1139 0 : nY = nY + ( aRect.GetHeight() / 2 );
1140 : }
1141 : }
1142 : else
1143 : {
1144 0 : Reference< XWindowPeer > xPeer = ImplGetCompatiblePeer( true );
1145 0 : Reference< XDevice > xD( xPeer, UNO_QUERY );
1146 :
1147 0 : SimpleFontMetric aFM;
1148 0 : FontDescriptor aFD;
1149 0 : Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_FONTDESCRIPTOR ) );
1150 :
1151 0 : aVal >>= aFD;
1152 0 : if ( !aFD.StyleName.isEmpty() )
1153 : {
1154 0 : Reference< XFont > xFont = xD->getFont( aFD );
1155 0 : aFM = xFont->getFontMetric();
1156 : }
1157 : else
1158 : {
1159 0 : Reference< XGraphics > xG = xD->createGraphics();
1160 0 : aFM = xG->getFontMetric();
1161 : }
1162 :
1163 0 : sal_Int16 nH = aFM.Ascent + aFM.Descent;
1164 0 : if ( !bOwnCtrl && !sTitle.isEmpty() )
1165 : // offset y based on height of font ( not sure if my guess at the correct calculation is correct here )
1166 0 : nY = nY + ( nH / 8); // how do I test this
1167 : }
1168 0 : xW->setPosSize( nX, nY, nWidth, nHeight, PosSize::POSSIZE );
1169 0 : }
1170 0 : }
1171 :
1172 : // ------------- UnoFrameModel -----------------
1173 :
1174 1 : UnoFrameModel::UnoFrameModel( const Reference< XComponentContext >& rxContext ) : ControlModelContainerBase( rxContext )
1175 : {
1176 1 : ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
1177 1 : ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
1178 1 : ImplRegisterProperty( BASEPROPERTY_ENABLED );
1179 1 : ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
1180 1 : ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
1181 1 : ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
1182 1 : ImplRegisterProperty( BASEPROPERTY_HELPURL );
1183 1 : ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
1184 1 : ImplRegisterProperty( BASEPROPERTY_LABEL );
1185 1 : ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
1186 1 : ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
1187 1 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES );
1188 1 : ImplRegisterProperty( BASEPROPERTY_HSCROLL );
1189 1 : ImplRegisterProperty( BASEPROPERTY_VSCROLL );
1190 1 : ImplRegisterProperty( BASEPROPERTY_SCROLLWIDTH );
1191 1 : ImplRegisterProperty( BASEPROPERTY_SCROLLHEIGHT );
1192 1 : ImplRegisterProperty( BASEPROPERTY_SCROLLTOP );
1193 1 : ImplRegisterProperty( BASEPROPERTY_SCROLLLEFT );
1194 :
1195 :
1196 1 : uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >();
1197 1 : ImplRegisterProperty( BASEPROPERTY_USERFORMCONTAINEES, uno::makeAny( xNameCont ) );
1198 1 : }
1199 :
1200 0 : UnoFrameModel::UnoFrameModel( const UnoFrameModel& rModel )
1201 0 : : ControlModelContainerBase( rModel )
1202 : {
1203 0 : }
1204 :
1205 2 : UnoFrameModel::~UnoFrameModel()
1206 : {
1207 2 : }
1208 :
1209 : UnoControlModel*
1210 0 : UnoFrameModel::Clone() const
1211 : {
1212 : // clone the container itself
1213 0 : UnoFrameModel* pClone = new UnoFrameModel( *this );
1214 0 : Clone_Impl( *pClone );
1215 0 : return pClone;
1216 : }
1217 :
1218 0 : OUString UnoFrameModel::getServiceName() throw(::com::sun::star::uno::RuntimeException, std::exception)
1219 : {
1220 0 : return OUString( "com.sun.star.awt.UnoFrameModel" );
1221 : }
1222 :
1223 22 : uno::Any UnoFrameModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1224 : {
1225 22 : uno::Any aAny;
1226 22 : switch ( nPropId )
1227 : {
1228 : case BASEPROPERTY_DEFAULTCONTROL:
1229 : {
1230 1 : aAny <<= OUString( "com.sun.star.awt.UnoControlFrame" );
1231 1 : return aAny;
1232 : }
1233 : case BASEPROPERTY_SCROLLWIDTH:
1234 : case BASEPROPERTY_SCROLLHEIGHT:
1235 : case BASEPROPERTY_SCROLLTOP:
1236 : case BASEPROPERTY_SCROLLLEFT:
1237 4 : aAny <<= sal_Int32(0);
1238 4 : return aAny;
1239 : case BASEPROPERTY_USERFORMCONTAINEES:
1240 : {
1241 1 : uno::Reference< XNameContainer > xNameCont = new SimpleNamedThingContainer< XControlModel >();
1242 1 : return makeAny( xNameCont );
1243 : }
1244 : }
1245 16 : return ControlModelContainerBase::ImplGetDefaultValue( nPropId );
1246 : }
1247 :
1248 0 : ::cppu::IPropertyArrayHelper& UnoFrameModel::getInfoHelper()
1249 : {
1250 : static UnoPropertyArrayHelper* pHelper = NULL;
1251 0 : if ( !pHelper )
1252 : {
1253 0 : uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1254 0 : pHelper = new UnoPropertyArrayHelper( aIDs );
1255 : }
1256 0 : return *pHelper;
1257 : }
1258 :
1259 : // beans::XMultiPropertySet
1260 0 : uno::Reference< beans::XPropertySetInfo > UnoFrameModel::getPropertySetInfo( ) throw(uno::RuntimeException, std::exception)
1261 : {
1262 0 : static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1263 0 : return xInfo;
1264 : }
1265 :
1266 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1267 14 : stardiv_Toolkit_UnoControlDialogModel_get_implementation(
1268 : css::uno::XComponentContext *context,
1269 : css::uno::Sequence<css::uno::Any> const &)
1270 : {
1271 14 : return cppu::acquire(new OGeometryControlModel<UnoControlDialogModel>(context));
1272 : }
1273 :
1274 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1275 8 : stardiv_Toolkit_UnoDialogControl_get_implementation(
1276 : css::uno::XComponentContext *context,
1277 : css::uno::Sequence<css::uno::Any> const &)
1278 : {
1279 8 : return cppu::acquire(new UnoDialogControl(context));
1280 : }
1281 :
1282 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1283 0 : stardiv_Toolkit_UnoMultiPageControl_get_implementation(
1284 : css::uno::XComponentContext *context,
1285 : css::uno::Sequence<css::uno::Any> const &)
1286 : {
1287 0 : return cppu::acquire(new UnoMultiPageControl(context));
1288 : }
1289 :
1290 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1291 0 : stardiv_Toolkit_UnoMultiPageModel_get_implementation(
1292 : css::uno::XComponentContext *context,
1293 : css::uno::Sequence<css::uno::Any> const &)
1294 : {
1295 0 : return cppu::acquire(new UnoMultiPageModel(context));
1296 : }
1297 :
1298 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1299 0 : stardiv_Toolkit_UnoPageControl_get_implementation(
1300 : css::uno::XComponentContext *context,
1301 : css::uno::Sequence<css::uno::Any> const &)
1302 : {
1303 0 : return cppu::acquire(new UnoPageControl(context));
1304 : }
1305 :
1306 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1307 0 : stardiv_Toolkit_UnoPageModel_get_implementation(
1308 : css::uno::XComponentContext *context,
1309 : css::uno::Sequence<css::uno::Any> const &)
1310 : {
1311 0 : return cppu::acquire(new UnoPageModel(context));
1312 : }
1313 :
1314 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1315 0 : stardiv_Toolkit_UnoFrameControl_get_implementation(
1316 : css::uno::XComponentContext *context,
1317 : css::uno::Sequence<css::uno::Any> const &)
1318 : {
1319 0 : return cppu::acquire(new UnoFrameControl(context));
1320 : }
1321 :
1322 : extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1323 0 : stardiv_Toolkit_UnoFrameModel_get_implementation(
1324 : css::uno::XComponentContext *context,
1325 : css::uno::Sequence<css::uno::Any> const &)
1326 : {
1327 0 : return cppu::acquire(new UnoFrameModel(context));
1328 : }
1329 :
1330 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
