?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sw / source / core / unocore / unotext.cxx
blob25d95d7035f8cb21644d94fea8a835e2c78936de
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: unotext.cxx,v $
10 * $Revision: 1.41 $
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_sw.hxx"
33
34
35 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
36 #include <com/sun/star/text/ControlCharacter.hpp>
37
38 #include <cmdid.h>
39 #include <vos/mutex.hxx>
40 #include <vcl/svapp.hxx>
41 #include <rtl/uuid.h>
42 #include <unoobj.hxx>
43 #include <unoport.hxx>
44 #include <unotbl.hxx>
45 #include <unoidx.hxx>
46 #include <unoframe.hxx>
47 #include <unofield.hxx>
48 #include <unometa.hxx>
49 #include <unodraw.hxx>
50 #include <unoredline.hxx>
51 #include <unomap.hxx>
52 #include <unoprnms.hxx>
53 #include <undobj.hxx>
54 #include <unocrsrhelper.hxx>
55 #include <docsh.hxx>
56 #include <docary.hxx>
57 #include <doc.hxx>
58 #include <redline.hxx>
59 #include <swundo.hxx>
60 #include <section.hxx>
61 #include <IMark.hxx>
62 #include <fmtanchr.hxx>
63 #include <crsskip.hxx>
64 #include <ndtxt.hxx>
65 #include <com/sun/star/text/TableColumnSeparator.hpp>
66 #include <memory>
67 #include <stdlib.h>
68
69 #include <iostream>
70
71 using namespace std;
72 using namespace ::com::sun::star;
73 using ::rtl::OUString;
74
75 const sal_Char cInvalidObject[] = "this object is invalid";
76 /******************************************************************
77 * SwXText
78 ******************************************************************/
79 /*-- 09.12.98 12:44:07---------------------------------------------------
80
81 -----------------------------------------------------------------------*/
82
83 void SwXText::PrepareForAttach( ::com::sun::star::uno::Reference<
84 ::com::sun::star::text::XTextRange > &,
85 const SwXTextRange* const, const SwPaM * const)
86 {
87 }
88
89 bool SwXText::CheckForOwnMemberMeta(const SwXTextRange* const,
90 const SwPaM* const, bool)
91 throw (::com::sun::star::lang::IllegalArgumentException,
92 ::com::sun::star::uno::RuntimeException)
93 {
94 ASSERT(CURSOR_META != eCrsrType, "should not be called!");
95 return false;
96 }
97
98 const SwStartNode *SwXText::GetStartNode() const
99 {
100 return GetDoc()->GetNodes().GetEndOfContent().StartOfSectionNode();
101 }
102
103 uno::Reference< text::XTextCursor > SwXText::createCursor() throw (uno::RuntimeException)
104 {
105 uno::Reference< text::XTextCursor > xRet;
106 if(IsValid())
107 {
108 SwNode& rNode = GetDoc()->GetNodes().GetEndOfContent();
109 SwPosition aPos(rNode);
110 xRet = static_cast<text::XWordCursor*>(
111 new SwXTextCursor(this, aPos, GetTextType(), GetDoc()));
112 xRet->gotoStart(sal_False);
113 }
114 return xRet;
115 }
116 /* -----------------------------15.03.2002 12:39------------------------------
117
118 ---------------------------------------------------------------------------*/
119 SwXText::SwXText(SwDoc* pDc, CursorType eType) :
120 pDoc(pDc),
121 bObjectValid(0 != pDc),
122 eCrsrType(eType),
123 m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT))
124 {
125 }
126 /*-- 09.12.98 12:43:55---------------------------------------------------
127
128 -----------------------------------------------------------------------*/
129 SwXText::~SwXText()
130 {
131 }
132 /*-- 09.12.98 12:43:02---------------------------------------------------
133
134 -----------------------------------------------------------------------*/
135 uno::Any SAL_CALL SwXText::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException)
136 {
137 const uno::Type& rXTextType = ::getCppuType((uno::Reference< text::XText >*)0);
138 const uno::Type& rXTextRangeCompareType = ::getCppuType((uno::Reference< text::XTextRangeCompare >*)0);
139 const uno::Type& rXSimpleTextType = ::getCppuType((const uno::Reference< XSimpleText >*)0);
140 const uno::Type& rXTextRangeType = ::getCppuType((uno::Reference< text::XTextRange >*)0);
141 const uno::Type& rXTypeProviderType = ::getCppuType((uno::Reference< lang::XTypeProvider >*)0);
142 const uno::Type& rXTextContentInsert = ::getCppuType((uno::Reference< text::XRelativeTextContentInsert >*)0);
143 const uno::Type& rXTextContentRemove = ::getCppuType((uno::Reference< text::XRelativeTextContentRemove >*)0);
144 const uno::Type& rXPropertySet = ::getCppuType((uno::Reference<beans::XPropertySet>*)0);
145 const uno::Type& rXUnoTunnel = ::getCppuType((uno::Reference< lang::XUnoTunnel >*)0);
146 const uno::Type& rXTextPortionAppend = ::getCppuType((uno::Reference< text::XTextPortionAppend >*)0);
147 const uno::Type& rXParagraphAppend = ::getCppuType((uno::Reference< text::XParagraphAppend >*)0);
148 const uno::Type& rXTextContentAppend = ::getCppuType((uno::Reference< text::XTextContentAppend >*)0);
149 const uno::Type& rXTextConvert = ::getCppuType((uno::Reference< text::XTextConvert >*)0);
150 const uno::Type& rXTextAppend = ::getCppuType((uno::Reference< text::XTextAppend >*)0);
151 const uno::Type& rXTextAppendAndConvert = ::getCppuType((uno::Reference< text::XTextAppendAndConvert >*)0);
152 const uno::Type& rXTextCopy = ::getCppuType((uno::Reference< text::XTextCopy >*)0);
153
154 uno::Any aRet;
155 if(rType == rXTextType)
156 {
157 uno::Reference< text::XText > xRet = this;
158 aRet.setValue(&xRet, rXTextType);
159 }
160 else if(rType == rXSimpleTextType)
161 {
162 uno::Reference< XSimpleText > xRet = this;
163 aRet.setValue(&xRet, rXSimpleTextType);
164 }
165 else if(rType == rXTextRangeType)
166 {
167 uno::Reference< text::XTextRange > xRet = this;
168 aRet.setValue(&xRet, rXTextRangeType);
169 }
170 else if(rType == rXTextRangeCompareType)
171 {
172 uno::Reference< text::XTextRangeCompare > xRet = this;
173 aRet.setValue(&xRet, rXTextRangeCompareType);
174 }
175 else if(rType == rXTypeProviderType)
176 {
177 uno::Reference< lang::XTypeProvider > xRet = this;
178 aRet.setValue(&xRet, rXTypeProviderType);
179 }
180 else if(rType == rXTextContentInsert)
181 {
182 uno::Reference< text::XRelativeTextContentInsert > xRet = this;
183 aRet.setValue(&xRet, rXTextContentInsert);
184 }
185 else if(rType == rXTextContentRemove)
186 {
187 uno::Reference< text::XRelativeTextContentRemove > xRet = this;
188 aRet.setValue(&xRet, rXTextContentRemove);
189 }
190 else if(rType == rXPropertySet)
191 {
192 uno::Reference< beans::XPropertySet > xRet = this;
193 aRet.setValue(&xRet, rXPropertySet);
194 }
195 else if(rType == rXUnoTunnel )
196 {
197 uno::Reference< lang::XUnoTunnel > xRet = this;
198 aRet.setValue(&xRet, rXUnoTunnel);
199 }
200 else if(rType == rXTextAppendAndConvert )
201 {
202 uno::Reference< XTextAppendAndConvert > xRet = this;
203 aRet.setValue(&xRet, rXTextAppendAndConvert);
204 }
205 else if(rType == rXTextAppend )
206 {
207 uno::Reference< XTextAppend > xRet = this;
208 aRet.setValue(&xRet, rXTextAppend);
209 }
210 else if(rType == rXTextPortionAppend )
211 {
212 uno::Reference< XTextPortionAppend > xRet = this;
213 aRet.setValue(&xRet, rXTextPortionAppend);
214 }
215 else if(rType == rXParagraphAppend )
216 {
217 uno::Reference< XParagraphAppend > xRet = this;
218 aRet.setValue(&xRet, rXParagraphAppend );
219 }
220 else if(rType == rXTextConvert )
221 {
222 uno::Reference< XTextConvert > xRet = this;
223 aRet.setValue(&xRet, rXParagraphAppend );
224 }
225 else if(rType == rXTextContentAppend )
226 {
227 uno::Reference< XTextContentAppend > xRet = this;
228 aRet.setValue(&xRet, rXTextContentAppend );
229 }
230 else if(rType == rXTextCopy )
231 {
232 uno::Reference< XTextCopy > xRet = this;
233 aRet.setValue(&xRet, rXTextCopy );
234 }
235 return aRet;
236 }
237 /* -----------------------------15.03.00 17:42--------------------------------
238
239 ---------------------------------------------------------------------------*/
240 uno::Sequence< uno::Type > SAL_CALL SwXText::getTypes() throw(uno::RuntimeException)
241 {
242 uno::Sequence< uno::Type > aRet(12);
243 uno::Type* pTypes = aRet.getArray();
244 pTypes[0] = ::getCppuType((uno::Reference< text::XText >*)0);
245 pTypes[1] = ::getCppuType((uno::Reference< text::XTextRangeCompare >*)0);
246 pTypes[2] = ::getCppuType((uno::Reference< text::XRelativeTextContentInsert >*)0);
247 pTypes[3] = ::getCppuType((uno::Reference< text::XRelativeTextContentRemove >*)0);
248 pTypes[4] = ::getCppuType((uno::Reference< lang::XUnoTunnel >*)0);
249 pTypes[5] = ::getCppuType((uno::Reference< beans::XPropertySet >*)0);
250 pTypes[6] = ::getCppuType((uno::Reference< text::XTextPortionAppend >*)0);
251 pTypes[7] = ::getCppuType((uno::Reference< text::XParagraphAppend >*)0);
252 pTypes[8] = ::getCppuType((uno::Reference< text::XTextContentAppend >*)0);
253 pTypes[9] = ::getCppuType((uno::Reference< text::XTextConvert >*)0);
254 pTypes[10] = ::getCppuType((uno::Reference< text::XTextAppend >*)0);
255 pTypes[11] = ::getCppuType((uno::Reference< text::XTextAppendAndConvert >*)0);
256
257 return aRet;
258 }
259
260 // belongs the range in the text ? insert it then.
261 void SwXText::insertString(const uno::Reference< text::XTextRange >& xTextRange,
262 const OUString& aString,
263 sal_Bool bAbsorb)
264 throw( uno::RuntimeException )
265 {
266 vos::OGuard aGuard(Application::GetSolarMutex());
267 if(GetDoc() && xTextRange.is())
268 {
269 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
270 SwXTextRange* pRange = 0;
271 OTextCursorHelper* pCursor = 0;
272 if(xRangeTunnel.is())
273 {
274 pRange = reinterpret_cast< SwXTextRange * >(
275 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
276 pCursor = reinterpret_cast< OTextCursorHelper * >(
277 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
278 }
279
280 if( ( pRange && pRange->GetDoc() == GetDoc() ) ||
281 ( pCursor && pCursor->GetDoc() == GetDoc() ) )
282 {
283 const SwStartNode* pOwnStartNode = GetStartNode();
284 if(pCursor)
285 {
286 const SwStartNode* pTmp = pCursor->GetPaM()->GetNode()->StartOfSectionNode();
287 while(pTmp && pTmp->IsSectionNode())
288 {
289 pTmp = pTmp->StartOfSectionNode();
290 }
291 if( !pOwnStartNode || pOwnStartNode != pTmp)
292 {
293 throw uno::RuntimeException();
294 }
295 }
296 else //dann pRange
297 {
298 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
299 const SwStartNode* pTmp = pBkmk->GetMarkPos().nNode.GetNode().StartOfSectionNode();
300 while(pTmp && pTmp->IsSectionNode())
301 pTmp = pTmp->StartOfSectionNode();
302 if(!pOwnStartNode || pOwnStartNode != pTmp)
303 throw uno::RuntimeException();
304 }
305 bool bForceExpandHints( false );
306 if (CURSOR_META == eCrsrType)
307 {
308 try
309 {
310 bForceExpandHints = CheckForOwnMemberMeta(
311 pRange, (pCursor) ? pCursor->GetPaM() : 0, bAbsorb);
312 }
313 catch (lang::IllegalArgumentException & iae)
314 {
315 // stupid method not allowed to throw iae
316 throw uno::RuntimeException(iae.Message, 0);
317 }
318 }
319 if(bAbsorb)
320 {
321 //!! scan for CR characters and inserting the paragraph breaks
322 //!! has to be done in the called function.
323 //!! Implemented in SwXTextRange::DeleteAndInsert
324 if (pCursor)
325 {
326 SwXTextCursor * const pTextCursor( dynamic_cast<SwXTextCursor*>(pCursor) );
327 if (pTextCursor)
328 {
329 pTextCursor->DeleteAndInsert(aString, bForceExpandHints);
330 }
331 else
332 {
333 xTextRange->setString(aString);
334 }
335 }
336 else
337 {
338 pRange->DeleteAndInsert(aString, bForceExpandHints);
339 }
340 }
341 else
342 {
343 //hier wird ein PaM angelegt, der vor dem Parameter-PaM liegt, damit der
344 //Text davor eingefuegt wird
345 UnoActionContext aContext(GetDoc());
346 const SwPosition* pPos = pCursor
347 ? pCursor->GetPaM()->Start()
348 : &pRange->GetBookmark()->GetMarkStart();
349 SwPaM aInsertPam(*pPos);
350 const sal_Bool bGroupUndo = GetDoc()->DoesGroupUndo();
351 GetDoc()->DoGroupUndo(sal_False);
352
353 SwUnoCursorHelper::DocInsertStringSplitCR(
354 *GetDoc(), aInsertPam, aString, bForceExpandHints );
355 GetDoc()->DoGroupUndo(bGroupUndo);
356 }
357 }
358 else
359 throw uno::RuntimeException();
360 }
361 else
362 throw uno::RuntimeException();
363 }
364
365 /*-- 09.12.98 12:43:16---------------------------------------------------
366
367 -----------------------------------------------------------------------*/
368 void SwXText::insertControlCharacter(const uno::Reference< text::XTextRange > & xTextRange,
369 sal_Int16 nControlCharacter, sal_Bool bAbsorb)
370 throw( lang::IllegalArgumentException, uno::RuntimeException )
371 {
372 vos::OGuard aGuard(Application::GetSolarMutex());
373 if (!xTextRange.is())
374 throw lang::IllegalArgumentException();
375 if (GetDoc())
376 {
377 SwUnoInternalPaM aPam(*GetDoc());
378 if(SwXTextRange::XTextRangeToSwPaM(aPam, xTextRange))
379 {
380 const bool bForceExpandHints(
381 CheckForOwnMemberMeta( 0, &aPam, bAbsorb) );
382
383 const enum IDocumentContentOperations::InsertFlags nInsertFlags =
384 (bForceExpandHints)
385 ? static_cast<IDocumentContentOperations::InsertFlags>(
386 IDocumentContentOperations::INS_FORCEHINTEXPAND |
387 IDocumentContentOperations::INS_EMPTYEXPAND)
388 : IDocumentContentOperations::INS_EMPTYEXPAND;
389
390 //Steuerzeichen einfuegen
391 SwPaM aTmp(*aPam.Start());
392 if(bAbsorb && aPam.HasMark())
393 {
394 pDoc->DeleteAndJoin(aPam);
395 }
396
397 sal_Unicode cIns = 0;
398 switch( nControlCharacter )
399 {
400 case text::ControlCharacter::PARAGRAPH_BREAK :
401 // eine Tabellen Zelle wird jetzt zu einer normalen Textzelle!
402 pDoc->ClearBoxNumAttrs( aTmp.GetPoint()->nNode );
403 pDoc->SplitNode( *aTmp.GetPoint(), sal_False );
404 break;
405 case text::ControlCharacter::APPEND_PARAGRAPH:
406 {
407 pDoc->ClearBoxNumAttrs( aTmp.GetPoint()->nNode );
408 pDoc->AppendTxtNode( *aTmp.GetPoint() );
409
410 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
411 SwXTextRange* pRange = 0;
412 OTextCursorHelper* pCursor = 0;
413 if(xRangeTunnel.is())
414 {
415 pRange = reinterpret_cast< SwXTextRange * >(
416 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
417 pCursor = reinterpret_cast< OTextCursorHelper * >(
418 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
419 }
420 if(pRange)
421 {
422 pRange->_CreateNewBookmark(aTmp);
423 }
424 else if(pCursor)
425 {
426 SwPaM* pCrsr = pCursor->GetPaM();
427 *pCrsr->GetPoint() = *aTmp.GetPoint();
428 pCrsr->DeleteMark();
429 }
430 }
431 break;
432 case text::ControlCharacter::LINE_BREAK: cIns = 10; break;
433 case text::ControlCharacter::SOFT_HYPHEN: cIns = CHAR_SOFTHYPHEN; break;
434 case text::ControlCharacter::HARD_HYPHEN: cIns = CHAR_HARDHYPHEN; break;
435 case text::ControlCharacter::HARD_SPACE: cIns = CHAR_HARDBLANK; break;
436 }
437 if( cIns )
438 {
439 pDoc->InsertString( aTmp, cIns, nInsertFlags );
440 }
441
442 if(bAbsorb)
443 {
444 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xTextRange, uno::UNO_QUERY);
445 SwXTextRange* pRange = 0;
446 OTextCursorHelper* pCursor = 0;
447 if(xRangeTunnel.is())
448 {
449 pRange = reinterpret_cast< SwXTextRange * >(
450 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
451 pCursor = reinterpret_cast< OTextCursorHelper * >(
452 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
453 }
454
455 SwCursor aCrsr(*aTmp.GetPoint(),0,false);
456 SwXTextCursor::SelectPam(aCrsr, sal_True);
457 aCrsr.Left(1, CRSR_SKIP_CHARS, FALSE, FALSE);
458 //hier muss der uebergebene PaM umgesetzt werden:
459 if(pRange)
460 pRange->_CreateNewBookmark(aCrsr);
461 else
462 {
463 SwPaM* pUnoCrsr = pCursor->GetPaM();
464 *pUnoCrsr->GetPoint() = *aCrsr.GetPoint();
465 if(aCrsr.HasMark())
466 {
467 pUnoCrsr->SetMark();
468 *pUnoCrsr->GetMark() = *aCrsr.GetMark();
469 }
470 else
471 pUnoCrsr->DeleteMark();
472 }
473 }
474 }
475 }
476 else
477 throw uno::RuntimeException();
478 }
479 /*-- 09.12.98 12:43:17---------------------------------------------------
480
481 -----------------------------------------------------------------------*/
482
483 void SwXText::insertTextContent(const uno::Reference< text::XTextRange > & xRange,
484 const uno::Reference< text::XTextContent > & xContent, sal_Bool bAbsorb)
485 throw( lang::IllegalArgumentException, uno::RuntimeException )
486 {
487 vos::OGuard aGuard(Application::GetSolarMutex());
488 // erstmal testen, ob der Range an der richtigen Stelle ist und dann
489 // am Sw-Content attachToRange aufrufen
490 if(!GetDoc())
491 {
492 uno::RuntimeException aRuntime;
493 aRuntime.Message = C2U(cInvalidObject);
494 throw aRuntime;
495 }
496 if(xRange.is() && xContent.is())
497 {
498 SwUnoInternalPaM aPam(*GetDoc());
499 if(SwXTextRange::XTextRangeToSwPaM(aPam, xRange))
500 {
501 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xRange, uno::UNO_QUERY);
502 SwXTextRange* pRange = 0;
503 OTextCursorHelper* pCursor = 0;
504 SwXTextPortion* pPortion = 0;
505 SwXText* pText = 0;
506 if(xRangeTunnel.is())
507 {
508 pRange = reinterpret_cast< SwXTextRange * >(
509 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
510 pCursor = reinterpret_cast< OTextCursorHelper * >(
511 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
512 pPortion = reinterpret_cast< SwXTextPortion * >(
513 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextPortion::getUnoTunnelId()) ));
514 pText = reinterpret_cast< SwXText * >(
515 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXText::getUnoTunnelId()) ));
516 }
517
518
519 uno::Reference< text::XTextCursor > xOwnCursor = createCursor();
520 uno::Reference<lang::XUnoTunnel> xOwnTunnel( xOwnCursor, uno::UNO_QUERY);
521 // OTextCursorHelper* pOwnCursor = reinterpret_cast< OTextCursorHelper * >(
522 // sal::static_int_cast< sal_IntPtr >( xOwnTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
523
524 const SwStartNode* pOwnStartNode = GetStartNode();
525 SwStartNodeType eSearchNodeType = SwNormalStartNode;
526 switch(eCrsrType)
527 {
528 case CURSOR_FRAME: eSearchNodeType = SwFlyStartNode; break;
529 case CURSOR_TBLTEXT: eSearchNodeType = SwTableBoxStartNode; break;
530 case CURSOR_FOOTNOTE: eSearchNodeType = SwFootnoteStartNode; break;
531 case CURSOR_HEADER: eSearchNodeType = SwHeaderStartNode; break;
532 case CURSOR_FOOTER: eSearchNodeType = SwFooterStartNode; break;
533 //case CURSOR_INVALID:
534 //case CURSOR_BODY:
535 default:
536 ;
537 }
538
539 const SwNode* pSrcNode = 0;
540 if(pCursor && pCursor->GetPaM())
541 {
542 pSrcNode = pCursor->GetPaM()->GetNode();
543 }
544 else if (pRange && pRange->GetBookmark())
545 {
546 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
547 pSrcNode = &pBkmk->GetMarkPos().nNode.GetNode();
548 }
549 else if (pPortion && pPortion->GetCursor())
550 {
551 pSrcNode = pPortion->GetCursor()->GetNode();
552 }
553 else if (pText)
554 {
555 uno::Reference<text::XTextCursor> xTextCursor = pText->createCursor();
556 xTextCursor->gotoEnd(sal_True);
557 uno::Reference<lang::XUnoTunnel> xCrsrTunnel( xTextCursor, uno::UNO_QUERY );
558 pCursor = reinterpret_cast< OTextCursorHelper * >(
559 sal::static_int_cast< sal_IntPtr >( xCrsrTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
560 pSrcNode = pCursor->GetPaM()->GetNode();
561 }
562 else
563 throw lang::IllegalArgumentException();
564
565 const SwStartNode* pTmp = pSrcNode->FindSttNodeByType(eSearchNodeType);
566
567 //SectionNodes ueberspringen
568 while(pTmp && pTmp->IsSectionNode())
569 {
570 pTmp = pTmp->StartOfSectionNode();
571 }
572 //if the document starts with a section
573 while(pOwnStartNode->IsSectionNode())
574 {
575 pOwnStartNode = pOwnStartNode->StartOfSectionNode();
576 }
577 //this checks if (this) and xRange are in the same text::XText interface
578 if(pOwnStartNode != pTmp)
579 {
580 uno::RuntimeException aRunException;
581 aRunException.Message = C2U("text interface and cursor not related");
582 throw aRunException;
583 }
584
585 const bool bForceExpandHints( CheckForOwnMemberMeta(
586 pRange, (pCursor) ? pCursor->GetPaM() : 0, bAbsorb) );
587
588 // Sonderbehandlung fuer Contents, die den Range nicht ersetzen, sonder darueber gelegt werden
589 // Bookmarks, IndexEntry
590 uno::Reference<lang::XUnoTunnel> xContentTunnel( xContent, uno::UNO_QUERY);
591 if(!xContentTunnel.is())
592 {
593 lang::IllegalArgumentException aArgException;
594 aArgException.Message = C2U("text content doesn't support lang::XUnoTunnel");
595 throw aArgException;
596 }
597 SwXDocumentIndexMark* pDocumentIndexMark = reinterpret_cast< SwXDocumentIndexMark * >(
598 sal::static_int_cast< sal_IntPtr >( xContentTunnel->getSomething( SwXDocumentIndexMark::getUnoTunnelId()) ));
599 SwXTextSection* pSection = reinterpret_cast< SwXTextSection * >(
600 sal::static_int_cast< sal_IntPtr >( xContentTunnel->getSomething( SwXTextSection::getUnoTunnelId()) ));
601 SwXBookmark* pBookmark = reinterpret_cast< SwXBookmark * >(
602 sal::static_int_cast< sal_IntPtr >( xContentTunnel->getSomething( SwXBookmark::getUnoTunnelId()) ));
603 SwXReferenceMark* pReferenceMark = reinterpret_cast< SwXReferenceMark * >(
604 sal::static_int_cast< sal_IntPtr >( xContentTunnel->getSomething( SwXReferenceMark::getUnoTunnelId()) ));
605 SwXMeta *const pMeta = reinterpret_cast< SwXMeta* >(
606 sal::static_int_cast< sal_IntPtr >(
607 xContentTunnel->getSomething( SwXMeta::getUnoTunnelId())));
608
609 const bool bAttribute = pBookmark || pDocumentIndexMark
610 || pSection || pReferenceMark || pMeta;
611
612 if(bAbsorb && !bAttribute)
613 {
614 xRange->setString(aEmptyStr);
615 }
616 //hier wird tatsaechlich eingefuegt
617 uno::Reference< text::XTextRange > xTempRange;
618 if(bAttribute && bAbsorb)
619 xTempRange = xRange;
620 else
621 xTempRange = xRange->getStart();
622 if (bForceExpandHints)
623 {
624 // if necessary, replace xTempRange with a new SwXTextCursor
625 PrepareForAttach(xTempRange, pRange,
626 (pCursor) ? pCursor->GetPaM() : 0);
627 }
628 xContent->attach(xTempRange);
629 }
630 else
631 {
632 lang::IllegalArgumentException aIllegal;
633 aIllegal.Message = C2U("first parameter invalid");
634 throw aIllegal;
635 }
636 }
637 else
638 {
639 lang::IllegalArgumentException aIllegal;
640 if(!xRange.is())
641 aIllegal.Message = C2U("first parameter invalid;");
642 if(!xContent.is())
643 aIllegal.Message += C2U("second parameter invalid");
644 throw aIllegal;
645 }
646
647 }
648 /* -----------------------------10.07.00 15:40--------------------------------
649
650 ---------------------------------------------------------------------------*/
651 void SwXText::insertTextContentBefore(
652 const uno::Reference< text::XTextContent>& xNewContent,
653 const uno::Reference< text::XTextContent>& xSuccessor)
654 throw(lang::IllegalArgumentException, uno::RuntimeException)
655 {
656 vos::OGuard aGuard(Application::GetSolarMutex());
657 if(!GetDoc())
658 {
659 uno::RuntimeException aRuntime;
660 aRuntime.Message = C2U(cInvalidObject);
661 throw aRuntime;
662 }
663
664 SwXParagraph* pPara = SwXParagraph::GetImplementation(xNewContent);
665 if(!pPara || !pPara->IsDescriptor() || !xSuccessor.is())
666 throw lang::IllegalArgumentException();
667
668 sal_Bool bRet = sal_False;
669 SwXTextSection* pXSection = SwXTextSection::GetImplementation( xSuccessor );
670 SwXTextTable* pXTable = SwXTextTable::GetImplementation(xSuccessor );
671 SwFrmFmt* pTableFmt = pXTable ? pXTable->GetFrmFmt() : 0;
672 SwUnoCrsr* pUnoCrsr = 0;
673 if(pTableFmt && pTableFmt->GetDoc() == GetDoc())
674 {
675 SwTable* pTable = SwTable::FindTable( pTableFmt );
676 SwTableNode* pTblNode = pTable->GetTableNode();
677
678 SwNodeIndex aTblIdx( *pTblNode, -1 );
679 SwPosition aBefore(aTblIdx);
680 bRet = GetDoc()->AppendTxtNode( aBefore );
681 pUnoCrsr = GetDoc()->CreateUnoCrsr( aBefore, FALSE);
682 }
683 else if(pXSection &&
684 pXSection->GetFmt() &&
685 pXSection->GetFmt()->GetDoc() == GetDoc())
686 {
687 SwSectionFmt* pSectFmt = pXSection->GetFmt();
688 SwSectionNode* pSectNode = pSectFmt->GetSectionNode();
689
690 SwNodeIndex aSectIdx( *pSectNode, -1 );
691 SwPosition aBefore(aSectIdx);
692 bRet = GetDoc()->AppendTxtNode( aBefore );
693 pUnoCrsr = GetDoc()->CreateUnoCrsr( aBefore, FALSE);
694 }
695 if(!bRet)
696 throw lang::IllegalArgumentException();
697 else
698 {
699 pPara->attachToText(this, pUnoCrsr);
700 }
701
702 }
703 /* -----------------------------10.07.00 15:40--------------------------------
704
705 ---------------------------------------------------------------------------*/
706 void SwXText::insertTextContentAfter(
707 const uno::Reference< text::XTextContent>& xNewContent,
708 const uno::Reference< text::XTextContent>& xPredecessor)
709 throw(lang::IllegalArgumentException, uno::RuntimeException)
710 {
711 vos::OGuard aGuard(Application::GetSolarMutex());
712 if(!GetDoc())
713 throw uno::RuntimeException();
714 SwXParagraph* pPara = SwXParagraph::GetImplementation(xNewContent);
715 if(!pPara || !pPara->IsDescriptor() || !xPredecessor.is())
716 throw lang::IllegalArgumentException();
717
718 SwUnoCrsr* pUnoCrsr = 0;
719 SwXTextSection* pXSection = SwXTextSection::GetImplementation( xPredecessor );
720 SwXTextTable* pXTable = SwXTextTable::GetImplementation(xPredecessor );
721 SwFrmFmt* pTableFmt = pXTable ? pXTable->GetFrmFmt() : 0;
722 sal_Bool bRet = sal_False;
723 if(pTableFmt && pTableFmt->GetDoc() == GetDoc())
724 {
725 SwTable* pTable = SwTable::FindTable( pTableFmt );
726 SwTableNode* pTblNode = pTable->GetTableNode();
727
728 SwEndNode* pTableEnd = pTblNode->EndOfSectionNode();
729 SwPosition aTableEnd(*pTableEnd);
730 bRet = GetDoc()->AppendTxtNode( aTableEnd );
731 pUnoCrsr = GetDoc()->CreateUnoCrsr( aTableEnd, FALSE);
732 }
733 else if(pXSection &&
734 pXSection->GetFmt() &&
735 pXSection->GetFmt()->GetDoc() == GetDoc())
736 {
737 SwSectionFmt* pSectFmt = pXSection->GetFmt();
738 SwSectionNode* pSectNode = pSectFmt->GetSectionNode();
739 SwEndNode* pEnd = pSectNode->EndOfSectionNode();
740 SwPosition aEnd(*pEnd);
741 bRet = GetDoc()->AppendTxtNode( aEnd );
742 pUnoCrsr = GetDoc()->CreateUnoCrsr( aEnd, FALSE);
743 }
744 if(!bRet)
745 throw lang::IllegalArgumentException();
746 else
747 {
748 pPara->attachToText(this, pUnoCrsr);
749 }
750 }
751 /* -----------------------------10.07.00 15:40--------------------------------
752
753 ---------------------------------------------------------------------------*/
754 void SwXText::removeTextContentBefore(
755 const uno::Reference< text::XTextContent>& xSuccessor)
756 throw(lang::IllegalArgumentException, uno::RuntimeException)
757 {
758 vos::OGuard aGuard(Application::GetSolarMutex());
759 if(!GetDoc())
760 {
761 uno::RuntimeException aRuntime;
762 aRuntime.Message = C2U(cInvalidObject);
763 throw aRuntime;
764 }
765
766 sal_Bool bRet = sal_False;
767 SwXTextSection* pXSection = SwXTextSection::GetImplementation( xSuccessor );
768 SwXTextTable* pXTable = SwXTextTable::GetImplementation( xSuccessor );
769 SwFrmFmt* pTableFmt = pXTable ? pXTable->GetFrmFmt() : 0;
770 if(pTableFmt && pTableFmt->GetDoc() == GetDoc())
771 {
772 SwTable* pTable = SwTable::FindTable( pTableFmt );
773 SwTableNode* pTblNode = pTable->GetTableNode();
774
775 SwNodeIndex aTblIdx( *pTblNode, -1 );
776 if(aTblIdx.GetNode().IsTxtNode())
777 {
778 SwPaM aBefore(aTblIdx);
779 bRet = GetDoc()->DelFullPara( aBefore );
780 }
781 }
782 else if(pXSection &&
783 pXSection->GetFmt() &&
784 pXSection->GetFmt()->GetDoc() == GetDoc())
785 {
786 SwSectionFmt* pSectFmt = pXSection->GetFmt();
787 SwSectionNode* pSectNode = pSectFmt->GetSectionNode();
788
789 SwNodeIndex aSectIdx( *pSectNode, -1 );
790 if(aSectIdx.GetNode().IsTxtNode())
791 {
792 SwPaM aBefore(aSectIdx);
793 bRet = GetDoc()->DelFullPara( aBefore );
794 }
795 }
796 if(!bRet)
797 throw lang::IllegalArgumentException();
798 }
799 /* -----------------------------10.07.00 15:40--------------------------------
800
801 ---------------------------------------------------------------------------*/
802 void SwXText::removeTextContentAfter(const uno::Reference< text::XTextContent>& xPredecessor)
803 throw(lang::IllegalArgumentException, uno::RuntimeException)
804 {
805 vos::OGuard aGuard(Application::GetSolarMutex());
806 if(!GetDoc())
807 {
808 uno::RuntimeException aRuntime;
809 aRuntime.Message = C2U(cInvalidObject);
810 throw aRuntime;
811 }
812
813 sal_Bool bRet = sal_False;
814 SwXTextSection* pXSection = SwXTextSection::GetImplementation( xPredecessor );
815 SwXTextTable* pXTable = SwXTextTable::GetImplementation(xPredecessor );
816 SwFrmFmt* pTableFmt = pXTable ? pXTable->GetFrmFmt() : 0;
817 if(pTableFmt && pTableFmt->GetDoc() == GetDoc())
818 {
819 SwTable* pTable = SwTable::FindTable( pTableFmt );
820 SwTableNode* pTblNode = pTable->GetTableNode();
821 SwEndNode* pTableEnd = pTblNode->EndOfSectionNode();
822
823 SwNodeIndex aTblIdx( *pTableEnd, 1 );
824 if(aTblIdx.GetNode().IsTxtNode())
825 {
826 SwPaM aPaM(aTblIdx);
827 bRet = GetDoc()->DelFullPara( aPaM );
828 }
829 }
830 else if(pXSection &&
831 pXSection->GetFmt() &&
832 pXSection->GetFmt()->GetDoc() == GetDoc())
833 {
834 SwSectionFmt* pSectFmt = pXSection->GetFmt();
835 SwSectionNode* pSectNode = pSectFmt->GetSectionNode();
836 SwEndNode* pEnd = pSectNode->EndOfSectionNode();
837 SwNodeIndex aSectIdx( *pEnd, 1 );
838 if(aSectIdx.GetNode().IsTxtNode())
839 {
840 SwPaM aAfter(aSectIdx);
841 bRet = GetDoc()->DelFullPara( aAfter );
842 }
843 }
844 if(!bRet)
845 throw lang::IllegalArgumentException();
846 }
847 /*-- 09.12.98 12:43:19---------------------------------------------------
848
849 -----------------------------------------------------------------------*/
850 void SwXText::removeTextContent(const uno::Reference< text::XTextContent > & xContent)
851 throw( container::NoSuchElementException, uno::RuntimeException )
852 {
853 vos::OGuard aGuard(Application::GetSolarMutex());
854 if(!xContent.is())
855 {
856 uno::RuntimeException aRuntime;
857 aRuntime.Message = C2U("first parameter invalid");
858 throw aRuntime;
859 }
860 else
861 xContent->dispose();
862 }
863 /*-- 09.12.98 12:43:22---------------------------------------------------
864
865 -----------------------------------------------------------------------*/
866 uno::Reference< text::XText > SwXText::getText(void)
867 throw( uno::RuntimeException )
868 {
869 vos::OGuard aGuard(Application::GetSolarMutex());
870 uno::Reference< text::XText > xRet = (SwXText*)this;
871 return xRet;
872
873 }
874 /*-- 09.12.98 12:43:24---------------------------------------------------
875
876 -----------------------------------------------------------------------*/
877 uno::Reference< text::XTextRange > SwXText::getStart(void) throw( uno::RuntimeException )
878 {
879 vos::OGuard aGuard(Application::GetSolarMutex());
880 uno::Reference< text::XTextCursor > xRef = createCursor();
881 if(!xRef.is())
882 {
883 uno::RuntimeException aRuntime;
884 aRuntime.Message = C2U(cInvalidObject);
885 throw aRuntime;
886 }
887 xRef->gotoStart(sal_False);
888 uno::Reference< text::XTextRange > xRet(xRef, uno::UNO_QUERY);
889 return xRet;
890 }
891 /*-- 09.12.98 12:43:27---------------------------------------------------
892
893 -----------------------------------------------------------------------*/
894 uno::Reference< text::XTextRange > SwXText::getEnd(void) throw( uno::RuntimeException )
895 {
896 vos::OGuard aGuard(Application::GetSolarMutex());
897 uno::Reference< text::XTextCursor > xRef = createCursor();
898 if(!xRef.is())
899 {
900 uno::RuntimeException aRuntime;
901 aRuntime.Message = C2U(cInvalidObject);
902 throw aRuntime;
903 }
904 xRef->gotoEnd(sal_False);
905 uno::Reference< text::XTextRange > xRet(xRef, uno::UNO_QUERY);
906 return xRet;
907 }
908 /*-- 09.12.98 12:43:29---------------------------------------------------
909
910 -----------------------------------------------------------------------*/
911 OUString SwXText::getString(void) throw( uno::RuntimeException )
912 {
913 vos::OGuard aGuard(Application::GetSolarMutex());
914 uno::Reference< text::XTextCursor > xRet = createCursor();
915 if(!xRet.is())
916 {
917 uno::RuntimeException aRuntime;
918 aRuntime.Message = C2U(cInvalidObject);
919 throw aRuntime;
920 }
921 else
922 {
923 xRet->gotoEnd(sal_True);
924 }
925 return xRet->getString();
926 }
927 /*-- 09.12.98 12:43:30---------------------------------------------------
928
929 -----------------------------------------------------------------------*/
930 void SwXText::setString(const OUString& aString) throw( uno::RuntimeException )
931 {
932 vos::OGuard aGuard(Application::GetSolarMutex());
933 const SwStartNode* pStartNode = GetStartNode();
934 if(!pStartNode)
935 throw uno::RuntimeException();
936
937 GetDoc()->StartUndo(UNDO_START, NULL);
938 //insert an empty paragraph at the start and at the end to ensure that
939 //all tables and sections can be removed by the selecting text::XTextCursor
940 if (CURSOR_META != eCrsrType)
941 {
942 SwPosition aStartPos(*pStartNode);
943 const SwEndNode* pEnd = pStartNode->EndOfSectionNode();
944 SwNodeIndex aEndIdx(*pEnd);
945 aEndIdx--;
946 //the inserting of nodes should only be done if really necessary
947 //to prevent #97924# (removes paragraph attributes when setting the text
948 //e.g. of a table cell
949 BOOL bInsertNodes = FALSE;
950 SwNodeIndex aStartIdx(*pStartNode);
951 do
952 {
953 aStartIdx++;
954 SwNode& rCurrentNode = aStartIdx.GetNode();
955 if(rCurrentNode.GetNodeType() == ND_SECTIONNODE
956 ||rCurrentNode.GetNodeType() == ND_TABLENODE)
957 {
958 bInsertNodes = TRUE;
959 break;
960 }
961 }
962 while(aStartIdx < aEndIdx);
963 if(bInsertNodes)
964 {
965 GetDoc()->AppendTxtNode( aStartPos );
966 SwPosition aEndPos(aEndIdx.GetNode());
967 SwPaM aPam(aEndPos);
968 GetDoc()->AppendTxtNode( *aPam.Start() );
969 }
970 }
971
972 uno::Reference< text::XTextCursor > xRet = createCursor();
973 if(!xRet.is())
974 {
975 GetDoc()->EndUndo(UNDO_END, NULL);
976 uno::RuntimeException aRuntime;
977 aRuntime.Message = C2U(cInvalidObject);
978 throw aRuntime;
979 }
980 else
981 {
982 xRet->gotoEnd(sal_True);
983 }
984 xRet->setString(aString);
985 GetDoc()->EndUndo(UNDO_END, NULL);
986 }
987
988 //FIXME why is CheckForOwnMember duplicated in some insert methods?
989 // Description: Checks if pRange/pCursor are member of the same text interface.
990 // Only one of the pointers has to be set!
991 sal_Bool SwXText::CheckForOwnMember(
992 const SwXTextRange* pRange,
993 const OTextCursorHelper* pCursor)
994 throw(lang::IllegalArgumentException, uno::RuntimeException)
995 {
996 DBG_ASSERT((!pRange || !pCursor) && (pRange || pCursor), "only one pointer will be checked" );
997 uno::Reference<text::XTextCursor> xOwnCursor = createCursor();
998
999 uno::Reference<lang::XUnoTunnel> xTunnel( xOwnCursor, uno::UNO_QUERY);
1000 OTextCursorHelper* pOwnCursor = 0;
1001 if(xTunnel.is())
1002 {
1003 pOwnCursor = reinterpret_cast< OTextCursorHelper * >(
1004 sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(OTextCursorHelper::getUnoTunnelId()) ));
1005 }
1006 DBG_ASSERT(pOwnCursor, "OTextCursorHelper::getUnoTunnelId() ??? ");
1007 const SwStartNode* pOwnStartNode = pOwnCursor->GetPaM()->GetNode()->StartOfSectionNode();
1008 SwStartNodeType eSearchNodeType = SwNormalStartNode;
1009 switch(eCrsrType)
1010 {
1011 case CURSOR_FRAME: eSearchNodeType = SwFlyStartNode; break;
1012 case CURSOR_TBLTEXT: eSearchNodeType = SwTableBoxStartNode; break;
1013 case CURSOR_FOOTNOTE: eSearchNodeType = SwFootnoteStartNode; break;
1014 case CURSOR_HEADER: eSearchNodeType = SwHeaderStartNode; break;
1015 case CURSOR_FOOTER: eSearchNodeType = SwFooterStartNode; break;
1016 //case CURSOR_INVALID:
1017 //case CURSOR_BODY:
1018 default:
1019 ;
1020 }
1021
1022 const SwNode* pSrcNode;
1023 if(pCursor)
1024 pSrcNode = pCursor->GetPaM()->GetNode();
1025 else //dann pRange
1026 {
1027 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
1028 pSrcNode = &pBkmk->GetMarkPos().nNode.GetNode();
1029 }
1030 const SwStartNode* pTmp = pSrcNode->FindSttNodeByType(eSearchNodeType);
1031
1032 //SectionNodes ueberspringen
1033 while(pTmp && pTmp->IsSectionNode())
1034 pTmp = pTmp->StartOfSectionNode();
1035
1036 //if the document starts with a section
1037 while(pOwnStartNode->IsSectionNode())
1038 pOwnStartNode = pOwnStartNode->StartOfSectionNode();
1039
1040 //this checks if (this) and xRange are in the same text::XText interface
1041 return(pOwnStartNode == pTmp);
1042 }
1043
1044 sal_Int16 SwXText::ComparePositions(
1045 const uno::Reference<text::XTextRange>& xPos1,
1046 const uno::Reference<text::XTextRange>& xPos2)
1047 throw(lang::IllegalArgumentException, uno::RuntimeException)
1048 {
1049 sal_Int16 nCompare = 0;
1050 SwUnoInternalPaM aPam1(*GetDoc());
1051 SwUnoInternalPaM aPam2(*GetDoc());
1052
1053 BOOL bExcept = FALSE;
1054 if(SwXTextRange::XTextRangeToSwPaM(aPam1, xPos1) &&
1055 SwXTextRange::XTextRangeToSwPaM(aPam2, xPos2))
1056 {
1057 uno::Reference<lang::XUnoTunnel> xRangeTunnel1( xPos1, uno::UNO_QUERY);
1058 SwXTextRange* pRange1 = 0;
1059 OTextCursorHelper* pCursor1 = 0;
1060 if(xRangeTunnel1.is())
1061 {
1062 pRange1 = reinterpret_cast< SwXTextRange * >(
1063 sal::static_int_cast< sal_IntPtr >( xRangeTunnel1->getSomething( SwXTextRange::getUnoTunnelId()) ));
1064 pCursor1 = reinterpret_cast< OTextCursorHelper * >(
1065 sal::static_int_cast< sal_IntPtr >( xRangeTunnel1->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
1066 }
1067 uno::Reference<lang::XUnoTunnel> xRangeTunnel2( xPos2, uno::UNO_QUERY);
1068 SwXTextRange* pRange2 = 0;
1069 OTextCursorHelper* pCursor2 = 0;
1070 if(xRangeTunnel2.is())
1071 {
1072 pRange2 = reinterpret_cast< SwXTextRange * >(
1073 sal::static_int_cast< sal_IntPtr >( xRangeTunnel2->getSomething( SwXTextRange::getUnoTunnelId()) ));
1074 pCursor2 = reinterpret_cast< OTextCursorHelper * >(
1075 sal::static_int_cast< sal_IntPtr >( xRangeTunnel2->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
1076 }
1077
1078 if((pRange1||pCursor1) && (pRange2||pCursor2))
1079 {
1080 if(CheckForOwnMember(pRange1, pCursor1)
1081 && CheckForOwnMember( pRange2, pCursor2))
1082 {
1083 const SwPosition *pStart1 = 0;
1084 const SwPosition *pStart2 = 0;
1085
1086 if(pRange1)
1087 pStart1 = pRange1->GetBookmark() ? &(pRange1->GetBookmark()->GetMarkStart()) : 0;
1088 else
1089 pStart1 = pCursor1->GetPaM() ? pCursor1->GetPaM()->Start() : 0;
1090
1091 if(pRange2)
1092 pStart2 = pRange2->GetBookmark() ? &(pRange2->GetBookmark()->GetMarkStart()) : 0;
1093 else
1094 pStart2 = pCursor2->GetPaM() ? pCursor2->GetPaM()->Start() : 0;
1095
1096 if(pStart1 && pStart2)
1097 {
1098 if(*pStart1 < *pStart2)
1099 nCompare = 1;
1100 else if(*pStart1 > *pStart2)
1101 nCompare = -1;
1102 else
1103 {
1104 DBG_ASSERT(*pStart1 == *pStart2, "SwPositions should be equal here");
1105 nCompare = 0;
1106 }
1107 }
1108 else
1109 bExcept = TRUE;
1110 }
1111 else
1112 bExcept = TRUE;
1113 }
1114 else
1115 bExcept = TRUE;
1116 }
1117 else
1118 bExcept = TRUE;
1119 if(bExcept)
1120 throw lang::IllegalArgumentException();
1121
1122 return nCompare;
1123 }
1124
1125 /*-- 28.03.00 10:37:22---------------------------------------------------
1126
1127 -----------------------------------------------------------------------*/
1128 sal_Int16 SwXText::compareRegionStarts(
1129 const uno::Reference<text::XTextRange>& xR1,
1130 const uno::Reference<text::XTextRange>& xR2)
1131 throw(lang::IllegalArgumentException, uno::RuntimeException)
1132 {
1133 vos::OGuard aGuard(Application::GetSolarMutex());
1134 if(!xR1.is() || !xR2.is())
1135 throw lang::IllegalArgumentException();
1136 uno::Reference<text::XTextRange> xStart1 = xR1->getStart();
1137 uno::Reference<text::XTextRange> xStart2 = xR2->getStart();
1138
1139 return ComparePositions(xStart1, xStart2);
1140 }
1141 /*-- 28.03.00 10:37:25---------------------------------------------------
1142
1143 -----------------------------------------------------------------------*/
1144 sal_Int16 SwXText::compareRegionEnds(
1145 const uno::Reference<text::XTextRange>& xR1,
1146 const uno::Reference<text::XTextRange>& xR2)
1147 throw(lang::IllegalArgumentException, uno::RuntimeException)
1148 {
1149 vos::OGuard aGuard(Application::GetSolarMutex());
1150 if(!xR1.is() || !xR2.is())
1151 throw lang::IllegalArgumentException();
1152 uno::Reference<text::XTextRange> xEnd1 = xR1->getEnd();
1153 uno::Reference<text::XTextRange> xEnd2 = xR2->getEnd();
1154
1155 return ComparePositions(xEnd1, xEnd2);
1156 }
1157
1158 /*-- 15.03.2002 12:30:40---------------------------------------------------
1159
1160 -----------------------------------------------------------------------*/
1161 uno::Reference< beans::XPropertySetInfo > SwXText::getPropertySetInfo( )
1162 throw(uno::RuntimeException)
1163 {
1164 static uno::Reference< beans::XPropertySetInfo > xInfo = m_pPropSet->getPropertySetInfo();
1165 return xInfo;
1166 }
1167 /*-- 15.03.2002 12:30:42---------------------------------------------------
1168
1169 -----------------------------------------------------------------------*/
1170 void SwXText::setPropertyValue( const ::rtl::OUString& /*aPropertyName*/, const uno::Any& /*aValue*/ )
1171 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1172 lang::IllegalArgumentException, lang::WrappedTargetException,
1173 uno::RuntimeException)
1174 {
1175 throw lang::IllegalArgumentException();
1176 }
1177 /*-- 15.03.2002 12:30:42---------------------------------------------------
1178
1179 -----------------------------------------------------------------------*/
1180 uno::Any SwXText::getPropertyValue(
1181 const ::rtl::OUString& rPropertyName )
1182 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1183 uno::RuntimeException)
1184 {
1185 vos::OGuard aGuard(Application::GetSolarMutex());
1186 if(!IsValid())
1187 throw uno::RuntimeException();
1188 const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName(rPropertyName);
1189 uno::Any aRet;
1190 if(pEntry)
1191 {
1192 switch(pEntry->nWID)
1193 {
1194 // no code necessary - the redline is always located at the end node
1195 // case FN_UNO_REDLINE_NODE_START:
1196 // break;
1197 case FN_UNO_REDLINE_NODE_END:
1198 {
1199 const SwRedlineTbl& rRedTbl = GetDoc()->GetRedlineTbl();
1200 USHORT nRedTblCount = rRedTbl.Count();
1201 if ( nRedTblCount > 0 )
1202 {
1203 const SwStartNode* pStartNode = GetStartNode();
1204 ULONG nOwnIndex = pStartNode->EndOfSectionIndex();
1205 for(USHORT nRed = 0; nRed < nRedTblCount; nRed++)
1206 {
1207 const SwRedline* pRedline = rRedTbl[nRed];
1208 const SwPosition* pRedStart = pRedline->Start();
1209 const SwNodeIndex nRedNode = pRedStart->nNode;
1210 if(nOwnIndex == nRedNode.GetIndex())
1211 {
1212 aRet <<= SwXRedlinePortion::CreateRedlineProperties(*pRedline, TRUE);
1213 break;
1214 }
1215 }
1216 }
1217 }
1218 break;
1219 }
1220 }
1221 else
1222 {
1223 beans::UnknownPropertyException aExcept;
1224 aExcept.Message = C2U("Unknown property: ");
1225 aExcept.Message += rPropertyName;
1226 throw aExcept;
1227 }
1228 return aRet;
1229
1230 }
1231 /*-- 15.03.2002 12:30:42---------------------------------------------------
1232
1233 -----------------------------------------------------------------------*/
1234 void SwXText::addPropertyChangeListener(
1235 const ::rtl::OUString& /*aPropertyName*/,
1236 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
1237 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1238 uno::RuntimeException)
1239 {
1240 throw uno::RuntimeException();
1241 }
1242 /*-- 15.03.2002 12:30:43---------------------------------------------------
1243
1244 -----------------------------------------------------------------------*/
1245 void SwXText::removePropertyChangeListener(
1246 const ::rtl::OUString& /*aPropertyName*/,
1247 const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
1248 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1249 uno::RuntimeException)
1250 {
1251 throw uno::RuntimeException();
1252 }
1253 /*-- 15.03.2002 12:30:43---------------------------------------------------
1254
1255 -----------------------------------------------------------------------*/
1256 void SwXText::addVetoableChangeListener(
1257 const ::rtl::OUString& /*PropertyName*/,
1258 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/ )
1259 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1260 uno::RuntimeException)
1261 {
1262 throw uno::RuntimeException();
1263 }
1264 /*-- 15.03.2002 12:30:43---------------------------------------------------
1265
1266 -----------------------------------------------------------------------*/
1267 void SwXText::removeVetoableChangeListener(
1268 const ::rtl::OUString& /*rPropertyName*/,
1269 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/ )
1270 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1271 uno::RuntimeException)
1272 {
1273 throw uno::RuntimeException();
1274 }
1275
1276 /* -----------------------------08.01.01 09:07--------------------------------
1277
1278 ---------------------------------------------------------------------------*/
1279 const uno::Sequence< sal_Int8 > & SwXText::getUnoTunnelId()
1280 {
1281 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
1282 return aSeq;
1283 }
1284 /* -----------------------------08.01.01 09:07--------------------------------
1285
1286 ---------------------------------------------------------------------------*/
1287 sal_Int64 SwXText::getSomething( const uno::Sequence< sal_Int8 >& rId )
1288 throw(uno::RuntimeException)
1289 {
1290 if( rId.getLength() == 16
1291 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
1292 rId.getConstArray(), 16 ) )
1293 {
1294 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
1295 }
1296 return 0;
1297 }
1298 /*-- 23.06.2006 08:56:30---------------------------------------------------
1299
1300 -----------------------------------------------------------------------*/
1301 uno::Reference< text::XTextRange > SwXText::appendParagraph(
1302 const uno::Sequence< beans::PropertyValue > & rProperties )
1303 throw (lang::IllegalArgumentException, uno::RuntimeException)
1304 {
1305 return finishOrAppendParagraph(false, rProperties);
1306 }
1307 /*-- 23.06.2006 08:56:22---------------------------------------------------
1308
1309 -----------------------------------------------------------------------*/
1310 uno::Reference< text::XTextRange > SwXText::finishParagraph(
1311 const uno::Sequence< beans::PropertyValue > & rProperties )
1312 throw (lang::IllegalArgumentException, uno::RuntimeException)
1313 {
1314 return finishOrAppendParagraph(true, rProperties);
1315 }
1316
1317 /*-- 08.05.2006 13:26:26---------------------------------------------------
1318
1319 -----------------------------------------------------------------------*/
1320 uno::Reference< text::XTextRange > SwXText::finishOrAppendParagraph(
1321 bool bFinish,
1322 const uno::Sequence< beans::PropertyValue > & rProperties )
1323 throw (lang::IllegalArgumentException, uno::RuntimeException)
1324
1325 {
1326 vos::OGuard aGuard(Application::GetSolarMutex());
1327 if(!IsValid())
1328 throw uno::RuntimeException();
1329 uno::Reference< text::XTextRange > xRet;
1330
1331 const SwStartNode* pStartNode = GetStartNode();
1332 if(!pStartNode)
1333 throw uno::RuntimeException();
1334 {
1335 bool bIllegalException = false;
1336 bool bRuntimeException = false;
1337 ::rtl::OUString sMessage;
1338 pDoc->StartUndo(UNDO_START , NULL);
1339 //find end node, go backward - don't skip tables because the new paragraph has to be the last node
1340 //aPam.Move( fnMoveBackward, fnGoNode );
1341 SwPosition aInsertPosition( SwNodeIndex( *pStartNode->EndOfSectionNode(), -1 ) );
1342 SwPaM aPam(aInsertPosition);
1343 pDoc->AppendTxtNode( *aPam.GetPoint() );
1344 //remove attributes from the previous paragraph
1345 pDoc->ResetAttrs(aPam);
1346 //in case of finishParagraph the PaM needs to be moved to the previous paragraph
1347 if(bFinish)
1348 aPam.Move( fnMoveBackward, fnGoNode );
1349 if(rProperties.getLength())
1350 {
1351 // now set the properties
1352 const SfxItemPropertySet* pParaPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARAGRAPH);
1353 const SfxItemPropertyMap* pParagraphMap = pParaPropSet->getPropertyMap();
1354
1355 const beans::PropertyValue* pValues = rProperties.getConstArray();
1356
1357 for( sal_Int32 nProp = 0; nProp < rProperties.getLength(); ++nProp)
1358 {
1359 if(pParagraphMap->getByName( pValues[nProp].Name ))
1360 {
1361 try
1362 {
1363 SwXTextCursor::SetPropertyValue(
1364 aPam,
1365 *pParaPropSet,
1366 pValues[nProp].Name,
1367 pValues[nProp].Value);
1368 }
1369 catch( lang::IllegalArgumentException& rIllegal )
1370 {
1371 sMessage = rIllegal.Message;
1372 bIllegalException = true;
1373 }
1374 catch( uno::RuntimeException& rRuntime )
1375 {
1376 sMessage = rRuntime.Message;
1377 bRuntimeException = true;
1378 }
1379 }
1380 else
1381 bIllegalException = true;
1382 if( bIllegalException || bRuntimeException )
1383 {
1384 break;
1385 }
1386 }
1387 }
1388 pDoc->EndUndo(UNDO_END, NULL);
1389 if( bIllegalException || bRuntimeException )
1390 {
1391 SwUndoIter aUndoIter( &aPam, UNDO_EMPTY );
1392 pDoc->Undo(aUndoIter);
1393 if(bIllegalException)
1394 {
1395 lang::IllegalArgumentException aEx;
1396 aEx.Message = sMessage;
1397 throw aEx;
1398 }
1399 else //if(bRuntimeException)
1400 {
1401 uno::RuntimeException aEx;
1402 aEx.Message = sMessage;
1403 throw aEx;
1404 }
1405 }
1406 SwTxtNode * pTxtNode( aPam.Start()->nNode.GetNode().GetTxtNode() );
1407 OSL_ENSURE(pTxtNode, "no SwTxtNode?");
1408 xRet = new SwXParagraph(this, pTxtNode);
1409 }
1410
1411 return xRet;
1412 }
1413 /*-- 08.05.2006 13:28:26---------------------------------------------------
1414 Append text portions at the end of the last paragraph of the text
1415 interface. Support of import filters.
1416 -----------------------------------------------------------------------*/
1417 uno::Reference< text::XTextRange > SwXText::appendTextPortion(
1418 const ::rtl::OUString& rText,
1419 const uno::Sequence< beans::PropertyValue > & rCharacterAndParagraphProperties )
1420 throw (lang::IllegalArgumentException, uno::RuntimeException)
1421 {
1422 vos::OGuard aGuard(Application::GetSolarMutex());
1423 if(!IsValid())
1424 throw uno::RuntimeException();
1425 uno::Reference< text::XTextRange > xRet;
1426 uno::Reference< text::XTextCursor > xTextCursor = createCursor();
1427 xTextCursor->gotoEnd(sal_False);
1428
1429 uno::Reference< lang::XUnoTunnel > xRangeTunnel( xTextCursor, uno::UNO_QUERY_THROW );
1430 SwXTextCursor* pTextCursor = reinterpret_cast< SwXTextCursor * >(
1431 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextCursor::getUnoTunnelId())));
1432 {
1433 bool bIllegalException = false;
1434 bool bRuntimeException = false;
1435 ::rtl::OUString sMessage;
1436 pDoc->StartUndo(UNDO_INSERT, NULL);
1437
1438 // SwPaM aPam(*pStartNode->EndOfSectionNode());
1439 //aPam.Move( fnMoveBackward, fnGoNode );
1440 SwUnoCrsr* pCursor = pTextCursor->GetCrsr();
1441 pCursor->MovePara( fnParaCurr, fnParaEnd );
1442 pDoc->DontExpandFmt( *pCursor->Start() );
1443
1444 if(rText.getLength())
1445 {
1446 xub_StrLen nContentPos = pCursor->GetPoint()->nContent.GetIndex();
1447 SwUnoCursorHelper::DocInsertStringSplitCR( *pDoc, *pCursor, rText,
1448 false );
1449 SwXTextCursor::SelectPam(*pCursor, sal_True);
1450 pCursor->GetPoint()->nContent = nContentPos;
1451 }
1452
1453 if(rCharacterAndParagraphProperties.getLength())
1454 {
1455 const SfxItemPropertyMap* pCursorMap = aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR)->getPropertyMap();
1456 const beans::PropertyValue* pValues = rCharacterAndParagraphProperties.getConstArray();
1457 const SfxItemPropertySet* pCursorPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR);
1458 for( sal_Int32 nProp = 0; nProp < rCharacterAndParagraphProperties.getLength(); ++nProp)
1459 {
1460 if( pCursorMap->getByName( pValues[nProp].Name ) )
1461 {
1462 try
1463 {
1464 SwXTextCursor::SetPropertyValue(
1465 *pCursor,
1466 *pCursorPropSet,
1467 pValues[nProp].Name,
1468 pValues[nProp].Value,
1469 nsSetAttrMode::SETATTR_NOFORMATATTR);
1470 }
1471 catch( lang::IllegalArgumentException& rIllegal )
1472 {
1473 sMessage = rIllegal.Message;
1474 bIllegalException = true;
1475 }
1476 catch( uno::RuntimeException& rRuntime )
1477 {
1478 sMessage = rRuntime.Message;
1479 bRuntimeException = true;
1480 }
1481 }
1482 else
1483 bIllegalException = true;
1484 if( bIllegalException || bRuntimeException )
1485 {
1486 break;
1487 }
1488 }
1489 }
1490 pDoc->EndUndo(UNDO_INSERT, NULL);
1491 if( bIllegalException || bRuntimeException )
1492 {
1493 SwUndoIter aUndoIter( pCursor, UNDO_EMPTY );
1494 pDoc->Undo(aUndoIter);
1495 delete pCursor;
1496 pCursor = 0;
1497 if(bIllegalException)
1498 {
1499 lang::IllegalArgumentException aEx;
1500 aEx.Message = sMessage;
1501 throw aEx;
1502 }
1503 else //if(bRuntimeException)
1504 {
1505 uno::RuntimeException aEx;
1506 aEx.Message = sMessage;
1507 throw aEx;
1508 }
1509 }
1510 xRet = new SwXTextRange(*pCursor, this);
1511 delete pCursor;
1512 }
1513 return xRet;
1514 }
1515 /*-- 11.05.2006 15:46:26---------------------------------------------------
1516 enable appending text contents like graphic objects, shapes and so on
1517 to support import filters
1518 -----------------------------------------------------------------------*/
1519 uno::Reference< text::XTextRange > SwXText::appendTextContent(
1520 const uno::Reference< text::XTextContent >& xTextContent,
1521 const uno::Sequence< beans::PropertyValue >& rCharacterAndParagraphProperties )
1522 throw (lang::IllegalArgumentException, uno::RuntimeException)
1523 {
1524 vos::OGuard aGuard(Application::GetSolarMutex());
1525 if(!IsValid())
1526 throw uno::RuntimeException();
1527 const SwStartNode* pStartNode = GetStartNode();
1528 if(!pStartNode)
1529 throw uno::RuntimeException();
1530 uno::Reference< text::XTextRange > xRet;
1531 {
1532 pDoc->StartUndo(UNDO_INSERT, NULL);
1533 //find end node, go backward - don't skip tables because the new paragraph has to be the last node
1534 SwPaM aPam(*pStartNode->EndOfSectionNode());
1535 aPam.Move( fnMoveBackward, fnGoNode );
1536 //set cursor to the end of the last text node
1537 SwCursor* pCursor = new SwCursor( *aPam.Start(),0,false );
1538 xRet = new SwXTextRange(*pCursor, this);
1539 pCursor->MovePara( fnParaCurr, fnParaEnd );
1540 pDoc->DontExpandFmt( *pCursor->Start() );
1541 //now attach the text content here
1542 insertTextContent( xRet, xTextContent, false );
1543 //now apply the properties to the anchor
1544 if( rCharacterAndParagraphProperties.getLength())
1545 {
1546 try
1547 {
1548 uno::Reference< beans::XPropertySet > xAnchor( xTextContent->getAnchor(), uno::UNO_QUERY);
1549 if( xAnchor.is() )
1550 {
1551 for( sal_Int32 nElement = 0; nElement < rCharacterAndParagraphProperties.getLength(); ++nElement )
1552 {
1553 xAnchor->setPropertyValue( rCharacterAndParagraphProperties[nElement].Name, rCharacterAndParagraphProperties[nElement].Value );
1554 }
1555 }
1556
1557 }
1558 catch(const uno::Exception&)
1559 {
1560 throw uno::RuntimeException();
1561 }
1562 }
1563 delete pCursor;
1564 pDoc->EndUndo(UNDO_INSERT, NULL);
1565 }
1566 return xRet;
1567 }
1568
1569 // move previously appended paragraphs into a text frames
1570 // to support import filters
1571 uno::Reference< text::XTextContent > SwXText::convertToTextFrame(
1572 const uno::Reference< text::XTextRange >& xStart,
1573 const uno::Reference< text::XTextRange >& xEnd,
1574 const uno::Sequence< beans::PropertyValue >& rFrameProperties )
1575 throw (lang::IllegalArgumentException, uno::RuntimeException)
1576 {
1577 vos::OGuard aGuard(Application::GetSolarMutex());
1578 if(!IsValid())
1579 throw uno::RuntimeException();
1580 uno::Reference< text::XTextContent > xRet;
1581 SwUnoInternalPaM aStartPam(*GetDoc());
1582 std::auto_ptr < SwUnoInternalPaM > pEndPam( new SwUnoInternalPaM(*GetDoc()));
1583 if(SwXTextRange::XTextRangeToSwPaM(aStartPam, xStart) &&
1584 SwXTextRange::XTextRangeToSwPaM(*pEndPam, xEnd) )
1585 {
1586 uno::Reference<lang::XUnoTunnel> xStartRangeTunnel( xStart, uno::UNO_QUERY);
1587 SwXTextRange* pStartRange = reinterpret_cast< SwXTextRange * >(
1588 sal::static_int_cast< sal_IntPtr >( xStartRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
1589 uno::Reference<lang::XUnoTunnel> xEndRangeTunnel( xEnd, uno::UNO_QUERY);
1590 SwXTextRange* pEndRange = reinterpret_cast< SwXTextRange * >(
1591 sal::static_int_cast< sal_IntPtr >( xEndRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
1592 //bookmarks have to be removed before the referenced text node is deleted in DelFullPara
1593 if(pStartRange)
1594 {
1595 ::sw::mark::IMark const * const pStartBookmark = pStartRange->GetBookmark();
1596 if(pStartBookmark)
1597 pDoc->getIDocumentMarkAccess()->deleteMark(pStartBookmark);
1598 }
1599 if(pEndRange)
1600 {
1601 ::sw::mark::IMark const * const pEndBookmark = pEndRange->GetBookmark();
1602 if(pEndBookmark)
1603 pDoc->getIDocumentMarkAccess()->deleteMark(pEndBookmark);
1604 }
1605
1606 pDoc->StartUndo( UNDO_START, NULL );
1607 bool bIllegalException = false;
1608 bool bRuntimeException = false;
1609 ::rtl::OUString sMessage;
1610 SwStartNode* pStartStartNode = aStartPam.GetNode()->StartOfSectionNode();
1611 while(pStartStartNode && pStartStartNode->IsSectionNode())
1612 {
1613 pStartStartNode = pStartStartNode->StartOfSectionNode();
1614 }
1615 SwStartNode* pEndStartNode = pEndPam->GetNode()->StartOfSectionNode();
1616 while(pEndStartNode && pEndStartNode->IsSectionNode())
1617 {
1618 pEndStartNode = pEndStartNode->StartOfSectionNode();
1619 }
1620 bool bParaAfterInserted = false;
1621 bool bParaBeforeInserted = false;
1622 if(pStartStartNode != pEndStartNode || pStartStartNode != GetStartNode())
1623 {
1624 //todo: if the start/end is in a table then insert a paragraph before/after, move
1625 //the start/end nodes, then convert and remove the addtional paragraphs in the end
1626 if( pStartStartNode->GetStartNodeType() == SwTableBoxStartNode )
1627 {
1628 SwTableNode* pSartTableNode = pStartStartNode->FindTableNode();
1629 SwNodeIndex aTblIdx( *pSartTableNode, -1 );
1630 SwPosition aBefore(aTblIdx);
1631 bParaBeforeInserted = GetDoc()->AppendTxtNode( aBefore );
1632 aStartPam.DeleteMark();
1633 *aStartPam.GetPoint() = aBefore;
1634 pStartStartNode = aStartPam.GetNode()->StartOfSectionNode();
1635 }
1636 if( pEndStartNode->GetStartNodeType() == SwTableBoxStartNode )
1637 {
1638 SwTableNode* pEndTableNode = pEndStartNode->FindTableNode();
1639 SwEndNode* pTableEnd = pEndTableNode->EndOfSectionNode();
1640 SwPosition aTableEnd(*pTableEnd);
1641 bParaAfterInserted = GetDoc()->AppendTxtNode( aTableEnd );
1642 pEndPam->DeleteMark();
1643 *pEndPam->GetPoint() = aTableEnd;
1644 pEndStartNode = pEndPam->GetNode()->StartOfSectionNode();
1645 }
1646 //now we should have the positions in the same hierarchy
1647 if(pStartStartNode != pEndStartNode || pStartStartNode != GetStartNode())
1648 {
1649 //if not - remove the additional paragraphs and throw
1650 if( bParaBeforeInserted )
1651 {
1652 SwCursor aDelete(*aStartPam.GetPoint(), 0, false);
1653 aDelete.MovePara(fnParaCurr, fnParaStart);
1654 aDelete.SetMark();
1655 aDelete.MovePara(fnParaCurr, fnParaEnd);
1656 GetDoc()->DelFullPara(aDelete);
1657 }
1658 if( bParaAfterInserted )
1659 {
1660 SwCursor aDelete(*pEndPam->GetPoint(), 0, false);
1661 aDelete.MovePara(fnParaCurr, fnParaStart);
1662 aDelete.SetMark();
1663 aDelete.MovePara(fnParaCurr, fnParaEnd);
1664 GetDoc()->DelFullPara(aDelete);
1665 }
1666 throw lang::IllegalArgumentException();
1667 }
1668 }
1669
1670 //make a selection from aStartPam to a EndPam
1671 SwSelBoxes aBoxes;
1672 SfxItemSet aFrameItemSet(pDoc->GetAttrPool(),
1673 RES_FRMATR_BEGIN, RES_FRMATR_END-1,
1674 0 );
1675
1676 aStartPam.SetMark();
1677 *aStartPam.End() = *pEndPam->End();
1678 pEndPam.reset(0);
1679
1680 SwXTextFrame* pNewFrame;
1681 uno::Reference< text::XTextFrame > xNewFrame = pNewFrame = new SwXTextFrame( pDoc );
1682 pNewFrame->SetSelection( aStartPam );
1683 try
1684 {
1685 const beans::PropertyValue* pValues = rFrameProperties.getConstArray();
1686 for(sal_Int32 nProp = 0; nProp < rFrameProperties.getLength(); ++nProp)
1687 pNewFrame->SwXFrame::setPropertyValue(pValues[nProp].Name, pValues[nProp].Value);
1688
1689 {//has to be in a block to remove the SwIndexes before DelFullPara is called
1690 uno::Reference< text::XTextRange> xInsertTextRange = new SwXTextRange(aStartPam, this);
1691 pNewFrame->attach( xInsertTextRange );
1692 pNewFrame->setName(pDoc->GetUniqueFrameName());
1693 }
1694
1695 if( !aStartPam.GetTxt().Len() )
1696 {
1697
1698 bool bMoved = false;
1699 {//has to be in a block to remove the SwIndexes before DelFullPara is called
1700 SwPaM aMovePam( *aStartPam.GetNode() );
1701 if( aMovePam.Move( fnMoveForward, fnGoCntnt ) )
1702 {
1703 //move the anchor to the next paragraph
1704 SwFmtAnchor aNewAnchor( pNewFrame->GetFrmFmt()->GetAnchor() );
1705 aNewAnchor.SetAnchor( aMovePam.Start() );
1706 pDoc->SetAttr( aNewAnchor, *pNewFrame->GetFrmFmt() );
1707 }
1708 bMoved = true;
1709 }
1710 if(bMoved)
1711 {
1712 aStartPam.DeleteMark();
1713 // SwPaM aDelPam( *aStartPam.GetNode() );
1714 pDoc->DelFullPara(aStartPam/*aDelPam*/);
1715 }
1716 }
1717 }
1718 catch( lang::IllegalArgumentException& rIllegal )
1719 {
1720 sMessage = rIllegal.Message;
1721 bIllegalException = true;
1722 }
1723 catch( uno::RuntimeException& rRuntime )
1724 {
1725 sMessage = rRuntime.Message;
1726 bRuntimeException = true;
1727 }
1728 xRet = pNewFrame;
1729 uno::Reference<text::XTextCursor> xFrameTextCursor;
1730 if( bParaBeforeInserted )
1731 {
1732 //todo: remove paragraph before frame
1733 xFrameTextCursor = pNewFrame->createTextCursor();
1734 uno::Reference<XUnoTunnel> xTunnel(xFrameTextCursor, uno::UNO_QUERY);
1735 SwXTextCursor* pFrameCursor = reinterpret_cast< SwXTextCursor* >(
1736 sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SwXTextCursor::getUnoTunnelId()) ));
1737 pDoc->DelFullPara(*pFrameCursor->GetPaM());
1738 }
1739 if( bParaAfterInserted )
1740 {
1741 //todo: remove paragraph after frame
1742 if( xFrameTextCursor.is() )
1743 xFrameTextCursor = pNewFrame->createTextCursor();
1744 xFrameTextCursor->gotoEnd( false );
1745 uno::Reference<XUnoTunnel> xTunnel(xFrameTextCursor, uno::UNO_QUERY);
1746 SwXTextCursor* pFrameCursor = reinterpret_cast< SwXTextCursor* >(
1747 sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething(SwXTextCursor::getUnoTunnelId()) ));
1748 pDoc->DelFullPara(*pFrameCursor->GetPaM());
1749 }
1750
1751 pDoc->EndUndo(UNDO_END, NULL);
1752 if( bIllegalException || bRuntimeException )
1753 {
1754 SwUndoIter aUndoIter( &aStartPam, UNDO_EMPTY );
1755 pDoc->Undo(aUndoIter);
1756 if(bIllegalException)
1757 {
1758 lang::IllegalArgumentException aEx;
1759 aEx.Message = sMessage;
1760 throw aEx;
1761 }
1762 else //if(bRuntimeException)
1763 {
1764 uno::RuntimeException aEx;
1765 aEx.Message = sMessage;
1766 throw aEx;
1767 }
1768 }
1769 }
1770 else
1771 throw lang::IllegalArgumentException();
1772 return xRet;
1773 }
1774 /*-- 11.05.2006 15:46:26---------------------------------------------------
1775 Move previously imported paragraphs into a new text table.
1776
1777 -----------------------------------------------------------------------*/
1778 struct VerticallyMergedCell
1779 {
1780 std::vector<uno::Reference< beans::XPropertySet > > aCells;
1781 sal_Int32 nLeftPosition;
1782 bool bOpen;
1783
1784 VerticallyMergedCell( uno::Reference< beans::XPropertySet >& rxCell, sal_Int32 nLeft ) :
1785 nLeftPosition( nLeft ),
1786 bOpen( true )
1787 {
1788 aCells.push_back( rxCell );
1789 }
1790 };
1791 #define COL_POS_FUZZY 2
1792 bool lcl_SimilarPosition( sal_Int32 nPos1, sal_Int32 nPos2 )
1793 {
1794 return abs( nPos1 - nPos2 ) < COL_POS_FUZZY;
1795 }
1796
1797 void SwXText::copyText(
1798 const uno::Reference< text::XTextCopy >& xSource )
1799 throw ( uno::RuntimeException )
1800 {
1801 #if DEBUG
1802 clog << "TODO - SwXText::copyText()" << endl;
1803 #endif
1804 uno::Reference< lang::XUnoTunnel > xTTunnel( xSource, uno::UNO_QUERY_THROW );
1805 SwXText* pText = 0;
1806 pText = reinterpret_cast< SwXText* >(
1807 sal::static_int_cast< sal_IntPtr >( xTTunnel->getSomething( SwXText::getUnoTunnelId()) ));
1808
1809
1810 uno::Reference< text::XText > xText( xSource, uno::UNO_QUERY_THROW );
1811 uno::Reference< text::XTextCursor > xCursor = xText->createTextCursor( );
1812 xCursor->gotoEnd( sal_True );
1813
1814 uno::Reference< lang::XUnoTunnel > xTunnel( xCursor, uno::UNO_QUERY_THROW );
1815
1816 OTextCursorHelper* pCursor = 0;
1817 pCursor = reinterpret_cast< OTextCursorHelper* >(
1818 sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
1819 if ( pCursor )
1820 {
1821 SwNodeIndex rNdIndex( *GetStartNode( ), 1 );
1822 SwPosition rPos( rNdIndex );
1823 pDoc->CopyRange( *pCursor->GetPaM( ), rPos, false );
1824 }
1825 }
1826
1827 uno::Reference< text::XTextTable > SwXText::convertToTable(
1828 const uno::Sequence< uno::Sequence< uno::Sequence< uno::Reference< text::XTextRange > > > >& rTableRanges,
1829 const uno::Sequence< uno::Sequence< uno::Sequence< beans::PropertyValue > > >& rCellProperties,
1830 const uno::Sequence< uno::Sequence< beans::PropertyValue > >& rRowProperties,
1831 const uno::Sequence< beans::PropertyValue >& rTableProperties )
1832 throw (lang::IllegalArgumentException, uno::RuntimeException)
1833 {
1834 vos::OGuard aGuard(Application::GetSolarMutex());
1835 if(!IsValid())
1836 throw uno::RuntimeException();
1837
1838 //at first collect the text ranges as SwPaMs
1839 const uno::Sequence< uno::Sequence< uno::Reference< text::XTextRange > > >* pTableRanges = rTableRanges.getConstArray();
1840 std::auto_ptr < SwPaM > pFirstPaM;
1841 std::vector< std::vector<SwNodeRange> > aTableNodes;
1842 bool bExcept = false;
1843 SwPaM aLastPaM(pDoc->GetNodes());
1844 for( sal_Int32 nRow = 0; !bExcept && (nRow < rTableRanges.getLength()); ++nRow)
1845 {
1846 std::vector<SwNodeRange> aRowNodes;
1847 const uno::Sequence< uno::Sequence< uno::Reference< text::XTextRange > > >& rRow = pTableRanges[nRow];
1848 const uno::Sequence< uno::Reference< text::XTextRange > >* pRow = pTableRanges[nRow].getConstArray();
1849
1850 for( sal_Int32 nCell = 0; nCell < rRow.getLength(); ++nCell)
1851 {
1852 if( pRow[nCell].getLength() != 2 )
1853 throw lang::IllegalArgumentException();
1854 const uno::Reference< text::XTextRange > xStartRange = pRow[nCell][0];
1855 const uno::Reference< text::XTextRange > xEndRange = pRow[nCell][1];
1856 SwUnoInternalPaM aStartCellPam(*pDoc);
1857 SwUnoInternalPaM aEndCellPam(*pDoc);
1858
1859 // !!! TODO - PaMs in tables and sections do not work here - the same applies to PaMs in frames !!!
1860
1861 if(!SwXTextRange::XTextRangeToSwPaM(aStartCellPam, xStartRange) ||
1862 !SwXTextRange::XTextRangeToSwPaM(aEndCellPam, xEndRange) )
1863 throw lang::IllegalArgumentException();
1864 /** check the nodes between start and end
1865 it is allowed to have pairs of StartNode/EndNodes
1866 */
1867 if(aStartCellPam.Start()->nNode < aEndCellPam.End()->nNode)
1868 {
1869 // increment on each StartNode and decrement on each EndNode
1870 // we must reach zero at the end and must not go below zero
1871 long nOpenNodeBlock = 0;
1872 SwNodeIndex aCellIndex = aStartCellPam.Start()->nNode;
1873 while( aCellIndex < aEndCellPam.End()->nNode.GetIndex())
1874 {
1875 if( aCellIndex.GetNode().IsStartNode() )
1876 ++nOpenNodeBlock;
1877 else if(aCellIndex.GetNode().IsEndNode() )
1878 --nOpenNodeBlock;
1879 if( nOpenNodeBlock < 0 )
1880 {
1881 bExcept = true;
1882 break;
1883 }
1884 ++aCellIndex;
1885 }
1886 if( nOpenNodeBlock != 0)
1887 {
1888 bExcept = true;
1889 break;
1890 }
1891 }
1892
1893 /** The vector<vector> NodeRanges has to contain consecutive nodes.
1894 In rTableRanges the ranges don't need to be full paragraphs but they have to follow
1895 each other. To process the ranges they have to be aligned on paragraph borders
1896 by inserting paragraph breaks. Non-consecutive ranges must initiate an
1897 exception.
1898
1899 */
1900 if(!nRow && !nCell)
1901 {
1902 //align the beginning - if necessary
1903 if(aStartCellPam.Start()->nContent.GetIndex())
1904 pDoc->SplitNode(*aStartCellPam.Start(), sal_False);
1905 }
1906 else
1907 {
1908 //check the predecessor
1909 ULONG nLastNodeIndex = aLastPaM.End()->nNode.GetIndex();
1910 ULONG nStartCellNodeIndex = aStartCellPam.Start()->nNode.GetIndex();
1911 ULONG nLastNodeEndIndex = aLastPaM.End()->nNode.GetIndex();
1912 if( nLastNodeIndex == nStartCellNodeIndex)
1913 {
1914 //- same node as predecessor then equal nContent?
1915 if(aLastPaM.End()->nContent != aStartCellPam.Start()->nContent)
1916 bExcept = true;
1917 else
1918 {
1919 pDoc->SplitNode(*aStartCellPam.Start(), sal_False);
1920 }
1921 }
1922 else if(nStartCellNodeIndex == ( nLastNodeEndIndex + 1))
1923 {
1924 //next paragraph - now the content index of the new should be 0
1925 //and of the old one should be equal to the text length
1926 //but if it isn't we don't care - the cell is being inserted on the
1927 //node border anyway
1928 }
1929 else
1930 {
1931 bExcept = true;
1932 }
1933 }
1934 //now check if there's a need to insert another paragraph break
1935 if( aEndCellPam.End()->nContent.GetIndex() < aEndCellPam.End()->nNode.GetNode().GetTxtNode()->Len())
1936 {
1937 pDoc->SplitNode(*aEndCellPam.End(), sal_False);
1938 //take care that the new start/endcell is moved to the right position
1939 //aStartCellPam has to point to the start of the new (previous) node
1940 //aEndCellPam has to point the the end of the new (previous) node
1941 aStartCellPam.DeleteMark();
1942 aStartCellPam.Move(fnMoveBackward, fnGoNode);
1943 aStartCellPam.GetPoint()->nContent = 0;
1944 aEndCellPam.DeleteMark();
1945 aEndCellPam.Move(fnMoveBackward, fnGoNode);
1946 aEndCellPam.GetPoint()->nContent = aEndCellPam.GetNode()->GetTxtNode()->Len();
1947
1948 }
1949
1950 *aLastPaM.GetPoint() = *aEndCellPam.Start();
1951 if( aStartCellPam.HasMark() )
1952 {
1953 aLastPaM.SetMark();
1954 *aLastPaM.GetMark() = *aEndCellPam.End();
1955 }
1956 else
1957 aLastPaM.DeleteMark();
1958
1959 SwNodeRange aCellRange( aStartCellPam.Start()->nNode, aEndCellPam.End()->nNode);
1960 aRowNodes.push_back(aCellRange);
1961 if( !nRow && !nCell )
1962 pFirstPaM.reset( new SwPaM(*aStartCellPam.Start()));
1963 }
1964 aTableNodes.push_back(aRowNodes);
1965 }
1966
1967 if(bExcept)
1968 {
1969 SwUndoIter aUndoIter( &aLastPaM, UNDO_EMPTY );
1970 pDoc->Undo(aUndoIter);
1971 throw lang::IllegalArgumentException();
1972 }
1973
1974 typedef uno::Sequence< text::TableColumnSeparator > TableColumnSeparators;
1975 std::vector< TableColumnSeparators > aRowSeparators(rRowProperties.getLength());
1976 std::vector<VerticallyMergedCell> aMergedCells;
1977
1978 const SwTable* pTable = pDoc->TextToTable( aTableNodes );
1979 SwXTextTable* pTextTable = 0;
1980 uno::Reference< text::XTextTable > xRet = pTextTable = new SwXTextTable( *pTable->GetFrmFmt() );
1981 uno::Reference< beans::XPropertySet > xPrSet = pTextTable;
1982 // set properties to the table - catch lang::WrappedTargetException and lang::IndexOutOfBoundsException
1983 try
1984 {
1985 //apply table properties
1986 const beans::PropertyValue* pTableProperties = rTableProperties.getConstArray();
1987 sal_Int32 nProperty = 0;
1988 for( ; nProperty < rTableProperties.getLength(); ++nProperty)
1989 {
1990 try
1991 {
1992 xPrSet->setPropertyValue( pTableProperties[nProperty].Name, pTableProperties[nProperty].Value );
1993 }
1994 catch ( const uno::Exception e )
1995 {
1996 #if DEBUG
1997 std::clog << "Exception when setting property: ";
1998 std::clog << rtl::OUStringToOString( pTableProperties[nProperty].Name, RTL_TEXTENCODING_UTF8 ).getStr( );
1999 std::clog << ". Message: ";
2000 std::clog << rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_UTF8 ).getStr( );
2001 std::clog << std::endl;
2002 #endif
2003 }
2004 }
2005
2006 //apply row properties
2007 uno::Reference< table::XTableRows > xRows = xRet->getRows();
2008 const beans::PropertyValues* pRowProperties = rRowProperties.getConstArray();
2009 sal_Int32 nRow = 0;
2010 for( ; nRow < xRows->getCount(); ++nRow)
2011 {
2012 if( nRow >= rRowProperties.getLength())
2013 {
2014 break;
2015 }
2016 uno::Reference< beans::XPropertySet > xRow;
2017 xRows->getByIndex( nRow ) >>= xRow;
2018 const beans::PropertyValue* pProperties = pRowProperties[nRow].getConstArray();
2019 for( nProperty = 0; nProperty < pRowProperties[nRow].getLength(); ++nProperty)
2020 {
2021 if( pProperties[ nProperty ].Name.equalsAsciiL(
2022 RTL_CONSTASCII_STRINGPARAM ( "TableColumnSeparators" )))
2023 {
2024 //add the separators to access the cell's positions for vertical merging later
2025 TableColumnSeparators aSeparators;
2026 pProperties[ nProperty ].Value >>= aSeparators;
2027 aRowSeparators[nRow] = aSeparators;
2028 }
2029 xRow->setPropertyValue( pProperties[ nProperty ].Name, pProperties[ nProperty ].Value );
2030 }
2031 }
2032
2033 #ifdef DEBUG
2034 //-->debug cell properties of all rows
2035 {
2036 ::rtl::OUString sNames;
2037 for( sal_Int32 nDebugRow = 0; nDebugRow < rCellProperties.getLength(); ++nDebugRow)
2038 {
2039 const uno::Sequence< beans::PropertyValues > aDebugCurrentRow = rCellProperties[nDebugRow];
2040 sal_Int32 nDebugCells = aDebugCurrentRow.getLength();
2041 (void) nDebugCells;
2042 for( sal_Int32 nDebugCell = 0; nDebugCell < nDebugCells; ++nDebugCell)
2043 {
2044 const uno::Sequence< beans::PropertyValue >& aDebugCellProperties = aDebugCurrentRow[nDebugCell];
2045 sal_Int32 nDebugCellProperties = aDebugCellProperties.getLength();
2046 for( sal_Int32 nDebugProperty = 0; nDebugProperty < nDebugCellProperties; ++nDebugProperty)
2047 {
2048 const ::rtl::OUString sName = aDebugCellProperties[nDebugProperty].Name;
2049 sNames += sName;
2050 sNames += ::rtl::OUString('-');
2051 }
2052 sNames += ::rtl::OUString('+');
2053 }
2054 sNames += ::rtl::OUString('|');
2055 }
2056 (void)sNames;
2057 }
2058 //--<
2059 #endif
2060
2061
2062 //apply cell properties
2063 for( nRow = 0; nRow < rCellProperties.getLength(); ++nRow)
2064 {
2065 const uno::Sequence< beans::PropertyValues > aCurrentRow = rCellProperties[nRow];
2066 sal_Int32 nCells = aCurrentRow.getLength();
2067 for( sal_Int32 nCell = 0; nCell < nCells; ++nCell)
2068 {
2069 const uno::Sequence< beans::PropertyValue >& aCellProperties = aCurrentRow[nCell];
2070 sal_Int32 nCellProperties = aCellProperties.getLength();
2071 uno::Reference< beans::XPropertySet > xCell( pTextTable->getCellByPosition(nCell, nRow), uno::UNO_QUERY );
2072 for( nProperty = 0; nProperty < nCellProperties; ++nProperty)
2073 {
2074 const OUString& rName = aCellProperties[nProperty].Name;
2075 if( rName.equalsAsciiL(
2076 RTL_CONSTASCII_STRINGPARAM ( "VerticalMerge")))
2077 {
2078 //determine left border position
2079 //add the cell to a queue of merged cells
2080 //
2081 sal_Bool bMerge = sal_False;
2082 aCellProperties[nProperty].Value >>= bMerge;
2083 sal_Int32 nLeftPos = -1;
2084 if( !nCell )
2085 nLeftPos = 0;
2086 else if( aRowSeparators[nRow].getLength() >= nCell )
2087 {
2088 const text::TableColumnSeparator* pSeparators = aRowSeparators[nRow].getConstArray();
2089 nLeftPos = pSeparators[nCell - 1].Position;
2090 }
2091 if( bMerge )
2092 {
2093 // 'close' all the cell with the same left position
2094 // if separate vertical merges in the same column exist
2095 if( aMergedCells.size() )
2096 {
2097 std::vector<VerticallyMergedCell>::iterator aMergedIter = aMergedCells.begin();
2098 while( aMergedIter != aMergedCells.end())
2099 {
2100 if( lcl_SimilarPosition( aMergedIter->nLeftPosition, nLeftPos) )
2101 {
2102 aMergedIter->bOpen = false;
2103 }
2104 ++aMergedIter;
2105 }
2106 }
2107 //add the new group of merged cells
2108 aMergedCells.push_back(VerticallyMergedCell(xCell, nLeftPos ));
2109 }
2110 else
2111 {
2112 //find the cell that
2113 DBG_ASSERT(aMergedCells.size(), "the first merged cell is missing");
2114 if( aMergedCells.size() )
2115 {
2116 std::vector<VerticallyMergedCell>::iterator aMergedIter = aMergedCells.begin();
2117 #if OSL_DEBUG_LEVEL > 1
2118 bool bDbgFound = false;
2119 #endif
2120 while( aMergedIter != aMergedCells.end())
2121 {
2122 if( aMergedIter->bOpen &&
2123 lcl_SimilarPosition( aMergedIter->nLeftPosition, nLeftPos) )
2124 {
2125 aMergedIter->aCells.push_back( xCell );
2126 #if OSL_DEBUG_LEVEL > 1
2127 bDbgFound = true;
2128 #endif
2129 }
2130 ++aMergedIter;
2131 }
2132 #if OSL_DEBUG_LEVEL > 1
2133 DBG_ASSERT( bDbgFound, "couldn't find first vertically merged cell" );
2134 #endif
2135 }
2136 }
2137 }
2138 else
2139 {
2140 try
2141 {
2142 xCell->setPropertyValue(rName, aCellProperties[nProperty].Value);
2143 }
2144 catch ( const uno::Exception e )
2145 {
2146 // Apply the paragraph and char properties to the cell's content
2147 uno::Reference< text::XText > xCellText( xCell, uno::UNO_QUERY );
2148 uno::Reference< text::XTextCursor > xCellCurs = xCellText->createTextCursor( );
2149 xCellCurs->gotoStart( false );
2150 xCellCurs->gotoEnd( true );
2151
2152 uno::Reference< beans::XPropertySet > xCellTextProps( xCellCurs, uno::UNO_QUERY );
2153 xCellTextProps->setPropertyValue( rName, aCellProperties[nProperty].Value );
2154 }
2155 }
2156 }
2157 }
2158 }
2159 //now that the cell properties are set the vertical merge values have to be applied
2160 if( aMergedCells.size() )
2161 {
2162 std::vector<VerticallyMergedCell>::iterator aMergedIter = aMergedCells.begin();
2163 while( aMergedIter != aMergedCells.end())
2164 {
2165 sal_Int32 nCellCount = (sal_Int32)aMergedIter->aCells.size();
2166 std::vector<uno::Reference< beans::XPropertySet > >::iterator aCellIter = aMergedIter->aCells.begin();
2167 bool bFirstCell = true;
2168 //the first of the cells get's the number of cells set as RowSpan
2169 //the others get the inverted number of remaining merged cells (3,-2,-1)
2170 while( aCellIter != aMergedIter->aCells.end() )
2171 {
2172 (*aCellIter)->setPropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_ROW_SPAN)), uno::makeAny( nCellCount ));
2173 if( bFirstCell )
2174 {
2175 nCellCount *= -1;
2176 bFirstCell = false;
2177 }
2178 ++nCellCount;
2179 ++aCellIter;
2180 }
2181 ++aMergedIter;
2182 }
2183 }
2184 }
2185 catch( const lang::WrappedTargetException& rWrapped )
2186 {
2187 (void)rWrapped;
2188 }
2189 catch ( const lang::IndexOutOfBoundsException& rBounds )
2190 {
2191 (void)rBounds;
2192 }
2193 return xRet;
2194 }
2195
2196 /******************************************************************
2197 * SwXBodyText
2198 ******************************************************************/
2199 SwXBodyText::SwXBodyText(SwDoc* _pDoc) :
2200 SwXText(_pDoc, CURSOR_BODY)
2201 {
2202 }
2203
2204 /*-- 10.12.98 11:17:27---------------------------------------------------
2205
2206 -----------------------------------------------------------------------*/
2207 SwXBodyText::~SwXBodyText()
2208 {
2209
2210 }
2211 /* -----------------------------06.04.00 16:33--------------------------------
2212
2213 ---------------------------------------------------------------------------*/
2214 OUString SwXBodyText::getImplementationName(void) throw( uno::RuntimeException )
2215 {
2216 return C2U("SwXBodyText");
2217 }
2218 /* -----------------------------06.04.00 16:33--------------------------------
2219
2220 ---------------------------------------------------------------------------*/
2221 BOOL SwXBodyText::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2222 {
2223 return C2U("com.sun.star.text.Text") == rServiceName;
2224 }
2225 /* -----------------------------06.04.00 16:33--------------------------------
2226
2227 ---------------------------------------------------------------------------*/
2228 uno::Sequence< OUString > SwXBodyText::getSupportedServiceNames(void) throw( uno::RuntimeException )
2229 {
2230 uno::Sequence< OUString > aRet(1);
2231 OUString* pArray = aRet.getArray();
2232 pArray[0] = C2U("com.sun.star.text.Text");
2233 return aRet;
2234 }
2235 /*-- 10.12.98 11:17:27---------------------------------------------------
2236
2237 -----------------------------------------------------------------------*/
2238 uno::Any SwXBodyText::queryAggregation(
2239 const uno::Type& rType )
2240 throw(uno::RuntimeException)
2241 {
2242 uno::Any aRet;
2243 const uno::Type& rXEnumerationAccessType = ::getCppuType((uno::Reference< container::XEnumerationAccess >*)0);
2244 const uno::Type& rXElementAccessType = ::getCppuType((uno::Reference< container::XElementAccess >*)0);
2245 const uno::Type& rXServiceInfoType = ::getCppuType((uno::Reference< lang::XServiceInfo >*)0);
2246
2247 if(rType == rXEnumerationAccessType)
2248 {
2249 uno::Reference<container::XEnumerationAccess> xRet = this;
2250 aRet.setValue(&xRet, rXEnumerationAccessType);
2251 }
2252 else if(rType == rXElementAccessType)
2253 {
2254 uno::Reference<container::XElementAccess> xRet = this;
2255 aRet.setValue(&xRet, rXElementAccessType);
2256 }
2257 else if(rType == rXServiceInfoType)
2258 {
2259 uno::Reference<lang::XServiceInfo> xRet = this;
2260 aRet.setValue(&xRet, rXServiceInfoType);
2261 }
2262 else
2263 {
2264 aRet = SwXText::queryInterface( rType );
2265 }
2266 if(aRet.getValueType() == ::getCppuVoidType())
2267 aRet = OWeakAggObject::queryAggregation( rType );
2268 return aRet;
2269 }
2270
2271 /*-- 10.12.98 11:17:28---------------------------------------------------
2272
2273 -----------------------------------------------------------------------*/
2274 uno::Sequence< uno::Type > SwXBodyText::getTypes( ) throw(uno::RuntimeException)
2275 {
2276 uno::Sequence< uno::Type > aTypes = SwXBodyTextBaseClass::getTypes();
2277 uno::Sequence< uno::Type > aTextTypes = SwXText::getTypes();
2278 long nIndex = aTypes.getLength();
2279 aTypes.realloc(aTypes.getLength() + aTextTypes.getLength());
2280 uno::Type* pTypes = aTypes.getArray();
2281 const uno::Type* pTextTypes = aTextTypes.getConstArray();
2282 for(int i = 0; i < aTextTypes.getLength(); i++)
2283 pTypes[nIndex++] = pTextTypes[i];
2284 return aTypes;
2285 }
2286 /* -----------------------------21.03.00 15:39--------------------------------
2287
2288 ---------------------------------------------------------------------------*/
2289 uno::Sequence< sal_Int8 > SwXBodyText::getImplementationId( ) throw(uno::RuntimeException)
2290 {
2291 vos::OGuard aGuard(Application::GetSolarMutex());
2292 static uno::Sequence< sal_Int8 > aId( 16 );
2293 static sal_Bool bInit = sal_False;
2294 if(!bInit)
2295 {
2296 rtl_createUuid( (sal_uInt8 *)(aId.getArray() ), 0, sal_True );
2297 bInit = sal_True;
2298 }
2299 return aId;
2300 }
2301 /*-- 10.12.98 11:17:28---------------------------------------------------
2302
2303 -----------------------------------------------------------------------*/
2304 uno::Any SAL_CALL
2305 SwXBodyText::queryInterface( const uno::Type& rType )
2306 throw(uno::RuntimeException)
2307 {
2308 uno::Any aRet = SwXText::queryInterface( rType );
2309 if(aRet.getValueType() == ::getCppuVoidType())
2310 aRet = SwXBodyTextBaseClass::queryInterface( rType );
2311 return aRet;
2312 }
2313 /* -----------------------------05.01.00 11:07--------------------------------
2314
2315 ---------------------------------------------------------------------------*/
2316 uno::Reference< text::XTextCursor > SwXBodyText::CreateTextCursor(sal_Bool bIgnoreTables)
2317 {
2318 uno::Reference< text::XTextCursor > xRet;
2319 if(IsValid())
2320 {
2321 SwNode& rNode = GetDoc()->GetNodes().GetEndOfContent();
2322 //the cursor has to skip tables contained in this text
2323 SwPaM aPam(rNode);
2324 aPam.Move( fnMoveBackward, fnGoDoc );
2325 if(!bIgnoreTables)
2326 {
2327 SwTableNode* pTblNode = aPam.GetNode()->FindTableNode();
2328 SwCntntNode* pCont = 0;
2329 while( pTblNode )
2330 {
2331 aPam.GetPoint()->nNode = *pTblNode->EndOfSectionNode();
2332 pCont = GetDoc()->GetNodes().GoNext(&aPam.GetPoint()->nNode);
2333 pTblNode = pCont->FindTableNode();
2334 }
2335 if(pCont)
2336 aPam.GetPoint()->nContent.Assign(pCont, 0);
2337 }
2338 xRet = (text::XWordCursor*)new SwXTextCursor(this, *aPam.GetPoint(), CURSOR_BODY, GetDoc());
2339 }
2340 return xRet;
2341 }
2342 /*-- 10.12.98 11:17:29---------------------------------------------------
2343
2344 -----------------------------------------------------------------------*/
2345 uno::Reference< text::XTextCursor > SwXBodyText::createTextCursor(void) throw( uno::RuntimeException )
2346 {
2347 vos::OGuard aGuard(Application::GetSolarMutex());
2348 uno::Reference< text::XTextCursor > aRef = CreateTextCursor(sal_False);
2349 if(!aRef.is())
2350 {
2351 uno::RuntimeException aRuntime;
2352 aRuntime.Message = C2U(cInvalidObject);
2353 throw aRuntime;
2354 }
2355 return aRef;
2356 }
2357 /*-- 10.12.98 11:17:29---------------------------------------------------
2358
2359 -----------------------------------------------------------------------*/
2360 uno::Reference< text::XTextCursor > SwXBodyText::createTextCursorByRange(
2361 const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException )
2362 {
2363 vos::OGuard aGuard(Application::GetSolarMutex());
2364 uno::Reference< text::XTextCursor > aRef;
2365 if(!IsValid())
2366 {
2367 uno::RuntimeException aRuntime;
2368 aRuntime.Message = C2U(cInvalidObject);
2369 throw aRuntime;
2370 }
2371 SwUnoInternalPaM aPam(*GetDoc());
2372 if(SwXTextRange::XTextRangeToSwPaM(aPam, aTextPosition))
2373 {
2374 SwNode& rNode = GetDoc()->GetNodes().GetEndOfContent();
2375
2376 SwStartNode* p1 = aPam.GetNode()->StartOfSectionNode();
2377 //document starts with a section?
2378 while(p1->IsSectionNode())
2379 {
2380 p1 = p1->StartOfSectionNode();
2381 }
2382 SwStartNode* p2 = rNode.StartOfSectionNode();
2383
2384 if(p1 == p2)
2385 aRef = (text::XWordCursor*)new SwXTextCursor(this , *aPam.GetPoint(), CURSOR_BODY, GetDoc(), aPam.GetMark());
2386 }
2387 if(!aRef.is())
2388 throw uno::RuntimeException();
2389 return aRef;
2390 }
2391 /*-- 10.12.98 11:17:30---------------------------------------------------
2392
2393 -----------------------------------------------------------------------*/
2394 uno::Reference< container::XEnumeration > SwXBodyText::createEnumeration(void)
2395 throw( uno::RuntimeException )
2396 {
2397 vos::OGuard aGuard(Application::GetSolarMutex());
2398 uno::Reference< container::XEnumeration > aRef;
2399 if(IsValid())
2400 {
2401 SwNode& rNode = GetDoc()->GetNodes().GetEndOfContent();
2402 SwPosition aPos(rNode);
2403 SwUnoCrsr* pUnoCrsr = GetDoc()->CreateUnoCrsr(aPos, sal_False);
2404 pUnoCrsr->Move( fnMoveBackward, fnGoDoc );
2405 aRef = new SwXParagraphEnumeration(this, pUnoCrsr, CURSOR_BODY);
2406 }
2407 else
2408 {
2409 uno::RuntimeException aRuntime;
2410 aRuntime.Message = C2U(cInvalidObject);
2411 throw aRuntime;
2412 }
2413 return aRef;
2414
2415 }
2416 /* -----------------18.12.98 13:36-------------------
2417 *
2418 * --------------------------------------------------*/
2419 uno::Type SwXBodyText::getElementType(void) throw( uno::RuntimeException )
2420 {
2421 return ::getCppuType((uno::Reference<text::XTextRange>*)0);
2422 }
2423 /* -----------------18.12.98 13:36-------------------
2424 *
2425 * --------------------------------------------------*/
2426 sal_Bool SwXBodyText::hasElements(void) throw( uno::RuntimeException )
2427 {
2428 vos::OGuard aGuard(Application::GetSolarMutex());
2429 if(IsValid())
2430 return sal_True;
2431 else
2432 {
2433 uno::RuntimeException aRuntime;
2434 aRuntime.Message = C2U(cInvalidObject);
2435 throw aRuntime;
2436 }
2437 }
2438 /******************************************************************
2439 * SwXHeadFootText
2440 ******************************************************************/
2441 TYPEINIT1(SwXHeadFootText, SwClient);
2442 /* -----------------------------06.04.00 16:40--------------------------------
2443
2444 ---------------------------------------------------------------------------*/
2445 OUString SwXHeadFootText::getImplementationName(void) throw( uno::RuntimeException )
2446 {
2447 return C2U("SwXHeadFootText");
2448 }
2449 /* -----------------------------06.04.00 16:40--------------------------------
2450
2451 ---------------------------------------------------------------------------*/
2452 BOOL SwXHeadFootText::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
2453 {
2454 return C2U("com.sun.star.text.Text") == rServiceName;
2455 }
2456 /* -----------------------------06.04.00 16:40--------------------------------
2457
2458 ---------------------------------------------------------------------------*/
2459 uno::Sequence< OUString > SwXHeadFootText::getSupportedServiceNames(void) throw( uno::RuntimeException )
2460 {
2461 uno::Sequence< OUString > aRet(1);
2462 OUString* pArray = aRet.getArray();
2463 pArray[0] = C2U("com.sun.star.text.Text");
2464 return aRet;
2465 }
2466 /*-- 11.12.98 10:14:48---------------------------------------------------
2467
2468 -----------------------------------------------------------------------*/
2469 SwXHeadFootText::SwXHeadFootText(SwFrmFmt& rHeadFootFmt, BOOL bHeader) :
2470 SwXText(rHeadFootFmt.GetDoc(), bHeader ? CURSOR_HEADER : CURSOR_FOOTER),
2471 SwClient(&rHeadFootFmt),
2472 bIsHeader(bHeader)
2473 {
2474
2475 }
2476 /*-- 11.12.98 10:14:48---------------------------------------------------
2477
2478 -----------------------------------------------------------------------*/
2479 SwXHeadFootText::~SwXHeadFootText()
2480 {
2481
2482 }
2483 /*-- 11.12.98 10:14:49---------------------------------------------------
2484
2485 -----------------------------------------------------------------------*/
2486 const SwStartNode *SwXHeadFootText::GetStartNode() const
2487 {
2488 const SwStartNode *pSttNd = 0;
2489 SwFrmFmt* pHeadFootFmt = GetFmt();
2490 if(pHeadFootFmt)
2491 {
2492 const SwFmtCntnt& rFlyCntnt = pHeadFootFmt->GetCntnt();
2493 if( rFlyCntnt.GetCntntIdx() )
2494 pSttNd = rFlyCntnt.GetCntntIdx()->GetNode().GetStartNode();
2495 }
2496 return pSttNd;
2497 }
2498
2499 uno::Reference< text::XTextCursor > SwXHeadFootText::createCursor() throw(uno::RuntimeException)
2500 {
2501 return createTextCursor();
2502 }
2503 /* -----------------------------21.03.00 15:39--------------------------------
2504
2505 ---------------------------------------------------------------------------*/
2506 uno::Sequence< uno::Type > SwXHeadFootText::getTypes( ) throw(uno::RuntimeException)
2507 {
2508 uno::Sequence< uno::Type > aHFTypes = SwXHeadFootTextBaseClass::getTypes();
2509 uno::Sequence< uno::Type > aTextTypes = SwXText::getTypes();
2510
2511 long nIndex = aHFTypes.getLength();
2512 aHFTypes.realloc(
2513 aHFTypes.getLength() +
2514 aTextTypes.getLength());
2515
2516 uno::Type* pHFTypes = aHFTypes.getArray();
2517 const uno::Type* pTextTypes = aTextTypes.getConstArray();
2518 for(long nPos = 0; nPos < aTextTypes.getLength(); nPos++)
2519 pHFTypes[nIndex++] = pTextTypes[nPos];
2520
2521 return aHFTypes;
2522 }
2523
2524 /* -----------------------------21.03.00 15:39--------------------------------
2525
2526 ---------------------------------------------------------------------------*/
2527 uno::Sequence< sal_Int8 > SwXHeadFootText::getImplementationId( ) throw(uno::RuntimeException)
2528 {
2529 vos::OGuard aGuard(Application::GetSolarMutex());
2530 static uno::Sequence< sal_Int8 > aId( 16 );
2531 static sal_Bool bInit = sal_False;
2532 if(!bInit)
2533 {
2534 rtl_createUuid( (sal_uInt8 *)(aId.getArray() ), 0, sal_True );
2535 bInit = sal_True;
2536 }
2537 return aId;
2538 }
2539 /* -----------------------------21.03.00 15:46--------------------------------
2540
2541 ---------------------------------------------------------------------------*/
2542 uno::Any SwXHeadFootText::queryInterface( const uno::Type& aType ) throw(uno::RuntimeException)
2543 {
2544 uno::Any aRet = SwXHeadFootTextBaseClass::queryInterface(aType);
2545 if(aRet.getValueType() == ::getCppuVoidType() )
2546 aRet = SwXText::queryInterface(aType);
2547 return aRet;
2548 }
2549
2550 /*-- 11.12.98 10:14:50---------------------------------------------------
2551
2552 -----------------------------------------------------------------------*/
2553 uno::Reference< text::XTextCursor > SwXHeadFootText::createTextCursor(void) throw( uno::RuntimeException )
2554 {
2555 vos::OGuard aGuard(Application::GetSolarMutex());
2556 uno::Reference< text::XTextCursor > xRet;
2557 SwFrmFmt* pHeadFootFmt = GetFmt();
2558 if(pHeadFootFmt)
2559 {
2560 const SwFmtCntnt& rFlyCntnt = pHeadFootFmt->GetCntnt();
2561 const SwNode& rNode = rFlyCntnt.GetCntntIdx()->GetNode();
2562 SwPosition aPos(rNode);
2563 SwXTextCursor* pCrsr = new SwXTextCursor(this, aPos, bIsHeader ? CURSOR_HEADER : CURSOR_FOOTER, GetDoc());
2564 SwUnoCrsr* pUnoCrsr = pCrsr->GetCrsr();
2565 pUnoCrsr->Move(fnMoveForward, fnGoNode);
2566
2567 //save current start node to be able to check if there is content after the table -
2568 //otherwise the cursor would be in the body text!
2569
2570 const SwStartNode* pOwnStartNode = rNode.FindSttNodeByType(
2571 bIsHeader ? SwHeaderStartNode : SwFooterStartNode);
2572 //steht hier eine Tabelle?
2573 SwTableNode* pTblNode = pUnoCrsr->GetNode()->FindTableNode();
2574 SwCntntNode* pCont = 0;
2575 while( pTblNode )
2576 {
2577 pUnoCrsr->GetPoint()->nNode = *pTblNode->EndOfSectionNode();
2578 pCont = GetDoc()->GetNodes().GoNext(&pUnoCrsr->GetPoint()->nNode);
2579 pTblNode = pCont->FindTableNode();
2580 }
2581 if(pCont)
2582 pUnoCrsr->GetPoint()->nContent.Assign(pCont, 0);
2583 const SwStartNode* pNewStartNode = pUnoCrsr->GetNode()->FindSttNodeByType(
2584 bIsHeader ? SwHeaderStartNode : SwFooterStartNode);
2585 if(!pNewStartNode || pNewStartNode != pOwnStartNode)
2586 {
2587 pCrsr = NULL;
2588 uno::RuntimeException aExcept;
2589 aExcept.Message = S2U("no text available");
2590 throw aExcept;
2591 }
2592 xRet = (text::XWordCursor*)pCrsr;
2593 }
2594 else
2595 {
2596 uno::RuntimeException aRuntime;
2597 aRuntime.Message = C2U(cInvalidObject);
2598 throw aRuntime;
2599 }
2600 return xRet;
2601 }
2602 /*-- 11.12.98 10:14:50---------------------------------------------------
2603
2604 -----------------------------------------------------------------------*/
2605 uno::Reference< text::XTextCursor > SwXHeadFootText::createTextCursorByRange(
2606 const uno::Reference< text::XTextRange > & aTextPosition) throw( uno::RuntimeException )
2607 {
2608 vos::OGuard aGuard(Application::GetSolarMutex());
2609 uno::Reference< text::XTextCursor > xRet;
2610 SwFrmFmt* pHeadFootFmt = GetFmt();
2611 SwUnoInternalPaM aPam(*GetDoc());
2612 if(pHeadFootFmt && SwXTextRange::XTextRangeToSwPaM(aPam, aTextPosition))
2613 {
2614 SwNode& rNode = pHeadFootFmt->GetCntnt().GetCntntIdx()->GetNode();
2615 SwPosition aPos(rNode);
2616 SwPaM aHFPam(aPos);
2617 aHFPam.Move(fnMoveForward, fnGoNode);
2618 SwStartNode* pOwnStartNode = aHFPam.GetNode()->FindSttNodeByType(
2619 bIsHeader ? SwHeaderStartNode : SwFooterStartNode);
2620 SwStartNode* p1 = aPam.GetNode()->FindSttNodeByType(
2621 bIsHeader ? SwHeaderStartNode : SwFooterStartNode);
2622 if(p1 == pOwnStartNode)
2623 xRet = (text::XWordCursor*)new SwXTextCursor(this, *aPam.GetPoint(),
2624 bIsHeader ? CURSOR_HEADER : CURSOR_FOOTER, GetDoc(), aPam.GetMark());
2625 }
2626 return xRet;
2627 }
2628 /* -----------------19.03.99 15:44-------------------
2629 *
2630 * --------------------------------------------------*/
2631 uno::Reference< container::XEnumeration > SwXHeadFootText::createEnumeration(void)
2632 throw( uno::RuntimeException )
2633 {
2634 vos::OGuard aGuard(Application::GetSolarMutex());
2635 uno::Reference< container::XEnumeration > aRef;
2636 //wenn this ungueltig ist, dann kommt die uno::Exception aus createTextCursor()
2637 SwFrmFmt* pHeadFootFmt = GetFmt();
2638 if(pHeadFootFmt)
2639 {
2640 const SwFmtCntnt& rFlyCntnt = pHeadFootFmt->GetCntnt();
2641 const SwNode& rNode = rFlyCntnt.GetCntntIdx()->GetNode();
2642 SwPosition aPos(rNode);
2643 SwUnoCrsr* pUnoCrsr = GetDoc()->CreateUnoCrsr(aPos, sal_False);
2644 pUnoCrsr->Move(fnMoveForward, fnGoNode);
2645 aRef = new SwXParagraphEnumeration(this, pUnoCrsr, bIsHeader ? CURSOR_HEADER : CURSOR_FOOTER);
2646 }
2647 else
2648 {
2649 uno::RuntimeException aRuntime;
2650 aRuntime.Message = C2U(cInvalidObject);
2651 throw aRuntime;
2652 }
2653
2654 return aRef;
2655 }
2656 /* -----------------19.03.99 15:50-------------------
2657 *
2658 * --------------------------------------------------*/
2659 uno::Type SwXHeadFootText::getElementType(void) throw( uno::RuntimeException )
2660 {
2661 return ::getCppuType((uno::Reference<text::XTextRange>*)0);
2662 }
2663 /* -----------------19.03.99 15:50-------------------
2664 *
2665 * --------------------------------------------------*/
2666 sal_Bool SwXHeadFootText::hasElements(void) throw( uno::RuntimeException )
2667 {
2668 return sal_True;
2669 }
2670
2671 /*-- 11.12.98 10:14:51---------------------------------------------------
2672
2673 -----------------------------------------------------------------------*/
2674 void SwXHeadFootText::Modify( SfxPoolItem *pOld, SfxPoolItem *pNew)
2675 {
2676 ClientModify( this, pOld, pNew);
2677 }
2678
vba interoperability for OOo