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