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