xref: /trunk/main/xmloff/source/text/txtvfldi.cxx (revision 86e1cf34)
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("unknown 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! can't 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! can't 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