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