forms/source/richtext/richtextcontrol.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 "richtextcontrol.hxx"
  21 #include "property.hrc"
  22 #include "services.hxx"
  23
  24 #include "richtextmodel.hxx"
  25 #include "richtextvclcontrol.hxx"
  26 #include "clipboarddispatcher.hxx"
  27 #include "parametrizedattributedispatcher.hxx"
  28 #include "specialdispatchers.hxx"
  29
  30 #include <com/sun/star/awt/PosSize.hpp>
  31
  32 #include <toolkit/helper/vclunohelper.hxx>
  33 #include <tools/diagnose_ex.h>
  34 #include <vcl/svapp.hxx>
  35
  36 #include <svx/svxids.hrc>
  37 #include <editeng/editview.hxx>
  38 #include <svl/itemset.hxx>
  39 #include <svl/itempool.hxx>
  40 #include <sfx2/msgpool.hxx>
  41
  42 namespace frm
  43 {
  44
  45
  46     using namespace ::com::sun::star::uno;
  47     using namespace ::com::sun::star::beans;
  48     using namespace ::com::sun::star::awt;
  49     using namespace ::com::sun::star::lang;
  50     using namespace ::com::sun::star::frame;
  51
  52     ORichTextControl::ORichTextControl()
  53         :UnoEditControl()
  54     {
  55     }
  56
  57
  58     ORichTextControl::~ORichTextControl()
  59     {
  60     }
  61
  62
  63     IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextControl, UnoEditControl, ORichTextControl_Base )
  64
  65
  66     Any SAL_CALL ORichTextControl::queryAggregation( const Type& _rType ) throw ( RuntimeException, std::exception )
  67     {
  68         Any aReturn = UnoEditControl::queryAggregation( _rType );
  69
  70         if ( !aReturn.hasValue() )
  71             aReturn = ORichTextControl_Base::queryInterface( _rType );
  72
  73         return aReturn;
  74     }
  75
  76
  77     namespace
  78     {
  79
  80         void implAdjustTriStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName,
  81             WinBits& _rAllBits, WinBits _nPositiveFlag, WinBits nNegativeFlag )
  82         {
  83             bool bFlagValue = false;
  84             if ( _rxProps->getPropertyValue( _rPropertyName ) >>= bFlagValue )
  85                 _rAllBits |= ( bFlagValue ? _nPositiveFlag : nNegativeFlag );
  86         }
  87
  88
  89         void implAdjustTwoStateFlag( const Any& _rValue, WinBits& _rAllBits, WinBits _nFlag, bool _bInvert = false )
  90         {
  91             bool bFlagValue = false;
  92             if ( _rValue >>= bFlagValue )
  93             {
  94                 if ( _bInvert )
  95                     bFlagValue = !bFlagValue;
  96                 if ( bFlagValue )
  97                     _rAllBits |= _nFlag;
  98                 else
  99                     _rAllBits &= ~_nFlag;
 100             }
 101         }
 102
 103
 104         void implAdjustTwoStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName,
 105             WinBits& _rAllBits, WinBits _nFlag, bool _bInvert = false )
 106         {
 107             implAdjustTwoStateFlag( _rxProps->getPropertyValue( _rPropertyName ), _rAllBits, _nFlag, _bInvert );
 108         }
 109
 110
 111         void adjustTwoStateWinBit( vcl::Window* _pWindow, const Any& _rValue, WinBits _nFlag, bool _bInvert = false )
 112         {
 113             WinBits nBits = _pWindow->GetStyle();
 114             implAdjustTwoStateFlag( _rValue, nBits, _nFlag, _bInvert );
 115             _pWindow->SetStyle( nBits );
 116         }
 117
 118
 119         WinBits getWinBits( const Reference< XControlModel >& _rxModel )
 120         {
 121             WinBits nBits = 0;
 122             try
 123             {
 124                 Reference< XPropertySet > xProps( _rxModel, UNO_QUERY );
 125                 if ( xProps.is() )
 126                 {
 127                     sal_Int16 nBorder = 0;
 128                     xProps->getPropertyValue( PROPERTY_BORDER ) >>= nBorder;
 129                     if ( nBorder )
 130                         nBits |= WB_BORDER;
 131
 132                     implAdjustTriStateFlag( xProps, PROPERTY_TABSTOP,        nBits, WB_TABSTOP, WB_NOTABSTOP );
 133                     implAdjustTwoStateFlag( xProps, PROPERTY_HSCROLL,        nBits, WB_HSCROLL );
 134                     implAdjustTwoStateFlag( xProps, PROPERTY_VSCROLL,        nBits, WB_VSCROLL );
 135                     implAdjustTwoStateFlag( xProps, PROPERTY_HARDLINEBREAKS, nBits, WB_WORDBREAK, true );
 136                 }
 137             }
 138             catch( const Exception& )
 139             {
 140                 DBG_UNHANDLED_EXCEPTION();
 141             }
 142             return nBits;
 143         }
 144     }
 145
 146
 147     void SAL_CALL ORichTextControl::createPeer( const Reference< XToolkit >& _rToolkit, const Reference< XWindowPeer >& _rParentPeer ) throw( RuntimeException, std::exception )
 148     {
 149         bool bReallyActAsRichText = false;
 150         try
 151         {
 152             Reference< XPropertySet > xModelProps( getModel(), UNO_QUERY_THROW );
 153             xModelProps->getPropertyValue( PROPERTY_RICH_TEXT ) >>= bReallyActAsRichText;
 154         }
 155         catch( const Exception& )
 156         {
 157             DBG_UNHANDLED_EXCEPTION();
 158         }
 159
 160         if ( !bReallyActAsRichText )
 161         {
 162             UnoEditControl::createPeer( _rToolkit, _rParentPeer );
 163             return;
 164         }
 165
 166         SolarMutexGuard aGuard;
 167
 168         if (!getPeer().is())
 169         {
 170             mbCreatingPeer = true;
 171
 172             // determine the VLC window for the parent
 173             vcl::Window* pParentWin = nullptr;
 174             if ( _rParentPeer.is() )
 175             {
 176                 VCLXWindow* pParentXWin = VCLXWindow::GetImplementation( _rParentPeer );
 177                 if ( pParentXWin )
 178                     pParentWin = pParentXWin->GetWindow();
 179                 DBG_ASSERT( pParentWin, "ORichTextControl::createPeer: could not obtain the VCL-level parent window!" );
 180             }
 181
 182             // create the peer
 183             Reference< XControlModel > xModel( getModel() );
 184             ORichTextPeer* pPeer = ORichTextPeer::Create( xModel, pParentWin, getWinBits( xModel ) );
 185             DBG_ASSERT( pPeer, "ORichTextControl::createPeer: invalid peer returned!" );
 186             if ( pPeer )
 187             {
 188                 // by definition, the returned component is acquired once
 189                 pPeer->release();
 190
 191                 // announce the peer to the base class
 192                 setPeer( pPeer );
 193
 194                 // initialize ourself (and thus the peer) with the model properties
 195                 updateFromModel();
 196
 197                 Reference< XView >  xPeerView( getPeer(), UNO_QUERY );
 198                 if ( xPeerView.is() )
 199                 {
 200                     xPeerView->setZoom( maComponentInfos.nZoomX, maComponentInfos.nZoomY );
 201                     xPeerView->setGraphics( mxGraphics );
 202                 }
 203
 204                 // a lot of initial settings from our component infos
 205                 setPosSize( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight, PosSize::POSSIZE );
 206
 207                 pPeer->setVisible   ( maComponentInfos.bVisible && !mbDesignMode );
 208                 pPeer->setEnable    ( maComponentInfos.bEnable                   );
 209                 pPeer->setDesignMode( mbDesignMode                               );
 210
 211                 peerCreated();
 212             }
 213
 214             mbCreatingPeer = false;
 215         }
 216     }
 217
 218
 219     OUString SAL_CALL ORichTextControl::getImplementationName()  throw( RuntimeException, std::exception )
 220     {
 221         return getImplementationName_Static();
 222     }
 223
 224
 225     Sequence< OUString > SAL_CALL ORichTextControl::getSupportedServiceNames()  throw( RuntimeException, std::exception )
 226     {
 227         return getSupportedServiceNames_Static();
 228     }
 229
 230     OUString SAL_CALL ORichTextControl::getImplementationName_Static()
 231     {
 232         return OUString( "com.sun.star.comp.form.ORichTextControl" );
 233     }
 234
 235     Sequence< OUString > SAL_CALL ORichTextControl::getSupportedServiceNames_Static()
 236     {
 237         Sequence< OUString > aServices( 3 );
 238         aServices[ 0 ] = "com.sun.star.awt.UnoControl";
 239         aServices[ 1 ] = "com.sun.star.awt.UnoControlEdit";
 240         aServices[ 2 ] = FRM_SUN_CONTROL_RICHTEXTCONTROL;
 241         return aServices;
 242     }
 243
 244     Reference< XDispatch > SAL_CALL ORichTextControl::queryDispatch( const css::util::URL& _rURL, const OUString& _rTargetFrameName, sal_Int32 _nSearchFlags ) throw (RuntimeException, std::exception)
 245     {
 246         Reference< XDispatch > aReturn;
 247         Reference< XDispatchProvider > xTypedPeer( getPeer(), UNO_QUERY );
 248         if ( xTypedPeer.is() )
 249         {
 250             aReturn = xTypedPeer->queryDispatch( _rURL, _rTargetFrameName, _nSearchFlags );
 251         }
 252         return aReturn;
 253     }
 254
 255     Sequence< Reference< XDispatch > > SAL_CALL ORichTextControl::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) throw (RuntimeException, std::exception)
 256     {
 257         Sequence< Reference< XDispatch > > aReturn;
 258         Reference< XDispatchProvider > xTypedPeer( getPeer(), UNO_QUERY );
 259         if ( xTypedPeer.is() )
 260         {
 261             aReturn = xTypedPeer->queryDispatches( _rRequests );
 262         }
 263         return aReturn;
 264     }
 265
 266     bool ORichTextControl::requiresNewPeer( const OUString& _rPropertyName ) const
 267     {
 268         return UnoControl::requiresNewPeer( _rPropertyName ) || _rPropertyName == PROPERTY_RICH_TEXT;
 269     }
 270
 271     // ORichTextPeer
 272     ORichTextPeer* ORichTextPeer::Create( const Reference< XControlModel >& _rxModel, vcl::Window* _pParentWindow, WinBits _nStyle )
 273     {
 274         DBG_TESTSOLARMUTEX();
 275
 276         // the EditEngine of the model
 277         RichTextEngine* pEngine = ORichTextModel::getEditEngine( _rxModel );
 278         OSL_ENSURE( pEngine, "ORichTextPeer::Create: could not obtaine the edit engine from the model!" );
 279         if ( !pEngine )
 280             return nullptr;
 281
 282         // the peer itself
 283         ORichTextPeer* pPeer = new ORichTextPeer;
 284         pPeer->acquire();   // by definition, the returned object is acquired once
 285
 286         // the VCL control for the peer
 287         VclPtrInstance<RichTextControl> pRichTextControl( pEngine, _pParentWindow, _nStyle, nullptr, pPeer );
 288
 289         // some knittings
 290         pRichTextControl->SetComponentInterface( pPeer );
 291
 292         // outta here
 293         return pPeer;
 294     }
 295
 296
 297     ORichTextPeer::ORichTextPeer()
 298     {
 299     }
 300
 301
 302     ORichTextPeer::~ORichTextPeer()
 303     {
 304     }
 305
 306
 307     void ORichTextPeer::dispose( ) throw(RuntimeException, std::exception)
 308     {
 309         {
 310             SolarMutexGuard aGuard;
 311             VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >();
 312
 313             if ( pRichTextControl )
 314             {
 315                 for (   AttributeDispatchers::iterator aDisposeLoop = m_aDispatchers.begin();
 316                         aDisposeLoop != m_aDispatchers.end();
 317                         ++aDisposeLoop
 318                     )
 319                 {
 320                     pRichTextControl->disableAttributeNotification( aDisposeLoop->first );
 321                     aDisposeLoop->second->dispose();
 322                 }
 323             }
 324
 325             AttributeDispatchers aEmpty;
 326             m_aDispatchers.swap( aEmpty );
 327         }
 328
 329         VCLXWindow::dispose();
 330     }
 331
 332
 333     void SAL_CALL ORichTextPeer::draw( sal_Int32 _nX, sal_Int32 _nY ) throw(css::uno::RuntimeException, std::exception)
 334     {
 335         SolarMutexGuard aGuard;
 336
 337         VclPtr< RichTextControl > pControl = GetAs< RichTextControl >();
 338         if ( !pControl )
 339             return;
 340
 341         OutputDevice* pTargetDevice = VCLUnoHelper::GetOutputDevice( getGraphics() );
 342         OSL_ENSURE( pTargetDevice != nullptr, "ORichTextPeer::draw: no graphics -> no drawing!" );
 343         if ( !pTargetDevice )
 344             return;
 345
 346         ::Size aSize = pControl->GetSizePixel();
 347         const MapUnit eTargetUnit = pTargetDevice->GetMapMode().GetMapUnit();
 348         if ( eTargetUnit != MAP_PIXEL )
 349             aSize = pTargetDevice->PixelToLogic( aSize );
 350
 351         ::Point aPos( _nX, _nY );
 352         // the XView::draw API talks about pixels, always ...
 353         if ( eTargetUnit != MAP_PIXEL )
 354             aPos = pTargetDevice->PixelToLogic( aPos );
 355
 356         pControl->Draw( pTargetDevice, aPos, aSize, DrawFlags::NoControls );
 357     }
 358
 359
 360     void SAL_CALL ORichTextPeer::setProperty( const OUString& _rPropertyName, const Any& _rValue )
 361         throw (RuntimeException,
 362                std::exception)
 363     {
 364         SolarMutexGuard g;
 365
 366         if ( !GetWindow() )
 367         {
 368             VCLXWindow::setProperty( _rPropertyName, _rValue );
 369             return;
 370         }
 371
 372         if ( _rPropertyName == PROPERTY_BACKGROUNDCOLOR )
 373         {
 374             VclPtr< RichTextControl > pControl = GetAs< RichTextControl >();
 375             if ( !_rValue.hasValue() )
 376             {
 377                 pControl->SetBackgroundColor( );
 378             }
 379             else
 380             {
 381                 sal_Int32 nColor = COL_TRANSPARENT;
 382                 _rValue >>= nColor;
 383                 pControl->SetBackgroundColor( Color( nColor ) );
 384             }
 385         }
 386         else if ( _rPropertyName == PROPERTY_HSCROLL )
 387         {
 388             adjustTwoStateWinBit( GetWindow(), _rValue, WB_HSCROLL );
 389         }
 390         else if ( _rPropertyName == PROPERTY_VSCROLL )
 391         {
 392             adjustTwoStateWinBit( GetWindow(), _rValue, WB_VSCROLL );
 393         }
 394         else if ( _rPropertyName == PROPERTY_HARDLINEBREAKS )
 395         {
 396             adjustTwoStateWinBit( GetWindow(), _rValue, WB_WORDBREAK, true );
 397         }
 398         else if ( _rPropertyName == PROPERTY_READONLY )
 399         {
 400             VclPtr< RichTextControl > pControl = GetAs< RichTextControl >();
 401             bool bReadOnly( pControl->IsReadOnly() );
 402             OSL_VERIFY( _rValue >>= bReadOnly );
 403             pControl->SetReadOnly( bReadOnly );
 404
 405             // update the dispatchers
 406             for (   AttributeDispatchers::iterator aDispatcherLoop = m_aDispatchers.begin();
 407                     aDispatcherLoop != m_aDispatchers.end();
 408                     ++aDispatcherLoop
 409                 )
 410             {
 411                 aDispatcherLoop->second->invalidate();
 412             }
 413         }
 414         else if ( _rPropertyName == PROPERTY_HIDEINACTIVESELECTION )
 415         {
 416             VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >();
 417             bool bHide = pRichTextControl->GetHideInactiveSelection();
 418             OSL_VERIFY( _rValue >>= bHide );
 419             pRichTextControl->SetHideInactiveSelection( bHide );
 420         }
 421         else
 422             VCLXWindow::setProperty( _rPropertyName, _rValue );
 423     }
 424
 425
 426     IMPLEMENT_FORWARD_XINTERFACE2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base )
 427
 428
 429     IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base )
 430
 431
 432     namespace
 433     {
 434         SfxSlotId lcl_translateConflictingSlot( SfxSlotId _nIDFromPool )
 435         {
 436             // HACK HACK HACK
 437             // unfortunately, some of our applications have some conflicting slots,
 438             // i.e. slots which have the same UNO name as an existing other (common)
 439             // slot.
 440             // For instance, both the slots SID_SET_SUPER_SCRIPT (from SVX) and FN_SET_SUPER_SCRIPT
 441             // (from SW) have the UNO name "SuperScript".
 442             // Now, if the controls lives in a text document, and asks the SfxSlotPool for
 443             // the id belonging to "SuperScript", it gets the FN_SET_SUPER_SCRIPT - which
 444             // is completely unknown to the EditEngine.
 445             // So, we need to translate such conflicting ids.
 446
 447             // Note that the real solution would be to fix the applications to
 448             // *not* define conflicting slots. Alternatively, if SFX would provide a slot pool
 449             // which is *static* (i.e. independent on the active application), then we
 450             // would also never encounter such a conflict.
 451             SfxSlotId nReturn( _nIDFromPool );
 452             switch ( _nIDFromPool )
 453             {
 454             case 20411: /* FM_SET_SUPER_SCRIPT, originating in SW */
 455                 nReturn = SID_SET_SUPER_SCRIPT;
 456                 break;
 457             case 20412: /* FN_SET_SUB_SCRIPT, originating in SW */
 458                 nReturn = SID_SET_SUB_SCRIPT;
 459                 break;
 460             }
 461             return nReturn;
 462         }
 463     }
 464
 465
 466     ORichTextPeer::SingleAttributeDispatcher ORichTextPeer::implCreateDispatcher( SfxSlotId _nSlotId, const css::util::URL& _rURL )
 467     {
 468         VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >();
 469         OSL_PRECOND( pRichTextControl, "ORichTextPeer::implCreateDispatcher: invalid window!" );
 470         if ( !pRichTextControl )
 471             return SingleAttributeDispatcher( nullptr );
 472
 473         ORichTextFeatureDispatcher* pDispatcher = nullptr;
 474         OAttributeDispatcher* pAttributeDispatcher = nullptr;
 475         switch ( _nSlotId )
 476         {
 477         case SID_CUT:
 478             pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCut );
 479             break;
 480
 481         case SID_COPY:
 482             pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCopy );
 483             break;
 484
 485         case SID_PASTE:
 486             pDispatcher = new OPasteClipboardDispatcher( pRichTextControl->getView() );
 487             break;
 488
 489         case SID_SELECTALL:
 490             pDispatcher = new OSelectAllDispatcher( pRichTextControl->getView(), _rURL );
 491             break;
 492
 493         case SID_ATTR_PARA_LEFT_TO_RIGHT:
 494         case SID_ATTR_PARA_RIGHT_TO_LEFT:
 495             pAttributeDispatcher = new OParagraphDirectionDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl );
 496             break;
 497
 498         case SID_TEXTDIRECTION_TOP_TO_BOTTOM:
 499         case SID_TEXTDIRECTION_LEFT_TO_RIGHT:
 500             pDispatcher = new OTextDirectionDispatcher( pRichTextControl->getView(), _rURL );
 501             break;
 502
 503         case SID_ATTR_PARA_HANGPUNCTUATION:
 504         case SID_ATTR_PARA_FORBIDDEN_RULES:
 505         case SID_ATTR_PARA_SCRIPTSPACE:
 506             pAttributeDispatcher = new OAsianFontLayoutDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl );
 507             break;
 508
 509         default:
 510         {
 511             const SfxItemPool& rPool = *pRichTextControl->getView().GetEmptyItemSet().GetPool();
 512             bool bSupportedSlot = rPool.IsInRange( rPool.GetWhich( _nSlotId ) );
 513
 514             if ( !bSupportedSlot )
 515                 bSupportedSlot = RichTextControl::isMappableSlot( _nSlotId );
 516
 517             if ( bSupportedSlot )
 518             {   // it's really a slot which is supported by the EditEngine
 519
 520                 bool bNeedParametrizedDispatcher = true;
 521                 if  (  ( _nSlotId == SID_ATTR_CHAR_POSTURE )
 522                     || ( _nSlotId == SID_ATTR_CHAR_CJK_POSTURE )
 523                     || ( _nSlotId == SID_ATTR_CHAR_CTL_POSTURE )
 524                     || ( _nSlotId == SID_ATTR_CHAR_LATIN_POSTURE )
 525                     || ( _nSlotId == SID_ATTR_CHAR_WEIGHT )
 526                     || ( _nSlotId == SID_ATTR_CHAR_CJK_WEIGHT )
 527                     || ( _nSlotId == SID_ATTR_CHAR_CTL_WEIGHT )
 528                     || ( _nSlotId == SID_ATTR_CHAR_LATIN_WEIGHT )
 529                     || ( _nSlotId == SID_ATTR_CHAR_LANGUAGE )
 530                     || ( _nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE )
 531                     || ( _nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE )
 532                     || ( _nSlotId == SID_ATTR_CHAR_LATIN_LANGUAGE )
 533                     || ( _nSlotId == SID_ATTR_CHAR_CONTOUR )
 534                     || ( _nSlotId == SID_ATTR_CHAR_SHADOWED )
 535                     || ( _nSlotId == SID_ATTR_CHAR_WORDLINEMODE )
 536                     || ( _nSlotId == SID_ATTR_CHAR_COLOR )
 537                     || ( _nSlotId == SID_ATTR_CHAR_RELIEF )
 538                     || ( _nSlotId == SID_ATTR_CHAR_KERNING )
 539                     || ( _nSlotId == SID_ATTR_CHAR_AUTOKERN )
 540                     || ( _nSlotId == SID_ATTR_CHAR_SCALEWIDTH )
 541                     )
 542                 {
 543                     bNeedParametrizedDispatcher = true;
 544                 }
 545                 else
 546                 {
 547                     SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool();
 548                     const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId );
 549                     const SfxType* pType = pSlot ? pSlot->GetType() : nullptr;
 550                     if ( pType )
 551                     {
 552                         bNeedParametrizedDispatcher = ( pType->nAttribs > 0 );
 553                     }
 554                 }
 555
 556                 if ( bNeedParametrizedDispatcher )
 557                 {
 558                 #if OSL_DEBUG_LEVEL > 0
 559                     OString sTrace( "ORichTextPeer::implCreateDispatcher: creating *parametrized* dispatcher for " );
 560                     sTrace += OString( _rURL.Complete.getStr(), _rURL.Complete.getLength(), RTL_TEXTENCODING_ASCII_US );
 561                     OSL_TRACE( "%s", sTrace.getStr() );
 562                 #endif
 563                     pAttributeDispatcher = new OParametrizedAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl );
 564                 }
 565                 else
 566                 {
 567                 #if OSL_DEBUG_LEVEL > 0
 568                     OString sTrace( "ORichTextPeer::implCreateDispatcher: creating *normal* dispatcher for " );
 569                     sTrace += OString( _rURL.Complete.getStr(), _rURL.Complete.getLength(), RTL_TEXTENCODING_ASCII_US );
 570                     OSL_TRACE( "%s", sTrace.getStr() );
 571                 #endif
 572                     pAttributeDispatcher = new OAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl );
 573                 }
 574             }
 575         #if OSL_DEBUG_LEVEL > 0
 576             else
 577             {
 578                 OString sTrace( "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " );
 579                 sTrace += OString( _rURL.Complete.getStr(), _rURL.Complete.getLength(), RTL_TEXTENCODING_ASCII_US );
 580                 OSL_TRACE( "%s", sTrace.getStr() );
 581             }
 582         #endif
 583         }
 584         break;
 585         }
 586
 587         SingleAttributeDispatcher xDispatcher( pDispatcher );
 588         if ( pAttributeDispatcher )
 589         {
 590             xDispatcher = SingleAttributeDispatcher( pAttributeDispatcher );
 591             pRichTextControl->enableAttributeNotification( _nSlotId, pAttributeDispatcher );
 592         }
 593
 594         return xDispatcher;
 595     }
 596
 597
 598     namespace
 599     {
 600         SfxSlotId lcl_getSlotFromUnoName( SfxSlotPool& _rSlotPool, const OUString& _rUnoSlotName )
 601         {
 602             const SfxSlot* pSlot = _rSlotPool.GetUnoSlot( _rUnoSlotName );
 603             if ( pSlot )
 604             {
 605                 // okay, there's a slot with the given UNO name
 606                 return lcl_translateConflictingSlot( pSlot->GetSlotId() );
 607             }
 608
 609             // some hard-coded slots, which do not have a UNO name at SFX level, but which
 610             // we nevertheless need to transport via UNO mechanisms, so we need a name
 611             if ( _rUnoSlotName == "AllowHangingPunctuation" )
 612                 return SID_ATTR_PARA_HANGPUNCTUATION;
 613             if ( _rUnoSlotName == "ApplyForbiddenCharacterRules" )
 614                 return SID_ATTR_PARA_FORBIDDEN_RULES;
 615             if ( _rUnoSlotName == "UseScriptSpacing" )
 616                 return SID_ATTR_PARA_SCRIPTSPACE;
 617
 618             OSL_ENSURE( pSlot, "lcl_getSlotFromUnoName: unknown UNO slot name!" );
 619             return 0;
 620         }
 621     }
 622
 623
 624     Reference< XDispatch > SAL_CALL ORichTextPeer::queryDispatch( const css::util::URL& _rURL, const OUString& /*_rTargetFrameName*/, sal_Int32 /*_nSearchFlags*/ ) throw (RuntimeException, std::exception)
 625     {
 626         Reference< XDispatch > xReturn;
 627         if ( !GetWindow() )
 628         {
 629             OSL_FAIL( "ORichTextPeer::queryDispatch: already disposed?" );
 630             return xReturn;
 631         }
 632
 633         // is it an UNO slot?
 634         OUString sUnoProtocolPrefix( ".uno:" );
 635         if ( _rURL.Complete.startsWith( sUnoProtocolPrefix ) )
 636         {
 637             OUString sUnoSlotName = _rURL.Complete.copy( sUnoProtocolPrefix.getLength() );
 638             SfxSlotId nSlotId = lcl_getSlotFromUnoName( SfxSlotPool::GetSlotPool(), sUnoSlotName );
 639             if ( nSlotId > 0 )
 640             {
 641                 // do we already have a dispatcher for this?
 642                 AttributeDispatchers::const_iterator aDispatcherPos = m_aDispatchers.find( nSlotId );
 643                 if ( aDispatcherPos == m_aDispatchers.end() )
 644                 {
 645                     SingleAttributeDispatcher pDispatcher = implCreateDispatcher( nSlotId, _rURL );
 646                     if ( pDispatcher.is() )
 647                     {
 648                         aDispatcherPos = m_aDispatchers.insert( AttributeDispatchers::value_type( nSlotId, pDispatcher ) ).first;
 649                     }
 650                 }
 651
 652                 if ( aDispatcherPos != m_aDispatchers.end() )
 653                     xReturn = aDispatcherPos->second.get();
 654             }
 655         }
 656
 657         return xReturn;
 658     }
 659
 660
 661     Sequence< Reference< XDispatch > > SAL_CALL ORichTextPeer::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) throw (RuntimeException, std::exception)
 662     {
 663         Sequence< Reference< XDispatch > >  aReturn( _rRequests.getLength() );
 664         Reference< XDispatch >*             pReturn = aReturn.getArray();
 665
 666         const DispatchDescriptor* pRequest = _rRequests.getConstArray();
 667         const DispatchDescriptor* pRequestEnd = pRequest + _rRequests.getLength();
 668         for ( ; pRequest != pRequestEnd; ++pRequest, ++pReturn )
 669         {
 670             *pReturn = queryDispatch( pRequest->FeatureURL, pRequest->FrameName, pRequest->SearchFlags );
 671         }
 672         return aReturn;
 673     }
 674
 675
 676     void ORichTextPeer::onSelectionChanged( const ESelection& /*_rSelection*/ )
 677     {
 678         AttributeDispatchers::iterator aDispatcherPos = m_aDispatchers.find( SID_COPY );
 679         if ( aDispatcherPos != m_aDispatchers.end() )
 680             aDispatcherPos->second.get()->invalidate();
 681
 682         aDispatcherPos = m_aDispatchers.find( SID_CUT );
 683         if ( aDispatcherPos != m_aDispatchers.end() )
 684             aDispatcherPos->second.get()->invalidate();
 685     }
 686
 687
 688 }   // namespace frm
 689
 690 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* SAL_CALL
 691 com_sun_star_comp_form_ORichTextControl_get_implementation(css::uno::XComponentContext*,
 692         css::uno::Sequence<css::uno::Any> const &)
 693 {
 694     return cppu::acquire(new frm::ORichTextControl());
 695 }
 696
 697 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */