?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sc / source / ui / unoobj / fielduno.cxx
blobe303f2826e1d7422e9fea727a99856ff8909b7c5
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: fielduno.cxx,v $
10 * $Revision: 1.18.32.3 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33 #include <svtools/smplhint.hxx>
34
35
36 #include <svx/eeitem.hxx>
37
38 #include <svx/editeng.hxx>
39 #include <svx/editobj.hxx>
40 #include <svx/flditem.hxx>
41 #include <rtl/uuid.h>
42
43 #include <com/sun/star/beans/PropertyAttribute.hpp>
44 #include <com/sun/star/text/TextContentAnchorType.hpp>
45 #include <com/sun/star/text/WrapTextMode.hpp>
46 #include <com/sun/star/text/FilenameDisplayFormat.hpp>
47
48 #include "fielduno.hxx"
49 #include "textuno.hxx"
50 #include "miscuno.hxx"
51 #include "docsh.hxx"
52 #include "hints.hxx"
53 #include "editsrc.hxx"
54 #include "cellsuno.hxx"
55 #include "servuno.hxx" // fuer IDs
56 #include "unoguard.hxx"
57 #include "unonames.hxx"
58 #include "editutil.hxx"
59
60 using namespace com::sun::star;
61
62 //------------------------------------------------------------------------
63
64 // alles ohne Which-ID, Map nur fuer PropertySetInfo
65
66 const SfxItemPropertySet* lcl_GetURLPropertySet()
67 {
68 static SfxItemPropertyMapEntry aURLPropertyMap_Impl[] =
69 {
70 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 },
71 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
72 {MAP_CHAR_LEN(SC_UNONAME_REPR), 0, &getCppuType((rtl::OUString*)0), 0, 0},
73 {MAP_CHAR_LEN(SC_UNONAME_TARGET), 0, &getCppuType((rtl::OUString*)0), 0, 0},
74 {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 },
75 {MAP_CHAR_LEN(SC_UNONAME_URL), 0, &getCppuType((rtl::OUString*)0), 0, 0},
76 {0,0,0,0,0,0}
77 };
78 static SfxItemPropertySet aURLPropertySet_Impl( aURLPropertyMap_Impl );
79 return &aURLPropertySet_Impl;
80 }
81
82 const SfxItemPropertySet* lcl_GetHeaderFieldPropertySet()
83 {
84 static SfxItemPropertyMapEntry aHeaderFieldPropertyMap_Impl[] =
85 {
86 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 },
87 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
88 {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 },
89 {0,0,0,0,0,0}
90 };
91 static SfxItemPropertySet aHeaderFieldPropertySet_Impl( aHeaderFieldPropertyMap_Impl );
92 return &aHeaderFieldPropertySet_Impl;
93 }
94
95 const SfxItemPropertySet* lcl_GetFileFieldPropertySet()
96 {
97 static SfxItemPropertyMapEntry aFileFieldPropertyMap_Impl[] =
98 {
99 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPE), 0, &getCppuType((text::TextContentAnchorType*)0), beans::PropertyAttribute::READONLY, 0 },
100 {MAP_CHAR_LEN(SC_UNONAME_ANCTYPES), 0, &getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
101 {MAP_CHAR_LEN(SC_UNONAME_FILEFORM), 0, &getCppuType((sal_Int16*)0), 0, 0 },
102 {MAP_CHAR_LEN(SC_UNONAME_TEXTWRAP), 0, &getCppuType((text::WrapTextMode*)0), beans::PropertyAttribute::READONLY, 0 },
103 {0,0,0,0,0,0}
104 };
105 static SfxItemPropertySet aFileFieldPropertySet_Impl( aFileFieldPropertyMap_Impl );
106 return &aFileFieldPropertySet_Impl;
107 }
108
109 //------------------------------------------------------------------------
110
111 #define SCTEXTFIELD_SERVICE "com.sun.star.text.TextField"
112 #define SCTEXTCONTENT_SERVICE "com.sun.star.text.TextContent"
113
114 SC_SIMPLE_SERVICE_INFO( ScCellFieldsObj, "ScCellFieldsObj", "com.sun.star.text.TextFields" )
115 SC_SIMPLE_SERVICE_INFO( ScHeaderFieldsObj, "ScHeaderFieldsObj", "com.sun.star.text.TextFields" )
116
117 //------------------------------------------------------------------------
118
119 // ScUnoEditEngine nur um aus einer EditEngine die Felder herauszubekommen...
120
121 enum ScUnoCollectMode
122 {
123 SC_UNO_COLLECT_NONE,
124 SC_UNO_COLLECT_COUNT,
125 SC_UNO_COLLECT_FINDINDEX,
126 SC_UNO_COLLECT_FINDPOS
127 };
128
129 class ScUnoEditEngine : public ScEditEngineDefaulter
130 {
131 ScUnoCollectMode eMode;
132 USHORT nFieldCount;
133 TypeId aFieldType;
134 SvxFieldData* pFound; // lokale Kopie
135 USHORT nFieldPar;
136 xub_StrLen nFieldPos;
137 USHORT nFieldIndex;
138
139 public:
140 ScUnoEditEngine(ScEditEngineDefaulter* pSource);
141 ~ScUnoEditEngine();
142
143 //! nPos should be xub_StrLen
144 virtual String CalcFieldValue( const SvxFieldItem& rField, USHORT nPara, USHORT nPos,
145 Color*& rTxtColor, Color*& rFldColor );
146
147 USHORT CountFields(TypeId aType);
148 SvxFieldData* FindByIndex(USHORT nIndex, TypeId aType);
149 SvxFieldData* FindByPos(USHORT nPar, xub_StrLen nPos, TypeId aType);
150
151 USHORT GetFieldPar() const { return nFieldPar; }
152 xub_StrLen GetFieldPos() const { return nFieldPos; }
153 };
154
155 ScUnoEditEngine::ScUnoEditEngine(ScEditEngineDefaulter* pSource) :
156 ScEditEngineDefaulter( *pSource ),
157 eMode( SC_UNO_COLLECT_NONE ),
158 nFieldCount( 0 ),
159 aFieldType( NULL ),
160 pFound( NULL )
161 {
162 if (pSource)
163 {
164 EditTextObject* pData = pSource->CreateTextObject();
165 SetText( *pData );
166 delete pData;
167 }
168 }
169
170 ScUnoEditEngine::~ScUnoEditEngine()
171 {
172 delete pFound;
173 }
174
175 String ScUnoEditEngine::CalcFieldValue( const SvxFieldItem& rField,
176 USHORT nPara, USHORT nPos, Color*& rTxtColor, Color*& rFldColor )
177 {
178 String aRet(EditEngine::CalcFieldValue( rField, nPara, nPos, rTxtColor, rFldColor ));
179 if (eMode != SC_UNO_COLLECT_NONE)
180 {
181 const SvxFieldData* pFieldData = rField.GetField();
182 if ( pFieldData )
183 {
184 if ( !aFieldType || pFieldData->Type() == aFieldType )
185 {
186 if ( eMode == SC_UNO_COLLECT_FINDINDEX && !pFound && nFieldCount == nFieldIndex )
187 {
188 pFound = pFieldData->Clone();
189 nFieldPar = nPara;
190 nFieldPos = nPos;
191 }
192 if ( eMode == SC_UNO_COLLECT_FINDPOS && !pFound &&
193 nPara == nFieldPar && nPos == nFieldPos )
194 {
195 pFound = pFieldData->Clone();
196 nFieldIndex = nFieldCount;
197 }
198 ++nFieldCount;
199 }
200 }
201 }
202 return aRet;
203 }
204
205 USHORT ScUnoEditEngine::CountFields(TypeId aType)
206 {
207 eMode = SC_UNO_COLLECT_COUNT;
208 aFieldType = aType;
209 nFieldCount = 0;
210 UpdateFields();
211 aFieldType = NULL;
212 eMode = SC_UNO_COLLECT_NONE;
213
214 return nFieldCount;
215 }
216
217 SvxFieldData* ScUnoEditEngine::FindByIndex(USHORT nIndex, TypeId aType)
218 {
219 eMode = SC_UNO_COLLECT_FINDINDEX;
220 nFieldIndex = nIndex;
221 aFieldType = aType;
222 nFieldCount = 0;
223 UpdateFields();
224 aFieldType = NULL;
225 eMode = SC_UNO_COLLECT_NONE;
226
227 return pFound;
228 }
229
230 SvxFieldData* ScUnoEditEngine::FindByPos(USHORT nPar, xub_StrLen nPos, TypeId aType)
231 {
232 eMode = SC_UNO_COLLECT_FINDPOS;
233 nFieldPar = nPar;
234 nFieldPos = nPos;
235 aFieldType = aType;
236 nFieldCount = 0;
237 UpdateFields();
238 aFieldType = NULL;
239 eMode = SC_UNO_COLLECT_NONE;
240
241 return pFound;
242 }
243
244 //------------------------------------------------------------------------
245
246 ScCellFieldsObj::ScCellFieldsObj(ScDocShell* pDocSh, const ScAddress& rPos) :
247 pDocShell( pDocSh ),
248 aCellPos( rPos ),
249 mpRefreshListeners( NULL )
250 {
251 pDocShell->GetDocument()->AddUnoObject(*this);
252
253 pEditSource = new ScCellEditSource( pDocShell, aCellPos );
254 }
255
256 ScCellFieldsObj::~ScCellFieldsObj()
257 {
258 if (pDocShell)
259 pDocShell->GetDocument()->RemoveUnoObject(*this);
260
261 delete pEditSource;
262
263 // increment refcount to prevent double call off dtor
264 osl_incrementInterlockedCount( &m_refCount );
265
266 if (mpRefreshListeners)
267 {
268 lang::EventObject aEvent;
269 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
270 if (mpRefreshListeners)
271 {
272 mpRefreshListeners->disposeAndClear(aEvent);
273 DELETEZ( mpRefreshListeners );
274 }
275 }
276 }
277
278 void ScCellFieldsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
279 {
280 if ( rHint.ISA( ScUpdateRefHint ) )
281 {
282 // const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
283
284 //! Ref-Update
285 }
286 else if ( rHint.ISA( SfxSimpleHint ) &&
287 ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
288 {
289 pDocShell = NULL; // ungueltig geworden
290 }
291
292 // EditSource hat sich selber als Listener angemeldet
293 }
294
295 // XIndexAccess (via XTextFields)
296
297 ScCellFieldObj* ScCellFieldsObj::GetObjectByIndex_Impl(INT32 Index) const
298 {
299 //! Feld-Funktionen muessen an den Forwarder !!!
300 ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine();
301 ScUnoEditEngine aTempEngine(pEditEngine);
302
303 if ( aTempEngine.FindByIndex( (USHORT)Index, NULL ) ) // in der Zelle ist der Typ egal
304 {
305 USHORT nPar = aTempEngine.GetFieldPar();
306 xub_StrLen nPos = aTempEngine.GetFieldPos();
307 ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Feld ist 1 Zeichen
308 return new ScCellFieldObj( pDocShell, aCellPos, aSelection );
309 }
310 return NULL;
311 }
312
313 sal_Int32 SAL_CALL ScCellFieldsObj::getCount() throw(uno::RuntimeException)
314 {
315 ScUnoGuard aGuard;
316
317 //! Feld-Funktionen muessen an den Forwarder !!!
318 ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine();
319 ScUnoEditEngine aTempEngine(pEditEngine);
320
321 return aTempEngine.CountFields(NULL); // Felder zaehlen, in Zelle ist der Typ egal
322 }
323
324 uno::Any SAL_CALL ScCellFieldsObj::getByIndex( sal_Int32 nIndex )
325 throw(lang::IndexOutOfBoundsException,
326 lang::WrappedTargetException, uno::RuntimeException)
327 {
328 ScUnoGuard aGuard;
329 uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
330 if (xField.is())
331 return uno::makeAny(xField);
332 else
333 throw lang::IndexOutOfBoundsException();
334 // return uno::Any();
335 }
336
337 uno::Type SAL_CALL ScCellFieldsObj::getElementType() throw(uno::RuntimeException)
338 {
339 ScUnoGuard aGuard;
340 return getCppuType((uno::Reference<text::XTextField>*)0);
341 }
342
343 sal_Bool SAL_CALL ScCellFieldsObj::hasElements() throw(uno::RuntimeException)
344 {
345 ScUnoGuard aGuard;
346 return ( getCount() != 0 );
347 }
348
349 uno::Reference<container::XEnumeration> SAL_CALL ScCellFieldsObj::createEnumeration()
350 throw(uno::RuntimeException)
351 {
352 ScUnoGuard aGuard;
353 return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextFieldEnumeration")));
354 }
355
356 void SAL_CALL ScCellFieldsObj::addContainerListener(
357 const uno::Reference<container::XContainerListener>& /* xListener */ )
358 throw(uno::RuntimeException)
359 {
360 DBG_ERROR("not implemented");
361 }
362
363 void SAL_CALL ScCellFieldsObj::removeContainerListener(
364 const uno::Reference<container::XContainerListener>& /* xListener */ )
365 throw(uno::RuntimeException)
366 {
367 DBG_ERROR("not implemented");
368 }
369
370 // XRefreshable
371 void SAL_CALL ScCellFieldsObj::refresh( )
372 throw (uno::RuntimeException)
373 {
374 if (mpRefreshListeners)
375 {
376 // Call all listeners.
377 uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
378 sal_uInt32 nLength(aListeners.getLength());
379 if (nLength)
380 {
381 const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
382 if (pInterfaces)
383 {
384 lang::EventObject aEvent;
385 aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScCellFieldsObj*>(this)));
386 sal_uInt32 i(0);
387 while (i < nLength)
388 {
389 try
390 {
391 while(i < nLength)
392 {
393 static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
394 ++pInterfaces;
395 ++i;
396 }
397 }
398 catch(uno::RuntimeException&)
399 {
400 // DBG_ERROR("a object is gone without to remove from Broadcaster");
401 ++pInterfaces;
402 ++i;
403 }
404 }
405 }
406 }
407 }
408 }
409
410 void SAL_CALL ScCellFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
411 throw (uno::RuntimeException)
412 {
413 if (xListener.is())
414 {
415 ScUnoGuard aGuard;
416 if (!mpRefreshListeners)
417 mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
418 mpRefreshListeners->addInterface(xListener);
419 }
420 }
421
422 void SAL_CALL ScCellFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
423 throw (uno::RuntimeException)
424 {
425 if (xListener.is())
426 {
427 ScUnoGuard aGuard;
428 if (mpRefreshListeners)
429 mpRefreshListeners->removeInterface(xListener);
430 }
431 }
432
433 //------------------------------------------------------------------------
434
435 // Default-ctor wird fuer SMART_REFLECTION_IMPLEMENTATION gebraucht
436
437
438 //UNUSED2008-05 ScCellFieldObj::ScCellFieldObj() :
439 //UNUSED2008-05 OComponentHelper( getMutex() ),
440 //UNUSED2008-05 aPropSet( lcl_GetURLPropertyMap() ),
441 //UNUSED2008-05 pDocShell( NULL )
442 //UNUSED2008-05 {
443 //UNUSED2008-05 pEditSource = NULL;
444 //UNUSED2008-05 }
445
446 ScCellFieldObj::ScCellFieldObj(ScDocShell* pDocSh, const ScAddress& rPos,
447 const ESelection& rSel) :
448 OComponentHelper( getMutex() ),
449 pPropSet( lcl_GetURLPropertySet() ),
450 pDocShell( pDocSh ),
451 aCellPos( rPos ),
452 aSelection( rSel )
453 {
454 // pDocShell ist Null, wenn per ServiceProvider erzeugt
455
456 if (pDocShell)
457 {
458 pDocShell->GetDocument()->AddUnoObject(*this);
459 pEditSource = new ScCellEditSource( pDocShell, aCellPos );
460 }
461 else
462 pEditSource = NULL;
463 }
464
465 uno::Any SAL_CALL ScCellFieldObj::queryAggregation( const uno::Type& rType )
466 throw(uno::RuntimeException)
467 {
468 SC_QUERYINTERFACE( text::XTextField )
469 SC_QUERYINTERFACE( text::XTextContent ) // parent of XTextField
470 SC_QUERYINTERFACE( beans::XPropertySet )
471 SC_QUERYINTERFACE( lang::XUnoTunnel )
472 SC_QUERYINTERFACE( lang::XServiceInfo )
473
474 return OComponentHelper::queryAggregation( rType ); // XComponent
475 }
476
477 uno::Sequence<uno::Type> SAL_CALL ScCellFieldObj::getTypes() throw(uno::RuntimeException)
478 {
479 static uno::Sequence<uno::Type> aTypes;
480 if ( aTypes.getLength() == 0 )
481 {
482 uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes());
483 long nParentLen = aParentTypes.getLength();
484 const uno::Type* pParentPtr = aParentTypes.getConstArray();
485
486 aTypes.realloc( nParentLen + 4 );
487 uno::Type* pPtr = aTypes.getArray();
488 pPtr[nParentLen + 0] = getCppuType((const uno::Reference<text::XTextField>*)0);
489 pPtr[nParentLen + 1] = getCppuType((const uno::Reference<beans::XPropertySet>*)0);
490 pPtr[nParentLen + 2] = getCppuType((const uno::Reference<lang::XUnoTunnel>*)0);
491 pPtr[nParentLen + 3] = getCppuType((const uno::Reference<lang::XServiceInfo>*)0);
492
493 for (long i=0; i<nParentLen; i++)
494 pPtr[i] = pParentPtr[i]; // parent types first
495 }
496 return aTypes;
497 }
498
499 uno::Sequence<sal_Int8> SAL_CALL ScCellFieldObj::getImplementationId()
500 throw(uno::RuntimeException)
501 {
502 static uno::Sequence< sal_Int8 > aId;
503 if( aId.getLength() == 0 )
504 {
505 aId.realloc( 16 );
506 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
507 }
508 return aId;
509 }
510
511 uno::Any SAL_CALL ScCellFieldObj::queryInterface( const uno::Type& rType )
512 throw(uno::RuntimeException)
513 {
514 return OComponentHelper::queryInterface( rType );
515 }
516
517 void SAL_CALL ScCellFieldObj::acquire() throw()
518 {
519 OComponentHelper::acquire();
520 }
521
522 void SAL_CALL ScCellFieldObj::release() throw()
523 {
524 OComponentHelper::release();
525 }
526
527 void ScCellFieldObj::InitDoc( ScDocShell* pDocSh, const ScAddress& rPos,
528 const ESelection& rSel )
529 {
530 if ( pDocSh && !pEditSource )
531 {
532 aCellPos = rPos;
533 aSelection = rSel;
534 pDocShell = pDocSh;
535
536 pDocShell->GetDocument()->AddUnoObject(*this);
537 pEditSource = new ScCellEditSource( pDocShell, aCellPos );
538 }
539 }
540
541 ScCellFieldObj::~ScCellFieldObj()
542 {
543 if (pDocShell)
544 pDocShell->GetDocument()->RemoveUnoObject(*this);
545
546 delete pEditSource;
547 }
548
549 void ScCellFieldObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
550 {
551 //! Updates fuer aSelection (muessen erst noch erzeugt werden) !!!!!!
552
553 if ( rHint.ISA( ScUpdateRefHint ) )
554 {
555 // const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint;
556
557 //! Ref-Update
558 }
559 else if ( rHint.ISA( SfxSimpleHint ) &&
560 ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
561 {
562 pDocShell = NULL; // ungueltig geworden
563 }
564
565 // EditSource hat sich selber als Listener angemeldet
566 }
567
568 // per getImplementation gerufen:
569
570 SvxFieldItem ScCellFieldObj::CreateFieldItem()
571 {
572 DBG_ASSERT( !pEditSource, "CreateFieldItem mit eingefuegtem Feld" );
573
574 SvxURLField aField;
575 aField.SetFormat(SVXURLFORMAT_APPDEFAULT);
576 aField.SetURL( aUrl );
577 aField.SetRepresentation( aRepresentation );
578 aField.SetTargetFrame( aTarget );
579 return SvxFieldItem( aField, EE_FEATURE_FIELD );
580 }
581
582 void ScCellFieldObj::DeleteField()
583 {
584 if (pEditSource)
585 {
586 SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
587 // pEditEngine->QuickDelete( aSelection );
588 pForwarder->QuickInsertText( String(), aSelection );
589 pEditSource->UpdateData();
590
591 aSelection.nEndPara = aSelection.nStartPara;
592 aSelection.nEndPos = aSelection.nStartPos;
593
594 //! Broadcast, um Selektion in anderen Objekten anzupassen
595 //! (auch bei anderen Aktionen)
596 }
597 }
598
599 // XTextField
600
601 rtl::OUString SAL_CALL ScCellFieldObj::getPresentation( sal_Bool bShowCommand )
602 throw(uno::RuntimeException)
603 {
604 ScUnoGuard aGuard;
605 String aRet;
606
607 if (pEditSource)
608 {
609 //! Feld-Funktionen muessen an den Forwarder !!!
610 ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine();
611 ScUnoEditEngine aTempEngine(pEditEngine);
612
613 // Typ egal (in Zellen gibts nur URLs)
614 SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 );
615 DBG_ASSERT(pField,"getPresentation: Feld nicht gefunden");
616 if (pField)
617 {
618 SvxURLField* pURL = (SvxURLField*)pField;
619 if (bShowCommand)
620 aRet = pURL->GetURL();
621 else
622 aRet = pURL->GetRepresentation();
623 }
624 }
625
626 return aRet;
627 }
628
629 // XTextContent
630
631 void SAL_CALL ScCellFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange )
632 throw(lang::IllegalArgumentException, uno::RuntimeException)
633 {
634 ScUnoGuard aGuard;
635 if (xTextRange.is())
636 {
637 uno::Reference<text::XText> xText(xTextRange->getText());
638 if (xText.is())
639 {
640 xText->insertTextContent( xTextRange, this, TRUE );
641 }
642 }
643 }
644
645 uno::Reference<text::XTextRange> SAL_CALL ScCellFieldObj::getAnchor() throw(uno::RuntimeException)
646 {
647 ScUnoGuard aGuard;
648 if (pDocShell)
649 return new ScCellObj( pDocShell, aCellPos );
650 return NULL;
651 }
652
653 // XComponent
654
655 void SAL_CALL ScCellFieldObj::dispose() throw(uno::RuntimeException)
656 {
657 OComponentHelper::dispose();
658 }
659
660 void SAL_CALL ScCellFieldObj::addEventListener(
661 const uno::Reference<lang::XEventListener>& xListener )
662 throw(uno::RuntimeException)
663 {
664 OComponentHelper::addEventListener( xListener );
665 }
666
667 void SAL_CALL ScCellFieldObj::removeEventListener(
668 const uno::Reference<lang::XEventListener>& xListener )
669 throw(uno::RuntimeException)
670 {
671 OComponentHelper::removeEventListener( xListener );
672 }
673
674 // XPropertySet
675
676 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellFieldObj::getPropertySetInfo()
677 throw(uno::RuntimeException)
678 {
679 ScUnoGuard aGuard;
680 static uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo();
681 return aRef;
682 }
683
684 void SAL_CALL ScCellFieldObj::setPropertyValue(
685 const rtl::OUString& aPropertyName, const uno::Any& aValue )
686 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
687 lang::IllegalArgumentException, lang::WrappedTargetException,
688 uno::RuntimeException)
689 {
690 ScUnoGuard aGuard;
691 String aNameString(aPropertyName);
692 rtl::OUString aStrVal;
693 if (pEditSource)
694 {
695 //! Feld-Funktionen muessen an den Forwarder !!!
696 ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine();
697 ScUnoEditEngine aTempEngine(pEditEngine);
698
699 // Typ egal (in Zellen gibts nur URLs)
700 SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 );
701 DBG_ASSERT(pField,"setPropertyValue: Feld nicht gefunden");
702 if (pField)
703 {
704 SvxURLField* pURL = (SvxURLField*)pField; // ist eine Kopie in der ScUnoEditEngine
705
706 BOOL bOk = TRUE;
707 if ( aNameString.EqualsAscii( SC_UNONAME_URL ) )
708 {
709 if (aValue >>= aStrVal)
710 pURL->SetURL( aStrVal );
711 }
712 else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) )
713 {
714 if (aValue >>= aStrVal)
715 pURL->SetRepresentation( aStrVal );
716 }
717 else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) )
718 {
719 if (aValue >>= aStrVal)
720 pURL->SetTargetFrame( aStrVal );
721 }
722 else
723 bOk = FALSE;
724
725 if (bOk)
726 {
727 pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection );
728 pEditSource->UpdateData();
729 }
730 }
731 }
732 else // noch nicht eingefuegt
733 {
734 if ( aNameString.EqualsAscii( SC_UNONAME_URL ) )
735 {
736 if (aValue >>= aStrVal)
737 aUrl = String( aStrVal );
738 }
739 else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) )
740 {
741 if (aValue >>= aStrVal)
742 aRepresentation = String( aStrVal );
743 }
744 else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) )
745 {
746 if (aValue >>= aStrVal)
747 aTarget = String( aStrVal );
748 }
749 }
750 }
751
752 uno::Any SAL_CALL ScCellFieldObj::getPropertyValue( const rtl::OUString& aPropertyName )
753 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
754 uno::RuntimeException)
755 {
756 ScUnoGuard aGuard;
757 uno::Any aRet;
758 String aNameString(aPropertyName);
759
760 // anchor type is always "as character", text wrap always "none"
761
762 if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPE ) )
763 aRet <<= text::TextContentAnchorType_AS_CHARACTER;
764 else if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPES ) )
765 {
766 uno::Sequence<text::TextContentAnchorType> aSeq(1);
767 aSeq[0] = text::TextContentAnchorType_AS_CHARACTER;
768 aRet <<= aSeq;
769 }
770 else if ( aNameString.EqualsAscii( SC_UNONAME_TEXTWRAP ) )
771 aRet <<= text::WrapTextMode_NONE;
772 else if (pEditSource)
773 {
774 //! Feld-Funktionen muessen an den Forwarder !!!
775 ScEditEngineDefaulter* pEditEngine = ((ScCellEditSource*)pEditSource)->GetEditEngine();
776 ScUnoEditEngine aTempEngine(pEditEngine);
777
778 // Typ egal (in Zellen gibts nur URLs)
779 SvxFieldData* pField = aTempEngine.FindByPos( aSelection.nStartPara, aSelection.nStartPos, 0 );
780 DBG_ASSERT(pField,"getPropertyValue: Feld nicht gefunden");
781 if (pField)
782 {
783 SvxURLField* pURL = (SvxURLField*)pField;
784
785 if ( aNameString.EqualsAscii( SC_UNONAME_URL ) )
786 aRet <<= rtl::OUString( pURL->GetURL() );
787 else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) )
788 aRet <<= rtl::OUString( pURL->GetRepresentation() );
789 else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) )
790 aRet <<= rtl::OUString( pURL->GetTargetFrame() );
791 }
792 }
793 else // noch nicht eingefuegt
794 {
795 if ( aNameString.EqualsAscii( SC_UNONAME_URL ) )
796 aRet <<= rtl::OUString( aUrl );
797 else if ( aNameString.EqualsAscii( SC_UNONAME_REPR ) )
798 aRet <<= rtl::OUString( aRepresentation );
799 else if ( aNameString.EqualsAscii( SC_UNONAME_TARGET ) )
800 aRet <<= rtl::OUString( aTarget );
801 }
802 return aRet;
803 }
804
805 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScCellFieldObj )
806
807 // XUnoTunnel
808
809 sal_Int64 SAL_CALL ScCellFieldObj::getSomething(
810 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
811 {
812 if ( rId.getLength() == 16 &&
813 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
814 rId.getConstArray(), 16 ) )
815 {
816 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
817 }
818 return 0;
819 }
820
821 // static
822 const uno::Sequence<sal_Int8>& ScCellFieldObj::getUnoTunnelId()
823 {
824 static uno::Sequence<sal_Int8> * pSeq = 0;
825 if( !pSeq )
826 {
827 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
828 if( !pSeq )
829 {
830 static uno::Sequence< sal_Int8 > aSeq( 16 );
831 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
832 pSeq = &aSeq;
833 }
834 }
835 return *pSeq;
836 }
837
838 // static
839 ScCellFieldObj* ScCellFieldObj::getImplementation(
840 const uno::Reference<text::XTextContent> xObj )
841 {
842 ScCellFieldObj* pRet = NULL;
843 uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
844 if (xUT.is())
845 pRet = reinterpret_cast<ScCellFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
846 return pRet;
847 }
848
849 // XServiceInfo
850
851 rtl::OUString SAL_CALL ScCellFieldObj::getImplementationName() throw(uno::RuntimeException)
852 {
853 return rtl::OUString::createFromAscii( "ScCellFieldObj" );
854 }
855
856 sal_Bool SAL_CALL ScCellFieldObj::supportsService( const rtl::OUString& rServiceName )
857 throw(uno::RuntimeException)
858 {
859 String aServiceStr( rServiceName );
860 return aServiceStr.EqualsAscii( SCTEXTFIELD_SERVICE ) ||
861 aServiceStr.EqualsAscii( SCTEXTCONTENT_SERVICE );
862 }
863
864 uno::Sequence<rtl::OUString> SAL_CALL ScCellFieldObj::getSupportedServiceNames()
865 throw(uno::RuntimeException)
866 {
867 uno::Sequence<rtl::OUString> aRet(2);
868 rtl::OUString* pArray = aRet.getArray();
869 pArray[0] = rtl::OUString::createFromAscii( SCTEXTFIELD_SERVICE );
870 pArray[1] = rtl::OUString::createFromAscii( SCTEXTCONTENT_SERVICE );
871 return aRet;
872 }
873
874 //------------------------------------------------------------------------
875
876 ScHeaderFieldsObj::ScHeaderFieldsObj(ScHeaderFooterContentObj* pContent, USHORT nP, USHORT nT) :
877 pContentObj( pContent ),
878 nPart( nP ),
879 nType( nT ),
880 mpRefreshListeners( NULL )
881 {
882 DBG_ASSERT( pContentObj, "ScHeaderFieldsObj ohne Objekt?" );
883
884 if (pContentObj)
885 {
886 pContentObj->acquire(); // darf nicht wegkommen
887 pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart );
888 }
889 else
890 pEditSource = NULL;
891 }
892
893 ScHeaderFieldsObj::~ScHeaderFieldsObj()
894 {
895 delete pEditSource;
896
897 if (pContentObj)
898 pContentObj->release();
899
900 // increment refcount to prevent double call off dtor
901 osl_incrementInterlockedCount( &m_refCount );
902
903 if (mpRefreshListeners)
904 {
905 lang::EventObject aEvent;
906 aEvent.Source = static_cast<cppu::OWeakObject*>(this);
907 if (mpRefreshListeners)
908 {
909 mpRefreshListeners->disposeAndClear(aEvent);
910 DELETEZ( mpRefreshListeners );
911 }
912 }
913 }
914
915 // XIndexAccess (via XTextFields)
916
917 ScHeaderFieldObj* ScHeaderFieldsObj::GetObjectByIndex_Impl(INT32 Index) const
918 {
919 //! Feld-Funktionen muessen an den Forwarder !!!
920 ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine();
921 ScUnoEditEngine aTempEngine(pEditEngine);
922
923 TypeId aTypeId = NULL;
924 switch (nType)
925 {
926 case SC_SERVICE_PAGEFIELD: aTypeId = TYPE(SvxPageField); break;
927 case SC_SERVICE_PAGESFIELD: aTypeId = TYPE(SvxPagesField); break;
928 case SC_SERVICE_DATEFIELD: aTypeId = TYPE(SvxDateField); break;
929 case SC_SERVICE_TIMEFIELD: aTypeId = TYPE(SvxTimeField); break;
930 case SC_SERVICE_TITLEFIELD: aTypeId = TYPE(SvxFileField); break;
931 case SC_SERVICE_FILEFIELD: aTypeId = TYPE(SvxExtFileField); break;
932 case SC_SERVICE_SHEETFIELD: aTypeId = TYPE(SvxTableField); break;
933 // bei SC_SERVICE_INVALID bleibt TypeId Null
934 }
935 SvxFieldData* pData = aTempEngine.FindByIndex( (USHORT)Index, aTypeId );
936 if ( pData )
937 {
938 USHORT nPar = aTempEngine.GetFieldPar();
939 xub_StrLen nPos = aTempEngine.GetFieldPos();
940
941 USHORT nFieldType = nType;
942 if ( nFieldType == SC_SERVICE_INVALID )
943 {
944 if ( pData->ISA( SvxPageField ) ) nFieldType = SC_SERVICE_PAGEFIELD;
945 else if ( pData->ISA( SvxPagesField ) ) nFieldType = SC_SERVICE_PAGESFIELD;
946 else if ( pData->ISA( SvxDateField ) ) nFieldType = SC_SERVICE_DATEFIELD;
947 else if ( pData->ISA( SvxTimeField ) ) nFieldType = SC_SERVICE_TIMEFIELD;
948 else if ( pData->ISA( SvxFileField ) ) nFieldType = SC_SERVICE_TITLEFIELD;
949 else if ( pData->ISA( SvxExtFileField ) ) nFieldType = SC_SERVICE_FILEFIELD;
950 else if ( pData->ISA( SvxTableField ) ) nFieldType = SC_SERVICE_SHEETFIELD;
951 }
952
953 ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Field is 1 character
954 return new ScHeaderFieldObj( pContentObj, nPart, nFieldType, aSelection );
955 }
956 return NULL;
957 }
958
959 sal_Int32 SAL_CALL ScHeaderFieldsObj::getCount() throw(uno::RuntimeException)
960 {
961 ScUnoGuard aGuard;
962
963 //! Feld-Funktionen muessen an den Forwarder !!!
964 ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine();
965 ScUnoEditEngine aTempEngine(pEditEngine);
966
967 TypeId aTypeId = NULL;
968 switch (nType)
969 {
970 case SC_SERVICE_PAGEFIELD: aTypeId = TYPE(SvxPageField); break;
971 case SC_SERVICE_PAGESFIELD: aTypeId = TYPE(SvxPagesField); break;
972 case SC_SERVICE_DATEFIELD: aTypeId = TYPE(SvxDateField); break;
973 case SC_SERVICE_TIMEFIELD: aTypeId = TYPE(SvxTimeField); break;
974 case SC_SERVICE_TITLEFIELD: aTypeId = TYPE(SvxFileField); break;
975 case SC_SERVICE_FILEFIELD: aTypeId = TYPE(SvxExtFileField); break;
976 case SC_SERVICE_SHEETFIELD: aTypeId = TYPE(SvxTableField); break;
977 }
978 return aTempEngine.CountFields(aTypeId); // Felder zaehlen
979 }
980
981 uno::Any SAL_CALL ScHeaderFieldsObj::getByIndex( sal_Int32 nIndex )
982 throw(lang::IndexOutOfBoundsException,
983 lang::WrappedTargetException, uno::RuntimeException)
984 {
985 ScUnoGuard aGuard;
986 uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
987 if (xField.is())
988 return uno::makeAny(xField);
989 else
990 throw lang::IndexOutOfBoundsException();
991 // return uno::Any();
992 }
993
994 uno::Type SAL_CALL ScHeaderFieldsObj::getElementType() throw(uno::RuntimeException)
995 {
996 ScUnoGuard aGuard;
997 return getCppuType((uno::Reference<text::XTextField>*)0);
998 }
999
1000 sal_Bool SAL_CALL ScHeaderFieldsObj::hasElements() throw(uno::RuntimeException)
1001 {
1002 ScUnoGuard aGuard;
1003 return ( getCount() != 0 );
1004 }
1005
1006 uno::Reference<container::XEnumeration> SAL_CALL ScHeaderFieldsObj::createEnumeration()
1007 throw(uno::RuntimeException)
1008 {
1009 ScUnoGuard aGuard;
1010 return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.TextFieldEnumeration")));
1011 }
1012
1013 void SAL_CALL ScHeaderFieldsObj::addContainerListener(
1014 const uno::Reference<container::XContainerListener>& /* xListener */ )
1015 throw(uno::RuntimeException)
1016 {
1017 DBG_ERROR("not implemented");
1018 }
1019
1020 void SAL_CALL ScHeaderFieldsObj::removeContainerListener(
1021 const uno::Reference<container::XContainerListener>& /* xListener */ )
1022 throw(uno::RuntimeException)
1023 {
1024 DBG_ERROR("not implemented");
1025 }
1026
1027 // XRefreshable
1028 void SAL_CALL ScHeaderFieldsObj::refresh( )
1029 throw (uno::RuntimeException)
1030 {
1031 if (mpRefreshListeners)
1032 {
1033 // Call all listeners.
1034 uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
1035 sal_uInt32 nLength(aListeners.getLength());
1036 if (nLength)
1037 {
1038 const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
1039 if (pInterfaces)
1040 {
1041 lang::EventObject aEvent;
1042 aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScHeaderFieldsObj*>(this)));
1043 sal_uInt32 i(0);
1044 while (i < nLength)
1045 {
1046 try
1047 {
1048 while(i < nLength)
1049 {
1050 static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
1051 ++pInterfaces;
1052 ++i;
1053 }
1054 }
1055 catch(uno::RuntimeException&)
1056 {
1057 // DBG_ERROR("a object is gone without to remove from Broadcaster");
1058 ++pInterfaces;
1059 ++i;
1060 }
1061 }
1062 }
1063 }
1064 }
1065 }
1066
1067 void SAL_CALL ScHeaderFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
1068 throw (uno::RuntimeException)
1069 {
1070 if (xListener.is())
1071 {
1072 ScUnoGuard aGuard;
1073 if (!mpRefreshListeners)
1074 mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
1075 mpRefreshListeners->addInterface(xListener);
1076 }
1077 }
1078
1079 void SAL_CALL ScHeaderFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
1080 throw (uno::RuntimeException)
1081 {
1082 if (xListener.is())
1083 {
1084 ScUnoGuard aGuard;
1085 if (mpRefreshListeners)
1086 mpRefreshListeners->removeInterface(xListener);
1087 }
1088 }
1089
1090 //------------------------------------------------------------------------
1091
1092 SvxFileFormat lcl_UnoToSvxFileFormat( sal_Int16 nUnoValue )
1093 {
1094 switch( nUnoValue )
1095 {
1096 case text::FilenameDisplayFormat::FULL: return SVXFILEFORMAT_FULLPATH;
1097 case text::FilenameDisplayFormat::PATH: return SVXFILEFORMAT_PATH;
1098 case text::FilenameDisplayFormat::NAME: return SVXFILEFORMAT_NAME;
1099 // case text::FilenameDisplayFormat::NAME_AND_EXT:
1100 default:
1101 return SVXFILEFORMAT_NAME_EXT;
1102 }
1103 }
1104
1105 sal_Int16 lcl_SvxToUnoFileFormat( SvxFileFormat nSvxValue )
1106 {
1107 switch( nSvxValue )
1108 {
1109 case SVXFILEFORMAT_NAME_EXT: return text::FilenameDisplayFormat::NAME_AND_EXT;
1110 case SVXFILEFORMAT_FULLPATH: return text::FilenameDisplayFormat::FULL;
1111 case SVXFILEFORMAT_PATH: return text::FilenameDisplayFormat::PATH;
1112 // case SVXFILEFORMAT_NAME:
1113 default:
1114 return text::FilenameDisplayFormat::NAME;
1115 }
1116 }
1117
1118
1119 // Default-ctor wird fuer SMART_REFLECTION_IMPLEMENTATION gebraucht
1120 //UNUSED2008-05 ScHeaderFieldObj::ScHeaderFieldObj() :
1121 //UNUSED2008-05 OComponentHelper( getMutex() ),
1122 //UNUSED2008-05 aPropSet( lcl_GetHeaderFieldPropertyMap() ),
1123 //UNUSED2008-05 pContentObj( NULL ),
1124 //UNUSED2008-05 nPart( 0 ),
1125 //UNUSED2008-05 nType( 0 ),
1126 //UNUSED2008-05 nFileFormat( SVXFILEFORMAT_NAME_EXT )
1127 //UNUSED2008-05 {
1128 //UNUSED2008-05 pEditSource = NULL;
1129 //UNUSED2008-05 }
1130
1131 ScHeaderFieldObj::ScHeaderFieldObj(ScHeaderFooterContentObj* pContent, USHORT nP,
1132 USHORT nT, const ESelection& rSel) :
1133 OComponentHelper( getMutex() ),
1134 pPropSet( (nT == SC_SERVICE_FILEFIELD) ? lcl_GetFileFieldPropertySet() : lcl_GetHeaderFieldPropertySet() ),
1135 pContentObj( pContent ),
1136 nPart( nP ),
1137 nType( nT ),
1138 aSelection( rSel ),
1139 nFileFormat( SVXFILEFORMAT_NAME_EXT )
1140 {
1141 // pContent ist Null, wenn per ServiceProvider erzeugt
1142
1143 if (pContentObj)
1144 {
1145 pContentObj->acquire(); // darf nicht wegkommen
1146 pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart );
1147 }
1148 else
1149 pEditSource = NULL;
1150 }
1151
1152 uno::Any SAL_CALL ScHeaderFieldObj::queryAggregation( const uno::Type& rType )
1153 throw(uno::RuntimeException)
1154 {
1155 SC_QUERYINTERFACE( text::XTextField )
1156 SC_QUERYINTERFACE( text::XTextContent ) // parent of XTextField
1157 SC_QUERYINTERFACE( beans::XPropertySet )
1158 SC_QUERYINTERFACE( lang::XUnoTunnel )
1159 SC_QUERYINTERFACE( lang::XServiceInfo )
1160
1161 return OComponentHelper::queryAggregation( rType ); // XComponent
1162 }
1163
1164 uno::Sequence<uno::Type> SAL_CALL ScHeaderFieldObj::getTypes() throw(uno::RuntimeException)
1165 {
1166 static uno::Sequence<uno::Type> aTypes;
1167 if ( aTypes.getLength() == 0 )
1168 {
1169 uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes());
1170 long nParentLen = aParentTypes.getLength();
1171 const uno::Type* pParentPtr = aParentTypes.getConstArray();
1172
1173 aTypes.realloc( nParentLen + 4 );
1174 uno::Type* pPtr = aTypes.getArray();
1175 pPtr[nParentLen + 0] = getCppuType((const uno::Reference<text::XTextField>*)0);
1176 pPtr[nParentLen + 1] = getCppuType((const uno::Reference<beans::XPropertySet>*)0);
1177 pPtr[nParentLen + 2] = getCppuType((const uno::Reference<lang::XUnoTunnel>*)0);
1178 pPtr[nParentLen + 3] = getCppuType((const uno::Reference<lang::XServiceInfo>*)0);
1179
1180 for (long i=0; i<nParentLen; i++)
1181 pPtr[i] = pParentPtr[i]; // parent types first
1182 }
1183 return aTypes;
1184 }
1185
1186 uno::Sequence<sal_Int8> SAL_CALL ScHeaderFieldObj::getImplementationId()
1187 throw(uno::RuntimeException)
1188 {
1189 static uno::Sequence< sal_Int8 > aId;
1190 if( aId.getLength() == 0 )
1191 {
1192 aId.realloc( 16 );
1193 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
1194 }
1195 return aId;
1196 }
1197
1198 uno::Any SAL_CALL ScHeaderFieldObj::queryInterface( const uno::Type& rType )
1199 throw(uno::RuntimeException)
1200 {
1201 return OComponentHelper::queryInterface( rType );
1202 }
1203
1204 void SAL_CALL ScHeaderFieldObj::acquire() throw()
1205 {
1206 OComponentHelper::acquire();
1207 }
1208
1209 void SAL_CALL ScHeaderFieldObj::release() throw()
1210 {
1211 OComponentHelper::release();
1212 }
1213
1214 void ScHeaderFieldObj::InitDoc( ScHeaderFooterContentObj* pContent, USHORT nP,
1215 const ESelection& rSel )
1216 {
1217 if ( pContent && !pEditSource )
1218 {
1219 DBG_ASSERT( !pContentObj, "ContentObj, aber kein EditSource?" );
1220
1221 aSelection = rSel;
1222 nPart = nP;
1223 pContentObj = pContent;
1224
1225 pContentObj->acquire(); // darf nicht wegkommen
1226 pEditSource = new ScHeaderFooterEditSource( pContentObj, nPart );
1227 }
1228 }
1229
1230 ScHeaderFieldObj::~ScHeaderFieldObj()
1231 {
1232 delete pEditSource;
1233
1234 if (pContentObj)
1235 pContentObj->release();
1236 }
1237
1238 // per getImplementation gerufen:
1239
1240 SvxFieldItem ScHeaderFieldObj::CreateFieldItem()
1241 {
1242 DBG_ASSERT( !pEditSource, "CreateFieldItem mit eingefuegtem Feld" );
1243
1244 switch (nType)
1245 {
1246 case SC_SERVICE_PAGEFIELD:
1247 {
1248 SvxPageField aField;
1249 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1250 }
1251 case SC_SERVICE_PAGESFIELD:
1252 {
1253 SvxPagesField aField;
1254 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1255 }
1256 case SC_SERVICE_DATEFIELD:
1257 {
1258 SvxDateField aField;
1259 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1260 }
1261 case SC_SERVICE_TIMEFIELD:
1262 {
1263 SvxTimeField aField;
1264 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1265 }
1266 case SC_SERVICE_TITLEFIELD:
1267 {
1268 SvxFileField aField;
1269 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1270 }
1271 case SC_SERVICE_FILEFIELD:
1272 {
1273 SvxExtFileField aField;
1274 aField.SetFormat( (SvxFileFormat) nFileFormat );
1275 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1276 }
1277 case SC_SERVICE_SHEETFIELD:
1278 {
1279 SvxTableField aField;
1280 return SvxFieldItem( aField, EE_FEATURE_FIELD );
1281 }
1282 }
1283
1284 return SvxFieldItem( SvxFieldData(), EE_FEATURE_FIELD );
1285 }
1286
1287 void ScHeaderFieldObj::DeleteField()
1288 {
1289 if (pEditSource)
1290 {
1291 SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
1292 // pEditEngine->QuickDelete( aSelection );
1293 pForwarder->QuickInsertText( String(), aSelection );
1294 pEditSource->UpdateData();
1295
1296 aSelection.nEndPara = aSelection.nStartPara;
1297 aSelection.nEndPos = aSelection.nStartPos;
1298
1299 //! Broadcast, um Selektion in anderen Objekten anzupassen
1300 //! (auch bei anderen Aktionen)
1301 }
1302 }
1303
1304 // XTextField
1305
1306 rtl::OUString SAL_CALL ScHeaderFieldObj::getPresentation( sal_Bool /* bShowCommand */ )
1307 throw(uno::RuntimeException)
1308 {
1309 ScUnoGuard aGuard;
1310 String aRet;
1311
1312 if (pEditSource)
1313 {
1314 // Feld von der EditEngine formatieren lassen, bShowCommand gibt's nicht
1315
1316 SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder();
1317 aRet = pForwarder->GetText( aSelection );
1318 }
1319
1320 return aRet;
1321 }
1322
1323 // XTextContent
1324
1325 void SAL_CALL ScHeaderFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange )
1326 throw(lang::IllegalArgumentException, uno::RuntimeException)
1327 {
1328 ScUnoGuard aGuard;
1329 if (xTextRange.is())
1330 {
1331 uno::Reference<text::XText> xText(xTextRange->getText());
1332 if (xText.is())
1333 {
1334 xText->insertTextContent( xTextRange, this, TRUE );
1335 }
1336 }
1337 }
1338
1339 uno::Reference<text::XTextRange> SAL_CALL ScHeaderFieldObj::getAnchor() throw(uno::RuntimeException)
1340 {
1341 ScUnoGuard aGuard;
1342 if (pContentObj)
1343 {
1344 uno::Reference<text::XText> xText;
1345 if ( nPart == SC_HDFT_LEFT )
1346 xText = pContentObj->getLeftText();
1347 else if (nPart == SC_HDFT_CENTER)
1348 xText = pContentObj->getCenterText();
1349 else
1350 xText = pContentObj->getRightText();
1351 return uno::Reference<text::XTextRange>( xText, uno::UNO_QUERY );
1352 }
1353 return NULL;
1354 }
1355
1356 // XComponent
1357
1358 void SAL_CALL ScHeaderFieldObj::dispose() throw(uno::RuntimeException)
1359 {
1360 OComponentHelper::dispose();
1361 }
1362
1363 void SAL_CALL ScHeaderFieldObj::addEventListener(
1364 const uno::Reference<lang::XEventListener>& xListener )
1365 throw(uno::RuntimeException)
1366 {
1367 OComponentHelper::addEventListener( xListener );
1368 }
1369
1370 void SAL_CALL ScHeaderFieldObj::removeEventListener(
1371 const uno::Reference<lang::XEventListener>& xListener )
1372 throw(uno::RuntimeException)
1373 {
1374 OComponentHelper::removeEventListener( xListener );
1375 }
1376
1377 // XPropertySet
1378
1379 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScHeaderFieldObj::getPropertySetInfo()
1380 throw(uno::RuntimeException)
1381 {
1382 ScUnoGuard aGuard;
1383 if (nType == SC_SERVICE_FILEFIELD)
1384 {
1385 // file field has different properties
1386 static uno::Reference<beans::XPropertySetInfo> aFileFieldInfo = pPropSet->getPropertySetInfo();
1387 return aFileFieldInfo;
1388 }
1389 else
1390 {
1391 static uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo();
1392 return aRef;
1393 }
1394 }
1395
1396 void SAL_CALL ScHeaderFieldObj::setPropertyValue(
1397 const rtl::OUString& aPropertyName, const uno::Any& aValue )
1398 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1399 lang::IllegalArgumentException, lang::WrappedTargetException,
1400 uno::RuntimeException)
1401 {
1402 ScUnoGuard aGuard;
1403 String aNameString(aPropertyName);
1404 if ( nType == SC_SERVICE_FILEFIELD && aNameString.EqualsAscii( SC_UNONAME_FILEFORM ) )
1405 {
1406 sal_Int16 nIntVal = 0;
1407 if ( aValue >>= nIntVal )
1408 {
1409 SvxFileFormat eFormat = lcl_UnoToSvxFileFormat( nIntVal );
1410 if (pEditSource)
1411 {
1412 ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine();
1413 ScUnoEditEngine aTempEngine(pEditEngine);
1414 SvxFieldData* pField = aTempEngine.FindByPos(
1415 aSelection.nStartPara, aSelection.nStartPos, TYPE(SvxExtFileField) );
1416 DBG_ASSERT(pField,"setPropertyValue: Field not found");
1417 if (pField)
1418 {
1419 SvxExtFileField* pExtFile = (SvxExtFileField*)pField; // local to the ScUnoEditEngine
1420 pExtFile->SetFormat( eFormat );
1421 pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection );
1422 pEditSource->UpdateData();
1423 }
1424 }
1425 else
1426 nFileFormat = sal::static_int_cast<sal_Int16>(eFormat); // not inserted yet - store value
1427 }
1428 }
1429 }
1430
1431 uno::Any SAL_CALL ScHeaderFieldObj::getPropertyValue( const rtl::OUString& aPropertyName )
1432 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1433 uno::RuntimeException)
1434 {
1435 ScUnoGuard aGuard;
1436
1437 //! Properties?
1438 uno::Any aRet;
1439 String aNameString(aPropertyName);
1440
1441 // anchor type is always "as character", text wrap always "none"
1442
1443 if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPE ) )
1444 aRet <<= text::TextContentAnchorType_AS_CHARACTER;
1445 else if ( aNameString.EqualsAscii( SC_UNONAME_ANCTYPES ) )
1446 {
1447 uno::Sequence<text::TextContentAnchorType> aSeq(1);
1448 aSeq[0] = text::TextContentAnchorType_AS_CHARACTER;
1449 aRet <<= aSeq;
1450 }
1451 else if ( aNameString.EqualsAscii( SC_UNONAME_TEXTWRAP ) )
1452 aRet <<= text::WrapTextMode_NONE;
1453 else if ( nType == SC_SERVICE_FILEFIELD && aNameString.EqualsAscii( SC_UNONAME_FILEFORM ) )
1454 {
1455 SvxFileFormat eFormat = SVXFILEFORMAT_NAME_EXT;
1456 if (pEditSource)
1457 {
1458 ScEditEngineDefaulter* pEditEngine = ((ScHeaderFooterEditSource*)pEditSource)->GetEditEngine();
1459 ScUnoEditEngine aTempEngine(pEditEngine);
1460 SvxFieldData* pField = aTempEngine.FindByPos(
1461 aSelection.nStartPara, aSelection.nStartPos, TYPE(SvxExtFileField) );
1462 DBG_ASSERT(pField,"setPropertyValue: Field not found");
1463 if (pField)
1464 {
1465 const SvxExtFileField* pExtFile = (const SvxExtFileField*)pField;
1466 eFormat = pExtFile->GetFormat();
1467 }
1468 }
1469 else
1470 eFormat = (SvxFileFormat) nFileFormat; // not inserted yet - use stored value
1471
1472 sal_Int16 nIntVal = lcl_SvxToUnoFileFormat( eFormat );
1473 aRet <<= nIntVal;
1474 }
1475
1476 return aRet;
1477 }
1478
1479 SC_IMPL_DUMMY_PROPERTY_LISTENER( ScHeaderFieldObj )
1480
1481 // XUnoTunnel
1482
1483 sal_Int64 SAL_CALL ScHeaderFieldObj::getSomething(
1484 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
1485 {
1486 if ( rId.getLength() == 16 &&
1487 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
1488 rId.getConstArray(), 16 ) )
1489 {
1490 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
1491 }
1492 return 0;
1493 }
1494
1495 // static
1496 const uno::Sequence<sal_Int8>& ScHeaderFieldObj::getUnoTunnelId()
1497 {
1498 static uno::Sequence<sal_Int8> * pSeq = 0;
1499 if( !pSeq )
1500 {
1501 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
1502 if( !pSeq )
1503 {
1504 static uno::Sequence< sal_Int8 > aSeq( 16 );
1505 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
1506 pSeq = &aSeq;
1507 }
1508 }
1509 return *pSeq;
1510 }
1511
1512 // static
1513 ScHeaderFieldObj* ScHeaderFieldObj::getImplementation(
1514 const uno::Reference<text::XTextContent> xObj )
1515 {
1516 ScHeaderFieldObj* pRet = NULL;
1517 uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
1518 if (xUT.is())
1519 pRet = reinterpret_cast<ScHeaderFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
1520 return pRet;
1521 }
1522
1523 // XServiceInfo
1524
1525 rtl::OUString SAL_CALL ScHeaderFieldObj::getImplementationName() throw(uno::RuntimeException)
1526 {
1527 return rtl::OUString::createFromAscii( "ScHeaderFieldObj" );
1528 }
1529
1530 sal_Bool SAL_CALL ScHeaderFieldObj::supportsService( const rtl::OUString& rServiceName )
1531 throw(uno::RuntimeException)
1532 {
1533 String aServiceStr( rServiceName );
1534 return aServiceStr.EqualsAscii( SCTEXTFIELD_SERVICE ) ||
1535 aServiceStr.EqualsAscii( SCTEXTCONTENT_SERVICE );
1536 }
1537
1538 uno::Sequence<rtl::OUString> SAL_CALL ScHeaderFieldObj::getSupportedServiceNames()
1539 throw(uno::RuntimeException)
1540 {
1541 uno::Sequence<rtl::OUString> aRet(2);
1542 rtl::OUString* pArray = aRet.getArray();
1543 pArray[0] = rtl::OUString::createFromAscii( SCTEXTFIELD_SERVICE );
1544 pArray[1] = rtl::OUString::createFromAscii( SCTEXTCONTENT_SERVICE );
1545 return aRet;
1546 }
1547
1548 //------------------------------------------------------------------------
1549
1550
1551
1552
vba interoperability for OOo