?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sc / source / filter / xml / XMLTrackedChangesContext.cxx
blob5964f380553d93d86c714af987b1fdd341b58c1e
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: XMLTrackedChangesContext.cxx,v $
10 * $Revision: 1.32 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34 #include "XMLTrackedChangesContext.hxx"
35 #include "xmlimprt.hxx"
36 #include "xmlconti.hxx"
37 #include "XMLConverter.hxx"
38 #include "cell.hxx"
39 #include "textuno.hxx"
40 #include "editutil.hxx"
41 #include <xmloff/xmltoken.hxx>
42 #include <xmloff/xmlnmspe.hxx>
43 #include <xmloff/nmspmap.hxx>
44 #include <xmloff/xmluconv.hxx>
45 #include <svtools/zforlist.hxx>
46 #include <com/sun/star/text/XTextCursor.hpp>
47 #include <com/sun/star/text/ControlCharacter.hpp>
48
49 using rtl::OUString;
50 using namespace com::sun::star;
51 using namespace xmloff::token;
52
53 //-----------------------------------------------------------------------------
54
55 class ScXMLChangeInfoContext : public SvXMLImportContext
56 {
57 ScMyActionInfo aInfo;
58 ::rtl::OUStringBuffer sAuthorBuffer;
59 ::rtl::OUStringBuffer sDateTimeBuffer;
60 ::rtl::OUStringBuffer sCommentBuffer;
61 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
62 sal_uInt32 nParagraphCount;
63
64 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
65 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
66
67 public:
68 ScXMLChangeInfoContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
69 const ::com::sun::star::uno::Reference<
70 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
71 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
72 virtual ~ScXMLChangeInfoContext();
73
74 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
75 const ::rtl::OUString& rLocalName,
76 const ::com::sun::star::uno::Reference<
77 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
78
79 virtual void EndElement();
80 };
81
82 //-----------------------------------------------------------------------------
83
84 class ScXMLBigRangeContext : public SvXMLImportContext
85 {
86 ScBigRange& rBigRange;
87
88 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
89 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
90
91 public:
92 ScXMLBigRangeContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
93 const ::com::sun::star::uno::Reference<
94 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
95 ScBigRange& rBigRange);
96 virtual ~ScXMLBigRangeContext();
97
98 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
99 const ::rtl::OUString& rLocalName,
100 const ::com::sun::star::uno::Reference<
101 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
102
103 virtual void EndElement();
104 };
105
106 //-----------------------------------------------------------------------------
107
108 class ScXMLCellContentDeletionContext : public SvXMLImportContext
109 {
110 rtl::OUString sFormulaAddress;
111 rtl::OUString sFormula;
112 rtl::OUString sFormulaNmsp;
113 rtl::OUString sInputString;
114 ScBigRange aBigRange;
115 double fValue;
116 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
117 ScBaseCell* pCell;
118 sal_uInt32 nID;
119 sal_Int32 nMatrixCols;
120 sal_Int32 nMatrixRows;
121 formula::FormulaGrammar::Grammar eGrammar;
122 sal_uInt16 nType;
123 sal_uInt8 nMatrixFlag;
124 sal_Bool bBigRange;
125 sal_Bool bContainsCell;
126
127 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
128 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
129
130 public:
131 ScXMLCellContentDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
132 const ::com::sun::star::uno::Reference<
133 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
134 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
135 virtual ~ScXMLCellContentDeletionContext();
136
137 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
138 const ::rtl::OUString& rLocalName,
139 const ::com::sun::star::uno::Reference<
140 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
141
142 virtual void EndElement();
143 };
144
145 //-----------------------------------------------------------------------------
146
147 class ScXMLDependenceContext : public SvXMLImportContext
148 {
149 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
150
151 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
152 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
153
154 public:
155 ScXMLDependenceContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
156 const ::com::sun::star::uno::Reference<
157 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
158 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
159 virtual ~ScXMLDependenceContext();
160
161 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
162 const ::rtl::OUString& rLocalName,
163 const ::com::sun::star::uno::Reference<
164 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
165
166 virtual void EndElement();
167 };
168
169 //-----------------------------------------------------------------------------
170
171 class ScXMLDependingsContext : public SvXMLImportContext
172 {
173 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
174
175 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
176 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
177
178 public:
179 ScXMLDependingsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
180 const ::com::sun::star::uno::Reference<
181 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
182 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
183 virtual ~ScXMLDependingsContext();
184
185 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
186 const ::rtl::OUString& rLocalName,
187 const ::com::sun::star::uno::Reference<
188 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
189
190 virtual void EndElement();
191 };
192
193 //-----------------------------------------------------------------------------
194
195 class ScXMLChangeDeletionContext : public SvXMLImportContext
196 {
197 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
198
199 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
200 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
201
202 public:
203 ScXMLChangeDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
204 const ::com::sun::star::uno::Reference<
205 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
206 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
207 virtual ~ScXMLChangeDeletionContext();
208
209 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
210 const ::rtl::OUString& rLocalName,
211 const ::com::sun::star::uno::Reference<
212 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
213
214 virtual void EndElement();
215 };
216
217 //-----------------------------------------------------------------------------
218
219 class ScXMLDeletionsContext : public SvXMLImportContext
220 {
221 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
222
223 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
224 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
225
226 public:
227 ScXMLDeletionsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
228 const ::com::sun::star::uno::Reference<
229 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
230 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
231 virtual ~ScXMLDeletionsContext();
232
233 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
234 const ::rtl::OUString& rLocalName,
235 const ::com::sun::star::uno::Reference<
236 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
237
238 virtual void EndElement();
239 };
240
241 //-----------------------------------------------------------------------------
242
243 class ScXMLChangeCellContext;
244
245 class ScXMLChangeTextPContext : public SvXMLImportContext
246 {
247 ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList> xAttrList;
248 rtl::OUString sLName;
249 rtl::OUStringBuffer sText;
250 ScXMLChangeCellContext* pChangeCellContext;
251 SvXMLImportContext* pTextPContext;
252 USHORT nPrefix;
253
254 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
255 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
256
257 public:
258
259 ScXMLChangeTextPContext( ScXMLImport& rImport, USHORT nPrfx,
260 const ::rtl::OUString& rLName,
261 const ::com::sun::star::uno::Reference<
262 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
263 ScXMLChangeCellContext* pChangeCellContext);
264
265 virtual ~ScXMLChangeTextPContext();
266
267 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
268 const ::rtl::OUString& rLocalName,
269 const ::com::sun::star::uno::Reference<
270 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
271
272 virtual void Characters( const ::rtl::OUString& rChars );
273
274 virtual void EndElement();
275 };
276
277 //-----------------------------------------------------------------------------
278
279 class ScXMLChangeCellContext : public SvXMLImportContext
280 {
281 rtl::OUString sText;
282 rtl::OUString& rInputString;
283 ScBaseCell*& rOldCell;
284 ScEditEngineTextObj* pEditTextObj;
285 double& rDateTimeValue;
286 double fValue;
287 sal_uInt16& rType;
288 // sal_Bool bIsMatrix;
289 // sal_Bool bIsCoveredMatrix;
290 sal_Bool bEmpty;
291 sal_Bool bFirstParagraph;
292 sal_Bool bString;
293 sal_Bool bFormula;
294
295 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
296 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
297
298 public:
299 ScXMLChangeCellContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
300 const ::com::sun::star::uno::Reference<
301 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
302 ScBaseCell*& rOldCell, rtl::OUString& sAddress,
303 rtl::OUString& rFormula, rtl::OUString& rFormulaNmsp,
304 formula::FormulaGrammar::Grammar& rGrammar,
305 rtl::OUString& rInputString, double& fValue, sal_uInt16& nType,
306 sal_uInt8& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows);
307 virtual ~ScXMLChangeCellContext();
308
309 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
310 const ::rtl::OUString& rLocalName,
311 const ::com::sun::star::uno::Reference<
312 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
313
314 void CreateTextPContext(sal_Bool bIsNewParagraph);
315 sal_Bool IsEditCell() { return pEditTextObj != 0; }
316 void SetText(const rtl::OUString& sTempText) { sText = sTempText; }
317
318 virtual void EndElement();
319 };
320
321 //-----------------------------------------------------------------------------
322
323 class ScXMLPreviousContext : public SvXMLImportContext
324 {
325 rtl::OUString sFormulaAddress;
326 rtl::OUString sFormula;
327 rtl::OUString sFormulaNmsp;
328 rtl::OUString sInputString;
329 double fValue;
330 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
331 ScBaseCell* pOldCell;
332 sal_uInt32 nID;
333 sal_Int32 nMatrixCols;
334 sal_Int32 nMatrixRows;
335 formula::FormulaGrammar::Grammar eGrammar;
336 sal_uInt16 nType;
337 sal_uInt8 nMatrixFlag;
338
339 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
340 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
341
342 public:
343 ScXMLPreviousContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
344 const ::com::sun::star::uno::Reference<
345 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
346 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
347 virtual ~ScXMLPreviousContext();
348
349 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
350 const ::rtl::OUString& rLocalName,
351 const ::com::sun::star::uno::Reference<
352 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
353
354 virtual void EndElement();
355 };
356
357 //-----------------------------------------------------------------------------
358
359 class ScXMLContentChangeContext : public SvXMLImportContext
360 {
361 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
362 ScBigRange aBigRange;
363
364 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
365 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
366
367 public:
368 ScXMLContentChangeContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
369 const ::com::sun::star::uno::Reference<
370 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
371 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
372 virtual ~ScXMLContentChangeContext();
373
374 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
375 const ::rtl::OUString& rLocalName,
376 const ::com::sun::star::uno::Reference<
377 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
378 virtual void EndElement();
379 };
380
381 //-----------------------------------------------------------------------------
382
383 class ScXMLInsertionContext : public SvXMLImportContext
384 {
385 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
386
387 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
388 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
389
390 public:
391 ScXMLInsertionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
392 const ::com::sun::star::uno::Reference<
393 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
394 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
395 virtual ~ScXMLInsertionContext();
396
397 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
398 const ::rtl::OUString& rLocalName,
399 const ::com::sun::star::uno::Reference<
400 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
401 virtual void EndElement();
402 };
403
404 //-----------------------------------------------------------------------------
405
406 class ScXMLInsertionCutOffContext : public SvXMLImportContext
407 {
408 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
409
410 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
411 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
412
413 public:
414 ScXMLInsertionCutOffContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
415 const ::com::sun::star::uno::Reference<
416 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
417 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
418 virtual ~ScXMLInsertionCutOffContext();
419
420 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
421 const ::rtl::OUString& rLocalName,
422 const ::com::sun::star::uno::Reference<
423 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
424 virtual void EndElement();
425 };
426
427 //-----------------------------------------------------------------------------
428
429 class ScXMLMovementCutOffContext : public SvXMLImportContext
430 {
431 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
432
433 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
434 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
435
436 public:
437 ScXMLMovementCutOffContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
438 const ::com::sun::star::uno::Reference<
439 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
440 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
441 virtual ~ScXMLMovementCutOffContext();
442
443 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
444 const ::rtl::OUString& rLocalName,
445 const ::com::sun::star::uno::Reference<
446 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
447 virtual void EndElement();
448 };
449
450 //-----------------------------------------------------------------------------
451
452 class ScXMLCutOffsContext : public SvXMLImportContext
453 {
454 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
455
456 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
457 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
458
459 public:
460 ScXMLCutOffsContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
461 const ::com::sun::star::uno::Reference<
462 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
463 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
464 virtual ~ScXMLCutOffsContext();
465
466 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
467 const ::rtl::OUString& rLocalName,
468 const ::com::sun::star::uno::Reference<
469 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
470 virtual void EndElement();
471 };
472
473 //-----------------------------------------------------------------------------
474
475 class ScXMLDeletionContext : public SvXMLImportContext
476 {
477 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
478
479 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
480 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
481
482 public:
483 ScXMLDeletionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
484 const ::com::sun::star::uno::Reference<
485 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
486 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
487 virtual ~ScXMLDeletionContext();
488
489 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
490 const ::rtl::OUString& rLocalName,
491 const ::com::sun::star::uno::Reference<
492 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
493 virtual void EndElement();
494 };
495
496 //-----------------------------------------------------------------------------
497
498 class ScXMLMovementContext : public SvXMLImportContext
499 {
500 ScBigRange aSourceRange;
501 ScBigRange aTargetRange;
502 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
503
504 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
505 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
506
507 public:
508 ScXMLMovementContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
509 const ::com::sun::star::uno::Reference<
510 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
511 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
512 virtual ~ScXMLMovementContext();
513
514 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
515 const ::rtl::OUString& rLocalName,
516 const ::com::sun::star::uno::Reference<
517 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
518 virtual void EndElement();
519 };
520
521 //-----------------------------------------------------------------------------
522
523 class ScXMLRejectionContext : public SvXMLImportContext
524 {
525 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper;
526
527 const ScXMLImport& GetScImport() const { return (const ScXMLImport&)GetImport(); }
528 ScXMLImport& GetScImport() { return (ScXMLImport&)GetImport(); }
529
530 public:
531 ScXMLRejectionContext( ScXMLImport& rImport, USHORT nPrfx, const ::rtl::OUString& rLName,
532 const ::com::sun::star::uno::Reference<
533 ::com::sun::star::xml::sax::XAttributeList>& xAttrList,
534 ScXMLChangeTrackingImportHelper* pChangeTrackingImportHelper);
535 virtual ~ScXMLRejectionContext();
536
537 virtual SvXMLImportContext *CreateChildContext( USHORT nPrefix,
538 const ::rtl::OUString& rLocalName,
539 const ::com::sun::star::uno::Reference<
540 ::com::sun::star::xml::sax::XAttributeList>& xAttrList );
541 virtual void EndElement();
542 };
543
544 //------------------------------------------------------------------
545
546 ScXMLTrackedChangesContext::ScXMLTrackedChangesContext( ScXMLImport& rImport,
547 USHORT nPrfx,
548 const ::rtl::OUString& rLName,
549 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
550 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
551 SvXMLImportContext( rImport, nPrfx, rLName ),
552 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
553 {
554 rImport.LockSolarMutex();
555 pChangeTrackingImportHelper->SetChangeTrack(sal_True);
556
557 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
558 for( sal_Int16 i=0; i < nAttrCount; ++i )
559 {
560 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
561 rtl::OUString aLocalName;
562 sal_uInt16 nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
563 sAttrName, &aLocalName ));
564 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
565 if (nPrefix == XML_NAMESPACE_TABLE)
566 {
567 if (IsXMLToken(aLocalName, XML_PROTECTION_KEY))
568 {
569 if (sValue.getLength())
570 {
571 uno::Sequence<sal_Int8> aPass;
572 SvXMLUnitConverter::decodeBase64(aPass, sValue);
573 pChangeTrackingImportHelper->SetProtection(aPass);
574 }
575 }
576 }
577 }
578 }
579
580 ScXMLTrackedChangesContext::~ScXMLTrackedChangesContext()
581 {
582 GetScImport().UnlockSolarMutex();
583 }
584
585 SvXMLImportContext *ScXMLTrackedChangesContext::CreateChildContext( USHORT nPrefix,
586 const ::rtl::OUString& rLocalName,
587 const ::com::sun::star::uno::Reference<
588 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
589 {
590 SvXMLImportContext *pContext(0);
591
592 if (nPrefix == XML_NAMESPACE_TABLE)
593 {
594 if (IsXMLToken(rLocalName, XML_CELL_CONTENT_CHANGE))
595 {
596 pContext = new ScXMLContentChangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
597 }
598 else if (IsXMLToken(rLocalName, XML_INSERTION))
599 {
600 pContext = new ScXMLInsertionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
601 }
602 else if (IsXMLToken(rLocalName, XML_DELETION))
603 {
604 pContext = new ScXMLDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
605 }
606 else if (IsXMLToken(rLocalName, XML_MOVEMENT))
607 {
608 pContext = new ScXMLMovementContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
609 }
610 else if (IsXMLToken(rLocalName, XML_REJECTION))
611 {
612 pContext = new ScXMLRejectionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
613 }
614 }
615
616 if( !pContext )
617 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
618
619 return pContext;
620 }
621
622 void ScXMLTrackedChangesContext::EndElement()
623 {
624 }
625
626 ScXMLChangeInfoContext::ScXMLChangeInfoContext( ScXMLImport& rImport,
627 USHORT nPrfx,
628 const ::rtl::OUString& rLName,
629 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
630 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
631 SvXMLImportContext( rImport, nPrfx, rLName ),
632 aInfo(),
633 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
634 nParagraphCount(0)
635 {
636 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
637 for( sal_Int16 i=0; i < nAttrCount; ++i )
638 {
639 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
640 rtl::OUString aLocalName;
641 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
642 sAttrName, &aLocalName ));
643 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
644
645 if (nPrefix == XML_NAMESPACE_OFFICE)
646 {
647 if (IsXMLToken(aLocalName, XML_CHG_AUTHOR))
648 {
649 sAuthorBuffer = sValue;
650 }
651 else if (IsXMLToken(aLocalName, XML_CHG_DATE_TIME))
652 {
653 sDateTimeBuffer = sValue;
654 }
655 }
656 }
657 }
658
659 ScXMLChangeInfoContext::~ScXMLChangeInfoContext()
660 {
661 }
662
663 SvXMLImportContext *ScXMLChangeInfoContext::CreateChildContext( USHORT nPrefix,
664 const ::rtl::OUString& rLocalName,
665 const ::com::sun::star::uno::Reference<
666 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
667 {
668 SvXMLImportContext *pContext(0);
669
670 if( XML_NAMESPACE_DC == nPrefix )
671 {
672 if( IsXMLToken( rLocalName, XML_CREATOR ) )
673 pContext = new ScXMLContentContext(GetScImport(), nPrefix,
674 rLocalName, xAttrList, sAuthorBuffer);
675 else if( IsXMLToken( rLocalName, XML_DATE ) )
676 pContext = new ScXMLContentContext(GetScImport(), nPrefix,
677 rLocalName, xAttrList, sDateTimeBuffer);
678 }
679 else if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLocalName, XML_P)) )
680 {
681 if(nParagraphCount)
682 sCommentBuffer.append(static_cast<sal_Unicode>('\n'));
683 ++nParagraphCount;
684 pContext = new ScXMLContentContext( GetScImport(), nPrefix, rLocalName, xAttrList, sCommentBuffer);
685 }
686
687 if( !pContext )
688 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
689
690 return pContext;
691 }
692
693 void ScXMLChangeInfoContext::EndElement()
694 {
695 aInfo.sUser = sAuthorBuffer.makeStringAndClear();
696 GetScImport().GetMM100UnitConverter().convertDateTime(aInfo.aDateTime, sDateTimeBuffer.makeStringAndClear());
697 aInfo.sComment = sCommentBuffer.makeStringAndClear();
698 pChangeTrackingImportHelper->SetActionInfo(aInfo);
699 }
700
701 ScXMLBigRangeContext::ScXMLBigRangeContext( ScXMLImport& rImport,
702 USHORT nPrfx,
703 const ::rtl::OUString& rLName,
704 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
705 ScBigRange& rTempBigRange ) :
706 SvXMLImportContext( rImport, nPrfx, rLName ),
707 rBigRange(rTempBigRange)
708 {
709 sal_Bool bColumn(sal_False);
710 sal_Bool bRow(sal_False);
711 sal_Bool bTable(sal_False);
712 sal_Int32 nColumn(0);
713 sal_Int32 nRow(0);
714 sal_Int32 nTable(0);
715 sal_Int32 nStartColumn(0);
716 sal_Int32 nEndColumn(0);
717 sal_Int32 nStartRow(0);
718 sal_Int32 nEndRow(0);
719 sal_Int32 nStartTable(0);
720 sal_Int32 nEndTable(0);
721 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
722 for( sal_Int16 i=0; i < nAttrCount; ++i )
723 {
724 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
725 rtl::OUString aLocalName;
726 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
727 sAttrName, &aLocalName ));
728 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
729
730 if (nPrefix == XML_NAMESPACE_TABLE)
731 {
732 if (IsXMLToken(aLocalName, XML_COLUMN))
733 {
734 SvXMLUnitConverter::convertNumber(nColumn, sValue);
735 bColumn = sal_True;
736 }
737 else if (IsXMLToken(aLocalName, XML_ROW))
738 {
739 SvXMLUnitConverter::convertNumber(nRow, sValue);
740 bRow = sal_True;
741 }
742 else if (IsXMLToken(aLocalName, XML_TABLE))
743 {
744 SvXMLUnitConverter::convertNumber(nTable, sValue);
745 bTable = sal_True;
746 }
747 else if (IsXMLToken(aLocalName, XML_START_COLUMN))
748 SvXMLUnitConverter::convertNumber(nStartColumn, sValue);
749 else if (IsXMLToken(aLocalName, XML_END_COLUMN))
750 SvXMLUnitConverter::convertNumber(nEndColumn, sValue);
751 else if (IsXMLToken(aLocalName, XML_START_ROW))
752 SvXMLUnitConverter::convertNumber(nStartRow, sValue);
753 else if (IsXMLToken(aLocalName, XML_END_ROW))
754 SvXMLUnitConverter::convertNumber(nEndRow, sValue);
755 else if (IsXMLToken(aLocalName, XML_START_TABLE))
756 SvXMLUnitConverter::convertNumber(nStartTable, sValue);
757 else if (IsXMLToken(aLocalName, XML_END_TABLE))
758 SvXMLUnitConverter::convertNumber(nEndTable, sValue);
759 }
760 }
761 if (bColumn)
762 nStartColumn = nEndColumn = nColumn;
763 if (bRow)
764 nStartRow = nEndRow = nRow;
765 if (bTable)
766 nStartTable = nEndTable = nTable;
767 rBigRange.Set(nStartColumn, nStartRow, nStartTable,
768 nEndColumn, nEndRow, nEndTable);
769 }
770
771 ScXMLBigRangeContext::~ScXMLBigRangeContext()
772 {
773 }
774
775 SvXMLImportContext *ScXMLBigRangeContext::CreateChildContext( USHORT nPrefix,
776 const ::rtl::OUString& rLocalName,
777 const ::com::sun::star::uno::Reference<
778 ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
779 {
780 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
781 }
782
783 void ScXMLBigRangeContext::EndElement()
784 {
785 }
786
787 ScXMLCellContentDeletionContext::ScXMLCellContentDeletionContext( ScXMLImport& rImport,
788 USHORT nPrfx,
789 const ::rtl::OUString& rLName,
790 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
791 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper) :
792 SvXMLImportContext( rImport, nPrfx, rLName ),
793 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
794 pCell(NULL),
795 nID(0),
796 nMatrixCols(0),
797 nMatrixRows(0),
798 nType(NUMBERFORMAT_ALL),
799 nMatrixFlag(MM_NONE),
800 bBigRange(sal_False),
801 bContainsCell(sal_False)
802 {
803 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
804 for( sal_Int16 i=0; i < nAttrCount; ++i )
805 {
806 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
807 rtl::OUString aLocalName;
808 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
809 sAttrName, &aLocalName ));
810 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
811
812 if (nPrefix == XML_NAMESPACE_TABLE)
813 {
814 if (IsXMLToken(aLocalName, XML_ID))
815 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
816 }
817 }
818 }
819
820 ScXMLCellContentDeletionContext::~ScXMLCellContentDeletionContext()
821 {
822 }
823
824 SvXMLImportContext *ScXMLCellContentDeletionContext::CreateChildContext( USHORT nPrefix,
825 const ::rtl::OUString& rLocalName,
826 const ::com::sun::star::uno::Reference<
827 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
828 {
829 SvXMLImportContext *pContext(0);
830
831 if (nPrefix == XML_NAMESPACE_TABLE)
832 {
833 if (IsXMLToken(rLocalName, XML_CHANGE_TRACK_TABLE_CELL))
834 {
835 bContainsCell = sal_True;
836 pContext = new ScXMLChangeCellContext(GetScImport(), nPrefix, rLocalName, xAttrList,
837 pCell, sFormulaAddress, sFormula, sFormulaNmsp, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows );
838 }
839 else if (IsXMLToken(rLocalName, XML_CELL_ADDRESS))
840 {
841 DBG_ASSERT(!nID, "a action with a ID should not contain a BigRange");
842 bBigRange = sal_True;
843 pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aBigRange);
844 }
845 }
846
847 if( !pContext )
848 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
849
850 return pContext;
851 }
852
853 void ScXMLCellContentDeletionContext::EndElement()
854 {
855 ScMyCellInfo* pCellInfo(new ScMyCellInfo(pCell, sFormulaAddress, sFormula, eGrammar, sInputString, fValue, nType,
856 nMatrixFlag, nMatrixCols, nMatrixRows));
857 if (nID)
858 pChangeTrackingImportHelper->AddDeleted(nID, pCellInfo);
859 else
860 pChangeTrackingImportHelper->AddGenerated(pCellInfo, aBigRange);
861 }
862
863 ScXMLDependenceContext::ScXMLDependenceContext( ScXMLImport& rImport,
864 USHORT nPrfx,
865 const ::rtl::OUString& rLName,
866 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
867 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
868 SvXMLImportContext( rImport, nPrfx, rLName ),
869 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
870 {
871 sal_uInt32 nID(0);
872 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
873 for( sal_Int16 i=0; i < nAttrCount; ++i )
874 {
875 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
876 rtl::OUString aLocalName;
877 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
878 sAttrName, &aLocalName ));
879 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
880
881 if (nPrefix == XML_NAMESPACE_TABLE)
882 {
883 if (IsXMLToken(aLocalName, XML_ID))
884 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
885 }
886 }
887 pChangeTrackingImportHelper->AddDependence(nID);
888 }
889
890 ScXMLDependenceContext::~ScXMLDependenceContext()
891 {
892 }
893
894 SvXMLImportContext *ScXMLDependenceContext::CreateChildContext( USHORT nPrefix,
895 const ::rtl::OUString& rLocalName,
896 const ::com::sun::star::uno::Reference<
897 ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
898 {
899 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
900 }
901
902 void ScXMLDependenceContext::EndElement()
903 {
904 }
905
906 ScXMLDependingsContext::ScXMLDependingsContext( ScXMLImport& rImport,
907 USHORT nPrfx,
908 const ::rtl::OUString& rLName,
909 const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
910 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
911 SvXMLImportContext( rImport, nPrfx, rLName ),
912 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
913 {
914 // here are no attributes
915 }
916
917 ScXMLDependingsContext::~ScXMLDependingsContext()
918 {
919 }
920
921 SvXMLImportContext *ScXMLDependingsContext::CreateChildContext( USHORT nPrefix,
922 const ::rtl::OUString& rLocalName,
923 const ::com::sun::star::uno::Reference<
924 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
925 {
926 SvXMLImportContext *pContext(0);
927
928 if (nPrefix == XML_NAMESPACE_TABLE)
929 {
930 // #i80033# read both old (dependence) and new (dependency) elements
931 if (IsXMLToken(rLocalName, XML_DEPENDENCE) || IsXMLToken(rLocalName, XML_DEPENDENCY))
932 pContext = new ScXMLDependenceContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
933 }
934
935 if( !pContext )
936 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
937
938 return pContext;
939 }
940
941 void ScXMLDependingsContext::EndElement()
942 {
943 }
944
945 ScXMLChangeDeletionContext::ScXMLChangeDeletionContext( ScXMLImport& rImport,
946 USHORT nPrfx,
947 const ::rtl::OUString& rLName,
948 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
949 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
950 SvXMLImportContext( rImport, nPrfx, rLName ),
951 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
952 {
953 sal_uInt32 nID(0);
954 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
955 for( sal_Int16 i=0; i < nAttrCount; ++i )
956 {
957 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
958 rtl::OUString aLocalName;
959 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
960 sAttrName, &aLocalName ));
961 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
962
963 if (nPrefix == XML_NAMESPACE_TABLE)
964 {
965 if (IsXMLToken(aLocalName, XML_ID))
966 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
967 }
968 }
969 pChangeTrackingImportHelper->AddDeleted(nID);
970 }
971
972 ScXMLChangeDeletionContext::~ScXMLChangeDeletionContext()
973 {
974 }
975
976 SvXMLImportContext *ScXMLChangeDeletionContext::CreateChildContext( USHORT nPrefix,
977 const ::rtl::OUString& rLocalName,
978 const ::com::sun::star::uno::Reference<
979 ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
980 {
981 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
982 }
983
984 void ScXMLChangeDeletionContext::EndElement()
985 {
986 }
987
988 ScXMLDeletionsContext::ScXMLDeletionsContext( ScXMLImport& rImport,
989 USHORT nPrfx,
990 const ::rtl::OUString& rLName,
991 const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
992 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
993 SvXMLImportContext( rImport, nPrfx, rLName ),
994 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
995 {
996 // here are no attributes
997 }
998
999 ScXMLDeletionsContext::~ScXMLDeletionsContext()
1000 {
1001 }
1002
1003 SvXMLImportContext *ScXMLDeletionsContext::CreateChildContext( USHORT nPrefix,
1004 const ::rtl::OUString& rLocalName,
1005 const ::com::sun::star::uno::Reference<
1006 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1007 {
1008 SvXMLImportContext *pContext(0);
1009
1010 if (nPrefix == XML_NAMESPACE_TABLE)
1011 {
1012 if (IsXMLToken(rLocalName, XML_CHANGE_DELETION))
1013 pContext = new ScXMLChangeDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1014 else if (IsXMLToken(rLocalName, XML_CELL_CONTENT_DELETION))
1015 pContext = new ScXMLCellContentDeletionContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1016 }
1017
1018 if( !pContext )
1019 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1020
1021 return pContext;
1022 }
1023
1024 void ScXMLDeletionsContext::EndElement()
1025 {
1026 }
1027
1028 ScXMLChangeTextPContext::ScXMLChangeTextPContext( ScXMLImport& rImport,
1029 USHORT nPrfx,
1030 const ::rtl::OUString& rLName,
1031 const ::com::sun::star::uno::Reference<
1032 ::com::sun::star::xml::sax::XAttributeList>& xTempAttrList,
1033 ScXMLChangeCellContext* pTempChangeCellContext) :
1034 SvXMLImportContext( rImport, nPrfx, rLName ),
1035 xAttrList(xTempAttrList),
1036 sLName(rLName),
1037 sText(),
1038 pChangeCellContext(pTempChangeCellContext),
1039 pTextPContext(NULL),
1040 nPrefix(nPrfx)
1041 {
1042 // here are no attributes
1043 }
1044
1045 ScXMLChangeTextPContext::~ScXMLChangeTextPContext()
1046 {
1047 if (pTextPContext)
1048 delete pTextPContext;
1049 }
1050
1051 SvXMLImportContext *ScXMLChangeTextPContext::CreateChildContext( USHORT nTempPrefix,
1052 const ::rtl::OUString& rLName,
1053 const ::com::sun::star::uno::Reference<
1054 ::com::sun::star::xml::sax::XAttributeList>& xTempAttrList )
1055 {
1056 SvXMLImportContext *pContext(0);
1057
1058 if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLName, XML_S)) && !pTextPContext)
1059 {
1060 sal_Int32 nRepeat(0);
1061 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1062 for( sal_Int16 i=0; i < nAttrCount; ++i )
1063 {
1064 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1065 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1066 rtl::OUString aLocalName;
1067 USHORT nPrfx(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1068 sAttrName, &aLocalName ));
1069 if ((nPrfx == XML_NAMESPACE_TEXT) && (IsXMLToken(aLocalName, XML_C)))
1070 nRepeat = sValue.toInt32();
1071 }
1072 if (nRepeat)
1073 for (sal_Int32 j = 0; j < nRepeat; ++j)
1074 sText.append(static_cast<sal_Unicode>(' '));
1075 else
1076 sText.append(static_cast<sal_Unicode>(' '));
1077 }
1078 else
1079 {
1080 if (!pChangeCellContext->IsEditCell())
1081 pChangeCellContext->CreateTextPContext(sal_False);
1082 sal_Bool bWasContext (sal_True);
1083 if (!pTextPContext)
1084 {
1085 bWasContext = sal_False;
1086 pTextPContext = GetScImport().GetTextImport()->CreateTextChildContext(
1087 GetScImport(), nPrefix, sLName, xAttrList);
1088 }
1089 if (pTextPContext)
1090 {
1091 if (!bWasContext)
1092 pTextPContext->Characters(sText.makeStringAndClear());
1093 pContext = pTextPContext->CreateChildContext(nTempPrefix, rLName, xTempAttrList);
1094 }
1095 }
1096
1097 if( !pContext )
1098 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLName );
1099
1100 return pContext;
1101 }
1102
1103 void ScXMLChangeTextPContext::Characters( const ::rtl::OUString& rChars )
1104 {
1105 if (!pTextPContext)
1106 sText.append(rChars);
1107 else
1108 pTextPContext->Characters(rChars);
1109 }
1110
1111 void ScXMLChangeTextPContext::EndElement()
1112 {
1113 if (!pTextPContext)
1114 pChangeCellContext->SetText(sText.makeStringAndClear());
1115 }
1116
1117 ScXMLChangeCellContext::ScXMLChangeCellContext( ScXMLImport& rImport,
1118 USHORT nPrfx,
1119 const ::rtl::OUString& rLName,
1120 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1121 ScBaseCell*& rTempOldCell, rtl::OUString& rAddress,
1122 rtl::OUString& rFormula, rtl::OUString& rFormulaNmsp,
1123 formula::FormulaGrammar::Grammar& rGrammar,
1124 rtl::OUString& rTempInputString, double& fDateTimeValue, sal_uInt16& nType,
1125 sal_uInt8& nMatrixFlag, sal_Int32& nMatrixCols, sal_Int32& nMatrixRows ) :
1126 SvXMLImportContext( rImport, nPrfx, rLName ),
1127 rInputString(rTempInputString),
1128 rOldCell(rTempOldCell),
1129 pEditTextObj(NULL),
1130 rDateTimeValue(fDateTimeValue),
1131 rType(nType),
1132 bEmpty(sal_True),
1133 bFirstParagraph(sal_True),
1134 bString(sal_True),
1135 bFormula(sal_False)
1136 {
1137 sal_Bool bIsMatrix(sal_False);
1138 sal_Bool bIsCoveredMatrix(sal_False);
1139 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1140 for( sal_Int16 i=0; i < nAttrCount; ++i )
1141 {
1142 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1143 rtl::OUString aLocalName;
1144 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1145 sAttrName, &aLocalName ));
1146 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1147
1148 if (nPrefix == XML_NAMESPACE_TABLE)
1149 {
1150 if (IsXMLToken(aLocalName, XML_FORMULA))
1151 {
1152 bEmpty = sal_False;
1153 GetScImport().ExtractFormulaNamespaceGrammar( rFormula, rFormulaNmsp, rGrammar, sValue );
1154 bFormula = sal_True;
1155 }
1156 else if (IsXMLToken(aLocalName, XML_CELL_ADDRESS))
1157 {
1158 rAddress = sValue;
1159 }
1160 else if (IsXMLToken(aLocalName, XML_MATRIX_COVERED))
1161 {
1162 bIsCoveredMatrix = IsXMLToken(sValue, XML_TRUE);
1163 }
1164 else if (IsXMLToken(aLocalName, XML_NUMBER_MATRIX_COLUMNS_SPANNED))
1165 {
1166 bIsMatrix = sal_True;
1167 SvXMLUnitConverter::convertNumber(nMatrixCols, sValue);
1168 }
1169 else if (IsXMLToken(aLocalName, XML_NUMBER_MATRIX_ROWS_SPANNED))
1170 {
1171 bIsMatrix = sal_True;
1172 SvXMLUnitConverter::convertNumber(nMatrixRows, sValue);
1173 }
1174 }
1175 else if (nPrefix == XML_NAMESPACE_OFFICE)
1176 {
1177 if (IsXMLToken(aLocalName, XML_VALUE_TYPE))
1178 {
1179 if (IsXMLToken(sValue, XML_FLOAT))
1180 bString = sal_False;
1181 else if (IsXMLToken(sValue, XML_DATE))
1182 {
1183 rType = NUMBERFORMAT_DATE;
1184 bString = sal_False;
1185 }
1186 else if (IsXMLToken(sValue, XML_TIME))
1187 {
1188 rType = NUMBERFORMAT_TIME;
1189 bString = sal_False;
1190 }
1191 }
1192 else if (IsXMLToken(aLocalName, XML_VALUE))
1193 {
1194 SvXMLUnitConverter::convertDouble(fValue, sValue);
1195 bEmpty = sal_False;
1196 }
1197 else if (IsXMLToken(aLocalName, XML_DATE_VALUE))
1198 {
1199 bEmpty = sal_False;
1200 if (GetScImport().GetMM100UnitConverter().setNullDate(GetScImport().GetModel()))
1201 GetScImport().GetMM100UnitConverter().convertDateTime(rDateTimeValue, sValue);
1202 fValue = rDateTimeValue;
1203 }
1204 else if (IsXMLToken(aLocalName, XML_TIME_VALUE))
1205 {
1206 bEmpty = sal_False;
1207 GetScImport().GetMM100UnitConverter().convertTime(rDateTimeValue, sValue);
1208 fValue = rDateTimeValue;
1209 }
1210 }
1211 }
1212 if (bIsCoveredMatrix)
1213 nMatrixFlag = MM_REFERENCE;
1214 else if (bIsMatrix && nMatrixRows && nMatrixCols)
1215 nMatrixFlag = MM_FORMULA;
1216 }
1217
1218 ScXMLChangeCellContext::~ScXMLChangeCellContext()
1219 {
1220 }
1221
1222 SvXMLImportContext *ScXMLChangeCellContext::CreateChildContext( USHORT nPrefix,
1223 const ::rtl::OUString& rLocalName,
1224 const ::com::sun::star::uno::Reference<
1225 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1226 {
1227 SvXMLImportContext *pContext(0);
1228
1229 if ((nPrefix == XML_NAMESPACE_TEXT) && (IsXMLToken(rLocalName, XML_P)))
1230 {
1231 bEmpty = sal_False;
1232 if (bFirstParagraph)
1233 {
1234 pContext = new ScXMLChangeTextPContext(GetScImport(), nPrefix, rLocalName, xAttrList, this);
1235 bFirstParagraph = sal_False;
1236 }
1237 else
1238 {
1239 if (!pEditTextObj)
1240 CreateTextPContext(sal_True);
1241 pContext = GetScImport().GetTextImport()->CreateTextChildContext(
1242 GetScImport(), nPrefix, rLocalName, xAttrList);
1243 }
1244 }
1245
1246 if( !pContext )
1247 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1248
1249 return pContext;
1250 }
1251
1252 void ScXMLChangeCellContext::CreateTextPContext(sal_Bool bIsNewParagraph)
1253 {
1254 if (GetScImport().GetDocument())
1255 {
1256 pEditTextObj = new ScEditEngineTextObj();
1257 pEditTextObj->acquire();
1258 pEditTextObj->GetEditEngine()->SetEditTextObjectPool(GetScImport().GetDocument()->GetEditPool());
1259 uno::Reference <text::XText> xText(pEditTextObj);
1260 if (xText.is())
1261 {
1262 uno::Reference<text::XTextCursor> xTextCursor(xText->createTextCursor());
1263 if (bIsNewParagraph)
1264 {
1265 xText->setString(sText);
1266 xTextCursor->gotoEnd(sal_False);
1267 uno::Reference < text::XTextRange > xTextRange (xTextCursor, uno::UNO_QUERY);
1268 if (xTextRange.is())
1269 xText->insertControlCharacter(xTextRange, text::ControlCharacter::PARAGRAPH_BREAK, sal_False);
1270 }
1271 GetScImport().GetTextImport()->SetCursor(xTextCursor);
1272 }
1273 }
1274 }
1275
1276 void ScXMLChangeCellContext::EndElement()
1277 {
1278 if (!bEmpty)
1279 {
1280 if (pEditTextObj)
1281 {
1282 if (GetImport().GetTextImport()->GetCursor().is())
1283 {
1284 //GetImport().GetTextImport()->GetCursor()->gotoEnd(sal_False);
1285 if( GetImport().GetTextImport()->GetCursor()->goLeft( 1, sal_True ) )
1286 {
1287 OUString sEmpty;
1288 GetImport().GetTextImport()->GetText()->insertString(
1289 GetImport().GetTextImport()->GetCursorAsRange(), sEmpty,
1290 sal_True );
1291 }
1292 }
1293 if (GetScImport().GetDocument())
1294 rOldCell = new ScEditCell(pEditTextObj->CreateTextObject(), GetScImport().GetDocument(), GetScImport().GetDocument()->GetEditPool());
1295 GetScImport().GetTextImport()->ResetCursor();
1296 // delete pEditTextObj;
1297 pEditTextObj->release();
1298 }
1299 else
1300 {
1301 if (!bFormula)
1302 {
1303 if (sText.getLength() && bString)
1304 rOldCell = new ScStringCell(sText);
1305 else
1306 rOldCell = new ScValueCell(fValue);
1307 if (rType == NUMBERFORMAT_DATE || rType == NUMBERFORMAT_TIME)
1308 rInputString = sText;
1309 }
1310 else
1311 {
1312 // do nothing, this has to do later (on another place)
1313 /*ScAddress aCellPos;
1314 rOldCell = new ScFormulaCell(GetScImport().GetDocument(), aCellPos, sFormula);
1315 if (bString)
1316 static_cast<ScFormulaCell*>(rOldCell)->SetString(sValue);
1317 else
1318 static_cast<ScFormulaCell*>(rOldCell)->SetDouble(fValue);
1319 static_cast<ScFormulaCell*>(rOldCell)->SetInChangeTrack(sal_True);
1320 if (bIsCoveredMatrix)
1321 static_cast<ScFormulaCell*>(rOldCell)->SetMatrixFlag(MM_REFERENCE);
1322 else if (bIsMatrix && nMatrixRows && nMatrixCols)
1323 {
1324 static_cast<ScFormulaCell*>(rOldCell)->SetMatrixFlag(MM_FORMULA);
1325 static_cast<ScFormulaCell*>(rOldCell)->SetMatColsRows(static_cast<SCCOL>(nMatrixCols), static_cast<SCROW>(nMatrixRows));
1326 }*/
1327 }
1328 }
1329 }
1330 else
1331 rOldCell = NULL;
1332 }
1333
1334 ScXMLPreviousContext::ScXMLPreviousContext( ScXMLImport& rImport,
1335 USHORT nPrfx,
1336 const ::rtl::OUString& rLName,
1337 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1338 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1339 SvXMLImportContext( rImport, nPrfx, rLName ),
1340 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper),
1341 pOldCell(NULL),
1342 nID(0),
1343 nMatrixCols(0),
1344 nMatrixRows(0),
1345 eGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT),
1346 nType(NUMBERFORMAT_ALL),
1347 nMatrixFlag(MM_NONE)
1348 {
1349 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1350 for( sal_Int16 i=0; i < nAttrCount; ++i )
1351 {
1352 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1353 rtl::OUString aLocalName;
1354 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1355 sAttrName, &aLocalName ));
1356 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1357
1358 if (nPrefix == XML_NAMESPACE_TABLE)
1359 {
1360 if (IsXMLToken(aLocalName, XML_ID))
1361 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1362 }
1363 }
1364 }
1365
1366 ScXMLPreviousContext::~ScXMLPreviousContext()
1367 {
1368 }
1369
1370 SvXMLImportContext *ScXMLPreviousContext::CreateChildContext( USHORT nPrefix,
1371 const ::rtl::OUString& rLocalName,
1372 const ::com::sun::star::uno::Reference<
1373 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1374 {
1375 SvXMLImportContext *pContext(0);
1376
1377 if ((nPrefix == XML_NAMESPACE_TABLE) && (IsXMLToken(rLocalName, XML_CHANGE_TRACK_TABLE_CELL)))
1378 pContext = new ScXMLChangeCellContext(GetScImport(), nPrefix, rLocalName, xAttrList,
1379 pOldCell, sFormulaAddress, sFormula, sFormulaNmsp, eGrammar, sInputString, fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows);
1380
1381 if( !pContext )
1382 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1383
1384 return pContext;
1385 }
1386
1387 void ScXMLPreviousContext::EndElement()
1388 {
1389 pChangeTrackingImportHelper->SetPreviousChange(nID, new ScMyCellInfo(pOldCell, sFormulaAddress, sFormula, eGrammar, sInputString,
1390 fValue, nType, nMatrixFlag, nMatrixCols, nMatrixRows));
1391 }
1392
1393 ScXMLContentChangeContext::ScXMLContentChangeContext( ScXMLImport& rImport,
1394 USHORT nPrfx,
1395 const ::rtl::OUString& rLName,
1396 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1397 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1398 SvXMLImportContext( rImport, nPrfx, rLName ),
1399 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1400 {
1401 sal_uInt32 nActionNumber(0);
1402 sal_uInt32 nRejectingNumber(0);
1403 ScChangeActionState nActionState(SC_CAS_VIRGIN);
1404
1405 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1406 for( sal_Int16 i=0; i < nAttrCount; ++i )
1407 {
1408 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1409 rtl::OUString aLocalName;
1410 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1411 sAttrName, &aLocalName ));
1412 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1413
1414 if (nPrefix == XML_NAMESPACE_TABLE)
1415 {
1416 if (IsXMLToken(aLocalName, XML_ID))
1417 {
1418 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1419 }
1420 else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1421 {
1422 if (IsXMLToken(sValue, XML_ACCEPTED))
1423 nActionState = SC_CAS_ACCEPTED;
1424 else if (IsXMLToken(sValue, XML_REJECTED))
1425 nActionState = SC_CAS_REJECTED;
1426 }
1427 else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1428 {
1429 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1430 }
1431 }
1432 }
1433
1434 pChangeTrackingImportHelper->StartChangeAction(SC_CAT_CONTENT);
1435 pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1436 pChangeTrackingImportHelper->SetActionState(nActionState);
1437 pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1438 }
1439
1440 ScXMLContentChangeContext::~ScXMLContentChangeContext()
1441 {
1442 }
1443
1444 SvXMLImportContext *ScXMLContentChangeContext::CreateChildContext( USHORT nPrefix,
1445 const ::rtl::OUString& rLocalName,
1446 const ::com::sun::star::uno::Reference<
1447 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1448 {
1449 SvXMLImportContext *pContext(0);
1450
1451 if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1452 {
1453 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1454 }
1455 else if (nPrefix == XML_NAMESPACE_TABLE)
1456 {
1457 if (IsXMLToken(rLocalName, XML_CELL_ADDRESS))
1458 {
1459 pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aBigRange);
1460 }
1461 else if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1462 {
1463 pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1464 }
1465 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1466 pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1467 else if (IsXMLToken(rLocalName, XML_PREVIOUS))
1468 {
1469 pContext = new ScXMLPreviousContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1470 }
1471 }
1472
1473 if( !pContext )
1474 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1475
1476 return pContext;
1477 }
1478
1479 void ScXMLContentChangeContext::EndElement()
1480 {
1481 pChangeTrackingImportHelper->SetBigRange(aBigRange);
1482 pChangeTrackingImportHelper->EndChangeAction();
1483 }
1484
1485 ScXMLInsertionContext::ScXMLInsertionContext( ScXMLImport& rImport,
1486 USHORT nPrfx,
1487 const ::rtl::OUString& rLName,
1488 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1489 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1490 SvXMLImportContext( rImport, nPrfx, rLName ),
1491 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1492 {
1493 sal_uInt32 nActionNumber(0);
1494 sal_uInt32 nRejectingNumber(0);
1495 sal_Int32 nPosition(0);
1496 sal_Int32 nCount(1);
1497 sal_Int32 nTable(0);
1498 ScChangeActionState nActionState(SC_CAS_VIRGIN);
1499 ScChangeActionType nActionType(SC_CAT_INSERT_COLS);
1500
1501 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1502 for( sal_Int16 i=0; i < nAttrCount; ++i )
1503 {
1504 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1505 rtl::OUString aLocalName;
1506 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1507 sAttrName, &aLocalName ));
1508 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1509
1510 if (nPrefix == XML_NAMESPACE_TABLE)
1511 {
1512 if (IsXMLToken(aLocalName, XML_ID))
1513 {
1514 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1515 }
1516 else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1517 {
1518 if (IsXMLToken(sValue, XML_ACCEPTED))
1519 nActionState = SC_CAS_ACCEPTED;
1520 else if (IsXMLToken(sValue, XML_REJECTED))
1521 nActionState = SC_CAS_REJECTED;
1522 }
1523 else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1524 {
1525 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1526 }
1527 else if (IsXMLToken(aLocalName, XML_TYPE))
1528 {
1529 if (IsXMLToken(sValue, XML_ROW))
1530 nActionType = SC_CAT_INSERT_ROWS;
1531 else if (IsXMLToken(sValue, XML_TABLE))
1532 nActionType = SC_CAT_INSERT_TABS;
1533 }
1534 else if (IsXMLToken(aLocalName, XML_POSITION))
1535 {
1536 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1537 }
1538 else if (IsXMLToken(aLocalName, XML_TABLE))
1539 {
1540 SvXMLUnitConverter::convertNumber(nTable, sValue);
1541 }
1542 else if (IsXMLToken(aLocalName, XML_COUNT))
1543 {
1544 SvXMLUnitConverter::convertNumber(nCount, sValue);
1545 }
1546 }
1547 }
1548
1549 pChangeTrackingImportHelper->StartChangeAction(nActionType);
1550 pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1551 pChangeTrackingImportHelper->SetActionState(nActionState);
1552 pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1553 pChangeTrackingImportHelper->SetPosition(nPosition, nCount, nTable);
1554 }
1555
1556 ScXMLInsertionContext::~ScXMLInsertionContext()
1557 {
1558 }
1559
1560 SvXMLImportContext *ScXMLInsertionContext::CreateChildContext( USHORT nPrefix,
1561 const ::rtl::OUString& rLocalName,
1562 const ::com::sun::star::uno::Reference<
1563 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1564 {
1565 SvXMLImportContext *pContext(0);
1566
1567 if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1568 {
1569 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1570 }
1571 else if (nPrefix == XML_NAMESPACE_TABLE)
1572 {
1573 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1574 pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1575 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1576 pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1577 }
1578
1579 if( !pContext )
1580 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1581
1582 return pContext;
1583 }
1584
1585 void ScXMLInsertionContext::EndElement()
1586 {
1587 pChangeTrackingImportHelper->EndChangeAction();
1588 }
1589
1590 ScXMLInsertionCutOffContext::ScXMLInsertionCutOffContext( ScXMLImport& rImport,
1591 USHORT nPrfx,
1592 const ::rtl::OUString& rLName,
1593 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1594 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1595 SvXMLImportContext( rImport, nPrfx, rLName ),
1596 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1597 {
1598 sal_uInt32 nID(0);
1599 sal_Int32 nPosition(0);
1600 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1601 for( sal_Int16 i=0; i < nAttrCount; ++i )
1602 {
1603 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1604 rtl::OUString aLocalName;
1605 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1606 sAttrName, &aLocalName ));
1607 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1608
1609 if (nPrefix == XML_NAMESPACE_TABLE)
1610 {
1611 if (IsXMLToken(aLocalName, XML_ID))
1612 {
1613 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1614 }
1615 else if (IsXMLToken(aLocalName, XML_POSITION))
1616 {
1617 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1618 }
1619 }
1620 }
1621 pChangeTrackingImportHelper->SetInsertionCutOff(nID, nPosition);
1622 }
1623
1624 ScXMLInsertionCutOffContext::~ScXMLInsertionCutOffContext()
1625 {
1626 }
1627
1628 SvXMLImportContext *ScXMLInsertionCutOffContext::CreateChildContext( USHORT nPrefix,
1629 const ::rtl::OUString& rLocalName,
1630 const ::com::sun::star::uno::Reference<
1631 ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
1632 {
1633 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1634 }
1635
1636 void ScXMLInsertionCutOffContext::EndElement()
1637 {
1638 }
1639
1640 ScXMLMovementCutOffContext::ScXMLMovementCutOffContext( ScXMLImport& rImport,
1641 USHORT nPrfx,
1642 const ::rtl::OUString& rLName,
1643 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1644 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1645 SvXMLImportContext( rImport, nPrfx, rLName ),
1646 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1647 {
1648 sal_uInt32 nID(0);
1649 sal_Int32 nPosition(0);
1650 sal_Int32 nStartPosition(0);
1651 sal_Int32 nEndPosition(0);
1652 sal_Bool bPosition(sal_False);
1653 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1654 for( sal_Int16 i=0; i < nAttrCount; ++i )
1655 {
1656 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1657 rtl::OUString aLocalName;
1658 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1659 sAttrName, &aLocalName ));
1660 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1661
1662 if (nPrefix == XML_NAMESPACE_TABLE)
1663 {
1664 if (IsXMLToken(aLocalName, XML_ID))
1665 {
1666 nID = pChangeTrackingImportHelper->GetIDFromString(sValue);
1667 }
1668 else if (IsXMLToken(aLocalName, XML_POSITION))
1669 {
1670 bPosition = sal_True;
1671 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1672 }
1673 else if (IsXMLToken(aLocalName, XML_START_POSITION))
1674 {
1675 SvXMLUnitConverter::convertNumber(nStartPosition, sValue);
1676 }
1677 else if (IsXMLToken(aLocalName, XML_END_POSITION))
1678 {
1679 SvXMLUnitConverter::convertNumber(nEndPosition, sValue);
1680 }
1681 }
1682 }
1683 if (bPosition)
1684 nStartPosition = nEndPosition = nPosition;
1685 pChangeTrackingImportHelper->AddMoveCutOff(nID, nStartPosition, nEndPosition);
1686 }
1687
1688 ScXMLMovementCutOffContext::~ScXMLMovementCutOffContext()
1689 {
1690 }
1691
1692 SvXMLImportContext *ScXMLMovementCutOffContext::CreateChildContext( USHORT nPrefix,
1693 const ::rtl::OUString& rLocalName,
1694 const ::com::sun::star::uno::Reference<
1695 ::com::sun::star::xml::sax::XAttributeList>& /* xAttrList */ )
1696 {
1697 return new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1698 }
1699
1700 void ScXMLMovementCutOffContext::EndElement()
1701 {
1702 }
1703
1704 ScXMLCutOffsContext::ScXMLCutOffsContext( ScXMLImport& rImport,
1705 USHORT nPrfx,
1706 const ::rtl::OUString& rLName,
1707 const uno::Reference<xml::sax::XAttributeList>& /* xAttrList */,
1708 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1709 SvXMLImportContext( rImport, nPrfx, rLName ),
1710 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1711 {
1712 // here are no attributes
1713 }
1714
1715 ScXMLCutOffsContext::~ScXMLCutOffsContext()
1716 {
1717 }
1718
1719 SvXMLImportContext *ScXMLCutOffsContext::CreateChildContext( USHORT nPrefix,
1720 const ::rtl::OUString& rLocalName,
1721 const ::com::sun::star::uno::Reference<
1722 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1723 {
1724 SvXMLImportContext *pContext(0);
1725
1726 if (nPrefix == XML_NAMESPACE_TABLE)
1727 {
1728 if (IsXMLToken(rLocalName, XML_INSERTION_CUT_OFF))
1729 pContext = new ScXMLInsertionCutOffContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1730 else if (IsXMLToken(rLocalName, XML_MOVEMENT_CUT_OFF))
1731 pContext = new ScXMLMovementCutOffContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1732 }
1733
1734 if( !pContext )
1735 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1736
1737 return pContext;
1738 }
1739
1740 void ScXMLCutOffsContext::EndElement()
1741 {
1742 }
1743
1744 ScXMLDeletionContext::ScXMLDeletionContext( ScXMLImport& rImport,
1745 USHORT nPrfx,
1746 const ::rtl::OUString& rLName,
1747 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1748 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1749 SvXMLImportContext( rImport, nPrfx, rLName ),
1750 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1751 {
1752 sal_uInt32 nActionNumber(0);
1753 sal_uInt32 nRejectingNumber(0);
1754 sal_Int32 nPosition(0);
1755 sal_Int32 nMultiSpanned(0);
1756 sal_Int32 nTable(0);
1757 ScChangeActionState nActionState(SC_CAS_VIRGIN);
1758 ScChangeActionType nActionType(SC_CAT_DELETE_COLS);
1759
1760 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1761 for( sal_Int16 i=0; i < nAttrCount; i++ )
1762 {
1763 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1764 rtl::OUString aLocalName;
1765 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1766 sAttrName, &aLocalName ));
1767 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1768
1769 if (nPrefix == XML_NAMESPACE_TABLE)
1770 {
1771 if (IsXMLToken(aLocalName, XML_ID))
1772 {
1773 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1774 }
1775 else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1776 {
1777 if (IsXMLToken(sValue, XML_ACCEPTED))
1778 nActionState = SC_CAS_ACCEPTED;
1779 else if (IsXMLToken(sValue, XML_REJECTED))
1780 nActionState = SC_CAS_REJECTED;
1781 }
1782 else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1783 {
1784 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1785 }
1786 else if (IsXMLToken(aLocalName, XML_TYPE))
1787 {
1788 if (IsXMLToken(sValue, XML_ROW))
1789 {
1790 nActionType = SC_CAT_DELETE_ROWS;
1791 }
1792 else if (IsXMLToken(aLocalName, XML_TABLE))
1793 {
1794 nActionType = SC_CAT_DELETE_TABS;
1795 }
1796 }
1797 else if (IsXMLToken(aLocalName, XML_POSITION))
1798 {
1799 SvXMLUnitConverter::convertNumber(nPosition, sValue);
1800 }
1801 else if (IsXMLToken(aLocalName, XML_TABLE))
1802 {
1803 SvXMLUnitConverter::convertNumber(nTable, sValue);
1804 }
1805 else if (IsXMLToken(aLocalName, XML_MULTI_DELETION_SPANNED))
1806 {
1807 SvXMLUnitConverter::convertNumber(nMultiSpanned, sValue);
1808 }
1809 }
1810 }
1811
1812 pChangeTrackingImportHelper->StartChangeAction(nActionType);
1813 pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1814 pChangeTrackingImportHelper->SetActionState(nActionState);
1815 pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1816 pChangeTrackingImportHelper->SetPosition(nPosition, 1, nTable);
1817 pChangeTrackingImportHelper->SetMultiSpanned(static_cast<sal_Int16>(nMultiSpanned));
1818 }
1819
1820 ScXMLDeletionContext::~ScXMLDeletionContext()
1821 {
1822 }
1823
1824 SvXMLImportContext *ScXMLDeletionContext::CreateChildContext( USHORT nPrefix,
1825 const ::rtl::OUString& rLocalName,
1826 const ::com::sun::star::uno::Reference<
1827 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1828 {
1829 SvXMLImportContext *pContext(0);
1830
1831 if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1832 {
1833 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1834 }
1835 else if (nPrefix == XML_NAMESPACE_TABLE)
1836 {
1837 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1838 pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1839 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1840 pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1841 else if (IsXMLToken(rLocalName, XML_CUT_OFFS) || rLocalName.equalsAsciiL("cut_offs", 8))
1842 pContext = new ScXMLCutOffsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1843 else
1844 {
1845 DBG_ERROR("don't know this");
1846 }
1847 }
1848
1849 if( !pContext )
1850 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1851
1852 return pContext;
1853 }
1854
1855 void ScXMLDeletionContext::EndElement()
1856 {
1857 pChangeTrackingImportHelper->EndChangeAction();
1858 }
1859
1860 ScXMLMovementContext::ScXMLMovementContext( ScXMLImport& rImport,
1861 USHORT nPrfx,
1862 const ::rtl::OUString& rLName,
1863 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1864 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1865 SvXMLImportContext( rImport, nPrfx, rLName ),
1866 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1867 {
1868 sal_uInt32 nActionNumber(0);
1869 sal_uInt32 nRejectingNumber(0);
1870 ScChangeActionState nActionState(SC_CAS_VIRGIN);
1871
1872 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1873 for( sal_Int16 i=0; i < nAttrCount; ++i )
1874 {
1875 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1876 rtl::OUString aLocalName;
1877 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1878 sAttrName, &aLocalName ));
1879 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1880
1881 if (nPrefix == XML_NAMESPACE_TABLE)
1882 {
1883 if (IsXMLToken(aLocalName, XML_ID))
1884 {
1885 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1886 }
1887 else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1888 {
1889 if (IsXMLToken(sValue, XML_ACCEPTED))
1890 nActionState = SC_CAS_ACCEPTED;
1891 else if (IsXMLToken(sValue, XML_REJECTED))
1892 nActionState = SC_CAS_REJECTED;
1893 }
1894 else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1895 {
1896 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1897 }
1898 }
1899 }
1900
1901 pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1902 pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1903 pChangeTrackingImportHelper->SetActionState(nActionState);
1904 pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1905 }
1906
1907 ScXMLMovementContext::~ScXMLMovementContext()
1908 {
1909 }
1910
1911 SvXMLImportContext *ScXMLMovementContext::CreateChildContext( USHORT nPrefix,
1912 const ::rtl::OUString& rLocalName,
1913 const ::com::sun::star::uno::Reference<
1914 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
1915 {
1916 SvXMLImportContext *pContext(0);
1917
1918 if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
1919 {
1920 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1921 }
1922 else if (nPrefix == XML_NAMESPACE_TABLE)
1923 {
1924 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
1925 pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1926 else if (IsXMLToken(rLocalName, XML_DELETIONS))
1927 pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
1928 else if (IsXMLToken(rLocalName, XML_SOURCE_RANGE_ADDRESS))
1929 pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aSourceRange);
1930 else if (IsXMLToken(rLocalName, XML_TARGET_RANGE_ADDRESS))
1931 pContext = new ScXMLBigRangeContext(GetScImport(), nPrefix, rLocalName, xAttrList, aTargetRange);
1932 }
1933
1934 if( !pContext )
1935 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
1936
1937 return pContext;
1938 }
1939
1940 void ScXMLMovementContext::EndElement()
1941 {
1942 pChangeTrackingImportHelper->SetMoveRanges(aSourceRange, aTargetRange);
1943 pChangeTrackingImportHelper->EndChangeAction();
1944 }
1945
1946 ScXMLRejectionContext::ScXMLRejectionContext( ScXMLImport& rImport,
1947 USHORT nPrfx,
1948 const ::rtl::OUString& rLName,
1949 const uno::Reference<xml::sax::XAttributeList>& xAttrList,
1950 ScXMLChangeTrackingImportHelper* pTempChangeTrackingImportHelper ) :
1951 SvXMLImportContext( rImport, nPrfx, rLName ),
1952 pChangeTrackingImportHelper(pTempChangeTrackingImportHelper)
1953 {
1954 sal_uInt32 nActionNumber(0);
1955 sal_uInt32 nRejectingNumber(0);
1956 ScChangeActionState nActionState(SC_CAS_VIRGIN);
1957
1958 sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0);
1959 for( sal_Int16 i=0; i < nAttrCount; ++i )
1960 {
1961 const rtl::OUString& sAttrName(xAttrList->getNameByIndex( i ));
1962 rtl::OUString aLocalName;
1963 USHORT nPrefix(GetScImport().GetNamespaceMap().GetKeyByAttrName(
1964 sAttrName, &aLocalName ));
1965 const rtl::OUString& sValue(xAttrList->getValueByIndex( i ));
1966
1967 if (nPrefix == XML_NAMESPACE_TABLE)
1968 {
1969 if (IsXMLToken(aLocalName, XML_ID))
1970 {
1971 nActionNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1972 }
1973 else if (IsXMLToken(aLocalName, XML_ACCEPTANCE_STATE))
1974 {
1975 if (IsXMLToken(sValue, XML_ACCEPTED))
1976 nActionState = SC_CAS_ACCEPTED;
1977 else if (IsXMLToken(sValue, XML_REJECTED))
1978 nActionState = SC_CAS_REJECTED;
1979 }
1980 else if (IsXMLToken(aLocalName, XML_REJECTING_CHANGE_ID))
1981 {
1982 nRejectingNumber = pChangeTrackingImportHelper->GetIDFromString(sValue);
1983 }
1984 }
1985 }
1986
1987 pChangeTrackingImportHelper->StartChangeAction(SC_CAT_MOVE);
1988 pChangeTrackingImportHelper->SetActionNumber(nActionNumber);
1989 pChangeTrackingImportHelper->SetActionState(nActionState);
1990 pChangeTrackingImportHelper->SetRejectingNumber(nRejectingNumber);
1991 }
1992
1993 ScXMLRejectionContext::~ScXMLRejectionContext()
1994 {
1995 }
1996
1997 SvXMLImportContext *ScXMLRejectionContext::CreateChildContext( USHORT nPrefix,
1998 const ::rtl::OUString& rLocalName,
1999 const ::com::sun::star::uno::Reference<
2000 ::com::sun::star::xml::sax::XAttributeList>& xAttrList )
2001 {
2002 SvXMLImportContext *pContext(0);
2003
2004 if ((nPrefix == XML_NAMESPACE_OFFICE) && (IsXMLToken(rLocalName, XML_CHANGE_INFO)))
2005 {
2006 pContext = new ScXMLChangeInfoContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2007 }
2008 else if (nPrefix == XML_NAMESPACE_TABLE)
2009 {
2010 if (IsXMLToken(rLocalName, XML_DEPENDENCIES))
2011 pContext = new ScXMLDependingsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2012 else if (IsXMLToken(rLocalName, XML_DELETIONS))
2013 pContext = new ScXMLDeletionsContext(GetScImport(), nPrefix, rLocalName, xAttrList, pChangeTrackingImportHelper);
2014 }
2015
2016 if( !pContext )
2017 pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName );
2018
2019 return pContext;
2020 }
2021
2022 void ScXMLRejectionContext::EndElement()
2023 {
2024 pChangeTrackingImportHelper->EndChangeAction();
2025 }
2026
2027
2028
vba interoperability for OOo