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 "fielduno.hxx"
21 : #include "textuno.hxx"
22 : #include "miscuno.hxx"
23 : #include "docsh.hxx"
24 : #include "hints.hxx"
25 : #include "editsrc.hxx"
26 : #include "cellsuno.hxx"
27 : #include "servuno.hxx"
28 : #include "unonames.hxx"
29 : #include "editutil.hxx"
30 :
31 : #include <svl/smplhint.hxx>
32 : #include <vcl/svapp.hxx>
33 :
34 : #include <editeng/eeitem.hxx>
35 :
36 : #include <editeng/editeng.hxx>
37 : #include <editeng/editobj.hxx>
38 : #include <editeng/flditem.hxx>
39 : #include <comphelper/servicehelper.hxx>
40 : #include <cppuhelper/supportsservice.hxx>
41 :
42 : #include <com/sun/star/beans/PropertyAttribute.hpp>
43 : #include <com/sun/star/text/TextContentAnchorType.hpp>
44 : #include <com/sun/star/text/WrapTextMode.hpp>
45 : #include <com/sun/star/text/FilenameDisplayFormat.hpp>
46 : #include <com/sun/star/text/textfield/Type.hpp>
47 :
48 : using namespace com::sun::star;
49 :
50 : namespace {
51 :
52 : // alles ohne Which-ID, Map nur fuer PropertySetInfo
53 :
54 564 : const SfxItemPropertySet* getDateTimePropertySet()
55 : {
56 : static const SfxItemPropertyMapEntry aMapContent[] =
57 : {
58 50 : { OUString(SC_UNONAME_DATETIME), 0, cppu::UnoType<util::DateTime>::get(), 0, 0 },
59 50 : { OUString(SC_UNONAME_ISFIXED), 0, getBooleanCppuType(), 0, 0 },
60 50 : { OUString(SC_UNONAME_ISDATE), 0, getBooleanCppuType(), 0, 0 },
61 50 : { OUString(SC_UNONAME_NUMFMT), 0, cppu::UnoType<sal_Int32>::get(), 0, 0 },
62 : { OUString(), 0, css::uno::Type(), 0, 0 }
63 814 : };
64 564 : static SfxItemPropertySet aMap(aMapContent);
65 564 : return &aMap;
66 : }
67 :
68 272 : const SfxItemPropertySet* getEmptyPropertySet()
69 : {
70 : static const SfxItemPropertyMapEntry aMapContent[] =
71 : {
72 : { OUString(), 0, css::uno::Type(), 0, 0 }
73 320 : };
74 272 : static SfxItemPropertySet aMap(aMapContent);
75 272 : return &aMap;
76 : }
77 :
78 32 : const SfxItemPropertySet* lcl_GetURLPropertySet()
79 : {
80 : static const SfxItemPropertyMapEntry aURLPropertyMap_Impl[] =
81 : {
82 4 : {OUString(SC_UNONAME_ANCTYPE), 0, cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
83 4 : {OUString(SC_UNONAME_ANCTYPES), 0, getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
84 4 : {OUString(SC_UNONAME_REPR), 0, cppu::UnoType<OUString>::get(), 0, 0},
85 4 : {OUString(SC_UNONAME_TARGET), 0, cppu::UnoType<OUString>::get(), 0, 0},
86 4 : {OUString(SC_UNONAME_TEXTWRAP), 0, cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
87 4 : {OUString(SC_UNONAME_URL), 0, cppu::UnoType<OUString>::get(), 0, 0},
88 : { OUString(), 0, css::uno::Type(), 0, 0 }
89 60 : };
90 32 : static SfxItemPropertySet aURLPropertySet_Impl( aURLPropertyMap_Impl );
91 32 : return &aURLPropertySet_Impl;
92 : }
93 :
94 1526 : const SfxItemPropertySet* lcl_GetHeaderFieldPropertySet()
95 : {
96 : static const SfxItemPropertyMapEntry aHeaderFieldPropertyMap_Impl[] =
97 : {
98 46 : {OUString(SC_UNONAME_ANCTYPE), 0, cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
99 46 : {OUString(SC_UNONAME_ANCTYPES), 0, getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
100 46 : {OUString(SC_UNONAME_TEXTWRAP), 0, cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
101 : { OUString(), 0, css::uno::Type(), 0, 0 }
102 1710 : };
103 1526 : static SfxItemPropertySet aHeaderFieldPropertySet_Impl( aHeaderFieldPropertyMap_Impl );
104 1526 : return &aHeaderFieldPropertySet_Impl;
105 : }
106 :
107 4 : const SfxItemPropertySet* lcl_GetFileFieldPropertySet()
108 : {
109 : static const SfxItemPropertyMapEntry aFileFieldPropertyMap_Impl[] =
110 : {
111 2 : {OUString(SC_UNONAME_ANCTYPE), 0, cppu::UnoType<text::TextContentAnchorType>::get(), beans::PropertyAttribute::READONLY, 0 },
112 2 : {OUString(SC_UNONAME_ANCTYPES), 0, getCppuType((uno::Sequence<text::TextContentAnchorType>*)0), beans::PropertyAttribute::READONLY, 0 },
113 2 : {OUString(SC_UNONAME_FILEFORM), 0, cppu::UnoType<sal_Int16>::get(), 0, 0 },
114 2 : {OUString(SC_UNONAME_TEXTWRAP), 0, cppu::UnoType<text::WrapTextMode>::get(), beans::PropertyAttribute::READONLY, 0 },
115 : { OUString(), 0, css::uno::Type(), 0, 0 }
116 14 : };
117 4 : static SfxItemPropertySet aFileFieldPropertySet_Impl( aFileFieldPropertyMap_Impl );
118 4 : return &aFileFieldPropertySet_Impl;
119 : }
120 :
121 0 : SvxFileFormat lcl_UnoToSvxFileFormat( sal_Int16 nUnoValue )
122 : {
123 0 : switch( nUnoValue )
124 : {
125 0 : case text::FilenameDisplayFormat::FULL: return SVXFILEFORMAT_FULLPATH;
126 0 : case text::FilenameDisplayFormat::PATH: return SVXFILEFORMAT_PATH;
127 0 : case text::FilenameDisplayFormat::NAME: return SVXFILEFORMAT_NAME;
128 : default:
129 0 : return SVXFILEFORMAT_NAME_EXT;
130 : }
131 : }
132 :
133 0 : sal_Int16 lcl_SvxToUnoFileFormat( SvxFileFormat nSvxValue )
134 : {
135 0 : switch( nSvxValue )
136 : {
137 0 : case SVXFILEFORMAT_NAME_EXT: return text::FilenameDisplayFormat::NAME_AND_EXT;
138 0 : case SVXFILEFORMAT_FULLPATH: return text::FilenameDisplayFormat::FULL;
139 0 : case SVXFILEFORMAT_PATH: return text::FilenameDisplayFormat::PATH;
140 : default:
141 0 : return text::FilenameDisplayFormat::NAME;
142 : }
143 : }
144 :
145 : }
146 :
147 0 : SC_SIMPLE_SERVICE_INFO( ScCellFieldsObj, "ScCellFieldsObj", "com.sun.star.text.TextFields" )
148 0 : SC_SIMPLE_SERVICE_INFO( ScHeaderFieldsObj, "ScHeaderFieldsObj", "com.sun.star.text.TextFields" )
149 :
150 : // ScUnoEditEngine nur um aus einer EditEngine die Felder herauszubekommen...
151 :
152 : enum ScUnoCollectMode
153 : {
154 : SC_UNO_COLLECT_NONE,
155 : SC_UNO_COLLECT_COUNT,
156 : SC_UNO_COLLECT_FINDINDEX,
157 : SC_UNO_COLLECT_FINDPOS
158 : };
159 :
160 : /**
161 : * This class exists solely to allow searching through field items. TODO:
162 : * Look into providing the same functionality directly in EditEngine, to
163 : * avoid having this class altogether.
164 : */
165 : class ScUnoEditEngine : public ScEditEngineDefaulter
166 : {
167 : ScUnoCollectMode eMode;
168 : sal_uInt16 nFieldCount;
169 : sal_Int32 mnFieldType;
170 : SvxFieldData* pFound; // lokale Kopie
171 : sal_Int32 nFieldPar;
172 : sal_Int32 nFieldPos;
173 : sal_uInt16 nFieldIndex;
174 :
175 : public:
176 : ScUnoEditEngine(ScEditEngineDefaulter* pSource);
177 : virtual ~ScUnoEditEngine();
178 :
179 : virtual OUString CalcFieldValue( const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos,
180 : Color*& rTxtColor, Color*& rFldColor ) SAL_OVERRIDE;
181 :
182 : sal_uInt16 CountFields();
183 : SvxFieldData* FindByIndex(sal_uInt16 nIndex);
184 : SvxFieldData* FindByPos(sal_Int32 nPar, sal_Int32 nPos, sal_Int32 nType);
185 :
186 4 : sal_Int32 GetFieldPar() const { return nFieldPar; }
187 4 : sal_Int32 GetFieldPos() const { return nFieldPos; }
188 : };
189 :
190 172 : ScUnoEditEngine::ScUnoEditEngine(ScEditEngineDefaulter* pSource)
191 : : ScEditEngineDefaulter(*pSource)
192 : , eMode(SC_UNO_COLLECT_NONE)
193 : , nFieldCount(0)
194 : , mnFieldType(text::textfield::Type::UNSPECIFIED)
195 : , pFound(NULL)
196 : , nFieldPar(0)
197 : , nFieldPos(0)
198 172 : , nFieldIndex(0)
199 : {
200 172 : EditTextObject* pData = pSource->CreateTextObject();
201 172 : SetText( *pData );
202 172 : delete pData;
203 172 : }
204 :
205 344 : ScUnoEditEngine::~ScUnoEditEngine()
206 : {
207 172 : delete pFound;
208 172 : }
209 :
210 344 : OUString ScUnoEditEngine::CalcFieldValue( const SvxFieldItem& rField,
211 : sal_Int32 nPara, sal_Int32 nPos, Color*& rTxtColor, Color*& rFldColor )
212 : {
213 344 : OUString aRet(EditEngine::CalcFieldValue( rField, nPara, nPos, rTxtColor, rFldColor ));
214 344 : if (eMode != SC_UNO_COLLECT_NONE)
215 : {
216 172 : const SvxFieldData* pFieldData = rField.GetField();
217 172 : if ( pFieldData )
218 : {
219 172 : if (mnFieldType == text::textfield::Type::UNSPECIFIED || pFieldData->GetClassId() == mnFieldType)
220 : {
221 172 : if ( eMode == SC_UNO_COLLECT_FINDINDEX && !pFound && nFieldCount == nFieldIndex )
222 : {
223 4 : pFound = pFieldData->Clone();
224 4 : nFieldPar = nPara;
225 4 : nFieldPos = nPos;
226 : }
227 326 : if ( eMode == SC_UNO_COLLECT_FINDPOS && !pFound &&
228 308 : nPara == nFieldPar && nPos == nFieldPos )
229 : {
230 154 : pFound = pFieldData->Clone();
231 154 : nFieldIndex = nFieldCount;
232 : }
233 172 : ++nFieldCount;
234 : }
235 : }
236 : }
237 344 : return aRet;
238 : }
239 :
240 12 : sal_uInt16 ScUnoEditEngine::CountFields()
241 : {
242 12 : eMode = SC_UNO_COLLECT_COUNT;
243 12 : mnFieldType = text::textfield::Type::UNSPECIFIED;
244 12 : nFieldCount = 0;
245 12 : UpdateFields();
246 12 : eMode = SC_UNO_COLLECT_NONE;
247 :
248 12 : return nFieldCount;
249 : }
250 :
251 6 : SvxFieldData* ScUnoEditEngine::FindByIndex(sal_uInt16 nIndex)
252 : {
253 6 : eMode = SC_UNO_COLLECT_FINDINDEX;
254 6 : nFieldIndex = nIndex;
255 6 : mnFieldType = text::textfield::Type::UNSPECIFIED;
256 6 : nFieldCount = 0;
257 6 : UpdateFields();
258 6 : eMode = SC_UNO_COLLECT_NONE;
259 :
260 6 : return pFound;
261 : }
262 :
263 154 : SvxFieldData* ScUnoEditEngine::FindByPos(sal_Int32 nPar, sal_Int32 nPos, sal_Int32 nType)
264 : {
265 154 : eMode = SC_UNO_COLLECT_FINDPOS;
266 154 : nFieldPar = nPar;
267 154 : nFieldPos = nPos;
268 154 : mnFieldType = nType;
269 154 : nFieldCount = 0;
270 154 : UpdateFields();
271 154 : mnFieldType = text::textfield::Type::UNSPECIFIED;
272 154 : eMode = SC_UNO_COLLECT_NONE;
273 :
274 154 : return pFound;
275 : }
276 :
277 8 : ScCellFieldsObj::ScCellFieldsObj(
278 : const uno::Reference<text::XTextRange>& xContent,
279 : ScDocShell* pDocSh, const ScAddress& rPos) :
280 : mxContent(xContent),
281 : pDocShell( pDocSh ),
282 : aCellPos( rPos ),
283 8 : mpRefreshListeners( NULL )
284 : {
285 8 : pDocShell->GetDocument().AddUnoObject(*this);
286 :
287 8 : mpEditSource = new ScCellEditSource( pDocShell, aCellPos );
288 8 : }
289 :
290 24 : ScCellFieldsObj::~ScCellFieldsObj()
291 : {
292 8 : SolarMutexGuard g;
293 :
294 8 : if (pDocShell)
295 0 : pDocShell->GetDocument().RemoveUnoObject(*this);
296 :
297 8 : delete mpEditSource;
298 :
299 : // increment refcount to prevent double call off dtor
300 8 : osl_atomic_increment( &m_refCount );
301 :
302 8 : if (mpRefreshListeners)
303 : {
304 2 : lang::EventObject aEvent;
305 2 : aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
306 2 : if (mpRefreshListeners)
307 : {
308 2 : mpRefreshListeners->disposeAndClear(aEvent);
309 2 : DELETEZ( mpRefreshListeners );
310 2 : }
311 8 : }
312 16 : }
313 :
314 8 : void ScCellFieldsObj::Notify( SfxBroadcaster&, const SfxHint& rHint )
315 : {
316 8 : if ( dynamic_cast<const ScUpdateRefHint*>(&rHint) )
317 : {
318 : //! Ref-Update
319 : }
320 16 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) &&
321 8 : static_cast<const SfxSimpleHint&>(rHint).GetId() == SFX_HINT_DYING )
322 : {
323 8 : pDocShell = NULL; // ungueltig geworden
324 : }
325 :
326 : // EditSource hat sich selber als Listener angemeldet
327 8 : }
328 :
329 : // XIndexAccess (via XTextFields)
330 :
331 6 : uno::Reference<text::XTextField> ScCellFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const
332 : {
333 : //! Feld-Funktionen muessen an den Forwarder !!!
334 6 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
335 6 : ScUnoEditEngine aTempEngine(pEditEngine);
336 6 : SvxFieldData* pData = aTempEngine.FindByIndex(static_cast<sal_uInt16>(Index));
337 6 : if (!pData)
338 2 : return uno::Reference<text::XTextField>();
339 :
340 4 : sal_Int32 nPar = aTempEngine.GetFieldPar();
341 4 : sal_Int32 nPos = aTempEngine.GetFieldPos();
342 4 : ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Feld ist 1 Zeichen
343 :
344 4 : sal_Int32 eType = pData->GetClassId();
345 : uno::Reference<text::XTextField> xRet(
346 8 : new ScEditFieldObj(mxContent, new ScCellEditSource(pDocShell, aCellPos), eType, aSelection));
347 10 : return xRet;
348 : }
349 :
350 10 : sal_Int32 SAL_CALL ScCellFieldsObj::getCount() throw(uno::RuntimeException, std::exception)
351 : {
352 10 : SolarMutexGuard aGuard;
353 :
354 : //! Feld-Funktionen muessen an den Forwarder !!!
355 10 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
356 20 : ScUnoEditEngine aTempEngine(pEditEngine);
357 :
358 20 : return aTempEngine.CountFields(); // Felder zaehlen, in Zelle ist der Typ egal
359 : }
360 :
361 6 : uno::Any SAL_CALL ScCellFieldsObj::getByIndex( sal_Int32 nIndex )
362 : throw(lang::IndexOutOfBoundsException,
363 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
364 : {
365 6 : SolarMutexGuard aGuard;
366 12 : uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
367 6 : if (xField.is())
368 8 : return uno::makeAny(xField);
369 : else
370 8 : throw lang::IndexOutOfBoundsException();
371 : }
372 :
373 2 : uno::Type SAL_CALL ScCellFieldsObj::getElementType() throw(uno::RuntimeException, std::exception)
374 : {
375 2 : SolarMutexGuard aGuard;
376 2 : return cppu::UnoType<text::XTextField>::get();
377 : }
378 :
379 2 : sal_Bool SAL_CALL ScCellFieldsObj::hasElements() throw(uno::RuntimeException, std::exception)
380 : {
381 2 : SolarMutexGuard aGuard;
382 2 : return ( getCount() != 0 );
383 : }
384 :
385 6 : uno::Reference<container::XEnumeration> SAL_CALL ScCellFieldsObj::createEnumeration()
386 : throw(uno::RuntimeException, std::exception)
387 : {
388 6 : SolarMutexGuard aGuard;
389 6 : return new ScIndexEnumeration(this, OUString("com.sun.star.text.TextFieldEnumeration"));
390 : }
391 :
392 0 : void SAL_CALL ScCellFieldsObj::addContainerListener(
393 : const uno::Reference<container::XContainerListener>& /* xListener */ )
394 : throw(uno::RuntimeException, std::exception)
395 : {
396 : OSL_FAIL("not implemented");
397 0 : }
398 :
399 0 : void SAL_CALL ScCellFieldsObj::removeContainerListener(
400 : const uno::Reference<container::XContainerListener>& /* xListener */ )
401 : throw(uno::RuntimeException, std::exception)
402 : {
403 : OSL_FAIL("not implemented");
404 0 : }
405 :
406 : // XRefreshable
407 4 : void SAL_CALL ScCellFieldsObj::refresh( )
408 : throw (uno::RuntimeException, std::exception)
409 : {
410 4 : if (mpRefreshListeners)
411 : {
412 : // Call all listeners.
413 4 : uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
414 4 : sal_uInt32 nLength(aListeners.getLength());
415 4 : if (nLength)
416 : {
417 2 : const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
418 2 : if (pInterfaces)
419 : {
420 2 : lang::EventObject aEvent;
421 2 : aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScCellFieldsObj*>(this)));
422 2 : sal_uInt32 i(0);
423 6 : while (i < nLength)
424 : {
425 : try
426 : {
427 6 : while(i < nLength)
428 : {
429 2 : static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
430 2 : ++pInterfaces;
431 2 : ++i;
432 : }
433 : }
434 0 : catch(uno::RuntimeException&)
435 : {
436 0 : ++pInterfaces;
437 0 : ++i;
438 : }
439 2 : }
440 : }
441 4 : }
442 : }
443 4 : }
444 :
445 2 : void SAL_CALL ScCellFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
446 : throw (uno::RuntimeException, std::exception)
447 : {
448 2 : if (xListener.is())
449 : {
450 2 : SolarMutexGuard aGuard;
451 2 : if (!mpRefreshListeners)
452 2 : mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
453 2 : mpRefreshListeners->addInterface(xListener);
454 : }
455 2 : }
456 :
457 2 : void SAL_CALL ScCellFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
458 : throw (uno::RuntimeException, std::exception)
459 : {
460 2 : if (xListener.is())
461 : {
462 2 : SolarMutexGuard aGuard;
463 2 : if (mpRefreshListeners)
464 2 : mpRefreshListeners->removeInterface(xListener);
465 : }
466 2 : }
467 :
468 2 : ScHeaderFieldsObj::ScHeaderFieldsObj(ScHeaderFooterTextData& rData) :
469 : mrData(rData),
470 2 : mpRefreshListeners( NULL )
471 : {
472 2 : mpEditSource = new ScHeaderFooterEditSource(rData);
473 2 : }
474 :
475 6 : ScHeaderFieldsObj::~ScHeaderFieldsObj()
476 : {
477 2 : delete mpEditSource;
478 :
479 : // increment refcount to prevent double call off dtor
480 2 : osl_atomic_increment( &m_refCount );
481 :
482 2 : if (mpRefreshListeners)
483 : {
484 2 : lang::EventObject aEvent;
485 2 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
486 2 : if (mpRefreshListeners)
487 : {
488 2 : mpRefreshListeners->disposeAndClear(aEvent);
489 2 : DELETEZ( mpRefreshListeners );
490 2 : }
491 : }
492 4 : }
493 :
494 : // XIndexAccess (via XTextFields)
495 :
496 0 : uno::Reference<text::XTextField> ScHeaderFieldsObj::GetObjectByIndex_Impl(sal_Int32 Index) const
497 : {
498 : //! Feld-Funktionen muessen an den Forwarder !!!
499 0 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
500 0 : ScUnoEditEngine aTempEngine(pEditEngine);
501 :
502 0 : SvxFieldData* pData = aTempEngine.FindByIndex(static_cast<sal_uInt16>(Index));
503 0 : if (!pData)
504 0 : return NULL;
505 :
506 : // Get the parent text range instance.
507 0 : uno::Reference<text::XTextRange> xTextRange;
508 0 : ScHeaderFooterContentObj& rContentObj = mrData.GetContentObj();
509 0 : uno::Reference<text::XText> xText;
510 0 : sal_uInt16 nPart = mrData.GetPart();
511 0 : if (nPart == SC_HDFT_LEFT)
512 0 : xText = rContentObj.getLeftText();
513 0 : else if (nPart == SC_HDFT_CENTER)
514 0 : xText = rContentObj.getCenterText();
515 : else
516 0 : xText = rContentObj.getRightText();
517 :
518 0 : uno::Reference<text::XTextRange> xTemp(xText, uno::UNO_QUERY);
519 0 : xTextRange = xTemp;
520 :
521 0 : sal_Int32 nPar = aTempEngine.GetFieldPar();
522 0 : sal_Int32 nPos = aTempEngine.GetFieldPos();
523 0 : ESelection aSelection( nPar, nPos, nPar, nPos+1 ); // Field is 1 character
524 :
525 0 : sal_Int32 eRealType = pData->GetClassId();
526 : uno::Reference<text::XTextField> xRet(
527 0 : new ScEditFieldObj(xTextRange, new ScHeaderFooterEditSource(mrData), eRealType, aSelection));
528 0 : return xRet;
529 : }
530 :
531 2 : sal_Int32 SAL_CALL ScHeaderFieldsObj::getCount() throw(uno::RuntimeException, std::exception)
532 : {
533 2 : SolarMutexGuard aGuard;
534 :
535 : //! Feld-Funktionen muessen an den Forwarder !!!
536 2 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
537 4 : ScUnoEditEngine aTempEngine(pEditEngine);
538 4 : return aTempEngine.CountFields();
539 : }
540 :
541 0 : uno::Any SAL_CALL ScHeaderFieldsObj::getByIndex( sal_Int32 nIndex )
542 : throw(lang::IndexOutOfBoundsException,
543 : lang::WrappedTargetException, uno::RuntimeException, std::exception)
544 : {
545 0 : SolarMutexGuard aGuard;
546 0 : uno::Reference<text::XTextField> xField(GetObjectByIndex_Impl(nIndex));
547 0 : if (xField.is())
548 0 : return uno::makeAny(xField);
549 : else
550 0 : throw lang::IndexOutOfBoundsException();
551 : }
552 :
553 2 : uno::Type SAL_CALL ScHeaderFieldsObj::getElementType() throw(uno::RuntimeException, std::exception)
554 : {
555 2 : SolarMutexGuard aGuard;
556 2 : return cppu::UnoType<text::XTextField>::get();
557 : }
558 :
559 2 : sal_Bool SAL_CALL ScHeaderFieldsObj::hasElements() throw(uno::RuntimeException, std::exception)
560 : {
561 2 : SolarMutexGuard aGuard;
562 2 : return ( getCount() != 0 );
563 : }
564 :
565 2 : uno::Reference<container::XEnumeration> SAL_CALL ScHeaderFieldsObj::createEnumeration()
566 : throw(uno::RuntimeException, std::exception)
567 : {
568 2 : SolarMutexGuard aGuard;
569 2 : return new ScIndexEnumeration(this, OUString("com.sun.star.text.TextFieldEnumeration"));
570 : }
571 :
572 0 : void SAL_CALL ScHeaderFieldsObj::addContainerListener(
573 : const uno::Reference<container::XContainerListener>& /* xListener */ )
574 : throw(uno::RuntimeException, std::exception)
575 : {
576 : OSL_FAIL("not implemented");
577 0 : }
578 :
579 0 : void SAL_CALL ScHeaderFieldsObj::removeContainerListener(
580 : const uno::Reference<container::XContainerListener>& /* xListener */ )
581 : throw(uno::RuntimeException, std::exception)
582 : {
583 : OSL_FAIL("not implemented");
584 0 : }
585 :
586 : // XRefreshable
587 4 : void SAL_CALL ScHeaderFieldsObj::refresh( )
588 : throw (uno::RuntimeException, std::exception)
589 : {
590 4 : if (mpRefreshListeners)
591 : {
592 : // Call all listeners.
593 4 : uno::Sequence< uno::Reference< uno::XInterface > > aListeners(mpRefreshListeners->getElements());
594 4 : sal_uInt32 nLength(aListeners.getLength());
595 4 : if (nLength)
596 : {
597 2 : const uno::Reference< uno::XInterface >* pInterfaces = aListeners.getConstArray();
598 2 : if (pInterfaces)
599 : {
600 2 : lang::EventObject aEvent;
601 2 : aEvent.Source.set(uno::Reference< util::XRefreshable >(const_cast<ScHeaderFieldsObj*>(this)));
602 2 : sal_uInt32 i(0);
603 6 : while (i < nLength)
604 : {
605 : try
606 : {
607 6 : while(i < nLength)
608 : {
609 2 : static_cast< util::XRefreshListener* >(pInterfaces->get())->refreshed(aEvent);
610 2 : ++pInterfaces;
611 2 : ++i;
612 : }
613 : }
614 0 : catch(uno::RuntimeException&)
615 : {
616 0 : ++pInterfaces;
617 0 : ++i;
618 : }
619 2 : }
620 : }
621 4 : }
622 : }
623 4 : }
624 :
625 2 : void SAL_CALL ScHeaderFieldsObj::addRefreshListener( const uno::Reference< util::XRefreshListener >& xListener )
626 : throw (uno::RuntimeException, std::exception)
627 : {
628 2 : if (xListener.is())
629 : {
630 2 : SolarMutexGuard aGuard;
631 2 : if (!mpRefreshListeners)
632 2 : mpRefreshListeners = new cppu::OInterfaceContainerHelper(aMutex);
633 2 : mpRefreshListeners->addInterface(xListener);
634 : }
635 2 : }
636 :
637 2 : void SAL_CALL ScHeaderFieldsObj::removeRefreshListener( const uno::Reference<util::XRefreshListener >& xListener )
638 : throw (uno::RuntimeException, std::exception)
639 : {
640 2 : if (xListener.is())
641 : {
642 2 : SolarMutexGuard aGuard;
643 2 : if (mpRefreshListeners)
644 2 : mpRefreshListeners->removeInterface(xListener);
645 : }
646 2 : }
647 :
648 2346 : SvxFieldData* ScEditFieldObj::getData()
649 : {
650 2346 : if (!mpData)
651 : {
652 2338 : switch (meType)
653 : {
654 : case text::textfield::Type::DATE:
655 0 : mpData.reset(new SvxDateField);
656 0 : break;
657 : case text::textfield::Type::EXTENDED_FILE:
658 : mpData.reset(
659 0 : new SvxExtFileField(OUString(), SVXFILETYPE_VAR, SVXFILEFORMAT_NAME_EXT));
660 0 : break;
661 : case text::textfield::Type::PAGE:
662 618 : mpData.reset(new SvxPageField);
663 618 : break;
664 : case text::textfield::Type::PAGES:
665 266 : mpData.reset(new SvxPagesField);
666 266 : break;
667 : case text::textfield::Type::TABLE:
668 630 : mpData.reset(new SvxTableField);
669 630 : break;
670 : case text::textfield::Type::TIME:
671 6 : mpData.reset(new SvxTimeField);
672 6 : break;
673 : case text::textfield::Type::EXTENDED_TIME:
674 : {
675 540 : if (mbIsDate)
676 274 : mpData.reset(new SvxDateField);
677 : else
678 266 : mpData.reset(new SvxExtTimeField);
679 : }
680 540 : break;
681 : case text::textfield::Type::DOCINFO_TITLE:
682 266 : mpData.reset(new SvxFileField);
683 266 : break;
684 : case text::textfield::Type::URL:
685 : mpData.reset(
686 12 : new SvxURLField(OUString(), OUString(), SVXURLFORMAT_APPDEFAULT));
687 12 : break;
688 : default:
689 0 : mpData.reset(new SvxFieldData);
690 : }
691 : }
692 2346 : return mpData.get();
693 : }
694 :
695 32 : void ScEditFieldObj::setPropertyValueURL(const OUString& rName, const com::sun::star::uno::Any& rVal)
696 : {
697 32 : OUString aStrVal;
698 32 : if (mpEditSource)
699 : {
700 : // Edit engine instance already exists for this field item. Use it.
701 24 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
702 24 : ScUnoEditEngine aTempEngine(pEditEngine);
703 :
704 : // Typ egal (in Zellen gibts nur URLs)
705 : SvxFieldData* pField = aTempEngine.FindByPos(
706 24 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
707 : OSL_ENSURE(pField,"setPropertyValue: Feld nicht gefunden");
708 24 : if (!pField)
709 0 : return;
710 :
711 24 : if (pField->GetClassId() != text::textfield::Type::URL)
712 : // Make sure this is indeed a URL field.
713 0 : return;
714 :
715 24 : SvxURLField* pURL = static_cast<SvxURLField*>(pField);
716 :
717 24 : if (rName == SC_UNONAME_URL)
718 : {
719 8 : if (rVal >>= aStrVal)
720 8 : pURL->SetURL(aStrVal);
721 : }
722 16 : else if (rName == SC_UNONAME_REPR)
723 : {
724 8 : if (rVal >>= aStrVal)
725 8 : pURL->SetRepresentation(aStrVal);
726 : }
727 8 : else if (rName == SC_UNONAME_TARGET)
728 : {
729 8 : if (rVal >>= aStrVal)
730 8 : pURL->SetTargetFrame(aStrVal);
731 : }
732 : else
733 0 : throw beans::UnknownPropertyException();
734 :
735 24 : pEditEngine->QuickInsertField( SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection );
736 24 : mpEditSource->UpdateData();
737 24 : return;
738 : }
739 :
740 : // Edit engine instance not yet present. Store the item data for later use.
741 8 : SvxFieldData* pData = getData();
742 8 : if (!pData)
743 0 : throw uno::RuntimeException();
744 :
745 8 : SvxURLField* p = static_cast<SvxURLField*>(pData);
746 8 : if (rName == SC_UNONAME_URL)
747 : {
748 4 : if (rVal >>= aStrVal)
749 4 : p->SetURL(aStrVal);
750 : }
751 4 : else if (rName == SC_UNONAME_REPR)
752 : {
753 4 : if (rVal >>= aStrVal)
754 4 : p->SetRepresentation(aStrVal);
755 : }
756 0 : else if (rName == SC_UNONAME_TARGET)
757 : {
758 0 : if (rVal >>= aStrVal)
759 0 : p->SetTargetFrame(aStrVal);
760 : }
761 : else
762 0 : throw beans::UnknownPropertyException();
763 : }
764 :
765 54 : uno::Any ScEditFieldObj::getPropertyValueURL(const OUString& rName)
766 : {
767 54 : uno::Any aRet;
768 :
769 : // anchor type is always "as character", text wrap always "none"
770 :
771 54 : if (mpEditSource)
772 : {
773 : //! Feld-Funktionen muessen an den Forwarder !!!
774 54 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
775 54 : ScUnoEditEngine aTempEngine(pEditEngine);
776 :
777 : // Typ egal (in Zellen gibts nur URLs)
778 : const SvxFieldData* pField = aTempEngine.FindByPos(
779 54 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
780 : OSL_ENSURE(pField,"getPropertyValue: Feld nicht gefunden");
781 54 : if (!pField)
782 0 : throw uno::RuntimeException();
783 :
784 54 : if (pField->GetClassId() != text::textfield::Type::URL)
785 0 : throw uno::RuntimeException();
786 :
787 54 : const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
788 :
789 54 : if (rName == SC_UNONAME_URL)
790 18 : aRet <<= pURL->GetURL();
791 36 : else if (rName == SC_UNONAME_REPR)
792 18 : aRet <<= pURL->GetRepresentation();
793 18 : else if (rName == SC_UNONAME_TARGET)
794 18 : aRet <<= pURL->GetTargetFrame();
795 : else
796 0 : throw beans::UnknownPropertyException();
797 : }
798 : else // noch nicht eingefuegt
799 : {
800 0 : const SvxFieldData* pField = getData();
801 0 : if (!pField)
802 0 : return aRet;
803 :
804 0 : const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
805 0 : if (rName == SC_UNONAME_URL)
806 0 : aRet <<= pURL->GetURL();
807 0 : else if (rName == SC_UNONAME_REPR)
808 0 : aRet <<= pURL->GetRepresentation();
809 0 : else if (rName == SC_UNONAME_TARGET)
810 0 : aRet <<= pURL->GetTargetFrame();
811 : else
812 0 : throw beans::UnknownPropertyException();
813 : }
814 54 : return aRet;
815 : }
816 :
817 0 : void ScEditFieldObj::setPropertyValueFile(const OUString& rName, const uno::Any& rVal)
818 : {
819 0 : if (rName == SC_UNONAME_FILEFORM)
820 : {
821 0 : sal_Int16 nIntVal = 0;
822 0 : if (rVal >>= nIntVal)
823 : {
824 0 : SvxFileFormat eFormat = lcl_UnoToSvxFileFormat(nIntVal);
825 0 : if (mpEditSource)
826 : {
827 0 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
828 0 : ScUnoEditEngine aTempEngine(pEditEngine);
829 : SvxFieldData* pField = aTempEngine.FindByPos(
830 0 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::EXTENDED_FILE);
831 : OSL_ENSURE(pField, "setPropertyValueFile: Field not found");
832 0 : if (pField)
833 : {
834 0 : SvxExtFileField* pExtFile = static_cast<SvxExtFileField*>(pField); // local to the ScUnoEditEngine
835 0 : pExtFile->SetFormat(eFormat);
836 0 : pEditEngine->QuickInsertField(SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection);
837 0 : mpEditSource->UpdateData();
838 0 : }
839 : }
840 : else
841 : {
842 0 : SvxFieldData* pField = getData();
843 0 : SvxExtFileField* pExtFile = static_cast<SvxExtFileField*>(pField);
844 0 : pExtFile->SetFormat(eFormat);
845 : }
846 : }
847 : }
848 : else
849 0 : throw beans::UnknownPropertyException();
850 0 : }
851 :
852 0 : uno::Any ScEditFieldObj::getPropertyValueFile(const OUString& rName)
853 : {
854 0 : uno::Any aRet;
855 0 : if (rName == SC_UNONAME_FILEFORM)
856 : {
857 0 : SvxFileFormat eFormat = SVXFILEFORMAT_NAME_EXT;
858 0 : const SvxFieldData* pField = NULL;
859 0 : if (mpEditSource)
860 : {
861 0 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
862 0 : ScUnoEditEngine aTempEngine(pEditEngine);
863 : pField = aTempEngine.FindByPos(
864 0 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::EXTENDED_FILE);
865 : }
866 : else
867 0 : pField = getData();
868 :
869 : OSL_ENSURE(pField, "setPropertyValueFile: Field not found");
870 0 : if (!pField)
871 0 : throw uno::RuntimeException();
872 :
873 0 : const SvxExtFileField* pExtFile = static_cast<const SvxExtFileField*>(pField);
874 0 : eFormat = pExtFile->GetFormat();
875 0 : sal_Int16 nIntVal = lcl_SvxToUnoFileFormat(eFormat);
876 0 : aRet <<= nIntVal;
877 : }
878 : else
879 0 : throw beans::UnknownPropertyException();
880 :
881 0 : return aRet;
882 : }
883 :
884 1104 : void ScEditFieldObj::setPropertyValueDateTime(const OUString& rName, const uno::Any& rVal)
885 : {
886 1104 : if (mpEditSource)
887 : {
888 : // Field already inserted.
889 24 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
890 24 : ScUnoEditEngine aTempEngine(pEditEngine);
891 24 : SvxFieldData* pField = aTempEngine.FindByPos(aSelection.nStartPara, aSelection.nStartPos, meType);
892 24 : if (!pField)
893 1104 : return;
894 :
895 24 : switch (meType)
896 : {
897 : case text::textfield::Type::DATE:
898 : {
899 0 : SvxDateField* p = static_cast<SvxDateField*>(pField);
900 0 : if (rName == SC_UNONAME_ISDATE)
901 : {
902 : // Do nothing for now.
903 : }
904 0 : else if (rName == SC_UNONAME_ISFIXED)
905 : {
906 0 : SvxDateType eType = rVal.get<sal_Bool>() ? SVXDATETYPE_FIX : SVXDATETYPE_VAR;
907 0 : p->SetType(eType);
908 : }
909 0 : else if (rName == SC_UNONAME_DATETIME)
910 : {
911 0 : maDateTime = rVal.get<util::DateTime>();
912 0 : Date aDate(maDateTime.Day, maDateTime.Month, maDateTime.Year);
913 0 : p->SetFixDate(aDate);
914 : }
915 0 : else if (rName == SC_UNONAME_NUMFMT)
916 : {
917 0 : mnNumFormat = rVal.get<sal_Int32>();
918 0 : p->SetFormat(static_cast<SvxDateFormat>(mnNumFormat));
919 : }
920 : else
921 0 : throw beans::UnknownPropertyException();
922 : }
923 0 : break;
924 : case text::textfield::Type::TIME:
925 : {
926 : // SvxTimeField doesn't have any attributes.
927 78 : if (rName != SC_UNONAME_ISDATE && rName != SC_UNONAME_ISFIXED &&
928 42 : rName != SC_UNONAME_DATETIME && rName != SC_UNONAME_NUMFMT)
929 0 : throw beans::UnknownPropertyException();
930 : }
931 24 : break;
932 : case text::textfield::Type::EXTENDED_TIME:
933 : {
934 0 : SvxExtTimeField* p = static_cast<SvxExtTimeField*>(pField);
935 0 : if (rName == SC_UNONAME_ISDATE)
936 : {
937 : // Do nothing for now.
938 : }
939 0 : else if (rName == SC_UNONAME_ISFIXED)
940 : {
941 0 : SvxTimeType eType = rVal.get<sal_Bool>() ? SVXTIMETYPE_FIX : SVXTIMETYPE_VAR;
942 0 : p->SetType(eType);
943 : }
944 0 : else if (rName == SC_UNONAME_DATETIME)
945 : {
946 0 : maDateTime = rVal.get<util::DateTime>();
947 0 : tools::Time aTime(maDateTime.Hours, maDateTime.Minutes, maDateTime.Seconds, maDateTime.NanoSeconds);
948 0 : p->SetFixTime(aTime);
949 : }
950 0 : else if (rName == SC_UNONAME_NUMFMT)
951 : {
952 0 : mnNumFormat = rVal.get<sal_Int32>();
953 0 : p->SetFormat(static_cast<SvxTimeFormat>(mnNumFormat));
954 : }
955 : else
956 0 : throw beans::UnknownPropertyException();
957 : }
958 0 : break;
959 : default:
960 0 : throw beans::UnknownPropertyException();
961 24 : }
962 : }
963 : else
964 : {
965 1080 : if (rName == SC_UNONAME_ISDATE)
966 540 : mbIsDate = rVal.get<sal_Bool>();
967 540 : else if (rName == SC_UNONAME_ISFIXED)
968 540 : mbIsFixed = rVal.get<sal_Bool>();
969 0 : else if (rName == SC_UNONAME_DATETIME)
970 0 : maDateTime = rVal.get<util::DateTime>();
971 0 : else if (rName == SC_UNONAME_NUMFMT)
972 0 : mnNumFormat = rVal.get<sal_Int32>();
973 : else
974 0 : throw beans::UnknownPropertyException();
975 : }
976 : }
977 :
978 48 : uno::Any ScEditFieldObj::getPropertyValueDateTime(const OUString& rName)
979 : {
980 48 : if (mpEditSource)
981 : {
982 : // Field already inserted.
983 48 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
984 48 : ScUnoEditEngine aTempEngine(pEditEngine);
985 48 : SvxFieldData* pField = aTempEngine.FindByPos(aSelection.nStartPara, aSelection.nStartPos, meType);
986 48 : if (!pField)
987 0 : throw uno::RuntimeException();
988 :
989 48 : switch (meType)
990 : {
991 : case text::textfield::Type::DATE:
992 : {
993 0 : SvxDateField* p = static_cast<SvxDateField*>(pField);
994 0 : if (rName == SC_UNONAME_ISDATE)
995 0 : return uno::makeAny(sal_True);
996 :
997 0 : if (rName == SC_UNONAME_ISFIXED)
998 0 : return uno::makeAny<sal_Bool>(p->GetType() == SVXDATETYPE_FIX);
999 :
1000 0 : if (rName == SC_UNONAME_DATETIME)
1001 : {
1002 0 : Date aD(p->GetFixDate());
1003 0 : maDateTime.Year = aD.GetYear();
1004 0 : maDateTime.Month = aD.GetMonth();
1005 0 : maDateTime.Day = aD.GetDay();
1006 0 : maDateTime.Hours = 0;
1007 0 : maDateTime.Minutes = 0;
1008 0 : maDateTime.Seconds = 0;
1009 0 : maDateTime.NanoSeconds = 0;
1010 0 : return uno::makeAny(maDateTime);
1011 : }
1012 :
1013 0 : if (rName == SC_UNONAME_NUMFMT)
1014 0 : return uno::makeAny<sal_Int32>(p->GetFormat());
1015 : }
1016 0 : break;
1017 : case text::textfield::Type::TIME:
1018 : {
1019 : // SvxTimeField doesn't have any attributes.
1020 48 : if (rName == SC_UNONAME_ISDATE)
1021 12 : return uno::makeAny(sal_False);
1022 :
1023 36 : if (rName == SC_UNONAME_ISFIXED)
1024 12 : return uno::makeAny(sal_False);
1025 :
1026 24 : if (rName == SC_UNONAME_DATETIME)
1027 : // This is the best we can do.
1028 12 : return uno::makeAny(maDateTime);
1029 :
1030 12 : if (rName == SC_UNONAME_NUMFMT)
1031 : // Same as above.
1032 12 : return uno::makeAny<sal_Int32>(0);
1033 : }
1034 0 : break;
1035 : case text::textfield::Type::EXTENDED_TIME:
1036 : {
1037 0 : SvxExtTimeField* p = static_cast<SvxExtTimeField*>(pField);
1038 0 : if (rName == SC_UNONAME_ISDATE)
1039 0 : return uno::makeAny(sal_False);
1040 :
1041 0 : if (rName == SC_UNONAME_ISFIXED)
1042 0 : return uno::makeAny<sal_Bool>(p->GetType() == SVXTIMETYPE_FIX);
1043 :
1044 0 : if (rName == SC_UNONAME_DATETIME)
1045 : {
1046 0 : tools::Time aT(p->GetFixTime());
1047 0 : maDateTime.Year = 0;
1048 0 : maDateTime.Month = 0;
1049 0 : maDateTime.Day = 0;
1050 0 : maDateTime.Hours = aT.GetHour();
1051 0 : maDateTime.Minutes = aT.GetMin();
1052 0 : maDateTime.Seconds = aT.GetSec();
1053 0 : maDateTime.NanoSeconds = aT.GetNanoSec();
1054 0 : return uno::makeAny(maDateTime);
1055 : }
1056 :
1057 0 : if (rName == SC_UNONAME_NUMFMT)
1058 0 : return uno::makeAny<sal_Int32>(p->GetFormat());
1059 : }
1060 0 : break;
1061 : default:
1062 : ;
1063 0 : }
1064 : }
1065 : else
1066 : {
1067 0 : if (rName == SC_UNONAME_ISDATE)
1068 0 : return uno::makeAny<sal_Bool>(mbIsDate);
1069 :
1070 0 : if (rName == SC_UNONAME_ISFIXED)
1071 0 : return uno::makeAny<sal_Bool>(mbIsFixed);
1072 :
1073 0 : if (rName == SC_UNONAME_DATETIME)
1074 0 : return uno::makeAny(maDateTime);
1075 :
1076 0 : if (rName == SC_UNONAME_NUMFMT)
1077 0 : return uno::makeAny(mnNumFormat);
1078 : }
1079 :
1080 0 : throw beans::UnknownPropertyException();
1081 : }
1082 :
1083 0 : void ScEditFieldObj::setPropertyValueSheet(const OUString& rName, const uno::Any& rVal)
1084 : {
1085 0 : if (mpEditSource)
1086 : {
1087 : // Edit engine instance already exists for this field item. Use it.
1088 0 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
1089 0 : ScUnoEditEngine aTempEngine(pEditEngine);
1090 :
1091 : // Typ egal (in Zellen gibts nur URLs)
1092 : SvxFieldData* pField = aTempEngine.FindByPos(
1093 0 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
1094 : OSL_ENSURE(pField,"setPropertyValue: Feld nicht gefunden");
1095 0 : if (!pField)
1096 0 : return;
1097 :
1098 0 : if (pField->GetClassId() != text::textfield::Type::TABLE)
1099 : // Make sure this is indeed a URL field.
1100 0 : return;
1101 :
1102 0 : SvxTableField* p = static_cast<SvxTableField*>(pField);
1103 :
1104 0 : if (rName == SC_UNONAME_TABLEPOS)
1105 : {
1106 0 : sal_Int32 nTab = rVal.get<sal_Int32>();
1107 0 : p->SetTab(nTab);
1108 : }
1109 : else
1110 0 : throw beans::UnknownPropertyException();
1111 :
1112 0 : pEditEngine->QuickInsertField(SvxFieldItem(*pField, EE_FEATURE_FIELD), aSelection);
1113 0 : mpEditSource->UpdateData();
1114 0 : return;
1115 : }
1116 :
1117 : // Edit engine instance not yet present. Store the item data for later use.
1118 0 : SvxFieldData* pData = getData();
1119 0 : if (!pData)
1120 0 : throw uno::RuntimeException();
1121 :
1122 0 : SvxTableField* p = static_cast<SvxTableField*>(pData);
1123 0 : if (rName == SC_UNONAME_TABLEPOS)
1124 : {
1125 0 : sal_Int32 nTab = rVal.get<sal_Int32>();
1126 0 : p->SetTab(nTab);
1127 : }
1128 : else
1129 0 : throw beans::UnknownPropertyException();
1130 :
1131 : }
1132 :
1133 2398 : ScEditFieldObj::ScEditFieldObj(
1134 : const uno::Reference<text::XTextRange>& rContent,
1135 : ScEditSource* pEditSrc, sal_Int32 eType, const ESelection& rSel) :
1136 2398 : OComponentHelper(getMutex()),
1137 : pPropSet(NULL),
1138 : mpEditSource(pEditSrc),
1139 : aSelection(rSel),
1140 4796 : meType(eType), mpData(NULL), mpContent(rContent), mnNumFormat(0), mbIsDate(false), mbIsFixed(false)
1141 : {
1142 2398 : switch (meType)
1143 : {
1144 : case text::textfield::Type::DOCINFO_TITLE:
1145 272 : pPropSet = getEmptyPropertySet();
1146 272 : break;
1147 : case text::textfield::Type::EXTENDED_FILE:
1148 4 : pPropSet = lcl_GetFileFieldPropertySet();
1149 4 : break;
1150 : case text::textfield::Type::URL:
1151 32 : pPropSet = lcl_GetURLPropertySet();
1152 32 : break;
1153 : case text::textfield::Type::DATE:
1154 : case text::textfield::Type::TIME:
1155 : case text::textfield::Type::EXTENDED_TIME:
1156 564 : pPropSet = getDateTimePropertySet();
1157 564 : break;
1158 : default:
1159 1526 : pPropSet = lcl_GetHeaderFieldPropertySet();
1160 : }
1161 :
1162 2398 : if (meType == text::textfield::Type::DATE)
1163 6 : mbIsDate = true;
1164 2398 : }
1165 :
1166 2338 : void ScEditFieldObj::InitDoc(
1167 : const uno::Reference<text::XTextRange>& rContent, ScEditSource* pEditSrc, const ESelection& rSel)
1168 : {
1169 2338 : if (!mpEditSource)
1170 : {
1171 2338 : mpContent = rContent;
1172 2338 : mpData.reset();
1173 :
1174 2338 : aSelection = rSel;
1175 2338 : mpEditSource = pEditSrc;
1176 : }
1177 2338 : }
1178 :
1179 7194 : ScEditFieldObj::~ScEditFieldObj()
1180 : {
1181 2398 : delete mpEditSource;
1182 4796 : }
1183 :
1184 2338 : SvxFieldItem ScEditFieldObj::CreateFieldItem()
1185 : {
1186 : OSL_ENSURE( !mpEditSource, "CreateFieldItem mit eingefuegtem Feld" );
1187 2338 : return SvxFieldItem(*getData(), EE_FEATURE_FIELD);
1188 : }
1189 :
1190 4 : void ScEditFieldObj::DeleteField()
1191 : {
1192 4 : if (mpEditSource)
1193 : {
1194 4 : SvxTextForwarder* pForwarder = mpEditSource->GetTextForwarder();
1195 4 : pForwarder->QuickInsertText( OUString(), aSelection );
1196 4 : mpEditSource->UpdateData();
1197 :
1198 4 : aSelection.nEndPara = aSelection.nStartPara;
1199 4 : aSelection.nEndPos = aSelection.nStartPos;
1200 :
1201 : //! Broadcast, um Selektion in anderen Objekten anzupassen
1202 : //! (auch bei anderen Aktionen)
1203 : }
1204 4 : }
1205 :
1206 2342 : bool ScEditFieldObj::IsInserted() const
1207 : {
1208 2342 : return mpEditSource != NULL;
1209 : }
1210 :
1211 : // XTextField
1212 :
1213 4 : OUString SAL_CALL ScEditFieldObj::getPresentation( sal_Bool bShowCommand )
1214 : throw(uno::RuntimeException, std::exception)
1215 : {
1216 4 : SolarMutexGuard aGuard;
1217 :
1218 4 : if (!mpEditSource)
1219 0 : return OUString();
1220 :
1221 : //! Feld-Funktionen muessen an den Forwarder !!!
1222 4 : ScEditEngineDefaulter* pEditEngine = mpEditSource->GetEditEngine();
1223 8 : ScUnoEditEngine aTempEngine(pEditEngine);
1224 :
1225 : // Typ egal (in Zellen gibts nur URLs)
1226 : const SvxFieldData* pField = aTempEngine.FindByPos(
1227 4 : aSelection.nStartPara, aSelection.nStartPos, text::textfield::Type::UNSPECIFIED);
1228 : OSL_ENSURE(pField,"getPresentation: Feld nicht gefunden");
1229 4 : if (!pField)
1230 0 : return OUString();
1231 :
1232 4 : switch (meType)
1233 : {
1234 : case text::textfield::Type::URL:
1235 : {
1236 4 : if (pField->GetClassId() != text::textfield::Type::URL)
1237 : // Not an URL field, but URL is expected.
1238 0 : throw uno::RuntimeException();
1239 :
1240 4 : const SvxURLField* pURL = static_cast<const SvxURLField*>(pField);
1241 4 : return bShowCommand ? pURL->GetURL() : pURL->GetRepresentation();
1242 : }
1243 : break;
1244 : default:
1245 : ;
1246 : }
1247 4 : return OUString();
1248 : }
1249 :
1250 : // XTextContent
1251 :
1252 4 : void SAL_CALL ScEditFieldObj::attach( const uno::Reference<text::XTextRange>& xTextRange )
1253 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
1254 : {
1255 4 : SolarMutexGuard aGuard;
1256 4 : if (xTextRange.is())
1257 : {
1258 4 : uno::Reference<text::XText> xText(xTextRange->getText());
1259 4 : if (xText.is())
1260 : {
1261 6 : xText->insertTextContent( xTextRange, this, sal_True );
1262 4 : }
1263 4 : }
1264 2 : }
1265 :
1266 8 : uno::Reference<text::XTextRange> SAL_CALL ScEditFieldObj::getAnchor() throw(uno::RuntimeException, std::exception)
1267 : {
1268 8 : SolarMutexGuard aGuard;
1269 8 : return mpContent;
1270 : }
1271 :
1272 : // XComponent
1273 :
1274 0 : void SAL_CALL ScEditFieldObj::dispose() throw(uno::RuntimeException, std::exception)
1275 : {
1276 0 : OComponentHelper::dispose();
1277 0 : }
1278 :
1279 0 : void SAL_CALL ScEditFieldObj::addEventListener(
1280 : const uno::Reference<lang::XEventListener>& xListener )
1281 : throw(uno::RuntimeException, std::exception)
1282 : {
1283 0 : OComponentHelper::addEventListener( xListener );
1284 0 : }
1285 :
1286 0 : void SAL_CALL ScEditFieldObj::removeEventListener(
1287 : const uno::Reference<lang::XEventListener>& xListener )
1288 : throw(uno::RuntimeException, std::exception)
1289 : {
1290 0 : OComponentHelper::removeEventListener( xListener );
1291 0 : }
1292 :
1293 : // XPropertySet
1294 :
1295 1640 : uno::Reference<beans::XPropertySetInfo> SAL_CALL ScEditFieldObj::getPropertySetInfo()
1296 : throw(uno::RuntimeException, std::exception)
1297 : {
1298 1640 : SolarMutexGuard aGuard;
1299 1640 : uno::Reference<beans::XPropertySetInfo> aRef = pPropSet->getPropertySetInfo();
1300 1640 : return aRef;
1301 : }
1302 :
1303 1136 : void SAL_CALL ScEditFieldObj::setPropertyValue(
1304 : const OUString& aPropertyName, const uno::Any& aValue )
1305 : throw (beans::UnknownPropertyException, beans::PropertyVetoException,
1306 : lang::IllegalArgumentException, lang::WrappedTargetException,
1307 : uno::RuntimeException, std::exception)
1308 : {
1309 1136 : SolarMutexGuard aGuard;
1310 1136 : if (aPropertyName == SC_UNONAME_ANCHOR)
1311 : {
1312 0 : aValue >>= mpContent;
1313 1136 : return;
1314 : }
1315 :
1316 1136 : switch (meType)
1317 : {
1318 : case text::textfield::Type::URL:
1319 32 : setPropertyValueURL(aPropertyName, aValue);
1320 32 : break;
1321 : case text::textfield::Type::EXTENDED_FILE:
1322 0 : setPropertyValueFile(aPropertyName, aValue);
1323 0 : break;
1324 : case text::textfield::Type::DATE:
1325 : case text::textfield::Type::TIME:
1326 : case text::textfield::Type::EXTENDED_TIME:
1327 1104 : setPropertyValueDateTime(aPropertyName, aValue);
1328 1104 : break;
1329 : case text::textfield::Type::TABLE:
1330 0 : setPropertyValueSheet(aPropertyName, aValue);
1331 0 : break;
1332 : case text::textfield::Type::DOCINFO_TITLE:
1333 : default:
1334 0 : throw beans::UnknownPropertyException();
1335 1136 : }
1336 : }
1337 :
1338 108 : uno::Any SAL_CALL ScEditFieldObj::getPropertyValue( const OUString& aPropertyName )
1339 : throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1340 : uno::RuntimeException, std::exception)
1341 : {
1342 108 : SolarMutexGuard aGuard;
1343 108 : if (aPropertyName.equals(SC_UNONAME_TEXTFIELD_TYPE))
1344 0 : return uno::makeAny(meType);
1345 :
1346 108 : if (aPropertyName == SC_UNONAME_ANCHOR)
1347 0 : return uno::makeAny(mpContent);
1348 :
1349 108 : if (aPropertyName == SC_UNONAME_ANCTYPE)
1350 : {
1351 2 : uno::Any aRet;
1352 2 : aRet <<= text::TextContentAnchorType_AS_CHARACTER;
1353 2 : return aRet;
1354 : }
1355 106 : if (aPropertyName == SC_UNONAME_ANCTYPES)
1356 : {
1357 2 : uno::Any aRet;
1358 4 : uno::Sequence<text::TextContentAnchorType> aSeq(1);
1359 2 : aSeq[0] = text::TextContentAnchorType_AS_CHARACTER;
1360 2 : aRet <<= aSeq;
1361 4 : return aRet;
1362 : }
1363 104 : if (aPropertyName == SC_UNONAME_TEXTWRAP)
1364 : {
1365 2 : uno::Any aRet;
1366 2 : aRet <<= text::WrapTextMode_NONE;
1367 2 : return aRet;
1368 : }
1369 :
1370 102 : switch (meType)
1371 : {
1372 : case text::textfield::Type::URL:
1373 54 : return getPropertyValueURL(aPropertyName);
1374 : case text::textfield::Type::EXTENDED_FILE:
1375 0 : return getPropertyValueFile(aPropertyName);
1376 : case text::textfield::Type::DATE:
1377 : case text::textfield::Type::TIME:
1378 : case text::textfield::Type::EXTENDED_TIME:
1379 48 : return getPropertyValueDateTime(aPropertyName);
1380 : case text::textfield::Type::DOCINFO_TITLE:
1381 : default:
1382 0 : throw beans::UnknownPropertyException();
1383 108 : }
1384 : }
1385 :
1386 0 : SC_IMPL_DUMMY_PROPERTY_LISTENER( ScEditFieldObj )
1387 :
1388 : // XUnoTunnel
1389 :
1390 2342 : sal_Int64 SAL_CALL ScEditFieldObj::getSomething(
1391 : const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException, std::exception)
1392 : {
1393 4684 : if ( rId.getLength() == 16 &&
1394 2342 : 0 == memcmp( getUnoTunnelId().getConstArray(),
1395 4684 : rId.getConstArray(), 16 ) )
1396 : {
1397 2342 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
1398 : }
1399 0 : return 0;
1400 : }
1401 :
1402 : namespace
1403 : {
1404 : class theScEditFieldObjUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theScEditFieldObjUnoTunnelId> {};
1405 : }
1406 :
1407 4684 : const uno::Sequence<sal_Int8>& ScEditFieldObj::getUnoTunnelId()
1408 : {
1409 4684 : return theScEditFieldObjUnoTunnelId::get().getSeq();
1410 : }
1411 :
1412 2342 : ScEditFieldObj* ScEditFieldObj::getImplementation(const uno::Reference<text::XTextContent>& xObj)
1413 : {
1414 2342 : ScEditFieldObj* pRet = NULL;
1415 2342 : uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
1416 2342 : if (xUT.is())
1417 2342 : pRet = reinterpret_cast<ScEditFieldObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
1418 2342 : return pRet;
1419 : }
1420 :
1421 : // XServiceInfo
1422 :
1423 0 : OUString SAL_CALL ScEditFieldObj::getImplementationName() throw(uno::RuntimeException, std::exception)
1424 : {
1425 0 : return OUString("ScEditFieldObj");
1426 : }
1427 :
1428 0 : sal_Bool SAL_CALL ScEditFieldObj::supportsService( const OUString& rServiceName )
1429 : throw(uno::RuntimeException, std::exception)
1430 : {
1431 0 : return cppu::supportsService(this, rServiceName);
1432 : }
1433 :
1434 0 : uno::Sequence<OUString> SAL_CALL ScEditFieldObj::getSupportedServiceNames()
1435 : throw(uno::RuntimeException, std::exception)
1436 : {
1437 0 : uno::Sequence<OUString> aRet(2);
1438 0 : OUString* pArray = aRet.getArray();
1439 0 : pArray[0] = "com.sun.star.text.TextField";
1440 0 : pArray[1] = "com.sun.star.text.TextContent";
1441 0 : return aRet;
1442 : }
1443 :
1444 0 : uno::Sequence<uno::Type> SAL_CALL ScEditFieldObj::getTypes() throw(uno::RuntimeException, std::exception)
1445 : {
1446 0 : static uno::Sequence<uno::Type> aTypes;
1447 0 : if ( aTypes.getLength() == 0 )
1448 : {
1449 0 : uno::Sequence<uno::Type> aParentTypes(OComponentHelper::getTypes());
1450 0 : long nParentLen = aParentTypes.getLength();
1451 0 : const uno::Type* pParentPtr = aParentTypes.getConstArray();
1452 :
1453 0 : aTypes.realloc( nParentLen + 4 );
1454 0 : uno::Type* pPtr = aTypes.getArray();
1455 0 : pPtr[nParentLen + 0] = cppu::UnoType<text::XTextField>::get();
1456 0 : pPtr[nParentLen + 1] = cppu::UnoType<beans::XPropertySet>::get();
1457 0 : pPtr[nParentLen + 2] = cppu::UnoType<lang::XUnoTunnel>::get();
1458 0 : pPtr[nParentLen + 3] = cppu::UnoType<lang::XServiceInfo>::get();
1459 :
1460 0 : for (long i=0; i<nParentLen; i++)
1461 0 : pPtr[i] = pParentPtr[i]; // parent types first
1462 : }
1463 0 : return aTypes;
1464 : }
1465 :
1466 0 : uno::Sequence<sal_Int8> SAL_CALL ScEditFieldObj::getImplementationId()
1467 : throw(uno::RuntimeException, std::exception)
1468 : {
1469 0 : return css::uno::Sequence<sal_Int8>();
1470 228 : }
1471 :
1472 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
