UnoControls/source/controls/framecontrol.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 <framecontrol.hxx>
  21 #include <OConnectionPointContainerHelper.hxx>
  22
  23 #include <com/sun/star/awt/XControlContainer.hpp>
  24 #include <com/sun/star/beans/PropertyAttribute.hpp>
  25 #include <com/sun/star/frame/Frame.hpp>
  26 #include <com/sun/star/frame/FrameSearchFlag.hpp>
  27 #include <com/sun/star/frame/XDispatch.hpp>
  28 #include <com/sun/star/util/URLTransformer.hpp>
  29 #include <com/sun/star/util/XURLTransformer.hpp>
  30 #include <cppuhelper/queryinterface.hxx>
  31 #include <cppuhelper/typeprovider.hxx>
  32 #include <osl/diagnose.h>
  33
  34 //  namespaces
  35
  36 using namespace ::osl;
  37 using namespace ::cppu;
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::lang;
  40 using namespace ::com::sun::star::beans;
  41 using namespace ::com::sun::star::awt;
  42 using namespace ::com::sun::star::frame;
  43 using namespace ::com::sun::star::util;
  44
  45 namespace unocontrols {
  46
  47 enum PropertyHandle  // values represent index in PropertyArray
  48 {                   // for FrameControl
  49     Componenturl    = 0,
  50     Frame           = 1,
  51     Loaderarguments = 2
  52 };
  53
  54 //  construct/destruct
  55
  56 FrameControl::FrameControl( const Reference< XComponentContext >& rxContext)
  57     : BaseControl                   ( rxContext                                     )
  58     , OBroadcastHelper              ( m_aMutex                                      )
  59     , OPropertySetHelper            ( *static_cast< OBroadcastHelper * >(this)      )
  60     , m_aConnectionPointContainer   ( new OConnectionPointContainerHelper(m_aMutex) )
  61 {
  62 }
  63
  64 FrameControl::~FrameControl()
  65 {
  66 }
  67
  68 //  XInterface
  69
  70 Any SAL_CALL FrameControl::queryInterface( const Type& rType )
  71 {
  72     // Attention:
  73     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  74     Any aReturn;
  75     Reference< XInterface > xDel = BaseControl::impl_getDelegator();
  76     if ( xDel.is() )
  77     {
  78         // If a delegator exists, forward question to its queryInterface.
  79         // Delegator will ask its own queryAggregation!
  80         aReturn = xDel->queryInterface( rType );
  81     }
  82     else
  83     {
  84         // If a delegator is unknown, forward question to own queryAggregation.
  85         aReturn = queryAggregation( rType );
  86     }
  87
  88     return aReturn;
  89 }
  90
  91 //  XInterface
  92
  93 void SAL_CALL FrameControl::acquire() throw()
  94 {
  95     // Attention:
  96     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  97
  98     // Forward to baseclass
  99     BaseControl::acquire();
 100 }
 101
 102 //  XInterface
 103
 104 void SAL_CALL FrameControl::release() throw()
 105 {
 106     // Attention:
 107     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 108
 109     // Forward to baseclass
 110     BaseControl::release();
 111 }
 112
 113 //  XTypeProvider
 114
 115 Sequence< Type > SAL_CALL FrameControl::getTypes()
 116 {
 117     static OTypeCollection ourTypeCollection(
 118                 cppu::UnoType<XControlModel>::get(),
 119                 cppu::UnoType<XControlContainer>::get(),
 120                 cppu::UnoType<XConnectionPointContainer>::get(),
 121                 BaseControl::getTypes() );
 122
 123     return ourTypeCollection.getTypes();
 124 }
 125
 126 //  XAggregation
 127
 128 Any SAL_CALL FrameControl::queryAggregation( const Type& aType )
 129 {
 130     // Ask for my own supported interfaces ...
 131     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 132     Any aReturn ( ::cppu::queryInterface(   aType                                               ,
 133                                                static_cast< XControlModel*              > ( this )  ,
 134                                                static_cast< XConnectionPointContainer*  > ( this )
 135                                         )
 136                 );
 137
 138     // If searched interface not supported by this class ...
 139     if ( !aReturn.hasValue() )
 140     {
 141         // ... ask baseclasses.
 142         aReturn = OPropertySetHelper::queryInterface( aType );
 143         if ( !aReturn.hasValue() )
 144         {
 145             aReturn = BaseControl::queryAggregation( aType );
 146         }
 147     }
 148
 149     return aReturn;
 150 }
 151
 152 OUString FrameControl::getImplementationName()
 153 {
 154     return impl_getStaticImplementationName();
 155 }
 156
 157 css::uno::Sequence<OUString> FrameControl::getSupportedServiceNames()
 158 {
 159     return impl_getStaticSupportedServiceNames();
 160 }
 161
 162 //  XControl
 163
 164 void SAL_CALL FrameControl::createPeer( const   Reference< XToolkit >&      xToolkit    ,
 165                                         const   Reference< XWindowPeer >&   xParentPeer )
 166 {
 167     BaseControl::createPeer( xToolkit, xParentPeer );
 168     if ( impl_getPeerWindow().is() )
 169     {
 170         if( !m_sComponentURL.isEmpty() )
 171         {
 172             impl_createFrame( getPeer(), m_sComponentURL, m_seqLoaderArguments );
 173         }
 174     }
 175 }
 176
 177 //  XControl
 178
 179 sal_Bool SAL_CALL FrameControl::setModel( const Reference< XControlModel >& /*xModel*/ )
 180 {
 181     // We have no model.
 182     return false;
 183 }
 184
 185 //  XControl
 186
 187 Reference< XControlModel > SAL_CALL FrameControl::getModel()
 188 {
 189     // We have no model.
 190     return Reference< XControlModel >();
 191 }
 192
 193 //  XControl
 194
 195 void SAL_CALL FrameControl::dispose()
 196 {
 197     impl_deleteFrame();
 198     BaseControl::dispose();
 199 }
 200
 201 //  XView
 202
 203 sal_Bool SAL_CALL FrameControl::setGraphics( const Reference< XGraphics >& /*xDevice*/ )
 204 {
 205     // it is not possible to print this control
 206     return false;
 207 }
 208
 209 //  XView
 210
 211 Reference< XGraphics > SAL_CALL FrameControl::getGraphics()
 212 {
 213     // when it's not possible to set graphics ! then it's possible to return null
 214     return Reference< XGraphics >();
 215 }
 216
 217 //  XConnectionPointContainer
 218
 219 Sequence< Type > SAL_CALL FrameControl::getConnectionPointTypes()
 220 {
 221     // Forwarded to helper class
 222     return m_aConnectionPointContainer->getConnectionPointTypes();
 223 }
 224
 225 //  XConnectionPointContainer
 226
 227 Reference< XConnectionPoint > SAL_CALL FrameControl::queryConnectionPoint( const Type& aType )
 228 {
 229     // Forwarded to helper class
 230     return m_aConnectionPointContainer->queryConnectionPoint( aType );
 231 }
 232
 233 //  XConnectionPointContainer
 234
 235 void SAL_CALL FrameControl::advise( const   Type&                       aType       ,
 236                                     const   Reference< XInterface >&    xListener   )
 237 {
 238     // Forwarded to helper class
 239     m_aConnectionPointContainer->advise( aType, xListener );
 240 }
 241
 242 //  XConnectionPointContainer
 243
 244 void SAL_CALL FrameControl::unadvise(   const   Type&                       aType       ,
 245                                         const   Reference< XInterface >&    xListener   )
 246 {
 247     // Forwarded to helper class
 248     m_aConnectionPointContainer->unadvise( aType, xListener );
 249 }
 250
 251 //  impl but public method to register service
 252
 253 Sequence< OUString > FrameControl::impl_getStaticSupportedServiceNames()
 254 {
 255     return { "com.sun.star.frame.FrameControl" };
 256 }
 257
 258 //  impl but public method to register service
 259
 260 OUString FrameControl::impl_getStaticImplementationName()
 261 {
 262     return "stardiv.UnoControls.FrameControl";
 263 }
 264
 265 //  OPropertySetHelper
 266
 267 sal_Bool FrameControl::convertFastPropertyValue(        Any&        rConvertedValue ,
 268                                                         Any&        rOldValue       ,
 269                                                         sal_Int32   nHandle         ,
 270                                                 const   Any&        rValue          )
 271 {
 272     bool bReturn = false;
 273     switch (nHandle)
 274     {
 275         case PropertyHandle::Componenturl        :      rConvertedValue   = rValue;
 276                                                         rOldValue       <<= m_sComponentURL;
 277                                                         bReturn           = true;
 278                                                         break;
 279
 280         case PropertyHandle::Loaderarguments     :      rConvertedValue   = rValue;
 281                                                         rOldValue       <<= m_seqLoaderArguments;
 282                                                         bReturn           = true;
 283                                                         break;
 284     }
 285
 286     if ( !bReturn )
 287     {
 288         throw IllegalArgumentException();
 289     }
 290
 291     return bReturn;
 292 }
 293
 294 //  OPropertySetHelper
 295
 296 void FrameControl::setFastPropertyValue_NoBroadcast(            sal_Int32   nHandle ,
 297                                                         const   Any&        rValue  )
 298 {
 299     // this method only set the value
 300     MutexGuard  aGuard (m_aMutex);
 301     switch (nHandle)
 302     {
 303         case PropertyHandle::Componenturl        :      rValue >>= m_sComponentURL;
 304                                                         if (getPeer().is())
 305                                                         {
 306                                                             impl_createFrame ( getPeer(), m_sComponentURL, m_seqLoaderArguments );
 307                                                         }
 308                                                         break;
 309
 310         case PropertyHandle::Loaderarguments     :      rValue >>= m_seqLoaderArguments;
 311                                                         break;
 312
 313         default :                                       OSL_ENSURE ( nHandle == -1, "This is an invalid property handle." );
 314     }
 315 }
 316
 317 //  OPropertySetHelper
 318
 319 void FrameControl::getFastPropertyValue(    Any&        rRet    ,
 320                                             sal_Int32   nHandle ) const
 321 {
 322     MutexGuard  aGuard ( Mutex::getGlobalMutex() );
 323
 324     switch (nHandle)
 325     {
 326         case PropertyHandle::Componenturl    :      rRet <<= m_sComponentURL;
 327                                                     break;
 328
 329         case PropertyHandle::Loaderarguments :      rRet <<= m_seqLoaderArguments;
 330                                                     break;
 331
 332         case PropertyHandle::Frame           :      rRet <<= m_xFrame;
 333                                                        break;
 334
 335         default :                                   OSL_ENSURE ( nHandle == -1, "This is an invalid property handle." );
 336     }
 337 }
 338
 339 //  OPropertySetHelper
 340
 341 IPropertyArrayHelper& FrameControl::getInfoHelper()
 342 {
 343     // Create a table that map names to index values.
 344     // attention: properties need to be sorted by name!
 345     static OPropertyArrayHelper ourPropertyInfo(
 346                 {
 347                     Property( "ComponentUrl", PropertyHandle::Componenturl, cppu::UnoType<OUString>::get(),
 348                             PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED ),
 349                     Property( "Frame", PropertyHandle::Frame, cppu::UnoType<XFrame>::get(),
 350                             PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT ),
 351                     Property( "LoaderArguments", PropertyHandle::Loaderarguments, cppu::UnoType<Sequence<PropertyValue>>::get(),
 352                             PropertyAttribute::BOUND | PropertyAttribute::CONSTRAINED )
 353                 },
 354                 true );
 355
 356     return ourPropertyInfo;
 357 }
 358
 359 //  OPropertySetHelper
 360
 361 Reference< XPropertySetInfo > SAL_CALL FrameControl::getPropertySetInfo()
 362 {
 363     // Create structure of propertysetinfo for baseclass "OPropertySetHelper".
 364     // (Use method "getInfoHelper()".)
 365     static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 366
 367     return xInfo;
 368 }
 369
 370 //  BaseControl
 371
 372 WindowDescriptor FrameControl::impl_getWindowDescriptor( const Reference< XWindowPeer >& xParentPeer )
 373 {
 374     WindowDescriptor aDescriptor;
 375
 376     aDescriptor.Type               = WindowClass_CONTAINER;
 377     aDescriptor.ParentIndex        = -1;
 378     aDescriptor.Parent             = xParentPeer;
 379     aDescriptor.Bounds             = getPosSize ();
 380     aDescriptor.WindowAttributes   = 0;
 381
 382     return aDescriptor;
 383 }
 384
 385 //  private method
 386
 387 void FrameControl::impl_createFrame(    const   Reference< XWindowPeer >&   xPeer       ,
 388                                         const   OUString&                   rURL        ,
 389                                         const   Sequence< PropertyValue >&  rArguments  )
 390 {
 391     Reference< XFrame2 >     xOldFrame;
 392     Reference< XFrame2 >     xNewFrame;
 393
 394     {
 395         MutexGuard  aGuard ( m_aMutex );
 396         xOldFrame = m_xFrame;
 397     }
 398
 399     xNewFrame = Frame::create( impl_getComponentContext() );
 400
 401     Reference< XWindow >  xWP ( xPeer, UNO_QUERY );
 402     xNewFrame->initialize ( xWP );
 403
 404     //  option
 405     //xFrame->setName( "WhatYouWant" );
 406
 407     Reference< XURLTransformer > xTrans = URLTransformer::create( impl_getComponentContext() );
 408     // load file
 409     URL aURL;
 410     aURL.Complete = rURL;
 411     xTrans->parseStrict( aURL );
 412
 413     Reference< XDispatch >  xDisp = xNewFrame->queryDispatch ( aURL, OUString (), FrameSearchFlag::SELF );
 414     if (xDisp.is())
 415     {
 416         xDisp->dispatch ( aURL, rArguments );
 417     }
 418
 419     // set the frame
 420     {
 421         MutexGuard aGuard ( m_aMutex );
 422         m_xFrame = xNewFrame;
 423     }
 424
 425     // notify the listeners
 426     sal_Int32   nFrameId = PropertyHandle::Frame;
 427     Any aNewFrame ( &xNewFrame, cppu::UnoType<XFrame>::get());
 428     Any aOldFrame ( &xOldFrame, cppu::UnoType<XFrame>::get());
 429
 430     fire ( &nFrameId, &aNewFrame, &aOldFrame, 1, false );
 431
 432     if (xOldFrame.is())
 433     {
 434         xOldFrame->dispose ();
 435     }
 436 }
 437
 438 //  private method
 439
 440 void FrameControl::impl_deleteFrame()
 441 {
 442     Reference< XFrame2 >  xOldFrame;
 443     Reference< XFrame2 >  xNullFrame;
 444
 445     {
 446         // do not dispose the frame in this guarded section (deadlock?)
 447         MutexGuard aGuard( m_aMutex );
 448         xOldFrame = m_xFrame;
 449         m_xFrame.clear();
 450     }
 451
 452     // notify the listeners
 453     sal_Int32 nFrameId = PropertyHandle::Frame;
 454     Any aNewFrame( &xNullFrame, cppu::UnoType<XFrame2>::get());
 455     Any aOldFrame( &xOldFrame, cppu::UnoType<XFrame2>::get());
 456     fire( &nFrameId, &aNewFrame, &aOldFrame, 1, false );
 457
 458     // dispose the frame
 459     if( xOldFrame.is() )
 460         xOldFrame->dispose();
 461 }
 462
 463
 464 }   // namespace unocontrols
 465
 466 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */