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 :
21 : #include <hintids.hxx>
22 : #include <unotools/collatorwrapper.hxx>
23 : #include <unotools/charclass.hxx>
24 : #include <editeng/unolingu.hxx>
25 : #include <svx/pageitem.hxx>
26 : #include <editeng/langitem.hxx>
27 : #include <editeng/fontitem.hxx>
28 : #include <com/sun/star/text/SetVariableType.hpp>
29 : #include <unofield.hxx>
30 : #include <frmfmt.hxx>
31 : #include <fmtfld.hxx>
32 : #include <txtfld.hxx>
33 : #include <fmtanchr.hxx>
34 : #include <txtftn.hxx>
35 : #include <doc.hxx>
36 : #include <layfrm.hxx>
37 : #include <pagefrm.hxx>
38 : #include <cntfrm.hxx>
39 : #include <rootfrm.hxx>
40 : #include <tabfrm.hxx>
41 : #include <flyfrm.hxx>
42 : #include <ftnfrm.hxx>
43 : #include <rowfrm.hxx>
44 : #include <expfld.hxx>
45 : #include <usrfld.hxx>
46 : #include <ndtxt.hxx>
47 : #include <calc.hxx>
48 : #include <pam.hxx>
49 : #include <docfld.hxx>
50 : #include <swcache.hxx>
51 : #include <swtable.hxx>
52 : #include <breakit.hxx>
53 : #include <SwStyleNameMapper.hxx>
54 : #include <unofldmid.h>
55 : #include <numrule.hxx>
56 : #include <switerator.hxx>
57 :
58 : using namespace ::com::sun::star;
59 : using namespace ::com::sun::star::text;
60 : using ::rtl::OUString;
61 :
62 : //-----------------------------------------------------------------------------
63 78 : static sal_Int16 lcl_SubTypeToAPI(sal_uInt16 nSubType)
64 : {
65 78 : sal_Int16 nRet = 0;
66 78 : switch(nSubType)
67 : {
68 : case nsSwGetSetExpType::GSE_EXPR:
69 0 : nRet = SetVariableType::VAR; // 0
70 0 : break;
71 : case nsSwGetSetExpType::GSE_SEQ:
72 76 : nRet = SetVariableType::SEQUENCE; // 1
73 76 : break;
74 : case nsSwGetSetExpType::GSE_FORMULA:
75 0 : nRet = SetVariableType::FORMULA; // 2
76 0 : break;
77 : case nsSwGetSetExpType::GSE_STRING:
78 2 : nRet = SetVariableType::STRING; // 3
79 2 : break;
80 : }
81 78 : return nRet;
82 : }
83 : //-----------------------------------------------------------------------------
84 1 : static sal_Int32 lcl_APIToSubType(const uno::Any& rAny)
85 : {
86 1 : sal_Int16 nVal = 0;
87 1 : rAny >>= nVal;
88 1 : sal_Int32 nSet = 0;
89 1 : switch(nVal)
90 : {
91 0 : case SetVariableType::VAR: nSet = nsSwGetSetExpType::GSE_EXPR; break;
92 0 : case SetVariableType::SEQUENCE: nSet = nsSwGetSetExpType::GSE_SEQ; break;
93 0 : case SetVariableType::FORMULA: nSet = nsSwGetSetExpType::GSE_FORMULA; break;
94 1 : case SetVariableType::STRING: nSet = nsSwGetSetExpType::GSE_STRING; break;
95 : default:
96 : OSL_FAIL("wrong value");
97 0 : nSet = -1;
98 : }
99 1 : return nSet;
100 : }
101 :
102 : //-----------------------------------------------------------------------------
103 :
104 0 : void ReplacePoint( String& rTmpName, bool bWithCommandType )
105 : {
106 : // replace first and last (if bWithCommandType: last two) dot Ersten und letzten Punkt ersetzen, da in Tabellennamen Punkte erlaubt sind
107 : // since table names may contain dots
108 :
109 0 : xub_StrLen nLen = rTmpName.Len();
110 0 : sal_Unicode *pStr = rTmpName.GetBufferAccess(), *pBackStr = pStr + nLen;
111 :
112 0 : long nBackCount = bWithCommandType ? 2 : 1;
113 : xub_StrLen i;
114 :
115 0 : for( i = nLen; i; --i, pBackStr-- )
116 0 : if( '.' == *pBackStr )
117 : {
118 0 : *pBackStr = DB_DELIM;
119 0 : if(!--nBackCount)
120 0 : break;
121 : }
122 0 : for( i = 0; i < nLen; ++i, ++pStr )
123 0 : if( '.' == *pStr )
124 : {
125 0 : *pStr = DB_DELIM;
126 0 : break;
127 : }
128 0 : }
129 :
130 0 : SwTxtNode* GetFirstTxtNode( const SwDoc& rDoc, SwPosition& rPos,
131 : const SwCntntFrm *pCFrm, Point &rPt )
132 : {
133 0 : SwTxtNode* pTxtNode = 0;
134 0 : if ( !pCFrm )
135 : {
136 0 : const SwNodes& rNodes = rDoc.GetNodes();
137 0 : rPos.nNode = *rNodes.GetEndOfContent().StartOfSectionNode();
138 : SwCntntNode* pCNd;
139 0 : while( 0 != (pCNd = rNodes.GoNext( &rPos.nNode ) ) &&
140 0 : 0 == ( pTxtNode = pCNd->GetTxtNode() ) )
141 : ;
142 : OSL_ENSURE( pTxtNode, "wo ist der 1.TextNode" );
143 0 : rPos.nContent.Assign( pTxtNode, 0 );
144 : }
145 0 : else if ( !pCFrm->IsValid() )
146 : {
147 0 : pTxtNode = (SwTxtNode*)pCFrm->GetNode();
148 0 : rPos.nNode = *pTxtNode;
149 0 : rPos.nContent.Assign( pTxtNode, 0 );
150 : }
151 : else
152 : {
153 0 : pCFrm->GetCrsrOfst( &rPos, rPt );
154 0 : pTxtNode = rPos.nNode.GetNode().GetTxtNode();
155 : }
156 0 : return pTxtNode;
157 : }
158 :
159 0 : const SwTxtNode* GetBodyTxtNode( const SwDoc& rDoc, SwPosition& rPos,
160 : const SwFrm& rFrm )
161 : {
162 0 : const SwLayoutFrm* pLayout = (SwLayoutFrm*)rFrm.GetUpper();
163 0 : const SwTxtNode* pTxtNode = 0;
164 :
165 0 : while( pLayout )
166 : {
167 0 : if( pLayout->IsFlyFrm() )
168 : {
169 : // hole das FlyFormat
170 0 : SwFrmFmt* pFlyFmt = ((SwFlyFrm*)pLayout)->GetFmt();
171 : OSL_ENSURE( pFlyFmt, "kein FlyFormat gefunden, wo steht das Feld" );
172 :
173 0 : const SwFmtAnchor &rAnchor = pFlyFmt->GetAnchor();
174 :
175 0 : if( FLY_AT_FLY == rAnchor.GetAnchorId() )
176 : {
177 : // und der Fly muss irgendwo angehaengt sein, also
178 : // den befragen
179 0 : pLayout = (SwLayoutFrm*)((SwFlyFrm*)pLayout)->GetAnchorFrm();
180 0 : continue;
181 : }
182 0 : else if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
183 0 : (FLY_AT_CHAR == rAnchor.GetAnchorId()) ||
184 0 : (FLY_AS_CHAR == rAnchor.GetAnchorId()))
185 : {
186 : OSL_ENSURE( rAnchor.GetCntntAnchor(), "keine gueltige Position" );
187 0 : rPos = *rAnchor.GetCntntAnchor();
188 0 : pTxtNode = rPos.nNode.GetNode().GetTxtNode();
189 0 : if ( FLY_AT_PARA == rAnchor.GetAnchorId() )
190 : {
191 : const_cast<SwTxtNode*>(pTxtNode)->MakeStartIndex(
192 0 : &rPos.nContent );
193 : // oder doch besser das Ende vom (Anker-)TextNode nehmen ??
194 : // ((SwTxtNode*)pTxtNode)->MakeEndIndex( &rPos.nContent );
195 : }
196 :
197 : // noch nicht abbrechen, kann ja auch noch im
198 : // Header/Footer/Footnote/Fly stehen !!
199 0 : pLayout = ((SwFlyFrm*)pLayout)->GetAnchorFrm()
200 0 : ? ((SwFlyFrm*)pLayout)->GetAnchorFrm()->GetUpper() : 0;
201 0 : continue;
202 : }
203 : else
204 : {
205 : pLayout->FindPageFrm()->GetCntntPosition(
206 0 : pLayout->Frm().Pos(), rPos );
207 0 : pTxtNode = rPos.nNode.GetNode().GetTxtNode();
208 : }
209 : }
210 0 : else if( pLayout->IsFtnFrm() )
211 : {
212 : // hole den Node vom Anker
213 0 : const SwTxtFtn* pFtn = ((SwFtnFrm*)pLayout)->GetAttr();
214 0 : pTxtNode = &pFtn->GetTxtNode();
215 0 : rPos.nNode = *pTxtNode;
216 0 : rPos.nContent = *pFtn->GetStart();
217 : }
218 0 : else if( pLayout->IsHeaderFrm() || pLayout->IsFooterFrm() )
219 : {
220 : const SwCntntFrm* pCntFrm;
221 0 : const SwPageFrm* pPgFrm = pLayout->FindPageFrm();
222 0 : if( pLayout->IsHeaderFrm() )
223 : {
224 : const SwTabFrm *pTab;
225 0 : if( 0 != ( pCntFrm = pPgFrm->FindFirstBodyCntnt()) &&
226 0 : 0 != (pTab = pCntFrm->FindTabFrm()) && pTab->IsFollow() &&
227 0 : pTab->GetTable()->GetRowsToRepeat() > 0 &&
228 0 : pTab->IsInHeadline( *pCntFrm ) )
229 : {
230 : // take the next line
231 0 : const SwLayoutFrm* pRow = pTab->GetFirstNonHeadlineRow();
232 0 : pCntFrm = pRow->ContainsCntnt();
233 : }
234 : }
235 : else
236 0 : pCntFrm = pPgFrm->FindLastBodyCntnt();
237 :
238 0 : if( pCntFrm )
239 : {
240 0 : pTxtNode = pCntFrm->GetNode()->GetTxtNode();
241 0 : rPos.nNode = *pTxtNode;
242 0 : ((SwTxtNode*)pTxtNode)->MakeEndIndex( &rPos.nContent );
243 : }
244 : else
245 : {
246 0 : Point aPt( pLayout->Frm().Pos() );
247 0 : aPt.Y()++; // aus dem Header raus
248 0 : pCntFrm = pPgFrm->GetCntntPos( aPt, sal_False, sal_True, sal_False );
249 0 : pTxtNode = GetFirstTxtNode( rDoc, rPos, pCntFrm, aPt );
250 : }
251 : }
252 : else
253 : {
254 0 : pLayout = pLayout->GetUpper();
255 0 : continue;
256 : }
257 0 : break; // gefunden und beende die Schleife
258 : }
259 0 : return pTxtNode;
260 : }
261 :
262 : /*--------------------------------------------------------------------
263 : Beschreibung: SwSetExpFieldType by JP
264 : --------------------------------------------------------------------*/
265 :
266 276 : SwGetExpFieldType::SwGetExpFieldType(SwDoc* pDc)
267 276 : : SwValueFieldType( pDc, RES_GETEXPFLD )
268 : {
269 276 : }
270 :
271 0 : SwFieldType* SwGetExpFieldType::Copy() const
272 : {
273 0 : return new SwGetExpFieldType(GetDoc());
274 : }
275 :
276 238 : void SwGetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* pNew )
277 : {
278 238 : if( pNew && RES_DOCPOS_UPDATE == pNew->Which() )
279 238 : NotifyClients( 0, pNew );
280 : // sonst nichts weiter expandieren
281 238 : }
282 :
283 : /*--------------------------------------------------------------------
284 : Beschreibung: SwGetExpField by JP
285 : --------------------------------------------------------------------*/
286 :
287 5 : SwGetExpField::SwGetExpField(SwGetExpFieldType* pTyp, const String& rFormel,
288 : sal_uInt16 nSub, sal_uLong nFmt)
289 : : SwFormulaField( pTyp, nFmt, 0.0 ),
290 : bIsInBodyTxt( sal_True ),
291 : nSubType(nSub),
292 5 : bLateInitialization( false )
293 : {
294 5 : SetFormula( rFormel );
295 5 : }
296 :
297 2 : String SwGetExpField::Expand() const
298 : {
299 2 : if(nSubType & nsSwExtendedSubType::SUB_CMD)
300 0 : return GetFormula();
301 : else
302 2 : return sExpand;
303 : }
304 :
305 0 : String SwGetExpField::GetFieldName() const
306 : {
307 : String aStr( SwFieldType::GetTypeStr(
308 : static_cast<sal_uInt16>(((nsSwGetSetExpType::GSE_FORMULA & nSubType) != 0)
309 : ? TYP_FORMELFLD
310 0 : : TYP_GETFLD ) ));
311 0 : aStr += ' ';
312 0 : aStr += GetFormula();
313 0 : return aStr;
314 : }
315 :
316 4 : SwField* SwGetExpField::Copy() const
317 : {
318 4 : SwGetExpField *pTmp = new SwGetExpField((SwGetExpFieldType*)GetTyp(),
319 4 : GetFormula(), nSubType, GetFormat());
320 4 : pTmp->SetLanguage(GetLanguage());
321 4 : pTmp->SwValueField::SetValue(GetValue());
322 4 : pTmp->sExpand = sExpand;
323 4 : pTmp->bIsInBodyTxt = bIsInBodyTxt;
324 4 : pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
325 4 : if( bLateInitialization )
326 0 : pTmp->SetLateInitialization();
327 :
328 4 : return pTmp;
329 : }
330 :
331 0 : void SwGetExpField::ChangeExpansion( const SwFrm& rFrm, const SwTxtFld& rFld )
332 : {
333 0 : if( bIsInBodyTxt ) // nur Felder in Footer, Header, FootNote, Flys
334 : return;
335 :
336 : OSL_ENSURE( !rFrm.IsInDocBody(), "Flag ist nicht richtig, Frame steht im DocBody" );
337 :
338 : // bestimme mal das Dokument (oder geht es noch einfacher?)
339 0 : const SwTxtNode* pTxtNode = &rFld.GetTxtNode();
340 0 : SwDoc& rDoc = *(SwDoc*)pTxtNode->GetDoc();
341 :
342 : // einen Index fuers bestimmen vom TextNode anlegen
343 0 : SwPosition aPos( SwNodeIndex( rDoc.GetNodes() ) );
344 0 : pTxtNode = GetBodyTxtNode( rDoc, aPos, rFrm );
345 :
346 : // Wenn kein Layout vorhanden, kommt es in Kopf und Fusszeilen dazu
347 : // das ChnageExpansion uebers Layout-Formatieren aufgerufen wird
348 : // aber kein TxtNode vorhanden ist
349 : //
350 0 : if(!pTxtNode)
351 : return;
352 : // #i82544#
353 0 : if( bLateInitialization )
354 : {
355 0 : SwFieldType* pSetExpFld = rDoc.GetFldType(RES_SETEXPFLD, GetFormula(), sal_False);
356 0 : if( pSetExpFld )
357 : {
358 0 : bLateInitialization = false;
359 0 : if( !(GetSubType() & nsSwGetSetExpType::GSE_STRING) &&
360 0 : static_cast< SwSetExpFieldType* >(pSetExpFld)->GetType() == nsSwGetSetExpType::GSE_STRING )
361 0 : SetSubType( nsSwGetSetExpType::GSE_STRING );
362 : }
363 : }
364 :
365 0 : _SetGetExpFld aEndFld( aPos.nNode, &rFld, &aPos.nContent );
366 0 : if(GetSubType() & nsSwGetSetExpType::GSE_STRING)
367 : {
368 : SwHash** ppHashTbl;
369 : sal_uInt16 nSize;
370 0 : rDoc.FldsToExpand( ppHashTbl, nSize, aEndFld );
371 0 : LookString( ppHashTbl, nSize, GetFormula(), sExpand );
372 0 : ::DeleteHashTable( ppHashTbl, nSize ); // HashTabelle loeschen
373 : }
374 : else
375 : {
376 : // fuelle den Calculator mit den Werten
377 0 : SwCalc aCalc( rDoc );
378 0 : rDoc.FldsToCalc(aCalc, aEndFld);
379 :
380 : // Wert berechnen
381 0 : SetValue(aCalc.Calculate(GetFormula()).GetDouble());
382 :
383 : // Auswertung nach Format
384 0 : sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue(
385 0 : GetValue(), GetFormat(), GetLanguage());
386 0 : }
387 : }
388 :
389 0 : rtl::OUString SwGetExpField::GetPar2() const
390 : {
391 0 : return GetFormula();
392 : }
393 :
394 0 : void SwGetExpField::SetPar2(const rtl::OUString& rStr)
395 : {
396 0 : SetFormula(rStr);
397 0 : }
398 :
399 1 : sal_uInt16 SwGetExpField::GetSubType() const
400 : {
401 1 : return nSubType;
402 : }
403 :
404 0 : void SwGetExpField::SetSubType(sal_uInt16 nType)
405 : {
406 0 : nSubType = nType;
407 0 : }
408 :
409 5 : void SwGetExpField::SetLanguage(sal_uInt16 nLng)
410 : {
411 5 : if (nSubType & nsSwExtendedSubType::SUB_CMD)
412 0 : SwField::SetLanguage(nLng);
413 : else
414 5 : SwValueField::SetLanguage(nLng);
415 5 : }
416 :
417 3 : bool SwGetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
418 : {
419 3 : switch( nWhichId )
420 : {
421 : case FIELD_PROP_DOUBLE:
422 0 : rAny <<= GetValue();
423 0 : break;
424 : case FIELD_PROP_FORMAT:
425 0 : rAny <<= (sal_Int32)GetFormat();
426 0 : break;
427 : case FIELD_PROP_USHORT1:
428 0 : rAny <<= (sal_Int16)nSubType;
429 0 : break;
430 : case FIELD_PROP_PAR1:
431 1 : rAny <<= OUString( GetFormula() );
432 1 : break;
433 : case FIELD_PROP_SUBTYPE:
434 : {
435 1 : sal_Int16 nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
436 1 : rAny <<= nRet;
437 : }
438 1 : break;
439 : case FIELD_PROP_BOOL2:
440 : {
441 0 : sal_Bool bTmp = 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
442 0 : rAny.setValue(&bTmp, ::getBooleanCppuType());
443 : }
444 0 : break;
445 : case FIELD_PROP_PAR4:
446 1 : rAny <<= rtl::OUString(GetExpStr());
447 1 : break;
448 : default:
449 0 : return SwField::QueryValue(rAny, nWhichId);
450 : }
451 3 : return true;
452 : }
453 :
454 0 : bool SwGetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
455 : {
456 0 : sal_Int32 nTmp = 0;
457 0 : String sTmp;
458 0 : switch( nWhichId )
459 : {
460 : case FIELD_PROP_DOUBLE:
461 0 : SwValueField::SetValue(*(double*) rAny.getValue());
462 0 : break;
463 : case FIELD_PROP_FORMAT:
464 0 : rAny >>= nTmp;
465 0 : SetFormat(nTmp);
466 0 : break;
467 : case FIELD_PROP_USHORT1:
468 0 : rAny >>= nTmp;
469 0 : nSubType = static_cast<sal_uInt16>(nTmp);
470 0 : break;
471 : case FIELD_PROP_PAR1:
472 0 : SetFormula( ::GetString( rAny, sTmp ));
473 0 : break;
474 : case FIELD_PROP_SUBTYPE:
475 0 : nTmp = lcl_APIToSubType(rAny);
476 0 : if( nTmp >=0 )
477 0 : SetSubType( static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp));
478 0 : break;
479 : case FIELD_PROP_BOOL2:
480 0 : if(*(sal_Bool*) rAny.getValue())
481 0 : nSubType |= nsSwExtendedSubType::SUB_CMD;
482 : else
483 0 : nSubType &= (~nsSwExtendedSubType::SUB_CMD);
484 0 : break;
485 : case FIELD_PROP_PAR4:
486 0 : ChgExpStr(::GetString( rAny, sTmp ));
487 0 : break;
488 : default:
489 0 : return SwField::PutValue(rAny, nWhichId);
490 : }
491 0 : return true;
492 : }
493 :
494 1106 : SwSetExpFieldType::SwSetExpFieldType( SwDoc* pDc, const String& rName, sal_uInt16 nTyp )
495 : : SwValueFieldType( pDc, RES_SETEXPFLD ),
496 : sName( rName ),
497 : pOutlChgNd( 0 ),
498 : sDelim( rtl::OUString(".") ),
499 : nType(nTyp), nLevel( UCHAR_MAX ),
500 1106 : bDeleted( sal_False )
501 : {
502 1106 : if( ( nsSwGetSetExpType::GSE_SEQ | nsSwGetSetExpType::GSE_STRING ) & nType )
503 1104 : EnableFormat(sal_False); // Numberformatter nicht einsetzen
504 1106 : }
505 :
506 1 : SwFieldType* SwSetExpFieldType::Copy() const
507 : {
508 1 : SwSetExpFieldType* pNew = new SwSetExpFieldType(GetDoc(), sName, nType);
509 1 : pNew->bDeleted = bDeleted;
510 1 : pNew->sDelim = sDelim;
511 1 : pNew->nLevel = nLevel;
512 :
513 1 : return pNew;
514 : }
515 :
516 426 : const rtl::OUString& SwSetExpFieldType::GetName() const
517 : {
518 426 : return sName;
519 : }
520 :
521 0 : void SwSetExpFieldType::Modify( const SfxPoolItem*, const SfxPoolItem* )
522 : {
523 0 : return; // nicht weiter expandieren
524 : }
525 :
526 0 : void SwSetExpFieldType::SetSeqFormat(sal_uLong nFmt)
527 : {
528 0 : SwIterator<SwFmtFld,SwFieldType> aIter(*this);
529 0 : for( SwFmtFld* pFld = aIter.First(); pFld; pFld = aIter.Next() )
530 0 : pFld->GetFld()->ChangeFormat( nFmt );
531 0 : }
532 :
533 0 : sal_uLong SwSetExpFieldType::GetSeqFormat()
534 : {
535 0 : if( !GetDepends() )
536 0 : return SVX_NUM_ARABIC;
537 :
538 0 : SwField *pFld = ((SwFmtFld*)GetDepends())->GetFld();
539 0 : return pFld->GetFormat();
540 : }
541 :
542 0 : sal_uInt16 SwSetExpFieldType::SetSeqRefNo( SwSetExpField& rFld )
543 : {
544 0 : if( !GetDepends() || !(nsSwGetSetExpType::GSE_SEQ & nType) )
545 0 : return USHRT_MAX;
546 :
547 : extern void InsertSort( std::vector<sal_uInt16>& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos = 0 );
548 0 : std::vector<sal_uInt16> aArr;
549 :
550 : sal_uInt16 n;
551 :
552 : // dann testmal, ob die Nummer schon vergeben ist oder ob eine neue
553 : // bestimmt werden muss.
554 0 : SwIterator<SwFmtFld,SwFieldType> aIter( *this );
555 : const SwTxtNode* pNd;
556 0 : for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() )
557 0 : if( pF->GetFld() != &rFld && pF->GetTxtFld() &&
558 0 : 0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) &&
559 0 : pNd->GetNodes().IsDocNodes() )
560 0 : InsertSort( aArr, ((SwSetExpField*)pF->GetFld())->GetSeqNumber() );
561 :
562 :
563 : // teste erstmal ob die Nummer schon vorhanden ist:
564 0 : sal_uInt16 nNum = rFld.GetSeqNumber();
565 0 : if( USHRT_MAX != nNum )
566 : {
567 0 : for( n = 0; n < aArr.size(); ++n )
568 0 : if( aArr[ n ] > nNum )
569 0 : return nNum; // nicht vorhanden -> also benutzen
570 0 : else if( aArr[ n ] == nNum )
571 0 : break; // schon vorhanden -> neue erzeugen
572 :
573 0 : if( n == aArr.size() )
574 0 : return nNum; // nicht vorhanden -> also benutzen
575 : }
576 :
577 : // alle Nummern entsprechend geflag, also bestimme die richtige Nummer
578 0 : for( n = 0; n < aArr.size(); ++n )
579 0 : if( n != aArr[ n ] )
580 0 : break;
581 :
582 0 : rFld.SetSeqNumber( n );
583 0 : return n;
584 : }
585 :
586 0 : sal_uInt16 SwSetExpFieldType::GetSeqFldList( SwSeqFldList& rList )
587 : {
588 0 : rList.Clear();
589 :
590 0 : SwIterator<SwFmtFld,SwFieldType> aIter( *this );
591 : const SwTxtNode* pNd;
592 0 : for( SwFmtFld* pF = aIter.First(); pF; pF = aIter.Next() )
593 0 : if( pF->GetTxtFld() &&
594 0 : 0 != ( pNd = pF->GetTxtFld()->GetpTxtNode() ) &&
595 0 : pNd->GetNodes().IsDocNodes() )
596 : {
597 : _SeqFldLstElem* pNew = new _SeqFldLstElem(
598 : pNd->GetExpandTxt( 0, USHRT_MAX ),
599 0 : ((SwSetExpField*)pF->GetFld())->GetSeqNumber() );
600 0 : rList.InsertSort( pNew );
601 : }
602 :
603 0 : return rList.Count();
604 : }
605 :
606 :
607 0 : void SwSetExpFieldType::SetChapter( SwSetExpField& rFld, const SwNode& rNd )
608 : {
609 0 : const SwTxtNode* pTxtNd = rNd.FindOutlineNodeOfLevel( nLevel );
610 0 : if( pTxtNd )
611 : {
612 0 : SwNumRule * pRule = pTxtNd->GetNumRule();
613 :
614 0 : if (pRule)
615 : {
616 : // --> OD 2005-11-02 #i51089 - TUNING#
617 0 : if ( pTxtNd->GetNum() )
618 : {
619 0 : const SwNodeNum & aNum = *(pTxtNd->GetNum());
620 :
621 : // nur die Nummer besorgen, ohne Pre-/Post-fixstrings
622 0 : String sNumber( pRule->MakeNumString(aNum, sal_False ));
623 :
624 0 : if( sNumber.Len() )
625 0 : rFld.ChgExpStr( ( sNumber += sDelim ) += rFld.GetExpStr() );
626 : }
627 : else
628 : {
629 : OSL_FAIL( "<SwSetExpFieldType::SetChapter(..)> - text node with numbering rule, but without number. This is a serious defect -> inform OD" );
630 : }
631 : }
632 : }
633 0 : }
634 :
635 84 : bool SwSetExpFieldType::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
636 : {
637 84 : switch( nWhichId )
638 : {
639 : case FIELD_PROP_SUBTYPE:
640 : {
641 76 : sal_Int16 nRet = lcl_SubTypeToAPI(GetType());
642 76 : rAny <<= nRet;
643 : }
644 76 : break;
645 : case FIELD_PROP_PAR2:
646 0 : rAny <<= OUString(GetDelimiter());
647 0 : break;
648 : case FIELD_PROP_SHORT1:
649 : {
650 8 : sal_Int8 nRet = nLevel < MAXLEVEL? nLevel : -1;
651 8 : rAny <<= nRet;
652 : }
653 8 : break;
654 : default:
655 : OSL_FAIL("illegal property");
656 : }
657 84 : return true;
658 : }
659 :
660 69 : bool SwSetExpFieldType::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
661 : {
662 69 : switch( nWhichId )
663 : {
664 : case FIELD_PROP_SUBTYPE:
665 : {
666 1 : sal_Int32 nSet = lcl_APIToSubType(rAny);
667 1 : if(nSet >=0)
668 1 : SetType(static_cast<sal_uInt16>(nSet));
669 : }
670 1 : break;
671 : case FIELD_PROP_PAR2:
672 : {
673 0 : String sTmp;
674 0 : if( ::GetString( rAny, sTmp ).Len() )
675 0 : SetDelimiter( sTmp );
676 : else
677 0 : SetDelimiter(rtl::OUString(" "));
678 : }
679 0 : break;
680 : case FIELD_PROP_SHORT1:
681 : {
682 68 : sal_Int8 nLvl = 0;
683 68 : rAny >>= nLvl;
684 68 : if(nLvl < 0 || nLvl >= MAXLEVEL)
685 68 : SetOutlineLvl(UCHAR_MAX);
686 : else
687 0 : SetOutlineLvl(nLvl);
688 : }
689 68 : break;
690 : default:
691 : OSL_FAIL("illegal property");
692 : }
693 69 : return true;
694 : }
695 :
696 0 : bool SwSeqFldList::InsertSort( _SeqFldLstElem* pNew )
697 : {
698 0 : sal_Unicode* p = pNew->sDlgEntry.GetBufferAccess();
699 0 : while( *p )
700 : {
701 0 : if( *p < 0x20 )
702 0 : *p = 0x20;
703 0 : ++p;
704 : }
705 :
706 : sal_uInt16 nPos;
707 0 : bool bRet = SeekEntry( *pNew, &nPos );
708 0 : if( !bRet )
709 0 : maData.insert( maData.begin() + nPos, pNew );
710 0 : return bRet;
711 : }
712 :
713 0 : bool SwSeqFldList::SeekEntry( const _SeqFldLstElem& rNew, sal_uInt16* pP ) const
714 : {
715 0 : sal_uInt16 nO = maData.size(), nM, nU = 0;
716 0 : if( nO > 0 )
717 : {
718 0 : CollatorWrapper & rCaseColl = ::GetAppCaseCollator(),
719 0 : & rColl = ::GetAppCollator();
720 0 : const CharClass& rCC = GetAppCharClass();
721 :
722 : //#59900# Die Sortierung soll die Nummer korrekt einordnen
723 : //also "10" nach "9" und nicht "10" nach "1"
724 0 : const String& rTmp2 = rNew.sDlgEntry;
725 0 : xub_StrLen nFndPos2 = 0;
726 0 : String sNum2( rTmp2.GetToken( 0, ' ', nFndPos2 ));
727 0 : sal_Bool bIsNum2IsNumeric = rCC.isAsciiNumeric( sNum2 );
728 0 : sal_Int32 nNum2 = bIsNum2IsNumeric ? sNum2.ToInt32() : 0;
729 :
730 0 : nO--;
731 0 : while( nU <= nO )
732 : {
733 0 : nM = nU + ( nO - nU ) / 2;
734 :
735 : //#59900# Die Sortierung soll die Nummer korrekt einordnen
736 : //also "10" nach "9" und nicht "10" nach "1"
737 0 : const String& rTmp1 = maData[nM]->sDlgEntry;
738 0 : xub_StrLen nFndPos1 = 0;
739 0 : String sNum1( rTmp1.GetToken( 0, ' ', nFndPos1 ));
740 : sal_Int32 nCmp;
741 :
742 0 : if( bIsNum2IsNumeric && rCC.isNumeric( sNum1 ) )
743 : {
744 0 : sal_Int32 nNum1 = sNum1.ToInt32();
745 0 : nCmp = nNum2 - nNum1;
746 0 : if( 0 == nCmp )
747 : nCmp = rCaseColl.compareString( rTmp2.Copy( nFndPos2 ),
748 0 : rTmp1.Copy( nFndPos1 ));
749 : }
750 : else
751 0 : nCmp = rColl.compareString( rTmp2, rTmp1 );
752 :
753 0 : if( 0 == nCmp )
754 : {
755 0 : if( pP ) *pP = nM;
756 0 : return true;
757 : }
758 0 : else if( 0 < nCmp )
759 0 : nU = nM + 1;
760 0 : else if( nM == 0 )
761 : break;
762 : else
763 0 : nO = nM - 1;
764 0 : }
765 : }
766 0 : if( pP ) *pP = nU;
767 0 : return false;
768 : }
769 :
770 : /*--------------------------------------------------------------------
771 : Beschreibung: SwSetExpField by JP
772 : --------------------------------------------------------------------*/
773 :
774 5 : SwSetExpField::SwSetExpField(SwSetExpFieldType* pTyp, const String& rFormel,
775 : sal_uLong nFmt)
776 : : SwFormulaField( pTyp, nFmt, 0.0 ), nSeqNo( USHRT_MAX ),
777 5 : nSubType(0)
778 : {
779 5 : SetFormula(rFormel);
780 : // SubType ignorieren !!!
781 5 : bInput = sal_False;
782 5 : if( IsSequenceFld() )
783 : {
784 0 : SwValueField::SetValue(1.0);
785 0 : if( !rFormel.Len() )
786 : {
787 0 : String sFormel(rFormel);
788 0 : sFormel += pTyp->GetName();
789 0 : sFormel += '+';
790 0 : sFormel += '1';
791 0 : SetFormula(sFormel);
792 : }
793 : }
794 5 : }
795 :
796 2 : String SwSetExpField::Expand() const
797 : {
798 2 : String aStr;
799 2 : if (nSubType & nsSwExtendedSubType::SUB_CMD)
800 : { // Der CommandString ist gefragt
801 0 : aStr = GetTyp()->GetName();
802 0 : aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " = " ));
803 0 : aStr += GetFormula();
804 : }
805 2 : else if(!(nSubType & nsSwExtendedSubType::SUB_INVISIBLE))
806 : { // Der Wert ist sichtbar
807 0 : aStr = sExpand;
808 : }
809 2 : return aStr;
810 : }
811 :
812 : /*--------------------------------------------------------------------
813 : @return the field name
814 : --------------------------------------------------------------------*/
815 :
816 0 : String SwSetExpField::GetFieldName() const
817 : {
818 0 : SwFldTypesEnum const nStrType( (IsSequenceFld())
819 : ? TYP_SEQFLD
820 : : (bInput)
821 : ? TYP_SETINPFLD
822 0 : : TYP_SETFLD );
823 :
824 0 : String aStr( SwFieldType::GetTypeStr( static_cast<sal_uInt16>(nStrType) ) );
825 0 : aStr += ' ';
826 0 : aStr += GetTyp()->GetName();
827 :
828 : // Sequence: without formula
829 0 : if (TYP_SEQFLD != nStrType)
830 : {
831 0 : aStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " = " ) );
832 0 : aStr += GetFormula();
833 : }
834 0 : return aStr;
835 : }
836 :
837 4 : SwField* SwSetExpField::Copy() const
838 : {
839 4 : SwSetExpField *pTmp = new SwSetExpField((SwSetExpFieldType*)GetTyp(),
840 4 : GetFormula(), GetFormat());
841 4 : pTmp->SwValueField::SetValue(GetValue());
842 4 : pTmp->sExpand = sExpand;
843 4 : pTmp->SetAutomaticLanguage(IsAutomaticLanguage());
844 4 : pTmp->SetLanguage(GetLanguage());
845 4 : pTmp->aPText = aPText;
846 4 : pTmp->bInput = bInput;
847 4 : pTmp->nSeqNo = nSeqNo;
848 4 : pTmp->SetSubType(GetSubType());
849 :
850 4 : return pTmp;
851 : }
852 :
853 5 : void SwSetExpField::SetSubType(sal_uInt16 nSub)
854 : {
855 5 : ((SwSetExpFieldType*)GetTyp())->SetType(nSub & 0xff);
856 5 : nSubType = nSub & 0xff00;
857 :
858 : OSL_ENSURE( (nSub & 0xff) != 3, "SubType ist illegal!" );
859 5 : }
860 :
861 6 : sal_uInt16 SwSetExpField::GetSubType() const
862 : {
863 6 : return ((SwSetExpFieldType*)GetTyp())->GetType() | nSubType;
864 : }
865 :
866 0 : void SwSetExpField::SetValue( const double& rAny )
867 : {
868 0 : SwValueField::SetValue(rAny);
869 :
870 0 : if( IsSequenceFld() )
871 0 : sExpand = FormatNumber( (sal_uInt32)GetValue(), GetFormat() );
872 : else
873 0 : sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue( rAny,
874 0 : GetFormat(), GetLanguage());
875 0 : }
876 :
877 0 : void SwGetExpField::SetValue( const double& rAny )
878 : {
879 0 : SwValueField::SetValue(rAny);
880 0 : sExpand = ((SwValueFieldType*)GetTyp())->ExpandValue( rAny, GetFormat(),
881 0 : GetLanguage());
882 0 : }
883 : /* --------------------------------------------------
884 : Description: Find the index of the reference text
885 : following the current field
886 : nHint: search starting position after the current
887 : field (or 0 if default)
888 : --------------------------------------------------*/
889 0 : xub_StrLen SwGetExpField::GetReferenceTextPos( const SwFmtFld& rFmt, SwDoc& rDoc, unsigned nHint)
890 : {
891 : //
892 0 : const SwTxtFld* pTxtFld = rFmt.GetTxtFld();
893 0 : const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
894 : //
895 0 : xub_StrLen nRet = nHint ? nHint : *pTxtFld->GetStart() + 1;
896 0 : String sNodeText = rTxtNode.GetTxt();
897 0 : sNodeText.Erase(0, nRet);
898 0 : if(sNodeText.Len())
899 : {
900 : // now check if sNodeText starts with a non-alphanumeric character plus blanks
901 0 : sal_uInt16 nSrcpt = pBreakIt->GetRealScriptOfText( sNodeText, 0 );
902 :
903 : static sal_uInt16 nIds[] =
904 : {
905 : RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
906 : RES_CHRATR_FONT, RES_CHRATR_FONT,
907 : RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
908 : RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONT,
909 : RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
910 : RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONT,
911 : 0, 0
912 : };
913 0 : SwAttrSet aSet(rDoc.GetAttrPool(), nIds);
914 0 : rTxtNode.GetAttr(aSet, nRet, nRet+1);
915 :
916 0 : if( RTL_TEXTENCODING_SYMBOL != ((SvxFontItem&)aSet.Get(
917 0 : GetWhichOfScript( RES_CHRATR_FONT, nSrcpt )) ).GetCharSet() )
918 : {
919 : LanguageType eLang = ((SvxLanguageItem&)aSet.Get(
920 0 : GetWhichOfScript( RES_CHRATR_LANGUAGE, nSrcpt )) ).GetLanguage();
921 0 : LanguageTag aLanguageTag( eLang);
922 0 : CharClass aCC( aLanguageTag);
923 0 : sal_Unicode c0 = sNodeText.GetChar(0);
924 0 : sal_Bool bIsAlphaNum = aCC.isAlphaNumeric( sNodeText, 0 );
925 0 : if( !bIsAlphaNum ||
926 : (c0 == ' ' || c0 == '\t'))
927 : {
928 : // ignoring blanks
929 0 : nRet++;
930 0 : unsigned i = 1;
931 0 : while (i < sNodeText.Len() &&
932 0 : (sNodeText.GetChar(i) == ' ' ||
933 0 : sNodeText.GetChar(i) == '\t')
934 : )
935 0 : nRet++, i++;
936 0 : }
937 0 : }
938 : }
939 0 : return nRet;
940 : }
941 :
942 :
943 : /*--------------------------------------------------------------------
944 : Beschreibung: Parameter setzen
945 : --------------------------------------------------------------------*/
946 :
947 0 : const rtl::OUString& SwSetExpField::GetPar1() const
948 : {
949 0 : return ((const SwSetExpFieldType*)GetTyp())->GetName();
950 : }
951 :
952 0 : rtl::OUString SwSetExpField::GetPar2() const
953 : {
954 0 : sal_uInt16 nType = ((SwSetExpFieldType*)GetTyp())->GetType();
955 :
956 0 : if (nType & nsSwGetSetExpType::GSE_STRING)
957 0 : return GetFormula();
958 0 : return GetExpandedFormula();
959 : }
960 :
961 0 : void SwSetExpField::SetPar2(const rtl::OUString& rStr)
962 : {
963 0 : sal_uInt16 nType = ((SwSetExpFieldType*)GetTyp())->GetType();
964 :
965 0 : if( !(nType & nsSwGetSetExpType::GSE_SEQ) || !rStr.isEmpty() )
966 : {
967 0 : if (nType & nsSwGetSetExpType::GSE_STRING)
968 0 : SetFormula(rStr);
969 : else
970 0 : SetExpandedFormula(rStr);
971 : }
972 0 : }
973 :
974 : /*--------------------------------------------------------------------
975 : Beschreibung: Eingabefeld Type
976 : ---------------------------------------------------------------------*/
977 :
978 276 : SwInputFieldType::SwInputFieldType( SwDoc* pD )
979 276 : : SwFieldType( RES_INPUTFLD ), pDoc( pD )
980 : {
981 276 : }
982 :
983 0 : SwFieldType* SwInputFieldType::Copy() const
984 : {
985 0 : SwInputFieldType* pType = new SwInputFieldType( pDoc );
986 0 : return pType;
987 : }
988 :
989 : /*--------------------------------------------------------------------
990 : Beschreibung: Eingabefeld
991 : --------------------------------------------------------------------*/
992 :
993 0 : SwInputField::SwInputField(SwInputFieldType* pTyp, const String& rContent,
994 : const String& rPrompt, sal_uInt16 nSub, sal_uLong nFmt) :
995 0 : SwField(pTyp, nFmt), aContent(rContent), aPText(rPrompt), nSubType(nSub)
996 : {
997 0 : }
998 :
999 0 : String SwInputField::GetFieldName() const
1000 : {
1001 0 : String aStr(SwField::GetFieldName());
1002 0 : if ((nSubType & 0x00ff) == INP_USR)
1003 : {
1004 0 : aStr += GetTyp()->GetName();
1005 0 : aStr += ' ';
1006 0 : aStr += aContent;
1007 : }
1008 0 : return aStr;
1009 : }
1010 :
1011 0 : SwField* SwInputField::Copy() const
1012 : {
1013 0 : SwInputField* pFld = new SwInputField((SwInputFieldType*)GetTyp(), aContent,
1014 0 : aPText, GetSubType(), GetFormat());
1015 :
1016 0 : pFld->SetHelp(aHelp);
1017 0 : pFld->SetToolTip(aToolTip);
1018 :
1019 0 : pFld->SetAutomaticLanguage(IsAutomaticLanguage());
1020 0 : return pFld;
1021 : }
1022 :
1023 0 : String SwInputField::Expand() const
1024 : {
1025 0 : String sRet;
1026 0 : if((nSubType & 0x00ff) == INP_TXT)
1027 0 : sRet = aContent;
1028 :
1029 0 : else if( (nSubType & 0x00ff) == INP_USR )
1030 : {
1031 : SwUserFieldType* pUserTyp = (SwUserFieldType*)
1032 0 : ((SwInputFieldType*)GetTyp())->GetDoc()->
1033 0 : GetFldType( RES_USERFLD, aContent, false );
1034 0 : if( pUserTyp )
1035 0 : sRet = pUserTyp->GetContent();
1036 : }
1037 0 : return sRet;
1038 : }
1039 :
1040 0 : bool SwInputField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1041 : {
1042 0 : switch( nWhichId )
1043 : {
1044 : case FIELD_PROP_PAR1:
1045 0 : rAny <<= OUString( aContent );
1046 0 : break;
1047 : case FIELD_PROP_PAR2:
1048 0 : rAny <<= OUString( aPText );
1049 0 : break;
1050 : case FIELD_PROP_PAR3:
1051 0 : rAny <<= OUString( aHelp );
1052 0 : break;
1053 : case FIELD_PROP_PAR4:
1054 0 : rAny <<= OUString( aToolTip );
1055 0 : break;
1056 : default:
1057 : OSL_FAIL("illegal property");
1058 : }
1059 0 : return true;
1060 : }
1061 :
1062 0 : bool SwInputField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1063 : {
1064 0 : switch( nWhichId )
1065 : {
1066 : case FIELD_PROP_PAR1:
1067 0 : rAny >>= aContent;
1068 0 : break;
1069 : case FIELD_PROP_PAR2:
1070 0 : ::GetString( rAny, aPText );
1071 0 : break;
1072 : case FIELD_PROP_PAR3:
1073 0 : ::GetString( rAny, aHelp );
1074 0 : break;
1075 : case FIELD_PROP_PAR4:
1076 0 : ::GetString( rAny, aToolTip );
1077 0 : break;
1078 : default:
1079 : OSL_FAIL("illegal property");
1080 : }
1081 0 : return true;
1082 : }
1083 : /*--------------------------------------------------------------------
1084 : Beschreibung: Bedingung setzen
1085 : --------------------------------------------------------------------*/
1086 :
1087 0 : void SwInputField::SetPar1(const rtl::OUString& rStr)
1088 : {
1089 0 : aContent = rStr;
1090 0 : }
1091 :
1092 0 : const rtl::OUString& SwInputField::GetPar1() const
1093 : {
1094 0 : return aContent;
1095 : }
1096 :
1097 : /*--------------------------------------------------------------------
1098 : Beschreibung: True/False Text
1099 : --------------------------------------------------------------------*/
1100 :
1101 0 : void SwInputField::SetPar2(const rtl::OUString& rStr)
1102 : {
1103 0 : aPText = rStr;
1104 0 : }
1105 :
1106 0 : rtl::OUString SwInputField::GetPar2() const
1107 : {
1108 0 : return aPText;
1109 : }
1110 :
1111 0 : void SwInputField::SetHelp(const String & rStr)
1112 : {
1113 0 : aHelp = rStr;
1114 0 : }
1115 :
1116 0 : String SwInputField::GetHelp() const
1117 : {
1118 0 : return aHelp;
1119 : }
1120 :
1121 0 : void SwInputField::SetToolTip(const String & rStr)
1122 : {
1123 0 : aToolTip = rStr;
1124 0 : }
1125 :
1126 0 : String SwInputField::GetToolTip() const
1127 : {
1128 0 : return aToolTip;
1129 : }
1130 :
1131 0 : sal_Bool SwInputField::isFormField() const
1132 : {
1133 0 : return aHelp.Len() > 0 || aToolTip.Len() > 0;
1134 : }
1135 :
1136 0 : sal_uInt16 SwInputField::GetSubType() const
1137 : {
1138 0 : return nSubType;
1139 : }
1140 :
1141 0 : void SwInputField::SetSubType(sal_uInt16 nSub)
1142 : {
1143 0 : nSubType = nSub;
1144 0 : }
1145 :
1146 2 : bool SwSetExpField::QueryValue( uno::Any& rAny, sal_uInt16 nWhichId ) const
1147 : {
1148 2 : switch( nWhichId )
1149 : {
1150 : case FIELD_PROP_BOOL2:
1151 : {
1152 0 : sal_Bool bVal = 0 == (nSubType & nsSwExtendedSubType::SUB_INVISIBLE);
1153 0 : rAny.setValue(&bVal, ::getBooleanCppuType());
1154 : }
1155 0 : break;
1156 : case FIELD_PROP_FORMAT:
1157 0 : rAny <<= (sal_Int32)GetFormat();
1158 0 : break;
1159 : case FIELD_PROP_USHORT2:
1160 0 : rAny <<= (sal_Int16)GetFormat();
1161 0 : break;
1162 : case FIELD_PROP_USHORT1:
1163 0 : rAny <<= (sal_Int16)nSeqNo;
1164 0 : break;
1165 : case FIELD_PROP_PAR1:
1166 0 : rAny <<= OUString ( SwStyleNameMapper::GetProgName(GetPar1(), nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1167 0 : break;
1168 : case FIELD_PROP_PAR2:
1169 : {
1170 : //I18N - if the formula contains only "TypeName+1"
1171 : //and it's one of the initially created sequence fields
1172 : //then the localized names has to be replaced by a programmatic name
1173 1 : OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, GetFormula(), sal_True);
1174 1 : rAny <<= OUString( sMyFormula );
1175 : }
1176 1 : break;
1177 : case FIELD_PROP_DOUBLE:
1178 0 : rAny <<= (double)GetValue();
1179 0 : break;
1180 : case FIELD_PROP_SUBTYPE:
1181 : {
1182 1 : sal_Int16 nRet = 0;
1183 1 : nRet = lcl_SubTypeToAPI(GetSubType() & 0xff);
1184 1 : rAny <<= nRet;
1185 : }
1186 1 : break;
1187 : case FIELD_PROP_PAR3:
1188 0 : rAny <<= OUString( aPText );
1189 0 : break;
1190 : case FIELD_PROP_BOOL3:
1191 : {
1192 0 : sal_Bool bTmp = 0 != (nSubType & nsSwExtendedSubType::SUB_CMD);
1193 0 : rAny.setValue(&bTmp, ::getBooleanCppuType());
1194 : }
1195 0 : break;
1196 : case FIELD_PROP_BOOL1:
1197 : {
1198 0 : sal_Bool bTmp = GetInputFlag();
1199 0 : rAny.setValue(&bTmp, ::getBooleanCppuType());
1200 : }
1201 0 : break;
1202 : case FIELD_PROP_PAR4:
1203 0 : rAny <<= rtl::OUString(GetExpStr());
1204 0 : break;
1205 : default:
1206 0 : return SwField::QueryValue(rAny, nWhichId);
1207 : }
1208 2 : return true;
1209 : }
1210 :
1211 0 : bool SwSetExpField::PutValue( const uno::Any& rAny, sal_uInt16 nWhichId )
1212 : {
1213 0 : sal_Int32 nTmp32 = 0;
1214 0 : sal_Int16 nTmp16 = 0;
1215 0 : String sTmp;
1216 0 : switch( nWhichId )
1217 : {
1218 : case FIELD_PROP_BOOL2:
1219 0 : if(*(sal_Bool*)rAny.getValue())
1220 0 : nSubType &= ~nsSwExtendedSubType::SUB_INVISIBLE;
1221 : else
1222 0 : nSubType |= nsSwExtendedSubType::SUB_INVISIBLE;
1223 0 : break;
1224 : case FIELD_PROP_FORMAT:
1225 0 : rAny >>= nTmp32;
1226 0 : SetFormat(nTmp32);
1227 0 : break;
1228 : case FIELD_PROP_USHORT2:
1229 : {
1230 0 : rAny >>= nTmp16;
1231 0 : if(nTmp16 <= SVX_NUMBER_NONE )
1232 0 : SetFormat(nTmp16);
1233 : else {
1234 : }
1235 : }
1236 0 : break;
1237 : case FIELD_PROP_USHORT1:
1238 0 : rAny >>= nTmp16;
1239 0 : nSeqNo = nTmp16;
1240 0 : break;
1241 : case FIELD_PROP_PAR1:
1242 : SetPar1( SwStyleNameMapper::GetUIName(
1243 0 : ::GetString( rAny, sTmp ), nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ) );
1244 0 : break;
1245 : case FIELD_PROP_PAR2:
1246 : {
1247 0 : OUString uTmp;
1248 0 : rAny >>= uTmp;
1249 : //I18N - if the formula contains only "TypeName+1"
1250 : //and it's one of the initially created sequence fields
1251 : //then the localized names has to be replaced by a programmatic name
1252 0 : OUString sMyFormula = SwXFieldMaster::LocalizeFormula(*this, uTmp, sal_False);
1253 0 : SetFormula( sMyFormula );
1254 : }
1255 0 : break;
1256 : case FIELD_PROP_DOUBLE:
1257 : {
1258 0 : double fVal = 0.0;
1259 0 : rAny >>= fVal;
1260 0 : SetValue(fVal);
1261 : }
1262 0 : break;
1263 : case FIELD_PROP_SUBTYPE:
1264 0 : nTmp32 = lcl_APIToSubType(rAny);
1265 0 : if(nTmp32 >= 0)
1266 0 : SetSubType(static_cast<sal_uInt16>((GetSubType() & 0xff00) | nTmp32));
1267 0 : break;
1268 : case FIELD_PROP_PAR3:
1269 0 : ::GetString( rAny, aPText );
1270 0 : break;
1271 : case FIELD_PROP_BOOL3:
1272 0 : if(*(sal_Bool*) rAny.getValue())
1273 0 : nSubType |= nsSwExtendedSubType::SUB_CMD;
1274 : else
1275 0 : nSubType &= (~nsSwExtendedSubType::SUB_CMD);
1276 0 : break;
1277 : case FIELD_PROP_BOOL1:
1278 0 : SetInputFlag(*(sal_Bool*) rAny.getValue());
1279 0 : break;
1280 : case FIELD_PROP_PAR4:
1281 0 : ChgExpStr( ::GetString( rAny, sTmp ));
1282 0 : break;
1283 : default:
1284 0 : return SwField::PutValue(rAny, nWhichId);
1285 : }
1286 0 : return true;
1287 : }
1288 :
1289 :
1290 :
1291 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
