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