1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_xmloff.hxx"
26
27 /** @#file
28 *
29 * export of all variable related text fields (and database display field)
30 */
31 #include "txtvfldi.hxx"
32 #include <xmloff/xmltoken.hxx>
33 #include <xmloff/txtimp.hxx>
34 #include <xmloff/xmlnumi.hxx>
35 #include "xmloff/xmlnmspe.hxx"
36 #include <xmloff/nmspmap.hxx>
37 #include "xmloff/i18nmap.hxx"
38 #include <xmloff/xmlimp.hxx>
39 #include <xmloff/xmluconv.hxx>
40 #include <xmloff/xmlement.hxx>
41 #include <com/sun/star/text/SetVariableType.hpp>
42 #include <com/sun/star/text/XTextField.hpp>
43 #include <com/sun/star/text/XDependentTextField.hpp>
44 #include <com/sun/star/text/XTextFieldsSupplier.hpp>
45 #include <com/sun/star/beans/XPropertySet.hpp>
46 #include <com/sun/star/beans/XPropertySetInfo.hpp>
47 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
48 #include <com/sun/star/xml/sax/XAttributeList.hpp>
49
50 #ifndef _RTL_USTRING
51 #include <rtl/ustring.hxx>
52 #endif
53 #include <tools/debug.hxx>
54
55
56 // service names
57 static const sal_Char sAPI_textfield_prefix[] = "com.sun.star.text.TextField.";
58 static const sal_Char sAPI_fieldmaster_prefix[] = "com.sun.star.text.FieldMaster.";
59 static const sal_Char sAPI_input[] = "Input";
60 static const sal_Char sAPI_input_user[] = "InputUser";
61 static const sal_Char sAPI_get_expression[] = "GetExpression";
62 static const sal_Char sAPI_set_expression[] = "SetExpression";
63 static const sal_Char sAPI_user[] = "User";
64 static const sal_Char sAPI_table_formula[] = "TableFormula";
65 static const sal_Char sAPI_database[] = "com.sun.star.text.TextField.Database";
66 static const sal_Char sAPI_fieldmaster_database[] = "com.sun.star.text.FieldMaster.Database";
67
68 // property names
69 static const sal_Char sAPI_hint[] = "Hint";
70 static const sal_Char sAPI_help[] = "Help";
71 static const sal_Char sAPI_tooltip[] = "Tooltip";
72 static const sal_Char sAPI_content[] = "Content";
73 static const sal_Char sAPI_sub_type[] = "SubType";
74 static const sal_Char sAPI_is_expression[] = "IsExpression";
75 static const sal_Char sAPI_is_input[] = "Input";
76 static const sal_Char sAPI_is_show_formula[] = "IsShowFormula";
77 static const sal_Char sAPI_numbering_type[] = "NumberingType";
78 static const sal_Char sAPI_number_format[] = "NumberFormat";
79 static const sal_Char sAPI_name[] = "Name";
80 static const sal_Char sAPI_numbering_separator[] = "NumberingSeparator";
81 static const sal_Char sAPI_chapter_numbering_level[]= "ChapterNumberingLevel";
82 static const sal_Char sAPI_value[] = "Value";
83 static const sal_Char sAPI_is_visible[] = "IsVisible";
84 static const sal_Char sAPI_variable_subtype[] = "VariableSubtype";
85 static const sal_Char sAPI_data_column_name[] = "DataColumnName";
86 static const sal_Char sAPI_is_data_base_format[] = "DataBaseFormat";
87 static const sal_Char sAPI_current_presentation[] = "CurrentPresentation";
88 static const sal_Char sAPI_sequence_value[] = "SequenceValue";
89 static const sal_Char sAPI_is_fixed_language[] = "IsFixedLanguage";
90
91
92 using ::rtl::OUString;
93 using ::rtl::OUStringBuffer;
94
95 using namespace ::com::sun::star;
96 using namespace ::com::sun::star::uno;
97 using namespace ::com::sun::star::beans;
98 using namespace ::com::sun::star::text;
99 using namespace ::com::sun::star::style;
100 using namespace ::xmloff::token;
101
102
103
104 //
105 // XMLVarFieldImportContext: superclass for all variable related fields
106 //
107
108 TYPEINIT1( XMLVarFieldImportContext, XMLTextFieldImportContext );
109
XMLVarFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,const sal_Char * pServiceName,sal_uInt16 nPrfx,const OUString & rLocalName,sal_Bool bName,sal_Bool bFormula,sal_Bool bFormulaDefault,sal_Bool bDescription,sal_Bool bHelp,sal_Bool bHint,sal_Bool bVisible,sal_Bool bIsDisplayFormula,sal_Bool bType,sal_Bool bStyle,sal_Bool bValue,sal_Bool bPresentation)110 XMLVarFieldImportContext::XMLVarFieldImportContext(
111 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
112 const sal_Char* pServiceName, sal_uInt16 nPrfx,
113 const OUString& rLocalName,
114 sal_Bool bName, sal_Bool bFormula, sal_Bool bFormulaDefault,
115 sal_Bool bDescription, sal_Bool bHelp, sal_Bool bHint, sal_Bool bVisible,
116 sal_Bool bIsDisplayFormula,
117 sal_Bool bType, sal_Bool bStyle, sal_Bool bValue,
118 sal_Bool bPresentation) :
119 XMLTextFieldImportContext(rImport, rHlp, pServiceName, nPrfx, rLocalName),
120 sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)),
121 sPropertyHint(RTL_CONSTASCII_USTRINGPARAM(sAPI_hint)),
122 sPropertyHelp(RTL_CONSTASCII_USTRINGPARAM(sAPI_help)),
123 sPropertyTooltip(RTL_CONSTASCII_USTRINGPARAM(sAPI_tooltip)),
124 sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_visible)),
125 sPropertyIsDisplayFormula(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_show_formula)),
126 sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)),
127 aValueHelper(rImport, rHlp, bType, bStyle, bValue, sal_False),
128 bDisplayFormula(sal_False),
129 bDisplayNone(sal_False),
130 bNameOK(sal_False),
131 bFormulaOK(sal_False),
132 bDescriptionOK(sal_False),
133 bHelpOK(sal_False),
134 bHintOK(sal_False),
135 bDisplayOK(sal_False),
136 bSetName(bName),
137 bSetFormula(bFormula),
138 bSetFormulaDefault(bFormulaDefault),
139 bSetDescription(bDescription),
140 bSetHelp(bHelp),
141 bSetHint(bHint),
142 bSetVisible(bVisible),
143 bSetDisplayFormula(bIsDisplayFormula),
144 bSetPresentation(bPresentation)
145 {
146 }
147
ProcessAttribute(sal_uInt16 nAttrToken,const OUString & sAttrValue)148 void XMLVarFieldImportContext::ProcessAttribute(
149 sal_uInt16 nAttrToken,
150 const OUString& sAttrValue )
151 {
152 switch (nAttrToken)
153 {
154 case XML_TOK_TEXTFIELD_NAME:
155 sName = sAttrValue;
156 bNameOK = sal_True;
157 bValid = sal_True; // we assume: field with name is valid!
158 break;
159 case XML_TOK_TEXTFIELD_DESCRIPTION:
160 sDescription = sAttrValue;
161 bDescriptionOK = sal_True;
162 break;
163 case XML_TOK_TEXTFIELD_HELP:
164 sHelp = sAttrValue;
165 bHelpOK = true;
166 break;
167 case XML_TOK_TEXTFIELD_HINT:
168 sHint = sAttrValue;
169 bHintOK = true;
170 break;
171 case XML_TOK_TEXTFIELD_FORMULA:
172 {
173 OUString sTmp;
174 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
175 _GetKeyByAttrName( sAttrValue, &sTmp, sal_False );
176 if( XML_NAMESPACE_OOOW == nPrefix )
177 {
178 sFormula = sTmp;
179 bFormulaOK = sal_True;
180 }
181 else
182 sFormula = sAttrValue;
183 }
184 break;
185 case XML_TOK_TEXTFIELD_DISPLAY:
186 if (IsXMLToken(sAttrValue, XML_FORMULA))
187 {
188 bDisplayFormula = sal_True;
189 bDisplayNone = sal_False;
190 bDisplayOK = sal_True;
191 }
192 else if (IsXMLToken(sAttrValue, XML_VALUE))
193 {
194 bDisplayFormula = sal_False;
195 bDisplayNone = sal_False;
196 bDisplayOK = sal_True;
197 }
198 else if (IsXMLToken(sAttrValue, XML_NONE))
199 {
200 bDisplayFormula = sal_False;
201 bDisplayNone = sal_True;
202 bDisplayOK = sal_True;
203 } // else: no change
204 DBG_ASSERT(!(bDisplayFormula && bDisplayNone),
205 "illegal display values");
206 break;
207 default:
208 // delegate all others to value helper
209 aValueHelper.ProcessAttribute(nAttrToken, sAttrValue);
210 break;
211 }
212 }
213
PrepareField(const Reference<XPropertySet> & xPropertySet)214 void XMLVarFieldImportContext::PrepareField(
215 const Reference<XPropertySet> & xPropertySet)
216 {
217 // bSetName: not implemented
218
219 if (bSetFormula)
220 {
221 if (!bFormulaOK && bSetFormulaDefault)
222 {
223 sFormula = GetContent();
224 bFormulaOK = sal_True;
225 }
226
227 if (bFormulaOK)
228 {
229 Any aAny;
230 aAny <<= sFormula;
231 xPropertySet->setPropertyValue(sPropertyContent, aAny);
232 }
233 }
234
235 if (bSetDescription && bDescriptionOK)
236 {
237 Any aAny;
238 aAny <<= sDescription;
239 xPropertySet->setPropertyValue(sPropertyHint, aAny);
240 }
241
242 if (bSetHelp && bHelpOK)
243 {
244 Any aAny;
245 aAny <<= sHelp;
246 xPropertySet->setPropertyValue(sPropertyHelp, aAny);
247 }
248
249 if (bSetHint && bHintOK)
250 {
251 Any aAny;
252 aAny <<= sHint;
253 xPropertySet->setPropertyValue(sPropertyTooltip, aAny);
254 }
255
256 if (bSetVisible && bDisplayOK)
257 {
258 Any aAny;
259 sal_Bool bTmp = ! (bDisplayNone && bDisplayOK);
260 aAny.setValue( &bTmp, ::getBooleanCppuType());
261 xPropertySet->setPropertyValue(sPropertyIsVisible, aAny);
262 }
263
264 // workaround for #no-bug#: display formula by default
265 if (xPropertySet->getPropertySetInfo()->
266 hasPropertyByName(sPropertyIsDisplayFormula) &&
267 !bSetDisplayFormula)
268 {
269 bDisplayFormula = sal_False;
270 bSetDisplayFormula = sal_True;
271 }
272
273
274 if (bSetDisplayFormula)
275 {
276 Any aAny;
277 sal_Bool bTmp = bDisplayFormula && bDisplayOK;
278 aAny.setValue( &bTmp, ::getBooleanCppuType());
279 xPropertySet->setPropertyValue(sPropertyIsDisplayFormula, aAny);
280 }
281
282 // delegate to value helper
283 aValueHelper.SetDefault(GetContent());
284 aValueHelper.PrepareField(xPropertySet);
285
286 // finally, set the curren presentation
287 if (bSetPresentation)
288 {
289 Any aAny;
290 aAny <<= GetContent();
291 xPropertySet->setPropertyValue(sPropertyCurrentPresentation, aAny);
292 }
293 }
294
295
296
297
298
299 //
300 // variable set fields
301 //
302
303 TYPEINIT1( XMLSetVarFieldImportContext, XMLVarFieldImportContext );
304
XMLSetVarFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,const sal_Char * pServiceName,sal_uInt16 nPrfx,const OUString & rLocalName,VarType eVarType,sal_Bool bName,sal_Bool bFormula,sal_Bool bFormulaDefault,sal_Bool bDescription,sal_Bool bHelp,sal_Bool bHint,sal_Bool bVisible,sal_Bool bIsDisplayFormula,sal_Bool bType,sal_Bool bStyle,sal_Bool bValue,sal_Bool bPresentation)305 XMLSetVarFieldImportContext::XMLSetVarFieldImportContext(
306 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
307 const sal_Char* pServiceName, sal_uInt16 nPrfx,
308 const OUString& rLocalName, VarType eVarType,
309 sal_Bool bName, sal_Bool bFormula, sal_Bool bFormulaDefault,
310 sal_Bool bDescription, sal_Bool bHelp, sal_Bool bHint, sal_Bool bVisible, sal_Bool bIsDisplayFormula,
311 sal_Bool bType, sal_Bool bStyle, sal_Bool bValue, sal_Bool bPresentation) :
312 XMLVarFieldImportContext(rImport, rHlp, pServiceName,
313 nPrfx, rLocalName,
314 bName, bFormula, bFormulaDefault,
315 bDescription, bHelp, bHint, bVisible, bIsDisplayFormula,
316 bType, bStyle, bValue, bPresentation),
317 eFieldType(eVarType)
318 {
319 }
320
EndElement()321 void XMLSetVarFieldImportContext::EndElement()
322 {
323 // should we call PrepareField on the field, or rather on it's master?
324 // currently: call on field (just like superclass)
325 // possible alternatives: call on master
326 // call field or master depending on variable
327 // PrepareMaster() in addition to PrepareField()
328
329 DBG_ASSERT(GetServiceName().getLength()>0, "no service name for element!");
330
331 if (bValid)
332 {
333 DBG_ASSERT(GetName().getLength()>0, "variable name needed!");
334
335 // find field master
336 Reference<XPropertySet> xMaster;
337 if (FindFieldMaster(xMaster))
338 {
339 // create field/Service
340 Reference<XPropertySet> xPropSet;
341 if (CreateField(xPropSet, OUString::createFromAscii(sAPI_textfield_prefix) + GetServiceName()))
342 {
343 Reference<XDependentTextField> xDepTextField(xPropSet, UNO_QUERY);
344 if (xDepTextField.is())
345 {
346 // attach field to field master
347 xDepTextField->attachTextFieldMaster(xMaster);
348
349 // attach field to document
350 Reference<XTextContent> xTextContent(xPropSet, UNO_QUERY);
351 if (xTextContent.is())
352 {
353 try {
354 // insert, set field properties and exit!
355 GetImportHelper().InsertTextContent(xTextContent);
356 PrepareField(xPropSet);
357 } catch (lang::IllegalArgumentException & /*e*/)
358 {
359 // ignore e: #i54023#
360 };
361 return;
362 }
363 }
364 }
365 }
366 }
367
368 // above: exit on success; so for all error cases we end up here!
369 // write element content
370 GetImportHelper().InsertString(GetContent());
371 }
372
FindFieldMaster(Reference<XPropertySet> & xMaster)373 sal_Bool XMLSetVarFieldImportContext::FindFieldMaster(
374 Reference<XPropertySet> & xMaster)
375 {
376 // currently: delegate to XMLVariableDeclImportContext;
377 // shoud eventually go here
378 return XMLVariableDeclImportContext::FindFieldMaster(xMaster,
379 GetImport(),
380 GetImportHelper(),
381 GetName(),
382 eFieldType);
383 }
384
385
386
387 //
388 // sequence field
389 //
390
391 TYPEINIT1( XMLSequenceFieldImportContext, XMLSetVarFieldImportContext );
392
XMLSequenceFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)393 XMLSequenceFieldImportContext::XMLSequenceFieldImportContext(
394 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
395 sal_uInt16 nPrfx, const OUString& rLocalName) :
396 XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
397 nPrfx, rLocalName, VarTypeSequence,
398 // name, formula
399 sal_True, sal_True, sal_True,
400 sal_False, sal_False, sal_False, sal_False,
401 sal_False,
402 sal_False, sal_False, sal_False, sal_True),
403
404 sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)),
405 sPropertySequenceValue(RTL_CONSTASCII_USTRINGPARAM(sAPI_sequence_value)),
406 sNumFormat(OUString::valueOf(sal_Unicode('1'))),
407 sNumFormatSync(GetXMLToken(XML_FALSE)),
408 bRefNameOK(sal_False)
409 {
410 }
411
ProcessAttribute(sal_uInt16 nAttrToken,const OUString & sAttrValue)412 void XMLSequenceFieldImportContext::ProcessAttribute(
413 sal_uInt16 nAttrToken, const OUString& sAttrValue )
414 {
415 switch (nAttrToken)
416 {
417 case XML_TOK_TEXTFIELD_NUM_FORMAT:
418 sNumFormat = sAttrValue;
419 break;
420 case XML_TOK_TEXTFIELD_NUM_LETTER_SYNC:
421 sNumFormatSync = sAttrValue;
422 break;
423 case XML_TOK_TEXTFIELD_REF_NAME:
424 sRefName = sAttrValue;
425 bRefNameOK = sal_True;
426 break;
427 default:
428 // delegate to super class (name, formula)
429 XMLSetVarFieldImportContext::ProcessAttribute(nAttrToken,
430 sAttrValue);
431 break;
432 } // switch
433 }
434
PrepareField(const Reference<XPropertySet> & xPropertySet)435 void XMLSequenceFieldImportContext::PrepareField(
436 const Reference<XPropertySet> & xPropertySet)
437 {
438 // delegate to super class (formula)
439 XMLSetVarFieldImportContext::PrepareField(xPropertySet);
440
441 // set format
442 sal_Int16 nNumType = NumberingType::ARABIC;
443 GetImport().GetMM100UnitConverter().convertNumFormat( nNumType, sNumFormat, sNumFormatSync );
444 Any aAny;
445 aAny <<= nNumType;
446 xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny);
447
448 // handle reference name
449 if (bRefNameOK)
450 {
451 aAny = xPropertySet->getPropertyValue(sPropertySequenceValue);
452 sal_Int16 nValue = 0;
453 aAny >>= nValue;
454 GetImportHelper().InsertSequenceID(sRefName, GetName(), nValue);
455 }
456 }
457
458
459
460 //
461 // variable set field
462 //
463
464 TYPEINIT1( XMLVariableSetFieldImportContext, XMLSetVarFieldImportContext );
465
XMLVariableSetFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)466 XMLVariableSetFieldImportContext::XMLVariableSetFieldImportContext(
467 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
468 sal_uInt16 nPrfx, const OUString& rLocalName) :
469 XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
470 nPrfx, rLocalName, VarTypeSimple,
471 // name, formula, value&type, style,
472 // display none
473 sal_True, sal_True, sal_True,
474 sal_False, sal_False, sal_False,
475 sal_True, sal_False,
476 sal_True, sal_True, sal_True,
477 sal_True),
478 sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type))
479 {
480 }
481
PrepareField(const Reference<XPropertySet> & xPropertySet)482 void XMLVariableSetFieldImportContext::PrepareField(
483 const Reference<XPropertySet> & xPropertySet)
484 {
485 // set type
486 Any aAny;
487 aAny <<= (IsStringValue()? SetVariableType::STRING : SetVariableType::VAR);
488 xPropertySet->setPropertyValue(sPropertySubType, aAny);
489
490 // the remainder is handled by super class
491 XMLSetVarFieldImportContext::PrepareField(xPropertySet);
492 }
493
494
495
496 //
497 // variable input field
498 //
499
500 TYPEINIT1( XMLVariableInputFieldImportContext, XMLSetVarFieldImportContext );
501
XMLVariableInputFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)502 XMLVariableInputFieldImportContext::XMLVariableInputFieldImportContext(
503 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
504 const OUString& rLocalName) :
505 XMLSetVarFieldImportContext(rImport, rHlp, sAPI_set_expression,
506 nPrfx, rLocalName, VarTypeSimple,
507 // name, description, display none/formula,
508 // value&type, style, formula
509 sal_True, sal_True, sal_True,
510 sal_True, sal_True, sal_True,
511 sal_True, sal_False,
512 sal_True, sal_True, sal_True,
513 sal_True),
514 sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)),
515 sPropertyIsInput(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_input))
516 {
517 }
518
PrepareField(const Reference<XPropertySet> & xPropertySet)519 void XMLVariableInputFieldImportContext::PrepareField(
520 const Reference<XPropertySet> & xPropertySet)
521 {
522 // set type (input field)
523 Any aAny;
524 sal_Bool bTrue = sal_True;
525 aAny.setValue( &bTrue, ::getBooleanCppuType() );
526 xPropertySet->setPropertyValue(sPropertyIsInput, aAny);
527
528 // set type
529 aAny <<= (IsStringValue()? SetVariableType::STRING : SetVariableType::VAR);
530 xPropertySet->setPropertyValue(sPropertySubType, aAny);
531
532 // the remainder is handled by super class
533 XMLSetVarFieldImportContext::PrepareField(xPropertySet);
534 }
535
536
537
538 //
539 // user field
540 //
541
542 TYPEINIT1( XMLUserFieldImportContext, XMLSetVarFieldImportContext );
543
XMLUserFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)544 XMLUserFieldImportContext::XMLUserFieldImportContext(
545 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
546 sal_uInt16 nPrfx, const OUString& rLocalName) :
547 XMLSetVarFieldImportContext(rImport, rHlp, sAPI_user, nPrfx,
548 rLocalName, VarTypeUserField,
549 // name, display none/formula, style
550 sal_True, sal_False, sal_False,
551 sal_False, sal_False, sal_False, sal_True,
552 sal_True,
553 sal_False, sal_True, sal_False,
554 sal_False)
555 {
556 }
557
558
559
560 //
561 // user input field
562 //
563
564 TYPEINIT1( XMLUserFieldInputImportContext, XMLVarFieldImportContext );
565
566 // bug: doesn't work (SO API lacking)
XMLUserFieldInputImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)567 XMLUserFieldInputImportContext::XMLUserFieldInputImportContext(
568 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
569 const OUString& rLocalName) :
570 XMLVarFieldImportContext(rImport, rHlp, sAPI_input_user,
571 nPrfx, rLocalName,
572 // name, description, style
573 sal_True, sal_False, sal_False,
574 sal_True, sal_False, sal_False,
575 sal_False, sal_False,
576 sal_False /*???*/, sal_True, sal_False,
577 sal_False)
578 {
579 }
580
PrepareField(const Reference<XPropertySet> & xPropertySet)581 void XMLUserFieldInputImportContext::PrepareField(
582 const Reference<XPropertySet> & xPropertySet)
583 {
584 Any aAny;
585 aAny <<= GetName();
586 xPropertySet->setPropertyValue(sPropertyContent, aAny);
587
588 // delegate to super class
589 XMLVarFieldImportContext::PrepareField(xPropertySet);
590 }
591
592
593 //
594 // variable get field
595 //
596
597 TYPEINIT1( XMLVariableGetFieldImportContext, XMLVarFieldImportContext );
598
XMLVariableGetFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)599 XMLVariableGetFieldImportContext::XMLVariableGetFieldImportContext(
600 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
601 sal_uInt16 nPrfx, const OUString& rLocalName) :
602 XMLVarFieldImportContext(rImport, rHlp, sAPI_get_expression,
603 nPrfx, rLocalName,
604 // name, style, display formula
605 sal_True, sal_False, sal_False,
606 sal_False, sal_False, sal_False,
607 sal_False, sal_True,
608 sal_True, sal_True, sal_False,
609 sal_True),
610 sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type))
611 {
612 }
613
PrepareField(const Reference<XPropertySet> & xPropertySet)614 void XMLVariableGetFieldImportContext::PrepareField(
615 const Reference<XPropertySet> & xPropertySet)
616 {
617 // set name
618 Any aAny;
619 aAny <<= GetName();
620 xPropertySet->setPropertyValue(sPropertyContent, aAny);
621
622 // the remainder is handled by super class
623 XMLVarFieldImportContext::PrepareField(xPropertySet);
624 }
625
626
627
628 //
629 // expression field
630 //
631
632 TYPEINIT1( XMLExpressionFieldImportContext, XMLVarFieldImportContext );
633
XMLExpressionFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)634 XMLExpressionFieldImportContext::XMLExpressionFieldImportContext(
635 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
636 sal_uInt16 nPrfx, const OUString& rLocalName) :
637 XMLVarFieldImportContext(rImport, rHlp, sAPI_get_expression,
638 nPrfx, rLocalName,
639 // formula, type, style, display formula
640 sal_False, sal_True, sal_True,
641 sal_False, sal_False, sal_False,
642 sal_False, sal_True,
643 sal_True, sal_True, sal_False,
644 sal_True),
645 sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type))
646 {
647 bValid = sal_True; // always valid
648 }
649
650
PrepareField(const Reference<XPropertySet> & xPropertySet)651 void XMLExpressionFieldImportContext::PrepareField(
652 const Reference<XPropertySet> & xPropertySet)
653 {
654 sal_Int16 nSubType = SetVariableType::FORMULA;
655 Any aAny;
656 aAny <<= nSubType;
657 xPropertySet->setPropertyValue(sPropertySubType, aAny);
658
659 // delegate to super class
660 XMLVarFieldImportContext::PrepareField(xPropertySet);
661 }
662
663
664
665 //
666 // text input field
667 //
668
669 TYPEINIT1( XMLTextInputFieldImportContext, XMLVarFieldImportContext );
670
XMLTextInputFieldImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & sLocalName)671 XMLTextInputFieldImportContext::XMLTextInputFieldImportContext(
672 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
673 sal_uInt16 nPrfx, const OUString& sLocalName) :
674 XMLVarFieldImportContext(rImport, rHlp, sAPI_input,
675 nPrfx, sLocalName,
676 // description
677 sal_False, sal_False, sal_False,
678 sal_True, sal_True, sal_True,
679 sal_False, sal_False,
680 sal_False, sal_False, sal_False,
681 sal_False),
682 sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content))
683 {
684 bValid = sal_True; // always valid
685 }
686
PrepareField(const Reference<XPropertySet> & xPropertySet)687 void XMLTextInputFieldImportContext::PrepareField(
688 const Reference<XPropertySet> & xPropertySet)
689 {
690 XMLVarFieldImportContext::PrepareField(xPropertySet);
691
692 Any aAny;
693 aAny <<= GetContent();
694 xPropertySet->setPropertyValue(sPropertyContent, aAny);
695 }
696
697
698 //
699 // table formula field
700 //
701
702 TYPEINIT1( XMLTableFormulaImportContext, XMLTextFieldImportContext );
703
XMLTableFormulaImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)704 XMLTableFormulaImportContext::XMLTableFormulaImportContext(
705 SvXMLImport& rImport,
706 XMLTextImportHelper& rHlp,
707 sal_uInt16 nPrfx,
708 const OUString& rLocalName) :
709 XMLTextFieldImportContext(rImport, rHlp, sAPI_table_formula,
710 nPrfx, rLocalName),
711 sPropertyIsShowFormula(RTL_CONSTASCII_USTRINGPARAM("IsShowFormula")),
712 sPropertyCurrentPresentation(
713 RTL_CONSTASCII_USTRINGPARAM("CurrentPresentation")),
714 aValueHelper(rImport, rHlp, sal_False, sal_True, sal_False, sal_True),
715 sFormula(),
716 bIsShowFormula(sal_False)
717 {
718 }
719
~XMLTableFormulaImportContext()720 XMLTableFormulaImportContext::~XMLTableFormulaImportContext()
721 {
722 }
723
ProcessAttribute(sal_uInt16 nAttrToken,const OUString & sAttrValue)724 void XMLTableFormulaImportContext::ProcessAttribute(
725 sal_uInt16 nAttrToken,
726 const OUString& sAttrValue )
727 {
728 switch (nAttrToken)
729 {
730 case XML_TOK_TEXTFIELD_FORMULA:
731 aValueHelper.ProcessAttribute( nAttrToken, sAttrValue );
732 bValid = sal_True; // we need a formula!
733 break;
734
735 case XML_TOK_TEXTFIELD_DATA_STYLE_NAME:
736 aValueHelper.ProcessAttribute( nAttrToken, sAttrValue );
737 break;
738 case XML_TOK_TEXTFIELD_DISPLAY:
739 if ( sAttrValue.equalsAsciiL(
740 RTL_CONSTASCII_STRINGPARAM("formula")) )
741 bIsShowFormula = sal_True;
742 break;
743 default:
744 // unknown attribute -> ignore
745 break;
746 }
747 }
748
PrepareField(const Reference<XPropertySet> & xPropertySet)749 void XMLTableFormulaImportContext::PrepareField(
750 const Reference<XPropertySet> & xPropertySet)
751 {
752 // set format and formula
753 aValueHelper.PrepareField( xPropertySet );
754
755 Any aAny;
756
757 // set 'show formula' and presentation
758 aAny.setValue( &bIsShowFormula, ::getBooleanCppuType() );
759 xPropertySet->setPropertyValue( sPropertyIsShowFormula, aAny );
760
761 aAny <<= GetContent();
762 xPropertySet->setPropertyValue( sPropertyCurrentPresentation, aAny );
763 }
764
765
766
767 //
768 // variable declarations
769 //
770 // Should be adapted to XMLVarField-/XMLSetVarFieldImportContext scheme!
771 //
772
773
774
775 //
776 // declaration containter import (<variable/user-field/sequence-decls>)
777 //
778
779 TYPEINIT1( XMLVariableDeclsImportContext, SvXMLImportContext );
780
XMLVariableDeclsImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName,enum VarType eVarType)781 XMLVariableDeclsImportContext::XMLVariableDeclsImportContext(
782 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
783 const OUString& rLocalName, enum VarType eVarType) :
784 SvXMLImportContext(rImport, nPrfx, rLocalName),
785 eVarDeclsContextType(eVarType),
786 rImportHelper(rHlp)
787 {
788 }
789
CreateChildContext(sal_uInt16 nPrefix,const OUString & rLocalName,const Reference<xml::sax::XAttributeList> & xAttrList)790 SvXMLImportContext* XMLVariableDeclsImportContext::CreateChildContext(
791 sal_uInt16 nPrefix, const OUString& rLocalName,
792 const Reference<xml::sax::XAttributeList> & xAttrList )
793 {
794 enum XMLTokenEnum eElementName;
795 SvXMLImportContext* pImportContext = NULL;
796
797 if( XML_NAMESPACE_TEXT == nPrefix )
798 {
799 switch (eVarDeclsContextType)
800 {
801 case VarTypeSequence:
802 eElementName = XML_SEQUENCE_DECL;
803 break;
804 case VarTypeSimple:
805 eElementName = XML_VARIABLE_DECL;
806 break;
807 case VarTypeUserField:
808 eElementName = XML_USER_FIELD_DECL;
809 break;
810 default:
811 DBG_ERROR("unknown field type!");
812 eElementName = XML_SEQUENCE_DECL;
813 break;
814 }
815
816 if( IsXMLToken( rLocalName, eElementName ) )
817 {
818 pImportContext = new XMLVariableDeclImportContext(
819 GetImport(), rImportHelper, nPrefix, rLocalName, xAttrList,
820 eVarDeclsContextType);
821 }
822 }
823
824 // if no context was created, use default context
825 if (NULL == pImportContext) {
826 pImportContext = SvXMLImportContext::CreateChildContext(nPrefix,
827 rLocalName,
828 xAttrList);
829 }
830
831 return pImportContext;
832 }
833
834
835
836 //
837 // declaration import (<variable/user-field/sequence-decl> elements)
838 //
839
840 TYPEINIT1( XMLVariableDeclImportContext, SvXMLImportContext );
841
XMLVariableDeclImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName,const Reference<xml::sax::XAttributeList> & xAttrList,enum VarType eVarType)842 XMLVariableDeclImportContext::XMLVariableDeclImportContext(
843 SvXMLImport& rImport, XMLTextImportHelper& rHlp,
844 sal_uInt16 nPrfx, const OUString& rLocalName,
845 const Reference<xml::sax::XAttributeList> & xAttrList,
846 enum VarType eVarType) :
847 SvXMLImportContext(rImport, nPrfx, rLocalName),
848 // bug?? which properties for userfield/userfieldmaster
849 sPropertyName(RTL_CONSTASCII_USTRINGPARAM(sAPI_name)),
850 sPropertySubType(RTL_CONSTASCII_USTRINGPARAM(sAPI_sub_type)),
851 sPropertyNumberingLevel(RTL_CONSTASCII_USTRINGPARAM(sAPI_chapter_numbering_level)),
852 sPropertyNumberingSeparator(RTL_CONSTASCII_USTRINGPARAM(sAPI_numbering_separator)),
853 sPropertyIsExpression(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_expression)),
854 aValueHelper(rImport, rHlp, sal_True, sal_False, sal_True, sal_False),
855 nNumLevel(-1), cSeparationChar('.')
856 {
857 if ( (XML_NAMESPACE_TEXT == nPrfx) &&
858 ( ( IsXMLToken( rLocalName, XML_SEQUENCE_DECL )) ||
859 ( IsXMLToken( rLocalName, XML_VARIABLE_DECL)) ||
860 ( IsXMLToken( rLocalName, XML_USER_FIELD_DECL)) )) {
861
862 // TODO: check validity (need name!)
863
864 // parse attributes
865 sal_Int16 nLength = xAttrList->getLength();
866 for(sal_Int16 i=0; i<nLength; i++) {
867
868 OUString sLocalName;
869 sal_uInt16 nPrefix = GetImport().GetNamespaceMap().
870 GetKeyByAttrName( xAttrList->getNameByIndex(i), &sLocalName );
871
872 sal_uInt16 nToken = rHlp.
873 GetTextFieldAttrTokenMap().Get(nPrefix, sLocalName);
874
875 switch (nToken)
876 {
877 case XML_TOK_TEXTFIELD_NAME:
878 sName = xAttrList->getValueByIndex(i);
879 break;
880 case XML_TOK_TEXTFIELD_NUMBERING_LEVEL:
881 {
882 sal_Int32 nLevel;
883 sal_Bool bRet = SvXMLUnitConverter::convertNumber(
884 nLevel, xAttrList->getValueByIndex(i), 0,
885 GetImport().GetTextImport()->GetChapterNumbering()->
886 getCount());
887 if (bRet)
888 {
889 nNumLevel = static_cast< sal_Int8 >( nLevel-1 ); // API numbers -1..9
890 }
891 break;
892 }
893 case XML_TOK_TEXTFIELD_NUMBERING_SEPARATOR:
894 cSeparationChar =
895 (sal_Char)xAttrList->getValueByIndex(i).toChar();
896 break;
897
898 default:
899 // delegate to value helper
900 aValueHelper.ProcessAttribute(nToken,
901 xAttrList->getValueByIndex(i));
902 break;
903 }
904 }
905
906 Reference<XPropertySet> xFieldMaster;
907 if (FindFieldMaster(xFieldMaster, GetImport(), rHlp,
908 sName, eVarType))
909 {
910 // now we have a field master: process attributes!
911 Any aAny;
912
913 switch (eVarType)
914 {
915 case VarTypeSequence:
916 aAny <<= nNumLevel;
917 xFieldMaster->setPropertyValue(sPropertyNumberingLevel, aAny);
918
919 if (nNumLevel >= 0)
920 {
921 OUString sStr(&cSeparationChar, 1);
922 aAny <<= sStr;
923 xFieldMaster->setPropertyValue(
924 sPropertyNumberingSeparator, aAny);
925 }
926 break;
927 case VarTypeSimple:
928 {
929 // set string or non-string SubType (#93192#)
930 // The SubType was already set in the FindFieldMaster
931 // method, but it needs to be adjusted if it's a string.
932 aAny <<= aValueHelper.IsStringValue()
933 ? SetVariableType::STRING : SetVariableType::VAR;
934 xFieldMaster->setPropertyValue(sPropertySubType, aAny);
935 }
936 break;
937 case VarTypeUserField:
938 {
939 sal_Bool bTmp = !aValueHelper.IsStringValue();
940 aAny.setValue(&bTmp, ::getBooleanCppuType());
941 xFieldMaster->setPropertyValue(sPropertyIsExpression, aAny);
942 aValueHelper.PrepareField(xFieldMaster);
943 break;
944 }
945 default:
946 DBG_ERROR("unkown varfield type");
947 } // switch
948 } // else: no field master found/constructed
949 } // else: no sequence-decl
950 }
951
952
953
FindFieldMaster(Reference<XPropertySet> & xMaster,SvXMLImport & rImport,XMLTextImportHelper & rImportHelper,const OUString & sVarName,enum VarType eVarType)954 sal_Bool XMLVariableDeclImportContext::FindFieldMaster(
955 Reference<XPropertySet> & xMaster, SvXMLImport& rImport,
956 XMLTextImportHelper& rImportHelper,
957 const OUString& sVarName, enum VarType eVarType)
958 {
959 static sal_Int32 nCollisionCount = 0;
960
961 // rename field
962 // currently: no family in use! Use 0.
963 OUString sName = rImportHelper.GetRenameMap().Get(
964 sal::static_int_cast< sal_uInt16 >(eVarType), sVarName);
965
966 // get text fields supplier and field masters
967 Reference<XTextFieldsSupplier> xTextFieldsSupp(rImport.GetModel(),
968 UNO_QUERY);
969 Reference<container::XNameAccess> xFieldMasterNameAccess(
970 xTextFieldsSupp->getTextFieldMasters(), UNO_QUERY);
971
972 OUStringBuffer sBuffer;
973 sBuffer.appendAscii(sAPI_fieldmaster_prefix);
974 sBuffer.appendAscii(sAPI_set_expression);
975 sBuffer.appendAscii(".");
976 sBuffer.append(sName);
977 OUString sVarServiceName = sBuffer.makeStringAndClear();
978
979 sBuffer.appendAscii(sAPI_fieldmaster_prefix);
980 sBuffer.appendAscii(sAPI_user);
981 sBuffer.appendAscii(".");
982 sBuffer.append(sName);
983 OUString sUserServiceName = sBuffer.makeStringAndClear();
984
985 if (xFieldMasterNameAccess->hasByName(sVarServiceName)) {
986 // variable field master already in document
987
988 Any aAny = xFieldMasterNameAccess->getByName(sVarServiceName);
989 aAny >>= xMaster;
990
991 aAny = xMaster->getPropertyValue(
992 // sPropertySubType
993 OUString::createFromAscii(sAPI_sub_type)
994 );
995 sal_Int16 nType = 0;
996 aAny >>= nType;
997
998 enum VarType eFMVarType =
999 (SetVariableType::SEQUENCE == nType) ?
1000 VarTypeSequence : VarTypeSimple;
1001
1002 if (eFMVarType != eVarType)
1003 {
1004 OUString sNew;
1005
1006 // FIXME! cant find if name is taken already!!!!
1007
1008 nCollisionCount++;
1009 OUStringBuffer aBuf;
1010 aBuf.append(sName);
1011 aBuf.appendAscii("_renamed_");
1012 aBuf.append(nCollisionCount);
1013 sNew = aBuf.makeStringAndClear();
1014
1015 rImportHelper.GetRenameMap().Add(
1016 sal::static_int_cast< sal_uInt16 >(eVarType), sName, sNew);
1017
1018 // call FindFieldMaster recursively to create new master
1019 return FindFieldMaster(xMaster, rImport, rImportHelper,
1020 sNew, eVarType);
1021 }
1022 } else if (xFieldMasterNameAccess->hasByName(sUserServiceName)) {
1023 // user field: get field master
1024 Any aAny = xFieldMasterNameAccess->getByName(sUserServiceName);
1025 aAny >>= xMaster;
1026
1027 if (VarTypeUserField != eVarType) {
1028 // find new name that is not taken
1029 OUString sNew;
1030
1031 // FIXME! cant find if name is taken already!!!!
1032
1033 nCollisionCount++;
1034 OUStringBuffer aBuf;
1035 aBuf.append(sName);
1036 aBuf.appendAscii("_renamed_");
1037 aBuf.append(nCollisionCount);
1038 sNew = aBuf.makeStringAndClear();
1039
1040 rImportHelper.GetRenameMap().Add(
1041 sal::static_int_cast< sal_uInt16 >(eVarType), sName, sNew);
1042
1043 // call FindFieldMaster recursively to create new master
1044 return FindFieldMaster(xMaster, rImport, rImportHelper,
1045 sNew, eVarType);
1046 }
1047 } else {
1048 // field name not used: create field master
1049
1050 // import -> model is MultiServiceFactory -> createInstance
1051 Reference<lang::XMultiServiceFactory>
1052 xFactory(rImport.GetModel(),UNO_QUERY);
1053 if( xFactory.is() ) {
1054
1055 OUStringBuffer sService;
1056 sService.appendAscii(sAPI_fieldmaster_prefix);
1057 sService.appendAscii((eVarType==VarTypeUserField) ?
1058 sAPI_user : sAPI_set_expression);
1059 Reference<XInterface> xIfc =
1060 xFactory->createInstance( sService.makeStringAndClear() );
1061 if (xIfc.is()) {
1062 Reference<XPropertySet> xTmp( xIfc, UNO_QUERY );
1063 xMaster = xTmp;
1064
1065 // set name
1066 Any aAny;
1067 aAny <<= sName;
1068 xMaster->setPropertyValue(
1069 // sPropertyName
1070 OUString::createFromAscii(sAPI_name)
1071 , aAny);
1072
1073 if (eVarType != VarTypeUserField) {
1074 // set subtype for setexp field
1075
1076 aAny <<= ((eVarType == VarTypeSimple) ?
1077 SetVariableType::VAR :
1078 SetVariableType::SEQUENCE);
1079 xMaster->setPropertyValue(
1080 // sPropertySubType
1081 OUString::createFromAscii(sAPI_sub_type)
1082 , aAny);
1083 } // else : user field: no subtype
1084
1085 } else {
1086 return sal_False;
1087 }
1088 } else {
1089 return sal_False;
1090 }
1091 }
1092
1093 DBG_ASSERT(xMaster.is(), "no field master found!?!");
1094 return sal_True;
1095 }
1096
1097
1098 //
1099 // Database Display field import
1100 //
1101
1102
1103 TYPEINIT1( XMLDatabaseDisplayImportContext, XMLDatabaseFieldImportContext );
1104
XMLDatabaseDisplayImportContext(SvXMLImport & rImport,XMLTextImportHelper & rHlp,sal_uInt16 nPrfx,const OUString & rLocalName)1105 XMLDatabaseDisplayImportContext::XMLDatabaseDisplayImportContext(
1106 SvXMLImport& rImport, XMLTextImportHelper& rHlp, sal_uInt16 nPrfx,
1107 const OUString& rLocalName) :
1108 XMLDatabaseFieldImportContext(rImport, rHlp, sAPI_database,
1109 nPrfx, rLocalName, false),
1110 sPropertyColumnName(RTL_CONSTASCII_USTRINGPARAM(sAPI_data_column_name)),
1111 sPropertyDatabaseFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_data_base_format)),
1112 sPropertyCurrentPresentation(RTL_CONSTASCII_USTRINGPARAM(sAPI_current_presentation)),
1113 sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_visible)),
1114 aValueHelper(rImport, rHlp, sal_False, sal_True, sal_False, sal_False),
1115 bColumnOK(sal_False),
1116 bDisplay( sal_True ),
1117 bDisplayOK( sal_False )
1118 {
1119 }
1120
ProcessAttribute(sal_uInt16 nAttrToken,const OUString & sAttrValue)1121 void XMLDatabaseDisplayImportContext::ProcessAttribute(
1122 sal_uInt16 nAttrToken, const OUString& sAttrValue )
1123 {
1124 switch (nAttrToken)
1125 {
1126 case XML_TOK_TEXTFIELD_COLUMN_NAME:
1127 sColumnName = sAttrValue;
1128 bColumnOK = sal_True;
1129 break;
1130 case XML_TOK_TEXTFIELD_DISPLAY:
1131 {
1132 sal_Bool bNone = IsXMLToken( sAttrValue, XML_NONE );
1133 sal_Bool bValue = IsXMLToken( sAttrValue, XML_VALUE );
1134 bDisplay = bValue;
1135 bDisplayOK = bNone || bValue;
1136 }
1137 break;
1138 case XML_TOK_TEXTFIELD_DATABASE_NAME:
1139 case XML_TOK_TEXTFIELD_TABLE_NAME:
1140 case XML_TOK_TEXTFIELD_TABLE_TYPE:
1141 // handled by super class
1142 XMLDatabaseFieldImportContext::ProcessAttribute(nAttrToken,
1143 sAttrValue);
1144 break;
1145 default:
1146 // remainder handled by value helper
1147 aValueHelper.ProcessAttribute(nAttrToken, sAttrValue);
1148 break;
1149 }
1150
1151 bValid = bTableOK && bDatabaseOK && bColumnOK;
1152 }
1153
EndElement()1154 void XMLDatabaseDisplayImportContext::EndElement()
1155 {
1156 // we have an EndElement of our own, because database fields need
1157 // to be attached to a field master before they can be inserted into
1158 // the document. Database stuff (database, table, column) all goes
1159 // to the field master, value & style go to the field.
1160
1161 if (bValid)
1162 {
1163
1164 // so here goes: we start with the master
1165 Reference<XPropertySet> xMaster;
1166
1167 // create and prepare field master first
1168 if (CreateField(xMaster,
1169 OUString(RTL_CONSTASCII_USTRINGPARAM(
1170 sAPI_fieldmaster_database))))
1171 {
1172 Any aAny;
1173 aAny <<= sColumnName;
1174 xMaster->setPropertyValue(sPropertyColumnName, aAny);
1175
1176 // fieldmaster takes database, table and column name
1177 XMLDatabaseFieldImportContext::PrepareField(xMaster);
1178
1179 // create field
1180 Reference<XPropertySet> xField;
1181 if (CreateField(xField,
1182 OUString(RTL_CONSTASCII_USTRINGPARAM(
1183 sAPI_database))))
1184 {
1185 // attach field master
1186 Reference<XDependentTextField> xDepField(xField, UNO_QUERY);
1187 if (xDepField.is())
1188 {
1189 // attach field to field master
1190 xDepField->attachTextFieldMaster(xMaster);
1191
1192 // attach field to document
1193 Reference<XTextContent> xTextContent(xField, UNO_QUERY);
1194 if (xTextContent.is())
1195 {
1196 // insert, set field properties and exit!
1197 GetImportHelper().InsertTextContent(xTextContent);
1198
1199 // prepare field: format from database?
1200 sal_Bool bTmp = !aValueHelper.IsFormatOK();
1201 aAny.setValue( &bTmp, ::getBooleanCppuType() );
1202 xField->setPropertyValue(sPropertyDatabaseFormat,aAny);
1203
1204 // value, value-type and format done by value helper
1205 aValueHelper.PrepareField(xField);
1206
1207 // visibility
1208 if( bDisplayOK )
1209 {
1210 aAny.setValue( &bDisplay, ::getBooleanCppuType() );
1211 xField->setPropertyValue(sPropertyIsVisible, aAny);
1212 }
1213
1214 // set presentation
1215 aAny <<= GetContent();
1216 xField->setPropertyValue(sPropertyCurrentPresentation,
1217 aAny);
1218
1219 // success!
1220 return;
1221 }
1222 }
1223 }
1224 }
1225 }
1226
1227 // above: exit on success; so for all error cases we end up here!
1228 // write element content
1229 GetImportHelper().InsertString(GetContent());
1230 }
1231
1232
1233 //
1234 // value import helper
1235 //
1236
1237 enum ValueType
1238 {
1239 XML_VALUE_TYPE_STRING,
1240 XML_VALUE_TYPE_FLOAT,
1241 XML_VALUE_TYPE_CURRENCY,
1242 XML_VALUE_TYPE_PERCENTAGE,
1243 XML_VALUE_TYPE_DATE,
1244 XML_VALUE_TYPE_TIME,
1245 XML_VALUE_TYPE_BOOLEAN
1246 };
1247
1248 static SvXMLEnumMapEntry __READONLY_DATA aValueTypeMap[] =
1249 {
1250 { XML_FLOAT, XML_VALUE_TYPE_FLOAT },
1251 { XML_CURRENCY, XML_VALUE_TYPE_CURRENCY },
1252 { XML_PERCENTAGE, XML_VALUE_TYPE_PERCENTAGE },
1253 { XML_DATE, XML_VALUE_TYPE_DATE },
1254 { XML_TIME, XML_VALUE_TYPE_TIME },
1255 { XML_BOOLEAN, XML_VALUE_TYPE_BOOLEAN },
1256 { XML_STRING, XML_VALUE_TYPE_STRING },
1257 { XML_TOKEN_INVALID, 0 }
1258 };
1259
XMLValueImportHelper(SvXMLImport & rImprt,XMLTextImportHelper & rHlp,sal_Bool bType,sal_Bool bStyle,sal_Bool bValue,sal_Bool bFormula)1260 XMLValueImportHelper::XMLValueImportHelper(
1261 SvXMLImport& rImprt,
1262 XMLTextImportHelper& rHlp,
1263 sal_Bool bType, sal_Bool bStyle, sal_Bool bValue, sal_Bool bFormula) :
1264 sPropertyContent(RTL_CONSTASCII_USTRINGPARAM(sAPI_content)),
1265 sPropertyValue(RTL_CONSTASCII_USTRINGPARAM(sAPI_value)),
1266 sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM(sAPI_number_format)),
1267 sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM(sAPI_is_fixed_language)),
1268
1269 rImport(rImprt),
1270 rHelper(rHlp),
1271
1272 fValue(0.0),
1273 nFormatKey(0),
1274 bIsDefaultLanguage(sal_True),
1275
1276 bStringType(sal_False),
1277 bFormatOK(sal_False),
1278 bTypeOK(sal_False),
1279 bStringValueOK(sal_False),
1280 bFloatValueOK(sal_False),
1281 bFormulaOK(sal_False),
1282
1283 bSetType(bType),
1284 bSetValue(bValue),
1285 bSetStyle(bStyle),
1286 bSetFormula(bFormula),
1287
1288 bStringDefault(sal_True),
1289 bFormulaDefault(sal_True)
1290 {
1291 }
1292
~XMLValueImportHelper()1293 XMLValueImportHelper::~XMLValueImportHelper()
1294 {
1295 }
1296
ProcessAttribute(sal_uInt16 nAttrToken,const OUString & sAttrValue)1297 void XMLValueImportHelper::ProcessAttribute(
1298 sal_uInt16 nAttrToken, const OUString& sAttrValue )
1299 {
1300 switch (nAttrToken)
1301 {
1302 case XML_TOK_TEXTFIELD_VALUE_TYPE:
1303 {
1304 // convert enum
1305 sal_uInt16 nTmp = 0;
1306 sal_Bool bRet = SvXMLUnitConverter::convertEnum(
1307 nTmp, sAttrValue, aValueTypeMap);
1308
1309 if (bRet) {
1310 ValueType eValueType = (ValueType)nTmp;
1311
1312 bTypeOK = sal_True;
1313
1314 switch (eValueType)
1315 {
1316 case XML_VALUE_TYPE_STRING:
1317 bStringType = sal_True;
1318 break;
1319 case XML_VALUE_TYPE_FLOAT:
1320 case XML_VALUE_TYPE_CURRENCY:
1321 case XML_VALUE_TYPE_PERCENTAGE:
1322 case XML_VALUE_TYPE_DATE:
1323 case XML_VALUE_TYPE_TIME:
1324 case XML_VALUE_TYPE_BOOLEAN:
1325 bStringType = sal_False;
1326 break;
1327
1328 default:
1329 DBG_ERROR("unknown value type");
1330 bTypeOK = sal_False;
1331 }
1332 }
1333 break;
1334 }
1335
1336 case XML_TOK_TEXTFIELD_VALUE:
1337 {
1338 double fTmp;
1339 sal_Bool bRet = SvXMLUnitConverter::convertDouble(fTmp,sAttrValue);
1340 if (bRet) {
1341 bFloatValueOK = sal_True;
1342 fValue = fTmp;
1343 }
1344 break;
1345 }
1346
1347 case XML_TOK_TEXTFIELD_TIME_VALUE:
1348 {
1349 double fTmp;
1350 sal_Bool bRet = SvXMLUnitConverter::convertTime(fTmp,sAttrValue);
1351 if (bRet) {
1352 bFloatValueOK = sal_True;
1353 fValue = fTmp;
1354 }
1355 break;
1356 }
1357
1358 case XML_TOK_TEXTFIELD_DATE_VALUE:
1359 {
1360 double fTmp;
1361 sal_Bool bRet = rImport.GetMM100UnitConverter().
1362 convertDateTime(fTmp,sAttrValue);
1363 if (bRet) {
1364 bFloatValueOK = sal_True;
1365 fValue = fTmp;
1366 }
1367 break;
1368 }
1369
1370 case XML_TOK_TEXTFIELD_BOOL_VALUE:
1371 {
1372 sal_Bool bTmp;
1373 sal_Bool bRet = SvXMLUnitConverter::convertBool(bTmp,sAttrValue);
1374 if (bRet) {
1375 bFloatValueOK = sal_True;
1376 fValue = (bTmp ? 1.0 : 0.0);
1377 }
1378 else
1379 {
1380 double fTmp;
1381 bRet = SvXMLUnitConverter::convertDouble(fTmp,sAttrValue);
1382 if (bRet) {
1383 bFloatValueOK = sal_True;
1384 fValue = fTmp;
1385 }
1386 }
1387 break;
1388 }
1389
1390 case XML_TOK_TEXTFIELD_STRING_VALUE:
1391 sValue = sAttrValue;
1392 bStringValueOK = sal_True;
1393 break;
1394
1395 case XML_TOK_TEXTFIELD_FORMULA:
1396 {
1397 OUString sTmp;
1398 sal_uInt16 nPrefix = rImport.GetNamespaceMap().
1399 _GetKeyByAttrName( sAttrValue, &sTmp, sal_False );
1400 if( XML_NAMESPACE_OOOW == nPrefix )
1401 {
1402 sFormula = sTmp;
1403 bFormulaOK = sal_True;
1404 }
1405 else
1406 sFormula = sAttrValue;
1407 }
1408 break;
1409
1410 case XML_TOK_TEXTFIELD_DATA_STYLE_NAME:
1411 {
1412 sal_Int32 nKey = rHelper.GetDataStyleKey(
1413 sAttrValue, &bIsDefaultLanguage);
1414 if (-1 != nKey)
1415 {
1416 nFormatKey = nKey;
1417 bFormatOK = sal_True;
1418 }
1419 break;
1420 }
1421 } // switch
1422 }
1423
PrepareField(const Reference<XPropertySet> & xPropertySet)1424 void XMLValueImportHelper::PrepareField(
1425 const Reference<XPropertySet> & xPropertySet)
1426 {
1427 Any aAny;
1428
1429 if (bSetType)
1430 {
1431 // ??? how to set type?
1432 }
1433
1434 if (bSetFormula)
1435 {
1436 aAny <<= (!bFormulaOK && bFormulaDefault) ? sDefault : sFormula;
1437 xPropertySet->setPropertyValue(sPropertyContent, aAny);
1438 }
1439
1440 // format/style
1441 if (bSetStyle && bFormatOK)
1442 {
1443 aAny <<= nFormatKey;
1444 xPropertySet->setPropertyValue(sPropertyNumberFormat, aAny);
1445
1446 if( xPropertySet->getPropertySetInfo()->
1447 hasPropertyByName( sPropertyIsFixedLanguage ) )
1448 {
1449 sal_Bool bIsFixedLanguage = ! bIsDefaultLanguage;
1450 aAny.setValue( &bIsFixedLanguage, ::getBooleanCppuType() );
1451 xPropertySet->setPropertyValue( sPropertyIsFixedLanguage, aAny );
1452 }
1453 }
1454
1455 // value: string or float
1456 if (bSetValue)
1457 {
1458 if (bStringType)
1459 {
1460 aAny <<= (!bStringValueOK && bStringDefault) ? sDefault : sValue;
1461 xPropertySet->setPropertyValue(sPropertyContent, aAny);
1462 }
1463 else
1464 {
1465 aAny <<= fValue;
1466 xPropertySet->setPropertyValue(sPropertyValue, aAny);
1467 }
1468 }
1469 }
1470
1471