?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix baseline build (old cairo) - 'cairo_rectangle_int_t' does not name a type
[LibreOffice.git] / sc / source / filter / xml / xmlcelli.cxx
blob997275a0a288feb81221844d8c58f64b61882aef
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 #include "xmlcelli.hxx"
21 #include "xmlimprt.hxx"
22 #include "xmltabi.hxx"
23 #include "xmlstyli.hxx"
24 #include "xmlannoi.hxx"
25 #include "global.hxx"
26 #include "document.hxx"
27 #include "cellsuno.hxx"
28 #include "docuno.hxx"
29 #include "unonames.hxx"
30 #include "postit.hxx"
31 #include "sheetdata.hxx"
32 #include "docsh.hxx"
33 #include "cellform.hxx"
34 #include "validat.hxx"
35 #include "patattr.hxx"
36 #include "scitems.hxx"
37 #include "docpool.hxx"
38
39 #include "XMLTableShapeImportHelper.hxx"
40 #include "XMLStylesImportHelper.hxx"
41 #include "celltextparacontext.hxx"
42
43 #include "arealink.hxx"
44 #include <sfx2/linkmgr.hxx>
45 #include "convuno.hxx"
46 #include "XMLConverter.hxx"
47 #include "scerrors.hxx"
48 #include "editutil.hxx"
49 #include "formulacell.hxx"
50 #include "editattributemap.hxx"
51 #include "stringutil.hxx"
52 #include "tokenarray.hxx"
53 #include "scmatrix.hxx"
54 #include "documentimport.hxx"
55 #include <datastream.hxx>
56 #include <rangeutl.hxx>
57
58 #include <xmloff/xmltkmap.hxx>
59 #include <xmloff/xmltoken.hxx>
60 #include <xmloff/nmspmap.hxx>
61 #include <xmloff/xmluconv.hxx>
62 #include <xmloff/families.hxx>
63 #include <xmloff/numehelp.hxx>
64 #include <xmloff/xmlnmspe.hxx>
65 #include <xmloff/prstylei.hxx>
66 #include <svl/zforlist.hxx>
67 #include <svx/svdocapt.hxx>
68 #include <editeng/outlobj.hxx>
69 #include <editeng/editobj.hxx>
70 #include <editeng/wghtitem.hxx>
71 #include <editeng/colritem.hxx>
72 #include <editeng/fhgtitem.hxx>
73 #include <editeng/postitem.hxx>
74 #include <editeng/fontitem.hxx>
75 #include <editeng/udlnitem.hxx>
76 #include <editeng/wrlmitem.hxx>
77 #include <editeng/crossedoutitem.hxx>
78 #include <editeng/charreliefitem.hxx>
79 #include <editeng/charscaleitem.hxx>
80 #include <editeng/contouritem.hxx>
81 #include <editeng/shdditem.hxx>
82 #include <editeng/kernitem.hxx>
83 #include <editeng/autokernitem.hxx>
84 #include <editeng/escapementitem.hxx>
85 #include <editeng/emphasismarkitem.hxx>
86 #include <editeng/langitem.hxx>
87 #include <svx/unoapi.hxx>
88 #include <svl/languageoptions.hxx>
89 #include <svl/sharedstringpool.hxx>
90 #include <svtools/miscopt.hxx>
91 #include <sax/tools/converter.hxx>
92
93 #include <com/sun/star/frame/XModel.hpp>
94 #include <com/sun/star/text/XText.hpp>
95 #include <com/sun/star/sheet/XSpreadsheets.hpp>
96 #include <com/sun/star/sheet/XSpreadsheet.hpp>
97 #include <com/sun/star/sheet/XCellRangeAddressable.hpp>
98
99 #include <com/sun/star/sheet/XSheetCondition.hpp>
100 #include <com/sun/star/table/XCellRange.hpp>
101 #include <com/sun/star/table/CellAddress.hpp>
102 #include <com/sun/star/util/NumberFormat.hpp>
103 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
104 #include <com/sun/star/util/XNumberFormatTypes.hpp>
105 #include <com/sun/star/util/Date.hpp>
106 #include <com/sun/star/lang/Locale.hpp>
107 #include <com/sun/star/text/ControlCharacter.hpp>
108 #include <com/sun/star/table/XCell.hpp>
109 #include <com/sun/star/document/XActionLockable.hpp>
110
111 #include <com/sun/star/sheet/ValidationType.hpp>
112 #include <com/sun/star/sheet/ValidationAlertStyle.hpp>
113 #include <com/sun/star/sheet/ConditionOperator.hpp>
114
115 #include <rtl/ustrbuf.hxx>
116 #include <tools/date.hxx>
117 #include <i18nlangtag/lang.h>
118 #include <comphelper/extract.hxx>
119
120 using namespace com::sun::star;
121 using namespace xmloff::token;
122
123 ScXMLTableRowCellContext::ParaFormat::ParaFormat(ScEditEngineDefaulter& rEditEngine) :
124 maItemSet(rEditEngine.GetEmptyItemSet()) {}
125
126 ScXMLTableRowCellContext::Field::Field(SvxFieldData* pData) : mpData(pData) {}
127
128 ScXMLTableRowCellContext::Field::~Field()
129 {
130 delete mpData;
131 }
132
133 ScXMLTableRowCellContext::ScXMLTableRowCellContext( ScXMLImport& rImport,
134 sal_uInt16 nPrfx,
135 const OUString& rLName,
136 const ::com::sun::star::uno::Reference<
137 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
138 const bool bTempIsCovered,
139 const sal_Int32 nTempRepeatedRows ) :
140 ScXMLImportContext(rImport, nPrfx, rLName),
141 mpEditEngine(GetScImport().GetEditEngine()),
142 mnCurParagraph(0),
143 pDetectiveObjVec(NULL),
144 pCellRangeSource(NULL),
145 fValue(0.0),
146 nMergedRows(1),
147 nMatrixRows(0),
148 nRepeatedRows(nTempRepeatedRows),
149 nMergedCols(1),
150 nMatrixCols(0),
151 nColsRepeated(1),
152 rXMLImport((ScXMLImport&)rImport),
153 eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
154 nCellType(util::NumberFormat::TEXT),
155 bIsMerged(false),
156 bIsMatrix(false),
157 bIsCovered(bTempIsCovered),
158 bIsEmpty(true),
159 mbNewValueType(false),
160 mbErrorValue(false),
161 bIsFirstTextImport(false),
162 bSolarMutexLocked(false),
163 bFormulaTextResult(false),
164 mbPossibleErrorCell(false),
165 mbCheckWithCompilerForError(false),
166 mbEditEngineHasText(false),
167 mbHasFormatRuns(false),
168 mbHasStyle(false)
169 {
170 rtl::math::setNan(&fValue); // NaN by default
171
172 rXMLImport.SetRemoveLastChar(false);
173 rXMLImport.GetTables().AddColumn(bTempIsCovered);
174 const sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
175 OUString aLocalName;
176 OUString* pStyleName = NULL;
177 OUString* pCurrencySymbol = NULL;
178 const SvXMLTokenMap& rTokenMap = rImport.GetTableRowCellAttrTokenMap();
179 for (sal_Int16 i = 0; i < nAttrCount; ++i)
180 {
181 sal_uInt16 nAttrPrefix = rImport.GetNamespaceMap().GetKeyByAttrName(
182 xAttrList->getNameByIndex(i), &aLocalName);
183
184 const OUString& sValue = xAttrList->getValueByIndex(i);
185 sal_uInt16 nToken = rTokenMap.Get(nAttrPrefix, aLocalName);
186 switch (nToken)
187 {
188 case XML_TOK_TABLE_ROW_CELL_ATTR_STYLE_NAME:
189 pStyleName = new OUString(sValue);
190 mbHasStyle = true;
191 break;
192 case XML_TOK_TABLE_ROW_CELL_ATTR_CONTENT_VALIDATION_NAME:
193 OSL_ENSURE(!maContentValidationName, "here should be only one Validation Name");
194 if (!sValue.isEmpty())
195 maContentValidationName.reset(sValue);
196 break;
197 case XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_ROWS:
198 bIsMerged = true;
199 nMergedRows = static_cast<SCROW>(sValue.toInt32());
200 break;
201 case XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_COLS:
202 bIsMerged = true;
203 nMergedCols = static_cast<SCCOL>(sValue.toInt32());
204 break;
205 case XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_COLS:
206 bIsMatrix = true;
207 nMatrixCols = static_cast<SCCOL>(sValue.toInt32());
208 break;
209 case XML_TOK_TABLE_ROW_CELL_ATTR_SPANNED_MATRIX_ROWS:
210 bIsMatrix = true;
211 nMatrixRows = static_cast<SCROW>(sValue.toInt32());
212 break;
213 case XML_TOK_TABLE_ROW_CELL_ATTR_REPEATED:
214 nColsRepeated = static_cast<SCCOL>(std::min<sal_Int32>( MAXCOLCOUNT,
215 std::max( sValue.toInt32(), static_cast<sal_Int32>(1) ) ));
216 break;
217 case XML_TOK_TABLE_ROW_CELL_ATTR_VALUE_TYPE:
218 nCellType = GetScImport().GetCellType(sValue);
219 bIsEmpty = false;
220 break;
221 case XML_TOK_TABLE_ROW_CELL_ATTR_NEW_VALUE_TYPE:
222 if(sValue == "error")
223 mbErrorValue = true;
224 else
225 nCellType = GetScImport().GetCellType(sValue);
226 bIsEmpty = false;
227 mbNewValueType = true;
228 break;
229 case XML_TOK_TABLE_ROW_CELL_ATTR_VALUE:
230 {
231 if (!sValue.isEmpty())
232 {
233 ::sax::Converter::convertDouble(fValue, sValue);
234 bIsEmpty = false;
235
236 //if office:value="0", let's get the text:p in case this is
237 //a special case in HasSpecialCaseFormulaText(). If it
238 //turns out not to be a special case, we'll use the 0 value.
239 if(fValue == 0.0)
240 bFormulaTextResult = true;
241 }
242 }
243 break;
244 case XML_TOK_TABLE_ROW_CELL_ATTR_DATE_VALUE:
245 {
246 if (!sValue.isEmpty() && rXMLImport.SetNullDateOnUnitConverter())
247 {
248 rXMLImport.GetMM100UnitConverter().convertDateTime(fValue, sValue);
249 bIsEmpty = false;
250 }
251 }
252 break;
253 case XML_TOK_TABLE_ROW_CELL_ATTR_TIME_VALUE:
254 {
255 if (!sValue.isEmpty())
256 {
257 ::sax::Converter::convertDuration(fValue, sValue);
258 bIsEmpty = false;
259 }
260 }
261 break;
262 case XML_TOK_TABLE_ROW_CELL_ATTR_STRING_VALUE:
263 {
264 if (!sValue.isEmpty())
265 {
266 OSL_ENSURE(!maStringValue, "here should be only one string value");
267 maStringValue.reset(sValue);
268 bIsEmpty = false;
269 }
270 }
271 break;
272 case XML_TOK_TABLE_ROW_CELL_ATTR_BOOLEAN_VALUE:
273 {
274 if (!sValue.isEmpty())
275 {
276 if ( IsXMLToken(sValue, XML_TRUE) )
277 fValue = 1.0;
278 else if ( IsXMLToken(sValue, XML_FALSE) )
279 fValue = 0.0;
280 else
281 ::sax::Converter::convertDouble(fValue, sValue);
282 bIsEmpty = false;
283 }
284 }
285 break;
286 case XML_TOK_TABLE_ROW_CELL_ATTR_FORMULA:
287 {
288 if (!sValue.isEmpty())
289 {
290 OSL_ENSURE(!maFormula, "here should be only one formula");
291 OUString aFormula, aFormulaNmsp;
292 rXMLImport.ExtractFormulaNamespaceGrammar( aFormula, aFormulaNmsp, eGrammar, sValue );
293 maFormula.reset( FormulaWithNamespace(aFormula, aFormulaNmsp) );
294 }
295 }
296 break;
297 case XML_TOK_TABLE_ROW_CELL_ATTR_CURRENCY:
298 pCurrencySymbol = new OUString(sValue);
299 break;
300 default:
301 ;
302 }
303 }
304 if (maFormula)
305 {
306 if (nCellType == util::NumberFormat::TEXT)
307 bFormulaTextResult = true;
308 if(nCellType == util::NumberFormat::DATETIME)
309 nCellType = util::NumberFormat::UNDEFINED;
310 //if bIsEmpty is true at this point, then there is no office value.
311 //we must get the text:p (even if it is empty) in case this a special
312 //case in HasSpecialCaseFormulaText().
313 if(bIsEmpty)
314 bFormulaTextResult = true;
315 }
316 rXMLImport.GetStylesImportHelper()->SetAttributes(pStyleName, pCurrencySymbol, nCellType);
317 }
318
319 ScXMLTableRowCellContext::~ScXMLTableRowCellContext()
320 {
321 delete pDetectiveObjVec;
322 delete pCellRangeSource;
323 }
324
325 void ScXMLTableRowCellContext::LockSolarMutex()
326 {
327 if (!bSolarMutexLocked)
328 {
329 GetScImport().LockSolarMutex();
330 bSolarMutexLocked = true;
331 }
332 }
333
334 void ScXMLTableRowCellContext::UnlockSolarMutex()
335 {
336 if (bSolarMutexLocked)
337 {
338 GetScImport().UnlockSolarMutex();
339 bSolarMutexLocked = false;
340 }
341 }
342
343 namespace {
344
345 bool cellExists( const ScAddress& rCellPos )
346 {
347 return( rCellPos.Col() >= 0 && rCellPos.Row() >= 0 &&
348 rCellPos.Col() <= MAXCOL && rCellPos.Row() <= MAXROW );
349 }
350
351 }
352
353 void ScXMLTableRowCellContext::PushParagraphSpan(const OUString& rSpan, const OUString& rStyleName)
354 {
355 sal_Int32 nBegin = maParagraph.getLength();
356 sal_Int32 nEnd = nBegin + rSpan.getLength();
357 maParagraph.append(rSpan);
358
359 PushFormat(nBegin, nEnd, rStyleName);
360 }
361
362 void ScXMLTableRowCellContext::PushParagraphField(SvxFieldData* pData, const OUString& rStyleName)
363 {
364 mbHasFormatRuns = true;
365 maFields.push_back(new Field(pData));
366 Field& rField = maFields.back();
367
368 sal_Int32 nPos = maParagraph.getLength();
369 maParagraph.append('\1'); // Placeholder text for inserted field item.
370 rField.maSelection.nStartPara = mnCurParagraph;
371 rField.maSelection.nEndPara = mnCurParagraph;
372 rField.maSelection.nStartPos = nPos;
373 rField.maSelection.nEndPos = nPos+1;
374
375 PushFormat(nPos, nPos+1, rStyleName);
376 }
377
378 void ScXMLTableRowCellContext::PushFormat(sal_Int32 nBegin, sal_Int32 nEnd, const OUString& rStyleName)
379 {
380 if (rStyleName.isEmpty())
381 return;
382
383 // Get the style information from xmloff.
384 rtl::Reference<XMLPropertySetMapper> xMapper = GetImport().GetTextImport()->GetTextImportPropertySetMapper()->getPropertySetMapper();
385 if (!xMapper.is())
386 // We can't do anything without the mapper.
387 return;
388
389 sal_Int32 nEntryCount = xMapper->GetEntryCount();
390
391 SvXMLStylesContext* pAutoStyles = GetImport().GetAutoStyles();
392
393 // Style name for text span corresponds with the name of an automatic style.
394 const XMLPropStyleContext* pStyle = dynamic_cast<const XMLPropStyleContext*>(
395 pAutoStyles->FindStyleChildContext(XML_STYLE_FAMILY_TEXT_TEXT, rStyleName));
396
397 if (!pStyle)
398 // No style by that name found.
399 return;
400
401 const std::vector<XMLPropertyState>& rProps = pStyle->GetProperties();
402 if (rProps.empty())
403 return;
404
405 const ScXMLEditAttributeMap& rEditAttrMap = GetScImport().GetEditAttributeMap();
406
407 mbHasFormatRuns = true;
408 maFormats.push_back(new ParaFormat(*mpEditEngine));
409 ParaFormat& rFmt = maFormats.back();
410 rFmt.maSelection.nStartPara = rFmt.maSelection.nEndPara = mnCurParagraph;
411 rFmt.maSelection.nStartPos = nBegin;
412 rFmt.maSelection.nEndPos = nEnd;
413
414 // Store the used text styles for export.
415 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(rXMLImport.GetModel())->GetSheetSaveData();
416 ScAddress aCellPos = rXMLImport.GetTables().GetCurrentCellPos();
417 pSheetData->AddTextStyle(rStyleName, aCellPos, rFmt.maSelection);
418
419 boost::scoped_ptr<SfxPoolItem> pPoolItem;
420 sal_uInt16 nLastItemID = EE_CHAR_END + 1;
421
422 std::vector<XMLPropertyState>::const_iterator it = rProps.begin(), itEnd = rProps.end();
423 for (; it != itEnd; ++it)
424 {
425 if (it->mnIndex == -1 || it->mnIndex >= nEntryCount)
426 continue;
427
428 const OUString& rName = xMapper->GetEntryAPIName(it->mnIndex);
429 const ScXMLEditAttributeMap::Entry* pEntry = rEditAttrMap.getEntryByAPIName(rName);
430 if (!pEntry)
431 continue;
432
433 if (nLastItemID != pEntry->mnItemID && pPoolItem)
434 {
435 // Flush the last item when the item ID changes.
436 rFmt.maItemSet.Put(*pPoolItem);
437 pPoolItem.reset();
438 }
439
440 switch (pEntry->mnItemID)
441 {
442 case EE_CHAR_FONTINFO:
443 case EE_CHAR_FONTINFO_CJK:
444 case EE_CHAR_FONTINFO_CTL:
445 {
446 // Font properties need to be consolidated into a single item.
447 if (!pPoolItem)
448 pPoolItem.reset(new SvxFontItem(pEntry->mnItemID));
449
450 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
451 }
452 break;
453 case EE_CHAR_WEIGHT:
454 case EE_CHAR_WEIGHT_CJK:
455 case EE_CHAR_WEIGHT_CTL:
456 {
457 if (!pPoolItem)
458 pPoolItem.reset(new SvxWeightItem(WEIGHT_NORMAL, pEntry->mnItemID));
459
460 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
461 }
462 break;
463 case EE_CHAR_FONTHEIGHT:
464 case EE_CHAR_FONTHEIGHT_CJK:
465 case EE_CHAR_FONTHEIGHT_CTL:
466 {
467 if (!pPoolItem)
468 pPoolItem.reset(new SvxFontHeightItem(240, 100, pEntry->mnItemID));
469
470 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
471 }
472 break;
473 case EE_CHAR_ITALIC:
474 case EE_CHAR_ITALIC_CJK:
475 case EE_CHAR_ITALIC_CTL:
476 {
477 if (!pPoolItem)
478 pPoolItem.reset(new SvxPostureItem(ITALIC_NONE, pEntry->mnItemID));
479
480 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
481 }
482 break;
483 case EE_CHAR_UNDERLINE:
484 {
485 if (!pPoolItem)
486 pPoolItem.reset(new SvxUnderlineItem(UNDERLINE_NONE, pEntry->mnItemID));
487
488 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
489 }
490 break;
491 case EE_CHAR_OVERLINE:
492 {
493 if (!pPoolItem)
494 pPoolItem.reset(new SvxOverlineItem(UNDERLINE_NONE, pEntry->mnItemID));
495
496 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
497 }
498 break;
499 case EE_CHAR_COLOR:
500 {
501 if (!pPoolItem)
502 pPoolItem.reset(new SvxColorItem(pEntry->mnItemID));
503
504 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
505 }
506 break;
507 case EE_CHAR_WLM:
508 {
509 if (!pPoolItem)
510 pPoolItem.reset(new SvxWordLineModeItem(false, pEntry->mnItemID));
511
512 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
513 }
514 break;
515 case EE_CHAR_STRIKEOUT:
516 {
517 if (!pPoolItem)
518 pPoolItem.reset(new SvxCrossedOutItem(STRIKEOUT_NONE, pEntry->mnItemID));
519
520 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
521 }
522 break;
523 case EE_CHAR_RELIEF:
524 {
525 if (!pPoolItem)
526 pPoolItem.reset(new SvxCharReliefItem(RELIEF_NONE, pEntry->mnItemID));
527
528 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
529 }
530 break;
531 case EE_CHAR_OUTLINE:
532 {
533 if (!pPoolItem)
534 pPoolItem.reset(new SvxContourItem(false, pEntry->mnItemID));
535
536 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
537 }
538 break;
539 case EE_CHAR_SHADOW:
540 {
541 if (!pPoolItem)
542 pPoolItem.reset(new SvxShadowedItem(false, pEntry->mnItemID));
543
544 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
545 }
546 break;
547 case EE_CHAR_KERNING:
548 {
549 if (!pPoolItem)
550 pPoolItem.reset(new SvxKerningItem(0, pEntry->mnItemID));
551
552 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
553 }
554 break;
555 case EE_CHAR_PAIRKERNING:
556 {
557 if (!pPoolItem)
558 pPoolItem.reset(new SvxAutoKernItem(false, pEntry->mnItemID));
559
560 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
561 }
562 break;
563 case EE_CHAR_FONTWIDTH:
564 {
565 if (!pPoolItem)
566 pPoolItem.reset(new SvxCharScaleWidthItem(100, pEntry->mnItemID));
567
568 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
569 }
570 break;
571 case EE_CHAR_ESCAPEMENT:
572 {
573 if (!pPoolItem)
574 pPoolItem.reset(new SvxEscapementItem(pEntry->mnItemID));
575
576 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
577 }
578 break;
579 case EE_CHAR_EMPHASISMARK:
580 {
581 if (!pPoolItem)
582 pPoolItem.reset(new SvxEmphasisMarkItem(EMPHASISMARK_NONE, pEntry->mnItemID));
583
584 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
585 }
586 break;
587 case EE_CHAR_LANGUAGE:
588 case EE_CHAR_LANGUAGE_CJK:
589 case EE_CHAR_LANGUAGE_CTL:
590 {
591 if (!pPoolItem)
592 pPoolItem.reset(new SvxLanguageItem(LANGUAGE_DONTKNOW, pEntry->mnItemID));
593
594 pPoolItem->PutValue(it->maValue, pEntry->mnFlag);
595 }
596 break;
597 default:
598 ;
599 }
600
601 nLastItemID = pEntry->mnItemID;
602 }
603
604 if (pPoolItem)
605 rFmt.maItemSet.Put(*pPoolItem);
606 }
607
608 OUString ScXMLTableRowCellContext::GetFirstParagraph() const
609 {
610 if (!maFirstParagraph)
611 return mpEditEngine->GetText(0);
612
613 return *maFirstParagraph;
614 }
615
616 void ScXMLTableRowCellContext::PushParagraphFieldDate(const OUString& rStyleName)
617 {
618 PushParagraphField(new SvxDateField, rStyleName);
619 }
620
621 void ScXMLTableRowCellContext::PushParagraphFieldSheetName(const OUString& rStyleName)
622 {
623 SCTAB nTab = GetScImport().GetTables().GetCurrentCellPos().Tab();
624 PushParagraphField(new SvxTableField(nTab), rStyleName);
625 }
626
627 void ScXMLTableRowCellContext::PushParagraphFieldDocTitle(const OUString& rStyleName)
628 {
629 PushParagraphField(new SvxFileField, rStyleName);
630 }
631
632 void ScXMLTableRowCellContext::PushParagraphFieldURL(
633 const OUString& rURL, const OUString& rRep, const OUString& rStyleName)
634 {
635 OUString aAbsURL = GetScImport().GetAbsoluteReference(rURL);
636 PushParagraphField(new SvxURLField(aAbsURL, rRep, SVXURLFORMAT_REPR), rStyleName);
637 }
638
639 void ScXMLTableRowCellContext::PushParagraphEnd()
640 {
641 // EditEngine always has at least one paragraph even when its content is empty.
642
643 if (mbEditEngineHasText)
644 {
645 if (maFirstParagraph)
646 {
647 // Flush the cached first paragraph first.
648 mpEditEngine->Clear();
649 mpEditEngine->SetText(*maFirstParagraph);
650 maFirstParagraph.reset();
651 }
652 mpEditEngine->InsertParagraph(mpEditEngine->GetParagraphCount(), maParagraph.makeStringAndClear());
653 }
654 else if (mbHasFormatRuns)
655 {
656 mpEditEngine->Clear();
657 mpEditEngine->SetText(maParagraph.makeStringAndClear());
658 mbEditEngineHasText = true;
659 }
660 else if (mnCurParagraph == 0)
661 {
662 maFirstParagraph.reset(maParagraph.makeStringAndClear());
663 mbEditEngineHasText = true;
664 }
665
666 ++mnCurParagraph;
667 }
668
669 SvXMLImportContext *ScXMLTableRowCellContext::CreateChildContext( sal_uInt16 nPrefix,
670 const OUString& rLName,
671 const ::com::sun::star::uno::Reference<
672 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
673 {
674 SvXMLImportContext *pContext = 0;
675
676 const SvXMLTokenMap& rTokenMap = rXMLImport.GetTableRowCellElemTokenMap();
677 bool bTextP(false);
678 switch( rTokenMap.Get( nPrefix, rLName ) )
679 {
680 case XML_TOK_TABLE_ROW_CELL_P:
681 {
682 bIsEmpty = false;
683 bTextP = true;
684
685 pContext = new ScXMLCellTextParaContext(rXMLImport, nPrefix, rLName, *this);
686 }
687 break;
688 case XML_TOK_TABLE_ROW_CELL_TABLE:
689 {
690 SAL_WARN("sc", "ScXMLTableRowCellContext::CreateChildContext: subtables are not supported");
691 }
692 break;
693 case XML_TOK_TABLE_ROW_CELL_ANNOTATION:
694 {
695 bIsEmpty = false;
696 OSL_ENSURE( !mxAnnotationData.get(), "ScXMLTableRowCellContext::CreateChildContext - multiple annotations in one cell" );
697 mxAnnotationData.reset( new ScXMLAnnotationData );
698 pContext = new ScXMLAnnotationContext( rXMLImport, nPrefix, rLName,
699 xAttrList, *mxAnnotationData, this);
700 }
701 break;
702 case XML_TOK_TABLE_ROW_CELL_DETECTIVE:
703 {
704 bIsEmpty = false;
705 if (!pDetectiveObjVec)
706 pDetectiveObjVec = new ScMyImpDetectiveObjVec();
707 pContext = new ScXMLDetectiveContext(
708 rXMLImport, nPrefix, rLName, pDetectiveObjVec );
709 }
710 break;
711 case XML_TOK_TABLE_ROW_CELL_CELL_RANGE_SOURCE:
712 {
713 bIsEmpty = false;
714 if (!pCellRangeSource)
715 pCellRangeSource = new ScMyImpCellRangeSource();
716 pContext = new ScXMLCellRangeSourceContext(
717 rXMLImport, nPrefix, rLName, xAttrList, pCellRangeSource );
718 }
719 break;
720 }
721
722 if (!pContext && !bTextP)
723 {
724 ScAddress aCellPos = rXMLImport.GetTables().GetCurrentCellPos();
725 uno::Reference<drawing::XShapes> xShapes (rXMLImport.GetTables().GetCurrentXShapes());
726 if (xShapes.is())
727 {
728 if (aCellPos.Col() > MAXCOL)
729 aCellPos.SetCol(MAXCOL);
730 if (aCellPos.Row() > MAXROW)
731 aCellPos.SetRow(MAXROW);
732 XMLTableShapeImportHelper* pTableShapeImport =
733 static_cast< XMLTableShapeImportHelper* >( rXMLImport.GetShapeImport().get() );
734 pTableShapeImport->SetOnTable(false);
735 com::sun::star::table::CellAddress aCellAddress;
736 ScUnoConversion::FillApiAddress( aCellAddress, aCellPos );
737 pTableShapeImport->SetCell(aCellAddress);
738 pContext = rXMLImport.GetShapeImport()->CreateGroupChildContext(
739 rXMLImport, nPrefix, rLName, xAttrList, xShapes);
740 if (pContext)
741 {
742 bIsEmpty = false;
743 rXMLImport.ProgressBarIncrement(false);
744 }
745 }
746 }
747
748 if( !pContext )
749 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
750
751 return pContext;
752 }
753
754 void ScXMLTableRowCellContext::DoMerge( const ScAddress& rScAddress, const SCCOL nCols, const SCROW nRows )
755 {
756 SCCOL mergeToCol = rScAddress.Col() + nCols;
757 SCROW mergeToRow = rScAddress.Row() + nRows;
758 bool bInBounds = rScAddress.Col() <= MAXCOL && rScAddress.Row() <= MAXROW &&
759 mergeToCol <= MAXCOL && mergeToRow <= MAXROW;
760 if( bInBounds )
761 {
762 rXMLImport.GetDocument()->DoMerge( rScAddress.Tab(),
763 rScAddress.Col(), rScAddress.Row(), mergeToCol, mergeToRow );
764 }
765 }
766
767 namespace {
768
769 ScValidationMode validationTypeToMode( const sheet::ValidationType eVType )
770 {
771 ScValidationMode eMode;
772 switch( eVType )
773 {
774 case sheet::ValidationType_WHOLE: eMode = SC_VALID_WHOLE; break;
775 case sheet::ValidationType_DECIMAL: eMode = SC_VALID_DECIMAL; break;
776 case sheet::ValidationType_DATE: eMode = SC_VALID_DATE; break;
777 case sheet::ValidationType_TIME: eMode = SC_VALID_TIME; break;
778 case sheet::ValidationType_TEXT_LEN: eMode = SC_VALID_TEXTLEN; break;
779 case sheet::ValidationType_LIST: eMode = SC_VALID_LIST; break;
780 case sheet::ValidationType_CUSTOM: eMode = SC_VALID_CUSTOM; break;
781 default: eMode = SC_VALID_ANY; break;
782 }
783 return eMode;
784 }
785
786 ScValidErrorStyle validAlertToValidError( const sheet::ValidationAlertStyle eVAlertStyle )
787 {
788 ScValidErrorStyle eVErrStyle;
789 switch( eVAlertStyle )
790 {
791 case sheet::ValidationAlertStyle_STOP: eVErrStyle = SC_VALERR_STOP; break;
792 case sheet::ValidationAlertStyle_WARNING: eVErrStyle = SC_VALERR_WARNING; break;
793 case sheet::ValidationAlertStyle_MACRO: eVErrStyle = SC_VALERR_MACRO; break;
794 default: eVErrStyle = SC_VALERR_INFO; break;
795 //should INFO be the default? seems to be the most unobtrusive choice.
796 }
797 return eVErrStyle;
798 }
799
800 }
801
802 void ScXMLTableRowCellContext::SetContentValidation( const ScRange& rScRange )
803 {
804 if (maContentValidationName)
805 {
806 ScDocument* pDoc = rXMLImport.GetDocument();
807 ScMyImportValidation aValidation;
808 aValidation.eGrammar1 = aValidation.eGrammar2 = pDoc->GetStorageGrammar();
809 if( rXMLImport.GetValidation(*maContentValidationName, aValidation) )
810 {
811 ScValidationData aScValidationData(
812 validationTypeToMode(aValidation.aValidationType),
813 ScConditionEntry::GetModeFromApi(static_cast<sal_Int32>(aValidation.aOperator)),
814 aValidation.sFormula1, aValidation.sFormula2, pDoc, ScAddress(),
815 aValidation.sFormulaNmsp1, aValidation.sFormulaNmsp2,
816 aValidation.eGrammar1, aValidation.eGrammar2
817 );
818
819 aScValidationData.SetIgnoreBlank( aValidation.bIgnoreBlanks );
820 aScValidationData.SetListType( aValidation.nShowList );
821
822 // set strings for error / input even if disabled (and disable afterwards)
823 aScValidationData.SetInput( aValidation.sImputTitle, aValidation.sImputMessage );
824 if( !aValidation.bShowImputMessage )
825 aScValidationData.ResetInput();
826 aScValidationData.SetError( aValidation.sErrorTitle, aValidation.sErrorMessage, validAlertToValidError(aValidation.aAlertStyle) );
827 if( !aValidation.bShowErrorMessage )
828 aScValidationData.ResetError();
829
830 if( !aValidation.sBaseCellAddress.isEmpty() )
831 aScValidationData.SetSrcString( aValidation.sBaseCellAddress );
832
833 sal_uLong nIndex = pDoc->AddValidationEntry( aScValidationData );
834
835 ScPatternAttr aPattern( pDoc->GetPool() );
836 aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALIDDATA, nIndex ) );
837 if( rScRange.aStart == rScRange.aEnd ) //for a single cell
838 {
839 pDoc->ApplyPattern( rScRange.aStart.Col(), rScRange.aStart.Row(),
840 rScRange.aStart.Tab(), aPattern );
841 }
842 else //for repeating cells
843 {
844 pDoc->ApplyPatternAreaTab( rScRange.aStart.Col(), rScRange.aStart.Row(),
845 rScRange.aEnd.Col(), rScRange.aEnd.Row(),
846 rScRange.aStart.Tab(), aPattern );
847 }
848
849 // is the below still needed?
850 // For now, any sheet with validity is blocked from stream-copying.
851 // Later, the validation names could be stored along with the style names.
852 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetImport().GetModel())->GetSheetSaveData();
853 pSheetData->BlockSheet( GetScImport().GetTables().GetCurrentSheet() );
854 }
855 }
856 }
857
858 void ScXMLTableRowCellContext::SetContentValidation( const ScAddress& rCellPos )
859 {
860 SetContentValidation( ScRange(rCellPos, rCellPos) );
861 }
862
863 void ScXMLTableRowCellContext::SetAnnotation(const ScAddress& rPos)
864 {
865 ScDocument* pDoc = rXMLImport.GetDocument();
866 if( !pDoc || !mxAnnotationData.get() )
867 return;
868
869 LockSolarMutex();
870
871 ScPostIt* pNote = 0;
872
873 uno::Reference< drawing::XShapes > xShapes = rXMLImport.GetTables().GetCurrentXShapes();
874 uno::Reference< container::XIndexAccess > xShapesIA( xShapes, uno::UNO_QUERY );
875 sal_Int32 nOldShapeCount = xShapesIA.is() ? xShapesIA->getCount() : 0;
876
877 OSL_ENSURE( !mxAnnotationData->mxShape.is() || mxAnnotationData->mxShapes.is(),
878 "ScXMLTableRowCellContext::SetAnnotation - shape without drawing page" );
879 if( mxAnnotationData->mxShape.is() && mxAnnotationData->mxShapes.is() )
880 {
881 OSL_ENSURE( mxAnnotationData->mxShapes.get() == xShapes.get(), "ScXMLTableRowCellContext::SetAnnotation - diffenet drawing pages" );
882 SdrObject* pObject = ::GetSdrObjectFromXShape( mxAnnotationData->mxShape );
883 OSL_ENSURE( pObject, "ScXMLTableRowCellContext::SetAnnotation - cannot get SdrObject from shape" );
884
885 /* Try to reuse the drawing object already created (but only if the
886 note is visible, and the object is a caption object). */
887 if( mxAnnotationData->mbShown && mxAnnotationData->mbUseShapePos )
888 {
889 if( SdrCaptionObj* pCaption = dynamic_cast< SdrCaptionObj* >( pObject ) )
890 {
891 OSL_ENSURE( !pCaption->GetLogicRect().IsEmpty(), "ScXMLTableRowCellContext::SetAnnotation - invalid caption rectangle" );
892 // create the cell note with the caption object
893 pNote = ScNoteUtil::CreateNoteFromCaption( *pDoc, rPos, *pCaption, true );
894 // forget pointer to object (do not create note again below)
895 pObject = 0;
896 }
897 }
898
899 // drawing object has not been used to create a note -> use shape data
900 if( pObject )
901 {
902 // rescue settings from drawing object before the shape is removed
903 ::std::unique_ptr< SfxItemSet > xItemSet( new SfxItemSet( pObject->GetMergedItemSet() ) );
904 ::std::unique_ptr< OutlinerParaObject > xOutlinerObj;
905 if( OutlinerParaObject* pOutlinerObj = pObject->GetOutlinerParaObject() )
906 xOutlinerObj.reset( new OutlinerParaObject( *pOutlinerObj ) );
907 Rectangle aCaptionRect;
908 if( mxAnnotationData->mbUseShapePos )
909 aCaptionRect = pObject->GetLogicRect();
910 // remove the shape from the drawing page, this invalidates pObject
911 mxAnnotationData->mxShapes->remove( mxAnnotationData->mxShape );
912 pObject = 0;
913 // update current number of existing objects
914 if( xShapesIA.is() )
915 nOldShapeCount = xShapesIA->getCount();
916
917 // an outliner object is required (empty note captions not allowed)
918 if( xOutlinerObj.get() )
919 {
920 // create cell note with all data from drawing object
921 pNote = ScNoteUtil::CreateNoteFromObjectData( *pDoc, rPos,
922 xItemSet.release(), xOutlinerObj.release(),
923 aCaptionRect, mxAnnotationData->mbShown, false );
924 }
925 }
926 }
927 else if( !mxAnnotationData->maSimpleText.isEmpty() )
928 {
929 // create note from simple text
930 pNote = ScNoteUtil::CreateNoteFromString( *pDoc, rPos,
931 mxAnnotationData->maSimpleText, mxAnnotationData->mbShown, false );
932 }
933
934 // set author and date
935 if( pNote )
936 {
937 double fDate;
938 if (rXMLImport.GetMM100UnitConverter().convertDateTime(fDate, mxAnnotationData->maCreateDate))
939 {
940 SvNumberFormatter* pNumForm = pDoc->GetFormatTable();
941 sal_uInt32 nfIndex = pNumForm->GetFormatIndex( NF_DATE_SYS_DDMMYYYY, LANGUAGE_SYSTEM );
942 OUString aDate;
943 Color* pColor = 0;
944 Color** ppColor = &pColor;
945 pNumForm->GetOutputString( fDate, nfIndex, aDate, ppColor );
946 pNote->SetDate( aDate );
947 }
948 pNote->SetAuthor( mxAnnotationData->maAuthor );
949 }
950
951 // register a shape that has been newly created in the ScNoteUtil functions
952 if( xShapesIA.is() && (nOldShapeCount < xShapesIA->getCount()) )
953 {
954 uno::Reference< drawing::XShape > xShape;
955 rXMLImport.GetShapeImport()->shapeWithZIndexAdded( xShape, xShapesIA->getCount() );
956 }
957
958 // store the style names for stream copying
959 ScSheetSaveData* pSheetData = ScModelObj::getImplementation(rXMLImport.GetModel())->GetSheetSaveData();
960 pSheetData->HandleNoteStyles( mxAnnotationData->maStyleName, mxAnnotationData->maTextStyle, rPos );
961
962 std::vector<ScXMLAnnotationStyleEntry>::const_iterator aIter = mxAnnotationData->maContentStyles.begin();
963 std::vector<ScXMLAnnotationStyleEntry>::const_iterator aEnd = mxAnnotationData->maContentStyles.end();
964 while (aIter != aEnd)
965 {
966 pSheetData->AddNoteContentStyle( aIter->mnFamily, aIter->maName, rPos, aIter->maSelection );
967 ++aIter;
968 }
969 }
970
971 // core implementation
972 void ScXMLTableRowCellContext::SetDetectiveObj( const ScAddress& rPosition )
973 {
974 if( cellExists(rPosition) && pDetectiveObjVec && pDetectiveObjVec->size() )
975 {
976 LockSolarMutex();
977 ScDetectiveFunc aDetFunc( rXMLImport.GetDocument(), rPosition.Tab() );
978 uno::Reference<container::XIndexAccess> xShapesIndex (rXMLImport.GetTables().GetCurrentXShapes(), uno::UNO_QUERY); // make draw page
979 ScMyImpDetectiveObjVec::iterator aItr(pDetectiveObjVec->begin());
980 ScMyImpDetectiveObjVec::iterator aEndItr(pDetectiveObjVec->end());
981 while(aItr != aEndItr)
982 {
983 aDetFunc.InsertObject( aItr->eObjType, rPosition, aItr->aSourceRange, aItr->bHasError );
984 if (xShapesIndex.is())
985 {
986 sal_Int32 nShapes = xShapesIndex->getCount();
987 uno::Reference < drawing::XShape > xShape;
988 rXMLImport.GetShapeImport()->shapeWithZIndexAdded(xShape, nShapes);
989 }
990 ++aItr;
991 }
992 }
993 }
994
995 // core implementation
996 void ScXMLTableRowCellContext::SetCellRangeSource( const ScAddress& rPosition )
997 {
998 if( cellExists(rPosition) && pCellRangeSource && !pCellRangeSource->sSourceStr.isEmpty() &&
999 !pCellRangeSource->sFilterName.isEmpty() && !pCellRangeSource->sURL.isEmpty() )
1000 {
1001 ScDocument* pDoc = rXMLImport.GetDocument();
1002 if (pDoc)
1003 {
1004 LockSolarMutex();
1005 ScRange aDestRange( rPosition.Col(), rPosition.Row(), rPosition.Tab(),
1006 rPosition.Col() + static_cast<SCCOL>(pCellRangeSource->nColumns - 1),
1007 rPosition.Row() + static_cast<SCROW>(pCellRangeSource->nRows - 1), rPosition.Tab() );
1008 OUString sFilterName( pCellRangeSource->sFilterName );
1009 OUString sSourceStr( pCellRangeSource->sSourceStr );
1010 ScAreaLink* pLink = new ScAreaLink( pDoc->GetDocumentShell(), pCellRangeSource->sURL,
1011 sFilterName, pCellRangeSource->sFilterOptions, sSourceStr, aDestRange, pCellRangeSource->nRefresh );
1012 sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager();
1013 pLinkManager->InsertFileLink( *pLink, OBJECT_CLIENT_FILE, pCellRangeSource->sURL, &sFilterName, &sSourceStr );
1014 }
1015 }
1016 }
1017
1018 void ScXMLTableRowCellContext::SetFormulaCell(ScFormulaCell* pFCell) const
1019 {
1020 if(pFCell)
1021 {
1022 if(mbErrorValue)
1023 {
1024 // don't do anything here
1025 // we need to recalc anyway
1026 }
1027 else if( bFormulaTextResult && maStringValue )
1028 {
1029 if( !IsPossibleErrorString() )
1030 {
1031 ScDocument* pDoc = rXMLImport.GetDocument();
1032 pFCell->SetHybridString(pDoc->GetSharedStringPool().intern(*maStringValue));
1033 pFCell->ResetDirty();
1034 }
1035 }
1036 else if (!rtl::math::isNan(fValue))
1037 {
1038 pFCell->SetHybridDouble(fValue);
1039 pFCell->ResetDirty();
1040 }
1041 }
1042 }
1043
1044 void ScXMLTableRowCellContext::PutTextCell( const ScAddress& rCurrentPos,
1045 const SCCOL nCurrentCol, const ::boost::optional< OUString >& pOUText )
1046 {
1047 bool bDoIncrement = true;
1048 //matrix reference cells that contain text formula results;
1049 //cell was already put in document, just need to set text here.
1050 if( rXMLImport.GetTables().IsPartOfMatrix(rCurrentPos) )
1051 {
1052 bDoIncrement = rXMLImport.GetDocument()->GetCellType(rCurrentPos) == CELLTYPE_FORMULA;
1053 if ( bDoIncrement )
1054 {
1055 ScFormulaCell* pFCell = rXMLImport.GetDocument()->GetFormulaCell(rCurrentPos);
1056 OUString aCellString;
1057 if (maStringValue)
1058 aCellString = *maStringValue;
1059 else if (mbEditEngineHasText)
1060 aCellString = GetFirstParagraph();
1061 else if ( nCurrentCol > 0 && pOUText && !pOUText->isEmpty() )
1062 aCellString = *pOUText;
1063 else
1064 bDoIncrement = false;
1065
1066 if(mbErrorValue)
1067 bDoIncrement = false;
1068
1069 if(!aCellString.isEmpty())
1070 {
1071 if (bDoIncrement && !IsPossibleErrorString() && pFCell)
1072 {
1073 ScDocument* pDoc = rXMLImport.GetDocument();
1074 pFCell->SetHybridString(pDoc->GetSharedStringPool().intern(aCellString));
1075 pFCell->ResetDirty();
1076 }
1077 else
1078 {
1079 ScAddress aTopLeftMatrixCell;
1080 if (pFCell && pFCell->GetMatrixOrigin(aTopLeftMatrixCell))
1081 {
1082 ScFormulaCell* pMatrixCell = rXMLImport.GetDocument()->GetFormulaCell(aTopLeftMatrixCell);
1083 if (pMatrixCell)
1084 pMatrixCell->SetDirty();
1085 }
1086 else
1087 SAL_WARN("sc", "matrix cell without matrix");
1088 }
1089 }
1090 }
1091 }
1092 else //regular text cells
1093 {
1094 ScDocumentImport& rDoc = rXMLImport.GetDoc();
1095 if (maStringValue)
1096 {
1097 rDoc.setStringCell(rCurrentPos, *maStringValue);
1098 bDoIncrement = true;
1099 }
1100 else if (mbEditEngineHasText)
1101 {
1102 if (maFirstParagraph)
1103 {
1104 // This is a normal text without format runs.
1105 rDoc.setStringCell(rCurrentPos, *maFirstParagraph);
1106 }
1107 else
1108 {
1109 // This text either has format runs, has field(s), or consists of multiple lines.
1110 {
1111 ParaFormatsType::const_iterator it = maFormats.begin(), itEnd = maFormats.end();
1112 for (; it != itEnd; ++it)
1113 mpEditEngine->QuickSetAttribs(it->maItemSet, it->maSelection);
1114 }
1115
1116 {
1117 FieldsType::const_iterator it = maFields.begin(), itEnd = maFields.end();
1118 for (; it != itEnd; ++it)
1119 mpEditEngine->QuickInsertField(SvxFieldItem(*it->mpData, EE_FEATURE_FIELD), it->maSelection);
1120 }
1121
1122 // This edit engine uses the SfxItemPool instance returned
1123 // from pDoc->GetEditPool() to create the text object, which
1124 // is a prerequisite for using this constructor of ScEditCell.
1125 rDoc.setEditCell(rCurrentPos, mpEditEngine->CreateTextObject());
1126 }
1127 bDoIncrement = true;
1128 }
1129 else if ( nCurrentCol > 0 && pOUText && !pOUText->isEmpty() )
1130 {
1131 rDoc.setStringCell(rCurrentPos, *pOUText);
1132 bDoIncrement = true;
1133 }
1134 else
1135 bDoIncrement = false;
1136 }
1137
1138 // #i56027# This is about setting simple text, not edit cells,
1139 // so ProgressBarIncrement must be called with bEditCell = FALSE.
1140 // Formatted text that is put into the cell by the child context
1141 // is handled in AddCellsToTable() (bIsEmpty is true then).
1142 if (bDoIncrement)
1143 rXMLImport.ProgressBarIncrement(false);
1144 }
1145
1146 void ScXMLTableRowCellContext::PutValueCell( const ScAddress& rCurrentPos )
1147 {
1148 //matrix reference cells that contain value formula results;
1149 //cell was already put in document, just need to set value here.
1150 if( rXMLImport.GetTables().IsPartOfMatrix(rCurrentPos) )
1151 {
1152 if (rXMLImport.GetDocument()->GetCellType(rCurrentPos) == CELLTYPE_FORMULA)
1153 {
1154 ScFormulaCell* pFCell = rXMLImport.GetDocument()->GetFormulaCell(rCurrentPos);
1155 SetFormulaCell(pFCell);
1156 if (pFCell)
1157 pFCell->SetNeedNumberFormat( true );
1158 }
1159 }
1160 else //regular value cell
1161 {
1162 // fdo#62250 absent values are not NaN, set to 0.0
1163 // PutValueCell() is called only for a known cell value type,
1164 // bIsEmpty==false in all these cases, no sense to check it here.
1165 if (::rtl::math::isNan( fValue))
1166 fValue = 0.0;
1167
1168 // #i62435# Initialize the value cell's script type if the default
1169 // style's number format is latin-only. If the cell uses a different
1170 // format, the script type will be reset when the style is applied.
1171
1172 rXMLImport.GetDoc().setNumericCell(rCurrentPos, fValue);
1173 }
1174 rXMLImport.ProgressBarIncrement(false);
1175 }
1176
1177 namespace {
1178
1179 bool isEmptyOrNote( ScDocument* pDoc, const ScAddress& rCurrentPos )
1180 {
1181 CellType eType = pDoc->GetCellType(rCurrentPos);
1182 return (eType == CELLTYPE_NONE);
1183 }
1184
1185 }
1186
1187 void ScXMLTableRowCellContext::AddTextAndValueCell( const ScAddress& rCellPos,
1188 const ::boost::optional< OUString >& pOUText, ScAddress& rCurrentPos )
1189 {
1190 ScMyTables& rTables = rXMLImport.GetTables();
1191 bool bWasEmpty = bIsEmpty;
1192 for (SCCOL i = 0; i < nColsRepeated; ++i)
1193 {
1194 rCurrentPos.SetCol( rCellPos.Col() + i );
1195
1196 // it makes no sense to import data after the last supported column
1197 // fdo#58539 & gnome#627150
1198 if(rCurrentPos.Col() > MAXCOL)
1199 break;
1200
1201 if (i > 0)
1202 rTables.AddColumn(false);
1203 if (!bIsEmpty)
1204 {
1205 for (SCROW j = 0; j < nRepeatedRows; ++j)
1206 {
1207 rCurrentPos.SetRow( rCellPos.Row() + j );
1208
1209 // it makes no sense to import data after last supported row
1210 // fdo#58539 & gnome#627150
1211 if(rCurrentPos.Row() > MAXROW)
1212 break;
1213
1214 if( (rCurrentPos.Col() == 0) && (j > 0) )
1215 {
1216 rTables.AddRow();
1217 rTables.AddColumn(false);
1218 }
1219 if( cellExists(rCurrentPos) )
1220 {
1221 if( ( !(bIsCovered) || isEmptyOrNote(rXMLImport.GetDocument(), rCurrentPos) ) )
1222 {
1223 switch (nCellType)
1224 {
1225 case util::NumberFormat::TEXT:
1226 {
1227 PutTextCell( rCurrentPos, i, pOUText );
1228 }
1229 break;
1230 case util::NumberFormat::NUMBER:
1231 case util::NumberFormat::PERCENT:
1232 case util::NumberFormat::CURRENCY:
1233 case util::NumberFormat::TIME:
1234 case util::NumberFormat::DATETIME:
1235 case util::NumberFormat::LOGICAL:
1236 {
1237 PutValueCell( rCurrentPos );
1238 }
1239 break;
1240 default:
1241 {
1242 OSL_FAIL("no cell type given");
1243 }
1244 break;
1245 }
1246 }
1247
1248 SetAnnotation( rCurrentPos );
1249 SetDetectiveObj( rCurrentPos );
1250 SetCellRangeSource( rCurrentPos );
1251 }
1252 else
1253 {
1254 if (!bWasEmpty || mxAnnotationData.get())
1255 {
1256 if (rCurrentPos.Row() > MAXROW)
1257 rXMLImport.SetRangeOverflowType(SCWARN_IMPORT_ROW_OVERFLOW);
1258 else
1259 rXMLImport.SetRangeOverflowType(SCWARN_IMPORT_COLUMN_OVERFLOW);
1260 }
1261 }
1262 }
1263 }
1264 else
1265 {
1266 if ((i == 0) && (rCellPos.Col() == 0))
1267 {
1268 for (sal_Int32 j = 1; j < nRepeatedRows; ++j)
1269 {
1270 rTables.AddRow();
1271 rTables.AddColumn(false);
1272 }
1273 }
1274 }
1275 }
1276 }
1277
1278 bool ScXMLTableRowCellContext::HasSpecialContent() const
1279 {
1280 return (mxAnnotationData.get() || pDetectiveObjVec || pCellRangeSource);
1281 }
1282
1283 bool ScXMLTableRowCellContext::CellsAreRepeated() const
1284 {
1285 return ( (nColsRepeated > 1) || (nRepeatedRows > 1) );
1286 }
1287
1288 namespace {
1289
1290 // from ScCellObj::GetOutputString_Imp(). all of it may not be necessary.
1291 OUString getOutputString( ScDocument* pDoc, const ScAddress& aCellPos )
1292 {
1293 if (!pDoc)
1294 return OUString();
1295
1296 CellType eType = pDoc->GetCellType(aCellPos);
1297 switch (eType)
1298 {
1299 case CELLTYPE_NONE:
1300 return OUString();
1301 case CELLTYPE_EDIT:
1302 {
1303 // GetString on EditCell replaces linebreaks with spaces;
1304 // however here we need line breaks
1305 const EditTextObject* pData = pDoc->GetEditText(aCellPos);
1306 if (pData)
1307 {
1308 EditEngine& rEngine = pDoc->GetEditEngine();
1309 rEngine.SetText(*pData);
1310 return rEngine.GetText(LINEEND_LF);
1311 }
1312 // also don't format EditCells per NumberFormatter
1313 }
1314 break;
1315 default:
1316 {
1317 // like in GetString for document (column)
1318 Color* pColor;
1319 sal_uLong nNumFmt = pDoc->GetNumberFormat(aCellPos);
1320 return ScCellFormat::GetString(
1321 *pDoc, aCellPos, nNumFmt, &pColor, *pDoc->GetFormatTable());
1322 }
1323 }
1324
1325 return OUString();
1326 }
1327
1328 }
1329
1330 void ScXMLTableRowCellContext::AddNonFormulaCell( const ScAddress& rCellPos )
1331 {
1332 ::boost::optional< OUString > pOUText;
1333
1334 if( nCellType == util::NumberFormat::TEXT )
1335 {
1336 if( cellExists(rCellPos) && CellsAreRepeated() )
1337 pOUText.reset( getOutputString(rXMLImport.GetDocument(), rCellPos) );
1338
1339 if (!mbEditEngineHasText && !pOUText && !maStringValue)
1340 bIsEmpty = true;
1341 }
1342
1343 ScAddress aCurrentPos( rCellPos );
1344 if( HasSpecialContent() )
1345 bIsEmpty = false;
1346
1347 AddTextAndValueCell( rCellPos, pOUText, aCurrentPos );
1348
1349 if( CellsAreRepeated() )
1350 {
1351 SCCOL nStartCol( rCellPos.Col() < MAXCOL ? rCellPos.Col() : MAXCOL );
1352 SCROW nStartRow( rCellPos.Row() < MAXROW ? rCellPos.Row() : MAXROW );
1353 SCCOL nEndCol( rCellPos.Col() + nColsRepeated - 1 < MAXCOL ? rCellPos.Col() + nColsRepeated - 1 : MAXCOL );
1354 SCROW nEndRow( rCellPos.Row() + nRepeatedRows - 1 < MAXROW ? rCellPos.Row() + nRepeatedRows - 1 : MAXROW );
1355 ScRange aScRange( nStartCol, nStartRow, rCellPos.Tab(), nEndCol, nEndRow, rCellPos.Tab() );
1356 SetContentValidation( aScRange );
1357 rXMLImport.GetStylesImportHelper()->AddRange( aScRange );
1358 }
1359 else if( cellExists(rCellPos) )
1360 {
1361 rXMLImport.GetStylesImportHelper()->AddCell(rCellPos);
1362 SetContentValidation( rCellPos );
1363 }
1364 }
1365
1366 void ScXMLTableRowCellContext::PutFormulaCell( const ScAddress& rCellPos )
1367 {
1368 ScDocument* pDoc = rXMLImport.GetDocument();
1369 ScDocumentImport& rDoc = rXMLImport.GetDoc();
1370
1371 OUString aText = maFormula->first;
1372
1373 ::boost::scoped_ptr<ScExternalRefManager::ApiGuard> pExtRefGuard (
1374 new ScExternalRefManager::ApiGuard(pDoc));
1375
1376 if ( !aText.isEmpty() )
1377 {
1378 if ( aText[0] == '=' && aText.getLength() > 1 )
1379 {
1380 // temporary formula string as string tokens
1381 ScTokenArray *pCode = new ScTokenArray();
1382
1383 OUString aFormulaNmsp = maFormula->second;
1384 if( eGrammar != formula::FormulaGrammar::GRAM_EXTERNAL )
1385 aFormulaNmsp.clear();
1386 pCode->AssignXMLString( aText, aFormulaNmsp );
1387
1388 rDoc.getDoc().IncXMLImportedFormulaCount( aText.getLength() );
1389 ScFormulaCell* pNewCell = new ScFormulaCell(pDoc, rCellPos, pCode, eGrammar, MM_NONE);
1390 SetFormulaCell(pNewCell);
1391 rDoc.setFormulaCell(rCellPos, pNewCell);
1392
1393 // Re-calculate to get number format only when style is not set.
1394 pNewCell->SetNeedNumberFormat(!mbHasStyle);
1395 }
1396 else if ( aText[0] == '\'' && aText.getLength() > 1 )
1397 {
1398 // for bEnglish, "'" at the beginning is always interpreted as text
1399 // marker and stripped
1400 rDoc.setStringCell(rCellPos, aText.copy(1));
1401 }
1402 else
1403 {
1404 SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
1405 sal_uInt32 nEnglish = pFormatter->GetStandardIndex(LANGUAGE_ENGLISH_US);
1406 double fVal;
1407 if ( pFormatter->IsNumberFormat( aText, nEnglish, fVal ) )
1408 rDoc.setNumericCell(rCellPos, fVal);
1409 //the (english) number format will not be set
1410 //search matching local format and apply it
1411 else
1412 rDoc.setStringCell(rCellPos, aText);
1413 }
1414 }
1415 }
1416
1417 void ScXMLTableRowCellContext::AddFormulaCell( const ScAddress& rCellPos )
1418 {
1419 if( cellExists(rCellPos) )
1420 {
1421 SetContentValidation( rCellPos );
1422 SAL_WARN_IF((nColsRepeated != 1) || (nRepeatedRows != 1), "sc", "repeated cells with formula not possible now");
1423 rXMLImport.GetStylesImportHelper()->AddCell(rCellPos);
1424
1425 //add matrix
1426 if(bIsMatrix)
1427 {
1428 if (nMatrixCols > 0 && nMatrixRows > 0)
1429 {
1430 //matrix cells are put in the document, but we must set the
1431 //value/text of each matrix cell later
1432 rXMLImport.GetTables().AddMatrixRange(
1433 rCellPos.Col(), rCellPos.Row(),
1434 std::min<SCCOL>(rCellPos.Col() + nMatrixCols - 1, MAXCOL),
1435 std::min<SCROW>(rCellPos.Row() + nMatrixRows - 1, MAXROW),
1436 maFormula->first, maFormula->second, eGrammar);
1437
1438 // Set the value/text of the top-left matrix position in its
1439 // cached result. For import, we only need to set the correct
1440 // matrix geometry and the value type of the top-left element.
1441 ScFormulaCell* pFCell = rXMLImport.GetDocument()->GetFormulaCell(rCellPos);
1442 if (pFCell)
1443 {
1444 ScMatrixRef pMat(new ScMatrix(nMatrixCols, nMatrixRows));
1445 if (bFormulaTextResult && maStringValue)
1446 {
1447 if (!IsPossibleErrorString())
1448 {
1449 pFCell->SetResultMatrix(
1450 nMatrixCols, nMatrixRows, pMat, new formula::FormulaStringToken(*maStringValue));
1451 pFCell->ResetDirty();
1452 }
1453 }
1454 else if (!rtl::math::isNan(fValue))
1455 {
1456 pFCell->SetResultMatrix(
1457 nMatrixCols, nMatrixRows, pMat, new formula::FormulaDoubleToken(fValue));
1458 pFCell->ResetDirty();
1459 }
1460 }
1461 }
1462 }
1463 else
1464 PutFormulaCell( rCellPos );
1465
1466 SetAnnotation( rCellPos );
1467 SetDetectiveObj( rCellPos );
1468 SetCellRangeSource( rCellPos );
1469 rXMLImport.ProgressBarIncrement(false);
1470 }
1471 else
1472 {
1473 if (rCellPos.Row() > MAXROW)
1474 rXMLImport.SetRangeOverflowType(SCWARN_IMPORT_ROW_OVERFLOW);
1475 else
1476 rXMLImport.SetRangeOverflowType(SCWARN_IMPORT_COLUMN_OVERFLOW);
1477 }
1478 }
1479
1480 //There are cases where a formula cell is exported with an office:value of 0 or
1481 //no office:value at all, but the formula cell will have a text:p value which
1482 //contains the intended formula result.
1483 //These cases include when a formula result:
1484 // - is blank
1485 // - has a constant error value beginning with "#" (such as "#VALUE!" or "#N/A")
1486 // - has an "Err:[###]" (where "[###]" is an error number)
1487 // Libreoffice 4.1+ with ODF1.2 extended write however calcext:value-type="error" in that case
1488 void ScXMLTableRowCellContext::HasSpecialCaseFormulaText()
1489 {
1490 if (!mbEditEngineHasText || mbNewValueType)
1491 return;
1492
1493 OUString aStr = GetFirstParagraph();
1494
1495 if (aStr.isEmpty() || aStr.startsWith("Err:"))
1496 mbPossibleErrorCell = true;
1497 else if (aStr.startsWith("#"))
1498 mbCheckWithCompilerForError = true;
1499 }
1500
1501 bool ScXMLTableRowCellContext::IsPossibleErrorString() const
1502 {
1503 if(mbNewValueType && !mbErrorValue)
1504 return false;
1505 else if(mbNewValueType && mbErrorValue)
1506 return true;
1507 return mbPossibleErrorCell || ( mbCheckWithCompilerForError && GetScImport().IsFormulaErrorConstant(*maStringValue) );
1508 }
1509
1510 void ScXMLTableRowCellContext::EndElement()
1511 {
1512 HasSpecialCaseFormulaText();
1513 if( bFormulaTextResult && (mbPossibleErrorCell || mbCheckWithCompilerForError) )
1514 {
1515 maStringValue.reset(GetFirstParagraph());
1516 nCellType = util::NumberFormat::TEXT;
1517 }
1518
1519 ScAddress aCellPos = rXMLImport.GetTables().GetCurrentCellPos();
1520 if( aCellPos.Col() > 0 && nRepeatedRows > 1 )
1521 aCellPos.SetRow( aCellPos.Row() - (nRepeatedRows - 1) );
1522 if( bIsMerged )
1523 DoMerge( aCellPos, nMergedCols - 1, nMergedRows - 1 );
1524
1525 if (maFormula)
1526 AddFormulaCell(aCellPos);
1527 else
1528 AddNonFormulaCell(aCellPos);
1529
1530 UnlockSolarMutex(); //if LockSolarMutex got used, we presumably need to ensure an UnlockSolarMutex
1531
1532 bIsMerged = false;
1533 nMergedCols = 1;
1534 nMergedRows = 1;
1535 nColsRepeated = 1;
1536 }
1537
1538 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE