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
  22 #include <com/sun/star/beans/PropertyAttribute.hpp>
  23 #include <com/sun/star/frame/Frame.hpp>
  24 #include <com/sun/star/frame/FrameSearchFlag.hpp>
  25 #include <com/sun/star/frame/XDispatch.hpp>
  26 #include <com/sun/star/util/URLTransformer.hpp>
  27 #include <com/sun/star/util/XURLTransformer.hpp>
  28 #include <comphelper/processfactory.hxx>
  29 #include <cppuhelper/queryinterface.hxx>
  30 #include <cppuhelper/typeprovider.hxx>
  31 #include <osl/diagnose.h>
  32
  33 //  namespaces
  34
  35 using namespace ::osl;
  36 using namespace ::cppu;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::beans;
  40 using namespace ::com::sun::star::awt;
  41 using namespace ::com::sun::star::frame;
  42 using namespace ::com::sun::star::util;
  43
  44 namespace unocontrols{
  45
  46 enum PropertyHandle  // values represent index in PropertyArray
  47 {                   // for FrameControl
  48     Componenturl    = 0,
  49     Frame           = 1,
  50     Loaderarguments = 2
  51 };
  52
  53 //  construct/destruct
  54
  55 FrameControl::FrameControl( const Reference< XComponentContext >& rxContext)
  56     : BaseControl                   ( rxContext                                     )
  57     , OBroadcastHelper              ( m_aMutex                                      )
  58     , OPropertySetHelper            ( *static_cast< OBroadcastHelper * >(this)      )
  59     , m_aConnectionPointContainer   ( new OConnectionPointContainerHelper(m_aMutex) )
  60 {
  61 }
  62
  63 FrameControl::~FrameControl()
  64 {
  65 }
  66
  67 //  XInterface
  68
  69 Any SAL_CALL FrameControl::queryInterface( const Type& rType )
  70 {
  71     // Attention:
  72     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  73     Any aReturn;
  74     Reference< XInterface > xDel = BaseControl::impl_getDelegator();
  75     if ( xDel.is() )
  76     {
  77         // If an delegator exist, forward question to his queryInterface.
  78         // Delegator will ask his own queryAggregation!
  79         aReturn = xDel->queryInterface( rType );
  80     }
  81     else
  82     {
  83         // If an delegator unknown, forward question to own queryAggregation.
  84         aReturn = queryAggregation( rType );
  85     }
  86
  87     return aReturn;
  88 }
  89
  90 //  XInterface
  91
  92 void SAL_CALL FrameControl::acquire() throw()
  93 {
  94     // Attention:
  95     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  96
  97     // Forward to baseclass
  98     BaseControl::acquire();
  99 }
 100
 101 //  XInterface
 102
 103 void SAL_CALL FrameControl::release() throw()
 104 {
 105     // Attention:
 106     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 107
 108     // Forward to baseclass
 109     BaseControl::release();
 110 }
 111
 112 //  XTypeProvider
 113
 114 Sequence< Type > SAL_CALL FrameControl::getTypes()
 115 {
 116     static OTypeCollection ourTypeCollection(
 117                 cppu::UnoType<XControlModel>::get(),
 118                 cppu::UnoType<XControlContainer>::get(),
 119                 cppu::UnoType<XConnectionPointContainer>::get(),
 120                 BaseControl::getTypes() );
 121
 122     return ourTypeCollection.getTypes();
 123 }
 124
 125 //  XAggregation
 126
 127 Any SAL_CALL FrameControl::queryAggregation( const Type& aType )
 128 {
 129     // Ask for my own supported interfaces ...
 130     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 131     Any aReturn ( ::cppu::queryInterface(   aType                                               ,
 132                                                static_cast< XControlModel*              > ( this )  ,
 133                                                static_cast< XConnectionPointContainer*  > ( this )
 134                                         )
 135                 );
 136
 137     // If searched interface not supported by this class ...
 138     if ( !aReturn.hasValue() )
 139     {
 140         // ... ask baseclasses.
 141         aReturn = OPropertySetHelper::queryInterface( aType );
 142         if ( !aReturn.hasValue() )
 143         {
 144             aReturn = BaseControl::queryAggregation( aType );
 145         }
 146     }
 147
 148     return aReturn;
 149 }
 150
 151 OUString FrameControl::getImplementationName()
 152 {
 153     return impl_getStaticImplementationName();
 154 }
 155
 156 css::uno::Sequence<OUString> FrameControl::getSupportedServiceNames()
 157 {
 158     return impl_getStaticSupportedServiceNames();
 159 }
 160
 161 //  XControl
 162
 163 void SAL_CALL FrameControl::createPeer( const   Reference< XToolkit >&      xToolkit    ,
 164                                         const   Reference< XWindowPeer >&   xParentPeer )
 165 {
 166     BaseControl::createPeer( xToolkit, xParentPeer );
 167     if ( impl_getPeerWindow().is() )
 168     {
 169         if( !m_sComponentURL.isEmpty() )
 170         {
 171             impl_createFrame( getPeer(), m_sComponentURL, m_seqLoaderArguments );
 172         }
 173     }
 174 }
 175
 176 //  XControl
 177
 178 sal_Bool SAL_CALL FrameControl::setModel( const Reference< XControlModel >& /*xModel*/ )
 179 {
 180     // We have no model.
 181     return false;
 182 }
 183
 184 //  XControl
 185
 186 Reference< XControlModel > SAL_CALL FrameControl::getModel()
 187 {
 188     // We have no model.
 189     return Reference< XControlModel >();
 190 }
 191
 192 //  XControl
 193
 194 void SAL_CALL FrameControl::dispose()
 195 {
 196     impl_deleteFrame();
 197     BaseControl::dispose();
 198 }
 199
 200 //  XView
 201
 202 sal_Bool SAL_CALL FrameControl::setGraphics( const Reference< XGraphics >& /*xDevice*/ )
 203 {
 204     // it is not possible to print this control
 205     return false;
 206 }
 207
 208 //  XView
 209
 210 Reference< XGraphics > SAL_CALL FrameControl::getGraphics()
 211 {
 212     // when it's not possible to set graphics ! then it's possible to return null
 213     return Reference< XGraphics >();
 214 }
 215
 216 //  XConnectionPointContainer
 217
 218 Sequence< Type > SAL_CALL FrameControl::getConnectionPointTypes()
 219 {
 220     // Forwarded to helper class
 221     return m_aConnectionPointContainer->getConnectionPointTypes();
 222 }
 223
 224 //  XConnectionPointContainer
 225
 226 Reference< XConnectionPoint > SAL_CALL FrameControl::queryConnectionPoint( const Type& aType )
 227 {
 228     // Forwarded to helper class
 229     return m_aConnectionPointContainer->queryConnectionPoint( aType );
 230 }
 231
 232 //  XConnectionPointContainer
 233
 234 void SAL_CALL FrameControl::advise( const   Type&                       aType       ,
 235                                     const   Reference< XInterface >&    xListener   )
 236 {
 237     // Forwarded to helper class
 238     m_aConnectionPointContainer->advise( aType, xListener );
 239 }
 240
 241 //  XConnectionPointContainer
 242
 243 void SAL_CALL FrameControl::unadvise(   const   Type&                       aType       ,
 244                                         const   Reference< XInterface >&    xListener   )
 245 {
 246     // Forwarded to helper class
 247     m_aConnectionPointContainer->unadvise( aType, xListener );
 248 }
 249
 250 //  impl but public method to register service
 251
 252 const Sequence< OUString > FrameControl::impl_getStaticSupportedServiceNames()
 253 {
 254     Sequence<OUString> seqServiceNames { "com.sun.star.frame.FrameControl" };
 255     return seqServiceNames;
 256 }
 257
 258 //  impl but public method to register service
 259
 260 const OUString FrameControl::impl_getStaticImplementationName()
 261 {
 262     return OUString("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* pDescriptor   = new WindowDescriptor;
 375
 376     pDescriptor->Type               = WindowClass_CONTAINER;
 377     pDescriptor->ParentIndex        = -1;
 378     pDescriptor->Parent             = xParentPeer;
 379     pDescriptor->Bounds             = getPosSize ();
 380     pDescriptor->WindowAttributes   = 0;
 381
 382     return pDescriptor;
 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: */