UnoControls/source/base/basecontrol.cxx

   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 "basecontrol.hxx"
  21
  22 #include <com/sun/star/awt/XDevice.hpp>
  23 #include <com/sun/star/awt/XDisplayBitmap.hpp>
  24 #include <com/sun/star/awt/DeviceInfo.hpp>
  25 #include <com/sun/star/awt/WindowAttribute.hpp>
  26 #include <com/sun/star/awt/PosSize.hpp>
  27 #include <com/sun/star/awt/Toolkit.hpp>
  28 #include <comphelper/processfactory.hxx>
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include <cppuhelper/queryinterface.hxx>
  31 #include <cppuhelper/typeprovider.hxx>
  32
  33 //  namespaces
  34
  35 using namespace ::cppu;
  36 using namespace ::osl;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::awt;
  40
  41 namespace unocontrols{
  42
  43 #define DEFAULT_PMULTIPLEXER                NULL
  44 #define DEFAULT_X                           0
  45 #define DEFAULT_Y                           0
  46 #define DEFAULT_WIDTH                       100
  47 #define DEFAULT_HEIGHT                      100
  48 #define DEFAULT_VISIBLE                     false
  49 #define DEFAULT_INDESIGNMODE                false
  50 #define DEFAULT_ENABLE                      true
  51
  52 //  construct/destruct
  53
  54 BaseControl::BaseControl( const Reference< XComponentContext >& rxContext )
  55     : IMPL_MutexContainer       (                       )
  56     , OComponentHelper          ( m_aMutex              )
  57     , m_xComponentContext       ( rxContext              )
  58     , m_pMultiplexer            ( DEFAULT_PMULTIPLEXER  )
  59     , m_nX                      ( DEFAULT_X             )
  60     , m_nY                      ( DEFAULT_Y             )
  61     , m_nWidth                  ( DEFAULT_WIDTH         )
  62     , m_nHeight                 ( DEFAULT_HEIGHT        )
  63     , m_bVisible                ( DEFAULT_VISIBLE       )
  64     , m_bInDesignMode           ( DEFAULT_INDESIGNMODE  )
  65     , m_bEnable                 ( DEFAULT_ENABLE        )
  66 {
  67 }
  68
  69 BaseControl::~BaseControl()
  70 {
  71 }
  72
  73 //  XInterface
  74
  75 Any SAL_CALL BaseControl::queryInterface( const Type& rType ) throw( RuntimeException, std::exception )
  76 {
  77     Any aReturn;
  78     if ( m_xDelegator.is() )
  79     {
  80         // If an delegator exist, forward question to his queryInterface.
  81         // Delegator will ask his own queryAggregation!
  82         aReturn = m_xDelegator->queryInterface( rType );
  83     }
  84     else
  85     {
  86         // If an delegator unknown, forward question to own queryAggregation.
  87         aReturn = queryAggregation( rType );
  88     }
  89
  90     return aReturn;
  91 }
  92
  93 //  XInterface
  94
  95 void SAL_CALL BaseControl::acquire() throw()
  96 {
  97     // Attention:
  98     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  99
 100     // Forward to baseclass
 101     OComponentHelper::acquire();
 102 }
 103
 104 //  XInterface
 105
 106 void SAL_CALL BaseControl::release() throw()
 107 {
 108     // Attention:
 109     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 110
 111     // Forward to baseclass
 112     OComponentHelper::release();
 113 }
 114
 115 //  XTypeProvider
 116
 117 Sequence< Type > SAL_CALL BaseControl::getTypes() throw( RuntimeException, std::exception )
 118 {
 119     // Optimize this method !
 120     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 121     // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
 122     static OTypeCollection* pTypeCollection = NULL;
 123
 124     if ( pTypeCollection == NULL )
 125     {
 126         // Ready for multithreading; get global mutex for first call of this method only! see before
 127         MutexGuard aGuard( Mutex::getGlobalMutex() );
 128
 129         // Control these pointer again ... it can be, that another instance will be faster then these!
 130         if ( pTypeCollection == NULL )
 131         {
 132             // Create a static typecollection ...
 133             static OTypeCollection aTypeCollection( cppu::UnoType<XPaintListener>::get(),
 134                                                     cppu::UnoType<XWindowListener>::get(),
 135                                                     cppu::UnoType<XView>::get(),
 136                                                     cppu::UnoType<XWindow>::get(),
 137                                                     cppu::UnoType<XServiceInfo>::get(),
 138                                                     cppu::UnoType<XControl>::get(),
 139                                                     OComponentHelper::getTypes()
 140                                                   );
 141
 142             // ... and set his address to static pointer!
 143             pTypeCollection = &aTypeCollection;
 144         }
 145     }
 146
 147     return pTypeCollection->getTypes();
 148 }
 149
 150 //  XTypeProvider
 151
 152 Sequence< sal_Int8 > SAL_CALL BaseControl::getImplementationId() throw( RuntimeException, std::exception )
 153 {
 154     return css::uno::Sequence<sal_Int8>();
 155 }
 156
 157 //  XAggregation
 158
 159 void SAL_CALL BaseControl::setDelegator( const Reference< XInterface >& xDel ) throw( RuntimeException, std::exception )
 160 {
 161     // Ready for multithreading
 162     MutexGuard aGuard( m_aMutex );
 163     m_xDelegator = xDel;
 164 }
 165
 166 //  XAggregation
 167
 168 Any SAL_CALL BaseControl::queryAggregation( const Type& aType ) throw( RuntimeException, std::exception )
 169 {
 170     // Ask for my own supported interfaces ...
 171     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 172     Any aReturn ( ::cppu::queryInterface(   aType                                   ,
 173                                                static_cast< XPaintListener*> ( this )   ,
 174                                                static_cast< XWindowListener*> ( this )  ,
 175                                                static_cast< XView*          > ( this )  ,
 176                                                static_cast< XWindow*        > ( this )  ,
 177                                                static_cast< XServiceInfo*   > ( this )  ,
 178                                                static_cast< XControl*       > ( this )
 179                                         )
 180                 );
 181
 182     // If searched interface supported by this class ...
 183     if ( aReturn.hasValue() )
 184     {
 185         // ... return this information.
 186         return aReturn;
 187     }
 188     else
 189     {
 190         // Else; ... ask baseclass for interfaces!
 191         return OComponentHelper::queryAggregation( aType );
 192     }
 193 }
 194
 195 //  XServiceInfo
 196
 197 OUString SAL_CALL BaseControl::getImplementationName() throw( RuntimeException, std::exception )
 198 {
 199     return impl_getStaticImplementationName();
 200 }
 201
 202 //  XServiceInfo
 203
 204 sal_Bool SAL_CALL BaseControl::supportsService( const OUString& sServiceName ) throw( RuntimeException, std::exception )
 205 {
 206     return cppu::supportsService(this, sServiceName);
 207 }
 208
 209 //  XServiceInfo
 210
 211 Sequence< OUString > SAL_CALL BaseControl::getSupportedServiceNames() throw( RuntimeException, std::exception )
 212 {
 213     return impl_getStaticSupportedServiceNames();
 214 }
 215
 216 //  XComponent
 217
 218 void SAL_CALL BaseControl::dispose() throw( RuntimeException, std::exception )
 219 {
 220     // Ready for multithreading
 221     MutexGuard aGuard( m_aMutex );
 222
 223     if ( m_pMultiplexer != NULL )
 224     {
 225         // to all other paint, focus, etc.
 226         m_pMultiplexer->disposeAndClear();
 227     }
 228
 229     // set the service manager to disposed
 230     OComponentHelper::dispose();
 231
 232     // release context and peer
 233     m_xContext.clear();
 234     impl_releasePeer();
 235
 236     // release view
 237     if ( m_xGraphicsView.is() )
 238     {
 239         m_xGraphicsView.clear();
 240     }
 241 }
 242
 243 //  XComponent
 244
 245 void SAL_CALL BaseControl::addEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException, std::exception )
 246 {
 247     // Ready for multithreading
 248     MutexGuard aGuard( m_aMutex );
 249     OComponentHelper::addEventListener( xListener );
 250 }
 251
 252 //  XComponent
 253
 254 void SAL_CALL BaseControl::removeEventListener( const Reference< XEventListener >& xListener ) throw( RuntimeException, std::exception )
 255 {
 256     // Ready for multithreading
 257     MutexGuard aGuard( m_aMutex );
 258     OComponentHelper::removeEventListener( xListener );
 259 }
 260
 261 //  XControl
 262
 263 void SAL_CALL BaseControl::createPeer(  const   Reference< XToolkit >&      xToolkit    ,
 264                                         const   Reference< XWindowPeer >&   xParentPeer ) throw( RuntimeException, std::exception )
 265 {
 266     // Ready for multithreading
 267     MutexGuard aGuard( m_aMutex );
 268
 269     if ( !m_xPeer.is() )
 270     {
 271         // use method "BaseControl::getWindowDescriptor()" fot change window attributes !!!
 272         WindowDescriptor* pDescriptor = impl_getWindowDescriptor( xParentPeer );
 273
 274         if ( m_bVisible )
 275         {
 276             pDescriptor->WindowAttributes |= WindowAttribute::SHOW;
 277         }
 278
 279         // very slow under remote conditions!
 280         // create the window on the server
 281         Reference< XToolkit > xLocalToolkit = xToolkit;
 282         if ( !xLocalToolkit.is() )
 283         {
 284             // but first create well known toolkit, if it not exist
 285             xLocalToolkit = Reference< XToolkit > ( Toolkit::create(m_xComponentContext), UNO_QUERY_THROW );
 286         }
 287         m_xPeer         = xLocalToolkit->createWindow( *pDescriptor );
 288         m_xPeerWindow   = Reference< XWindow >( m_xPeer, UNO_QUERY );
 289
 290         // don't forget to release the memory!
 291         delete pDescriptor;
 292
 293         if ( m_xPeerWindow.is() )
 294         {
 295             if ( m_pMultiplexer != NULL )
 296             {
 297                 m_pMultiplexer->setPeer( m_xPeerWindow );
 298             }
 299
 300             // create new referenz to xgraphics for painting on a peer
 301             // and add a paint listener
 302             Reference< XDevice > xDevice( m_xPeerWindow, UNO_QUERY );
 303
 304             if ( xDevice.is() )
 305             {
 306                 m_xGraphicsPeer = xDevice->createGraphics();
 307             }
 308
 309             if ( m_xGraphicsPeer.is() )
 310             {
 311                 addPaintListener( this );
 312                 addWindowListener( this );
 313             }
 314
 315             m_xPeerWindow->setPosSize(  m_nX, m_nY, m_nWidth, m_nHeight, PosSize::POSSIZE   );
 316             m_xPeerWindow->setEnable(   m_bEnable                                           );
 317             m_xPeerWindow->setVisible(  m_bVisible && !m_bInDesignMode                      );
 318         }
 319     }
 320 }
 321
 322 //  XControl
 323
 324 void SAL_CALL BaseControl::setContext( const Reference< XInterface >& xContext ) throw( RuntimeException, std::exception )
 325 {
 326     // Ready for multithreading
 327     MutexGuard aGuard( m_aMutex );
 328     m_xContext = xContext;
 329 }
 330
 331 //  XControl
 332
 333 void SAL_CALL BaseControl::setDesignMode( sal_Bool bOn ) throw( RuntimeException, std::exception )
 334 {
 335     // Ready for multithreading
 336     MutexGuard aGuard( m_aMutex );
 337     m_bInDesignMode = bOn;
 338 }
 339
 340 //  XControl
 341
 342 Reference< XInterface > SAL_CALL BaseControl::getContext() throw( RuntimeException, std::exception )
 343 {
 344     // Ready for multithreading
 345     MutexGuard aGuard( m_aMutex );
 346     return m_xContext;
 347 }
 348
 349 //  XControl
 350
 351 Reference< XWindowPeer > SAL_CALL BaseControl::getPeer() throw( RuntimeException, std::exception )
 352 {
 353     // Ready for multithreading
 354     MutexGuard aGuard( m_aMutex );
 355     return m_xPeer;
 356 }
 357
 358 //  XControl
 359
 360 Reference< XView > SAL_CALL BaseControl::getView() throw( RuntimeException, std::exception )
 361 {
 362     // Ready for multithreading
 363     MutexGuard aGuard( m_aMutex );
 364     return Reference< XView >( (OWeakObject*)this, UNO_QUERY );
 365 }
 366
 367 //  XControl
 368
 369 sal_Bool SAL_CALL BaseControl::isDesignMode() throw( RuntimeException, std::exception )
 370 {
 371     // Ready for multithreading
 372     MutexGuard aGuard( m_aMutex );
 373     return m_bInDesignMode;
 374 }
 375
 376 //  XControl
 377
 378 sal_Bool SAL_CALL BaseControl::isTransparent() throw( RuntimeException, std::exception )
 379 {
 380     return false;
 381 }
 382
 383 //  XWindow
 384
 385 void SAL_CALL BaseControl::setPosSize(  sal_Int32   nX      ,
 386                                         sal_Int32   nY      ,
 387                                         sal_Int32   nWidth  ,
 388                                         sal_Int32   nHeight ,
 389                                         sal_Int16   nFlags  ) throw( RuntimeException, std::exception )
 390 {
 391     // - change size and position of window and save the values
 392
 393     // Ready for multithreading
 394     MutexGuard aGuard( m_aMutex );
 395
 396     bool bChanged = false;
 397
 398     if ( nFlags & PosSize::X )
 399     {
 400         bChanged |= m_nX != nX, m_nX = nX;
 401     }
 402
 403     if ( nFlags & PosSize::Y )
 404     {
 405         bChanged |= m_nY != nY, m_nY = nY;
 406     }
 407
 408     if ( nFlags & PosSize::WIDTH )
 409     {
 410         bChanged |= m_nWidth != nWidth, m_nWidth  = nWidth;
 411     }
 412
 413     if ( nFlags & PosSize::HEIGHT )
 414     {
 415         bChanged |= m_nHeight != nHeight, m_nHeight = nHeight;
 416     }
 417
 418     if ( bChanged && m_xPeerWindow.is() )
 419     {
 420         m_xPeerWindow->setPosSize( m_nX, m_nY, m_nWidth, m_nHeight, nFlags );
 421     }
 422 }
 423
 424 //  XWindow
 425
 426 void SAL_CALL BaseControl::setVisible( sal_Bool bVisible ) throw( RuntimeException, std::exception )
 427 {
 428     // Ready for multithreading
 429     MutexGuard aGuard( m_aMutex );
 430
 431     // Set new state of flag
 432     m_bVisible = bVisible;
 433
 434     if ( m_xPeerWindow.is() )
 435     {
 436         // Set it also on peerwindow
 437         m_xPeerWindow->setVisible( m_bVisible );
 438     }
 439 }
 440
 441 //  XWindow
 442
 443 void SAL_CALL BaseControl::setEnable( sal_Bool bEnable ) throw( RuntimeException, std::exception )
 444 {
 445     // Ready for multithreading
 446     MutexGuard aGuard( m_aMutex );
 447
 448     // Set new state of flag
 449     m_bEnable = bEnable;
 450
 451     if ( m_xPeerWindow.is() )
 452     {
 453         // Set it also on peerwindow
 454         m_xPeerWindow->setEnable( m_bEnable );
 455     }
 456 }
 457
 458 //  XWindow
 459
 460 void SAL_CALL BaseControl::setFocus() throw( RuntimeException, std::exception )
 461 {
 462     // Ready for multithreading
 463     MutexGuard aGuard( m_aMutex );
 464
 465     if ( m_xPeerWindow.is() )
 466     {
 467         m_xPeerWindow->setFocus();
 468     }
 469 }
 470
 471 //  XWindow
 472
 473 Rectangle SAL_CALL BaseControl::getPosSize() throw( RuntimeException, std::exception )
 474 {
 475     // Ready for multithreading
 476     MutexGuard aGuard( m_aMutex );
 477     return Rectangle( m_nX, m_nY , m_nWidth, m_nHeight );
 478 }
 479
 480 //  XWindow
 481
 482 void SAL_CALL BaseControl::addWindowListener( const Reference< XWindowListener >& xListener ) throw( RuntimeException, std::exception )
 483 {
 484     impl_getMultiplexer()->advise( cppu::UnoType<XWindowListener>::get(), xListener );
 485 }
 486
 487 //  XWindow
 488
 489 void SAL_CALL BaseControl::addFocusListener( const Reference< XFocusListener >& xListener ) throw( RuntimeException, std::exception )
 490 {
 491     impl_getMultiplexer()->advise( cppu::UnoType<XFocusListener>::get(), xListener );
 492 }
 493
 494 //  XWindow
 495
 496 void SAL_CALL BaseControl::addKeyListener( const Reference< XKeyListener >& xListener ) throw( RuntimeException, std::exception )
 497 {
 498     impl_getMultiplexer()->advise( cppu::UnoType<XKeyListener>::get(), xListener );
 499 }
 500
 501 //  XWindow
 502
 503 void SAL_CALL BaseControl::addMouseListener( const Reference< XMouseListener >& xListener ) throw( RuntimeException, std::exception )
 504 {
 505     impl_getMultiplexer()->advise( cppu::UnoType<XMouseListener>::get(), xListener );
 506 }
 507
 508 //  XWindow
 509
 510 void SAL_CALL BaseControl::addMouseMotionListener( const Reference< XMouseMotionListener >& xListener ) throw( RuntimeException, std::exception )
 511 {
 512     impl_getMultiplexer()->advise( cppu::UnoType<XMouseMotionListener>::get(), xListener );
 513 }
 514
 515 //  XWindow
 516
 517 void SAL_CALL BaseControl::addPaintListener( const Reference< XPaintListener >& xListener ) throw( RuntimeException, std::exception )
 518 {
 519     impl_getMultiplexer()->advise( cppu::UnoType<XPaintListener>::get(), xListener );
 520 }
 521
 522 //  XWindow
 523
 524 void SAL_CALL BaseControl::removeWindowListener( const Reference< XWindowListener >& xListener ) throw( RuntimeException, std::exception )
 525 {
 526     impl_getMultiplexer()->unadvise( cppu::UnoType<XWindowListener>::get(), xListener );
 527 }
 528
 529 //  XWindow
 530
 531 void SAL_CALL BaseControl::removeFocusListener( const Reference< XFocusListener >& xListener ) throw( RuntimeException, std::exception )
 532 {
 533     impl_getMultiplexer()->unadvise( cppu::UnoType<XFocusListener>::get(), xListener );
 534 }
 535
 536 //  XWindow
 537
 538 void SAL_CALL BaseControl::removeKeyListener( const Reference< XKeyListener >& xListener ) throw( RuntimeException, std::exception )
 539 {
 540     impl_getMultiplexer()->unadvise( cppu::UnoType<XKeyListener>::get(), xListener );
 541 }
 542
 543 //  XWindow
 544
 545 void SAL_CALL BaseControl::removeMouseListener( const Reference< XMouseListener >& xListener ) throw( RuntimeException, std::exception )
 546 {
 547     impl_getMultiplexer()->unadvise( cppu::UnoType<XMouseListener>::get(), xListener );
 548 }
 549
 550 //  XWindow
 551
 552 void  SAL_CALL BaseControl::removeMouseMotionListener( const Reference< XMouseMotionListener >& xListener ) throw( RuntimeException, std::exception )
 553 {
 554     impl_getMultiplexer()->unadvise( cppu::UnoType<XMouseMotionListener>::get(), xListener );
 555 }
 556
 557 //  XWindow
 558
 559 void SAL_CALL BaseControl::removePaintListener( const Reference< XPaintListener >& xListener ) throw( RuntimeException, std::exception )
 560 {
 561     impl_getMultiplexer()->unadvise( cppu::UnoType<XPaintListener>::get(), xListener );
 562 }
 563
 564 //  XView
 565
 566 void SAL_CALL BaseControl::draw(    sal_Int32   nX  ,
 567                                     sal_Int32   nY  ) throw( RuntimeException, std::exception )
 568 {
 569     // Ready for multithreading
 570     MutexGuard aGuard( m_aMutex );
 571
 572     // - paint to an view
 573     // - use the method "paint()"
 574     // - see also "windowPaint()"
 575     impl_paint( nX, nY, m_xGraphicsView );
 576 }
 577
 578 //  XView
 579
 580 sal_Bool SAL_CALL BaseControl::setGraphics( const Reference< XGraphics >& xDevice ) throw( RuntimeException, std::exception )
 581 {
 582     // - set the graphics for an view
 583     // - in this class exist 2 graphics-member ... one for peer[_xGraphicsPeer] and one for view[_xGraphicsView]
 584     // - they are used by "windowPaint() and draw()", forwarded to "paint ()"
 585     bool bReturn = false;
 586     if ( xDevice.is() )
 587     {
 588         // Ready for multithreading
 589         MutexGuard aGuard( m_aMutex );
 590
 591         m_xGraphicsView = xDevice;
 592         bReturn         = true;
 593     }
 594
 595     return bReturn;
 596 }
 597
 598 //  XView
 599
 600 void SAL_CALL BaseControl::setZoom( float   /*fZoomX*/  ,
 601                                     float   /*fZoomY*/  ) throw( RuntimeException, std::exception )
 602 {
 603     // Not implemented yet
 604 }
 605
 606 //  XView
 607
 608 Reference< XGraphics > SAL_CALL BaseControl::getGraphics() throw( RuntimeException, std::exception )
 609 {
 610     // Ready for multithreading
 611     MutexGuard aGuard( m_aMutex );
 612     return m_xGraphicsView;
 613 }
 614
 615 //  XView
 616
 617 Size SAL_CALL BaseControl::getSize() throw( RuntimeException, std::exception )
 618 {
 619     // Ready for multithreading
 620     MutexGuard aGuard( m_aMutex );
 621     return Size( m_nWidth, m_nHeight );
 622 }
 623
 624 //  XEventListener
 625
 626 void SAL_CALL BaseControl::disposing( const EventObject& /*aSource*/ ) throw( RuntimeException, std::exception )
 627 {
 628     // Ready for multithreading
 629     MutexGuard aGuard( m_aMutex );
 630
 631     // - release ALL references
 632     // - it must be !!!
 633     if ( m_xGraphicsPeer.is() )
 634     {
 635         removePaintListener( this );
 636         removeWindowListener( this );
 637         m_xGraphicsPeer.clear();
 638     }
 639
 640     if ( m_xGraphicsView.is() )
 641     {
 642         m_xGraphicsView.clear();
 643     }
 644 }
 645
 646 //  XPaintListener
 647
 648 void SAL_CALL BaseControl::windowPaint( const PaintEvent& /*aEvent*/ ) throw( RuntimeException, std::exception )
 649 {
 650     // Ready for multithreading
 651     MutexGuard aGuard( m_aMutex );
 652
 653     // - repaint the peer
 654     // - use the method "paint ()" for painting on a peer and a print device !!!
 655     // - see also "draw ()"
 656     impl_paint( 0, 0, m_xGraphicsPeer );
 657 }
 658
 659 //  XWindowListener
 660
 661 void SAL_CALL BaseControl::windowResized( const WindowEvent& aEvent ) throw( RuntimeException, std::exception )
 662 {
 663     // Ready for multithreading
 664     MutexGuard aGuard( m_aMutex );
 665
 666     m_nWidth    =   aEvent.Width;
 667     m_nHeight   =   aEvent.Height;
 668     WindowEvent aMappedEvent = aEvent;
 669     aMappedEvent.X = 0;
 670     aMappedEvent.Y = 0;
 671     impl_recalcLayout( aMappedEvent );
 672 }
 673
 674 //  XWindowListener
 675
 676 void SAL_CALL BaseControl::windowMoved( const WindowEvent& aEvent ) throw( RuntimeException, std::exception )
 677 {
 678     // Ready for multithreading
 679     MutexGuard aGuard( m_aMutex );
 680
 681     m_nWidth    =   aEvent.Width;
 682     m_nHeight   =   aEvent.Height;
 683     WindowEvent aMappedEvent = aEvent;
 684     aMappedEvent.X = 0;
 685     aMappedEvent.Y = 0;
 686     impl_recalcLayout( aMappedEvent );
 687 }
 688
 689 //  XWindowListener
 690
 691 void SAL_CALL BaseControl::windowShown( const EventObject& /*aEvent*/ ) throw( RuntimeException, std::exception )
 692 {
 693 }
 694
 695 //  XWindowListener
 696
 697 void SAL_CALL BaseControl::windowHidden( const EventObject& /*aEvent*/ ) throw( RuntimeException, std::exception )
 698 {
 699 }
 700
 701 //  impl but public method to register service in DLL
 702 //  (In this BASE-implementation not implemented! Overwrite it in derived classes.)
 703
 704 const Sequence< OUString > BaseControl::impl_getStaticSupportedServiceNames()
 705 {
 706     return Sequence< OUString >();
 707 }
 708
 709 //  impl but public method to register service in DLL
 710 //  (In this BASE-implementation not implemented! Overwrite it in derived classes.)
 711
 712 const OUString BaseControl::impl_getStaticImplementationName()
 713 {
 714     return OUString();
 715 }
 716
 717 //  protected method
 718
 719 WindowDescriptor* BaseControl::impl_getWindowDescriptor( const Reference< XWindowPeer >& xParentPeer )
 720 {
 721     // - used from "createPeer()" to set the values of an ::com::sun::star::awt::WindowDescriptor !!!
 722     // - if you will change the descriptor-values, you must override this virtuell function
 723     // - the caller must release the memory for this dynamical descriptor !!!
 724
 725     WindowDescriptor* pDescriptor = new WindowDescriptor;
 726
 727     pDescriptor->Type               = WindowClass_SIMPLE;
 728     pDescriptor->WindowServiceName  = "window";
 729     pDescriptor->ParentIndex        = -1;
 730     pDescriptor->Parent             = xParentPeer;
 731     pDescriptor->Bounds             = getPosSize ();
 732     pDescriptor->WindowAttributes   = 0;
 733
 734     return pDescriptor;
 735 }
 736
 737 //  protected method
 738
 739 void BaseControl::impl_paint(           sal_Int32               /*nX*/          ,
 740                                         sal_Int32               /*nY*/          ,
 741                                 const   Reference< XGraphics >& /*xGraphics*/   )
 742 {
 743     // - one paint method for peer AND view !!!
 744     //   (see also => "windowPaint()" and "draw()")
 745     // - not used in this implementation, but its not necessary to make it pure virtual !!!
 746 }
 747
 748 //  protected method
 749
 750 void BaseControl::impl_recalcLayout( const WindowEvent& /*aEvent*/ )
 751 {
 752     // We need as virtual function to support automatically resizing of derived controls!
 753     // But we make it not pure virtual because it's not necessary for all derived classes!
 754 }
 755
 756 //  protected method
 757
 758
 759 //  private method
 760
 761 void BaseControl::impl_releasePeer()
 762 {
 763     if ( m_xPeer.is() )
 764     {
 765         if ( m_xGraphicsPeer.is() )
 766         {
 767             removePaintListener( this );
 768             removeWindowListener( this );
 769             m_xGraphicsPeer.clear();
 770         }
 771
 772         m_xPeer->dispose();
 773         m_xPeerWindow.clear();
 774         m_xPeer.clear();
 775
 776         if ( m_pMultiplexer != NULL )
 777         {
 778             // take changes on multiplexer
 779             m_pMultiplexer->setPeer( Reference< XWindow >() );
 780         }
 781     }
 782 }
 783
 784 //  private method
 785
 786 OMRCListenerMultiplexerHelper* BaseControl::impl_getMultiplexer()
 787 {
 788     if ( m_pMultiplexer == NULL )
 789     {
 790         m_pMultiplexer = new OMRCListenerMultiplexerHelper( (XWindow*)this, m_xPeerWindow );
 791         m_xMultiplexer = Reference< XInterface >( (OWeakObject*)m_pMultiplexer, UNO_QUERY );
 792     }
 793
 794     return m_pMultiplexer;
 795 }
 796
 797 } // namespace unocontrols
 798
 799 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */