xref: /aoo4110/main/sw/source/ui/uno/unotxdoc.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 #include <vos/mutex.hxx>
28 #include <vcl/image.hxx>
29 #include <vcl/virdev.hxx>
30 #include <vcl/svapp.hxx>
31 #include <vcl/print.hxx>
32 #include <sfx2/viewfrm.hxx>
33 #include <sfx2/sfxbasecontroller.hxx>
34 #include <sfx2/docfile.hxx>
35 #include <sfx2/printer.hxx>
36 #include <toolkit/helper/vclunohelper.hxx>
37 #include <toolkit/awt/vclxdevice.hxx>
38 #include <cmdid.h>
39 #include <swtypes.hxx>
40 #include <wdocsh.hxx>
41 #include <wrtsh.hxx>
42 #include <view.hxx>
43 #include <pview.hxx>
44 #include <srcview.hxx>
45 #include <viewsh.hxx>
46 #include <pvprtdat.hxx>
47 #include <printdata.hxx>
48 #include <svl/stritem.hxx>
49 #include <unotxdoc.hxx>
50 #include <svl/numuno.hxx>
51 #include <fldbas.hxx>
52 #include <unotextbodyhf.hxx>
53 #include <unotextrange.hxx>
54 #include <unotextcursor.hxx>
55 #include <unosett.hxx>
56 #include <unocoll.hxx>
57 #include <unoredlines.hxx>
58 #include <unosrch.hxx>
59 #include <sfx2/dispatch.hxx>
60 #include <sfx2/request.hxx>
61 #include <sfx2/objsh.hxx>   // SfxObjectShellRef <-> SV_DECL_REF(SfxObjectShell)
62 #include <unoprnms.hxx>
63 #include <unostyle.hxx>
64 #include <unodraw.hxx>
65 #include <svl/eitem.hxx>
66 #include <pagedesc.hxx>
67 #include <svtools/txtcmp.hxx>
68 #include <unocrsr.hxx>
69 #include <unofield.hxx>
70 #include <unoidx.hxx>
71 #include <unoflatpara.hxx>
72 #include <unotxvw.hxx>
73 #include <poolfmt.hxx>
74 #include <globdoc.hxx>
75 #include <viewopt.hxx>
76 #include <unochart.hxx>
77 #include <doc.hxx>
78 #include <charatr.hxx>
79 #include <svx/xmleohlp.hxx>
80 #include <globals.hrc>
81 #include <unomid.h>
82 #include <unotools/printwarningoptions.hxx>
83 #include <com/sun/star/util/SearchOptions.hpp>
84 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
85 #include <com/sun/star/lang/DisposedException.hpp>
86 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
87 #include <com/sun/star/beans/PropertyAttribute.hpp>
88 #include <com/sun/star/beans/XFastPropertySet.hpp>
89 #include <com/sun/star/document/RedlineDisplayType.hpp>
90 #include <com/sun/star/document/XDocumentEventBroadcaster.hpp>
91 #include <com/sun/star/frame/XController.hpp>
92 #include <com/sun/star/frame/XFrame.hpp>
93 #include <com/sun/star/script/XInvocation.hpp>
94 #include <com/sun/star/reflection/XIdlClassProvider.hpp>
95 #include <sfx2/linkmgr.hxx>
96 #include <svx/unofill.hxx>
97 #include <editeng/unolingu.hxx>
98 #include <sfx2/progress.hxx>
99 #include <swmodule.hxx>
100 #include <docstat.hxx>
101 #include <modcfg.hxx>
102 #include <ndtxt.hxx>
103 #include <utlui.hrc>
104 #include <swcont.hxx>
105 #include <unodefaults.hxx>
106 #include <SwXDocumentSettings.hxx>
107 #include <doc.hxx>
108 #include <editeng/forbiddencharacterstable.hxx>
109 #include <svl/zforlist.hxx>
110 #include <drawdoc.hxx>
111 #include <SwStyleNameMapper.hxx>
112 #include <osl/file.hxx>
113 #include <comphelper/storagehelper.hxx>
114 
115 
116 // --> FME 2004-06-08 #i12836# enhanced pdf export
117 #include <EnhancedPDFExportHelper.hxx>
118 // <--
119 #include <numrule.hxx>
120 
121 ///////////////////////////Modified on Jun. 14th//////////////////////////
122 ///////////////////////for getDocumentLanguages///////////////////////////
123 //-->
124 #include <editeng/langitem.hxx>
125 #include <doc.hxx>
126 #include <docary.hxx>      //SwCharFmts
127 #include <i18npool/mslangid.hxx>
128 
129 #include <format.hxx>
130 #include <charfmt.hxx>    //SwCharFmt
131 #include <fmtcol.hxx>     //SwTxtFmtColl
132 #include <unostyle.hxx>   //SwAutoStyleFamily
133 #include <istyleaccess.hxx> // handling of automatic styles
134 
135 #include <svl/stylepool.hxx>
136 #include <swatrset.hxx>
137 #include <view.hxx>
138 #include <srcview.hxx>
139 
140 //#include <com/sun/star/i18n/ScriptType.hpp>
141 #include <svtools/langtab.hxx>
142 #include <map>
143 #include <set>
144 #include <vector>
145 
146 #include <editeng/eeitem.hxx>
147 #include <editeng/editeng.hxx>
148 #include <svx/svdoutl.hxx>
149 #include <svl/languageoptions.hxx>
150 #include <svx/svdview.hxx>
151 
152 //
153 //<--
154 using namespace ::com::sun::star;
155 using namespace ::com::sun::star::text;
156 using namespace ::com::sun::star::i18n;
157 using namespace ::com::sun::star::uno;
158 using namespace ::com::sun::star::beans;
159 using namespace ::com::sun::star::lang;
160 using namespace ::com::sun::star::container;
161 using namespace ::com::sun::star::document;
162 using namespace ::com::sun::star::i18n;
163 using ::rtl::OUString;
164 using ::osl::FileBase;
165 
166 /* -----------------------------17.01.01 15:43--------------------------------
167 
168  ---------------------------------------------------------------------------*/
169 #define SW_CREATE_DASH_TABLE            0x01
170 #define SW_CREATE_GRADIENT_TABLE        0x02
171 #define SW_CREATE_HATCH_TABLE           0x03
172 #define SW_CREATE_BITMAP_TABLE          0x04
173 #define SW_CREATE_TRANSGRADIENT_TABLE   0x05
174 #define SW_CREATE_MARKER_TABLE          0x06
175 #define SW_CREATE_DRAW_DEFAULTS         0x07
176 
177 
178 /******************************************************************************
179  *
180  ******************************************************************************/
181 
182 extern bool lcl_GetPostIts( IDocumentFieldsAccess* pIDFA, _SetGetExpFlds * pSrtLst );
183 
lcl_GetPrintUIOptions(SwDocShell * pDocShell,const SfxViewShell * pView)184 SwPrintUIOptions * lcl_GetPrintUIOptions(
185     SwDocShell * pDocShell,
186     const SfxViewShell * pView )
187 {
188     if (!pDocShell)
189         return NULL;
190 
191     const sal_Bool bWebDoc      = NULL != dynamic_cast< const SwWebDocShell * >(pDocShell);
192     const bool bSwSrcView   = NULL != dynamic_cast< const SwSrcView * >(pView);
193     const SwView * pSwView = dynamic_cast< const SwView * >(pView);
194     const bool bHasSelection    = pSwView ? pSwView->HasSelection( sal_False ) : false;  // check for any selection, not just text selection
195     const bool bHasPostIts      = lcl_GetPostIts( pDocShell->GetDoc(), 0 );
196 
197     // get default values to use in dialog from documents SwPrintData
198     const SwPrintData &rPrintData = pDocShell->GetDoc()->getPrintData();
199 
200     return new SwPrintUIOptions( bWebDoc, bSwSrcView, bHasSelection, bHasPostIts, rPrintData );
201 }
202 
203 ////////////////////////////////////////////////////////////
204 
205 
lcl_GetParaStyle(const String & rCollName,SwDoc * pDoc)206 SwTxtFmtColl *lcl_GetParaStyle(const String& rCollName, SwDoc* pDoc)
207 {
208 	SwTxtFmtColl* pColl = pDoc->FindTxtFmtCollByName( rCollName );
209 	if( !pColl )
210 	{
211 		sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( rCollName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
212 		if( USHRT_MAX != nId )
213 			pColl = pDoc->GetTxtCollFromPool( nId );
214 	}
215 	return pColl;
216 }
lcl_DisposeView(SfxViewFrame * pToClose,SwDocShell * pDocShell)217 void lcl_DisposeView( SfxViewFrame* pToClose, SwDocShell* pDocShell )
218 {
219     // check if the view frame still exists
220     SfxViewFrame* pFound = SfxViewFrame::GetFirst( pDocShell,
221                                 sal_False );
222     while(pFound)
223     {
224         if( pFound == pToClose)
225         {
226             pToClose->DoClose();
227             break;
228         }
229         pFound = SfxViewFrame::GetNext( *pFound,
230                                 pDocShell,
231                                 sal_False );
232     }
233 }
234 /* -----------------------------10.03.00 18:02--------------------------------
235 
236  ---------------------------------------------------------------------------*/
getUnoTunnelId()237 const Sequence< sal_Int8 > & SwXTextDocument::getUnoTunnelId()
238 {
239     static Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
240 	return aSeq;
241 }
242 /* -----------------------------10.03.00 18:04--------------------------------
243 
244  ---------------------------------------------------------------------------*/
getSomething(const Sequence<sal_Int8> & rId)245 sal_Int64 SAL_CALL SwXTextDocument::getSomething( const Sequence< sal_Int8 >& rId )
246 	throw(RuntimeException)
247 {
248     if( rId.getLength() == 16
249         && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
250 										rId.getConstArray(), 16 ) )
251     {
252             return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ));
253     }
254 
255 	sal_Int64 nRet = SfxBaseModel::getSomething( rId );
256 	if ( nRet )
257 		return nRet;
258 	else
259 	{
260 		GetNumberFormatter();
261 		Any aNumTunnel = xNumFmtAgg->queryAggregation(::getCppuType((Reference<XUnoTunnel>*)0));
262 		Reference<XUnoTunnel> xNumTunnel;
263 		aNumTunnel >>= xNumTunnel;
264 		if(xNumTunnel.is())
265 			return xNumTunnel->getSomething(rId);
266 	}
267 
268 	return SfxBaseModel::getSomething( rId );
269 }
270 /* -----------------------------16.03.00 14:12--------------------------------
271 
272  ---------------------------------------------------------------------------*/
queryInterface(const uno::Type & rType)273 Any SAL_CALL SwXTextDocument::queryInterface( const uno::Type& rType ) throw(RuntimeException)
274 {
275 	Any aRet = SwXTextDocumentBaseClass::queryInterface(rType);
276 	if ( !aRet.hasValue() )
277 		aRet = SfxBaseModel::queryInterface(rType);
278 	if ( !aRet.hasValue() &&
279         rType == ::getCppuType((Reference<lang::XMultiServiceFactory>*)0))
280 	{
281 		Reference<lang::XMultiServiceFactory> xTmp = this;
282 		aRet <<= xTmp;
283 	}
284 
285     if ( !aRet.hasValue()
286         && rType != ::getCppuType((Reference< com::sun::star::document::XDocumentEventBroadcaster>*)0)
287         && rType != ::getCppuType((Reference< com::sun::star::frame::XController>*)0)
288         && rType != ::getCppuType((Reference< com::sun::star::frame::XFrame>*)0)
289         && rType != ::getCppuType((Reference< com::sun::star::script::XInvocation>*)0)
290         && rType != ::getCppuType((Reference< com::sun::star::reflection::XIdlClassProvider>*)0)
291         && rType != ::getCppuType((Reference< com::sun::star::beans::XFastPropertySet>*)0)
292         && rType != ::getCppuType((Reference< com::sun::star::awt::XWindow>*)0))
293     {
294 	    GetNumberFormatter();
295 	    if(xNumFmtAgg.is())
296 		    aRet = xNumFmtAgg->queryAggregation(rType);
297     }
298 	return aRet;
299 }
300 /* -----------------------------16.03.00 14:12--------------------------------
301 
302  ---------------------------------------------------------------------------*/
acquire()303 void SAL_CALL SwXTextDocument::acquire()throw()
304 {
305 	SfxBaseModel::acquire();
306 }
307 /* -----------------------------16.03.00 14:12--------------------------------
308 
309  ---------------------------------------------------------------------------*/
release()310 void SAL_CALL SwXTextDocument::release()throw()
311 {
312 	SfxBaseModel::release();
313 }
314 /* -----------------------------07.12.00 11:37--------------------------------
315 
316  ---------------------------------------------------------------------------*/
queryAdapter()317 Reference< XAdapter > SwXTextDocument::queryAdapter(  ) throw(RuntimeException)
318 {
319 	return SfxBaseModel::queryAdapter();
320 }
321 /* -----------------------------16.03.00 14:12--------------------------------
322 
323  ---------------------------------------------------------------------------*/
getTypes()324 Sequence< uno::Type > SAL_CALL SwXTextDocument::getTypes() throw(RuntimeException)
325 {
326 	Sequence< uno::Type > aBaseTypes = SfxBaseModel::getTypes();
327 	Sequence< uno::Type > aTextTypes = SwXTextDocumentBaseClass::getTypes();
328 
329 	Sequence< uno::Type > aNumTypes;
330 	GetNumberFormatter();
331 	if(xNumFmtAgg.is())
332 	{
333         const uno::Type& rProvType = ::getCppuType((Reference <XTypeProvider>*)0);
334         Any aNumProv = xNumFmtAgg->queryAggregation(rProvType);
335         Reference<XTypeProvider> xNumProv;
336         if(aNumProv >>= xNumProv)
337 		{
338 			aNumTypes = xNumProv->getTypes();
339 		}
340 	}
341 	long nIndex = aBaseTypes.getLength();
342     // don't forget the lang::XMultiServiceFactory
343 	aBaseTypes.realloc(aBaseTypes.getLength() + aTextTypes.getLength() + aNumTypes.getLength() + 1);
344 	uno::Type* pBaseTypes = aBaseTypes.getArray();
345 	const uno::Type* pTextTypes = aTextTypes.getConstArray();
346 	long nPos;
347 	for(nPos = 0; nPos < aTextTypes.getLength(); nPos++)
348 	{
349 		pBaseTypes[nIndex++] = pTextTypes[nPos];
350 	}
351 	const uno::Type* pNumTypes = aNumTypes.getConstArray();
352 	for(nPos = 0; nPos < aNumTypes.getLength(); nPos++)
353 	{
354 		pBaseTypes[nIndex++] = pNumTypes[nPos];
355 	}
356 	pBaseTypes[nIndex++] = ::getCppuType((Reference<lang::XMultiServiceFactory>*)0);
357 	return aBaseTypes;
358 }
359 /*-- 18.12.98 11:52:59---------------------------------------------------
360 
361   -----------------------------------------------------------------------*/
SwXTextDocument(SwDocShell * pShell)362 SwXTextDocument::SwXTextDocument(SwDocShell* pShell) :
363 	SfxBaseModel(pShell),
364 
365     aRefreshCont ( static_cast < XTextDocument* > ( this ) ),
366 
367     pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_DOCUMENT)),
368 
369     pDocShell(pShell),
370 
371     bObjectValid(pShell != 0),
372 
373     pDrawPage(0),
374     pxXDrawPage(0),
375 
376     pxXNumberingRules(0),
377     pxXFootnotes(0),
378     pxXFootnoteSettings(0),
379     pxXEndnotes(0),
380     pxXEndnoteSettings(0),
381     pxXReferenceMarks(0),
382     pxXTextFieldTypes(0),
383     pxXTextFieldMasters(0),
384     pxXTextSections(0),
385     pxXBookmarks(0),
386     pxXTextTables(0),
387 	pxXTextFrames(0),
388 	pxXGraphicObjects(0),
389 	pxXEmbeddedObjects(0),
390     pxXStyleFamilies(0),
391     pxXAutoStyles(0),
392     pxXChapterNumbering(0),
393     pxXDocumentIndexes(0),
394 
395 	pxXLineNumberingProperties(0),
396 	pxLinkTargetSupplier(0),
397     pxXRedlines(0),
398     m_pHiddenViewFrame(0),
399     m_pPrintUIOptions( NULL ),
400     m_pRenderData( NULL ),
401     // --> OD #i117783#
402     bApplyPagePrintSettingsFromXPagePrintable( sal_False )
403     // <--
404 {
405 }
406 /*-- 18.12.98 11:53:00---------------------------------------------------
407 
408   -----------------------------------------------------------------------*/
~SwXTextDocument()409 SwXTextDocument::~SwXTextDocument()
410 {
411 	InitNewDoc();
412 	if(xNumFmtAgg.is())
413 	{
414 		Reference< XInterface >  x0;
415 		xNumFmtAgg->setDelegator(x0);
416 		xNumFmtAgg = 0;
417 	}
418     delete m_pPrintUIOptions;
419     delete m_pRenderData;
420 }
421 
422 
423 /*-- 18.12.98 11:55:08---------------------------------------------------
424 
425   -----------------------------------------------------------------------*/
426 /* -----------------18.12.98 12:49-------------------
427  *
428  * --------------------------------------------------*/
GetPropertyHelper()429 SwXDocumentPropertyHelper * SwXTextDocument::GetPropertyHelper ()
430 {
431 	if(!xPropertyHelper.is())
432 	{
433 		pPropertyHelper = new SwXDocumentPropertyHelper(*pDocShell->GetDoc());
434 		xPropertyHelper = (cppu::OWeakObject*)pPropertyHelper;
435 	}
436 	return pPropertyHelper;
437 }
GetNumberFormatter()438 void SwXTextDocument::GetNumberFormatter()
439 {
440 	if(IsValid())
441 	{
442 		if(!xNumFmtAgg.is())
443 		{
444 			if ( pDocShell->GetDoc() )
445 			{
446 				SvNumberFormatsSupplierObj* pNumFmt = new SvNumberFormatsSupplierObj(
447 									pDocShell->GetDoc()->GetNumberFormatter( sal_True ));
448 				Reference< util::XNumberFormatsSupplier >  xTmp = pNumFmt;
449 				xNumFmtAgg = Reference< XAggregation >(xTmp, UNO_QUERY);
450 			}
451 			if(xNumFmtAgg.is())
452 				xNumFmtAgg->setDelegator((cppu::OWeakObject*)(SwXTextDocumentBaseClass*)this);
453 		}
454 		else
455 		{
456             const uno::Type& rTunnelType = ::getCppuType((Reference <XUnoTunnel>*)0);
457             Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType);
458 			SvNumberFormatsSupplierObj* pNumFmt = 0;
459             Reference< XUnoTunnel > xNumTunnel;
460             if(aNumTunnel >>= xNumTunnel)
461 			{
462                 pNumFmt = reinterpret_cast<SvNumberFormatsSupplierObj*>(
463                         xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId()));
464 
465 			}
466 			DBG_ASSERT(pNumFmt, "No number formatter available");
467 			if(!pNumFmt->GetNumberFormatter())
468 				pNumFmt->SetNumberFormatter(pDocShell->GetDoc()->GetNumberFormatter( sal_True ));
469 		}
470 	}
471 }
472 /*-- 18.12.98 11:55:11---------------------------------------------------
473 
474   -----------------------------------------------------------------------*/
getText(void)475 Reference< XText >  SwXTextDocument::getText(void) throw( RuntimeException )
476 {
477 	::vos::OGuard aGuard(Application::GetSolarMutex());
478 	if(!IsValid())
479 		throw RuntimeException();
480 	if(!xBodyText.is())
481 	{
482 		pBodyText = new SwXBodyText(pDocShell->GetDoc());
483 		xBodyText = pBodyText;
484 	}
485 	return xBodyText;
486 }
487 /*-- 18.12.98 11:55:11---------------------------------------------------
488 
489   -----------------------------------------------------------------------*/
reformat(void)490 void SwXTextDocument::reformat(void) throw( RuntimeException )
491 {
492 	::vos::OGuard aGuard(Application::GetSolarMutex());
493 	if(!IsValid())
494 		throw RuntimeException();
495 }
496 /*-- 18.12.98 11:55:16---------------------------------------------------
497 
498   -----------------------------------------------------------------------*/
lockControllers(void)499 void SwXTextDocument::lockControllers(void) throw( RuntimeException )
500 {
501 	::vos::OGuard aGuard(Application::GetSolarMutex());
502 	if(IsValid())
503 	{
504 		UnoActionContext* pContext = new UnoActionContext(pDocShell->GetDoc());
505 		aActionArr.Insert(pContext, 0);
506 	}
507 	else
508 		throw RuntimeException();
509 }
510 /*-- 18.12.98 11:55:16---------------------------------------------------
511 
512   -----------------------------------------------------------------------*/
unlockControllers(void)513 void SwXTextDocument::unlockControllers(void) throw( RuntimeException )
514 {
515 	::vos::OGuard aGuard(Application::GetSolarMutex());
516 	if(aActionArr.Count())
517 	{
518 		UnoActionContext* pContext = aActionArr.GetObject(0);
519 		aActionArr.Remove(0);
520 		delete pContext;
521 	}
522 	else
523 		throw RuntimeException();
524 }
525 /*-- 18.12.98 11:55:17---------------------------------------------------
526 
527   -----------------------------------------------------------------------*/
hasControllersLocked(void)528 sal_Bool SwXTextDocument::hasControllersLocked(void) throw( RuntimeException )
529 {
530 	::vos::OGuard aGuard(Application::GetSolarMutex());
531 	return aActionArr.Count() > 0;
532 }
533 /*-- 18.12.98 13:12:23---------------------------------------------------
534 
535   -----------------------------------------------------------------------*/
getCurrentController(void)536 Reference< frame::XController >  SwXTextDocument::getCurrentController(void) throw( RuntimeException )
537 {
538 	return SfxBaseModel::getCurrentController();
539 }
540 /*-- 18.12.98 13:12:24---------------------------------------------------
541 
542   -----------------------------------------------------------------------*/
setCurrentController(const Reference<frame::XController> & xController)543 void SwXTextDocument::setCurrentController(const Reference< frame::XController > & xController)
544 	throw( NoSuchElementException, RuntimeException )
545 {
546 	SfxBaseModel::setCurrentController(xController);
547 }
548 /* -----------------27.01.99 11:48-------------------
549  *
550  * --------------------------------------------------*/
getCurrentSelection()551 Reference< XInterface >  SwXTextDocument::getCurrentSelection() throw( RuntimeException )
552 {
553 	::vos::OGuard aGuard(Application::GetSolarMutex());
554 	Reference< XInterface >  xRef;
555 	if(IsValid())
556 	{
557 
558 		const TypeId aTypeId = TYPE(SwView);
559 		SwView* pView = (SwView*)SfxViewShell::GetFirst(&aTypeId);
560 		while(pView && pView->GetObjectShell() != pDocShell)
561 		{
562 			pView = (SwView*)SfxViewShell::GetNext(*pView, &aTypeId);
563 		}
564 		if(pView)
565 		{
566 			Any aRef = pView->GetUNOObject()->getSelection();
567             aRef >>= xRef;
568 		}
569 	}
570 	return xRef;
571 }
572 
573 /*-- 18.12.98 13:12:24---------------------------------------------------
574 
575   -----------------------------------------------------------------------*/
attachResource(const OUString & aURL,const Sequence<beans::PropertyValue> & aArgs)576 sal_Bool SwXTextDocument::attachResource(const OUString& aURL, const Sequence< beans::PropertyValue >& aArgs)
577 		throw( RuntimeException )
578 {
579 	return SfxBaseModel::attachResource(aURL, aArgs);
580 }
581 /*-- 18.12.98 13:12:24---------------------------------------------------
582 
583   -----------------------------------------------------------------------*/
getURL(void)584 OUString SwXTextDocument::getURL(void) throw( RuntimeException )
585 {
586 	return SfxBaseModel::getURL();
587 }
588 /*-- 18.12.98 13:12:24---------------------------------------------------
589 
590   -----------------------------------------------------------------------*/
getArgs(void)591 Sequence< beans::PropertyValue > SwXTextDocument::getArgs(void) throw( RuntimeException )
592 {
593 	return SfxBaseModel::getArgs();
594 }
595 /*-- 18.12.98 13:12:24---------------------------------------------------
596 
597   -----------------------------------------------------------------------*/
connectController(const Reference<frame::XController> & xController)598 void SwXTextDocument::connectController(const Reference< frame::XController > & xController) throw( RuntimeException )
599 {
600 	SfxBaseModel::connectController(xController);
601 }
602 /*-- 18.12.98 13:12:25---------------------------------------------------
603 
604   -----------------------------------------------------------------------*/
disconnectController(const Reference<frame::XController> & xController)605 void SwXTextDocument::disconnectController(const Reference< frame::XController > & xController) throw( RuntimeException )
606 {
607 	SfxBaseModel::disconnectController(xController);
608 }
609 /*-- 18.12.98 13:12:25---------------------------------------------------
610 
611   -----------------------------------------------------------------------*/
dispose(void)612 void SwXTextDocument::dispose(void) throw( RuntimeException )
613 {
614     SfxBaseModel::dispose();
615 }
616 /*-- 10.05.2005 14:14:39---------------------------------------------------
617 
618   -----------------------------------------------------------------------*/
close(sal_Bool bDeliverOwnership)619 void SwXTextDocument::close( sal_Bool bDeliverOwnership ) throw( util::CloseVetoException, RuntimeException )
620 {
621     if ( IsValid() && m_pHiddenViewFrame )
622     {
623         ASSERT( false, "<SwXTextDocument::close(..)> - rendering data not cleaned up???" );
624         lcl_DisposeView( m_pHiddenViewFrame, pDocShell);
625         m_pHiddenViewFrame = 0;
626         // prevent crash described in #i108805
627         SfxItemSet *pSet = pDocShell->GetMedium()->GetItemSet();
628         pSet->Put( SfxBoolItem( SID_HIDDEN, sal_False ) );
629     }
630 
631     SfxBaseModel::close(bDeliverOwnership);
632 }
633 /*-- 18.12.98 13:12:25---------------------------------------------------
634 
635   -----------------------------------------------------------------------*/
addEventListener(const Reference<lang::XEventListener> & aListener)636 void SwXTextDocument::addEventListener(const Reference< lang::XEventListener > & aListener) throw( RuntimeException )
637 {
638 	SfxBaseModel::addEventListener(aListener);
639 }
640 /*-- 18.12.98 13:12:26---------------------------------------------------
641 
642   -----------------------------------------------------------------------*/
removeEventListener(const Reference<lang::XEventListener> & aListener)643 void SwXTextDocument::removeEventListener(const Reference< lang::XEventListener > & aListener) throw( RuntimeException )
644 {
645 	SfxBaseModel::removeEventListener(aListener);
646 }
647 
648 /*-- 18.12.98 11:55:19---------------------------------------------------
649 
650   -----------------------------------------------------------------------*/
getLineNumberingProperties(void)651 Reference< XPropertySet > SwXTextDocument::getLineNumberingProperties(void)
652 			throw( RuntimeException )
653 {
654 	::vos::OGuard aGuard(Application::GetSolarMutex());
655 	if(IsValid())
656 	{
657 		if(!pxXLineNumberingProperties)
658 		{
659 			pxXLineNumberingProperties = new Reference<XPropertySet>;
660 			(*pxXLineNumberingProperties) = new SwXLineNumberingProperties(pDocShell->GetDoc());
661 		}
662 	}
663 	else
664 		throw RuntimeException();
665 	return *pxXLineNumberingProperties;
666 }
667 /*-- 18.12.98 11:55:20---------------------------------------------------
668 
669   -----------------------------------------------------------------------*/
getChapterNumberingRules(void)670 Reference< XIndexReplace >  SwXTextDocument::getChapterNumberingRules(void)
671 									throw( RuntimeException )
672 {
673 	::vos::OGuard aGuard(Application::GetSolarMutex());
674 	if(!IsValid())
675 		throw RuntimeException();
676 	if(!pxXChapterNumbering)
677 	{
678 		pxXChapterNumbering = new Reference< XIndexReplace > ;
679 		*pxXChapterNumbering = new SwXChapterNumbering(*pDocShell);
680 	}
681 	return *pxXChapterNumbering;
682 }
683 
getNumberingRules(void)684 Reference< XIndexAccess >  SwXTextDocument::getNumberingRules(void) throw( RuntimeException )
685 {
686     ::vos::OGuard aGuard(Application::GetSolarMutex());
687     if(!IsValid())
688         throw RuntimeException();
689     if(!pxXNumberingRules )
690     {
691         ((SwXTextDocument*)this)->pxXNumberingRules = new Reference< XIndexAccess > ;
692         *pxXNumberingRules = new SwXNumberingRulesCollection( pDocShell->GetDoc() );
693     }
694     return *pxXNumberingRules;
695 }
696 
697 /*-- 18.12.98 11:55:21---------------------------------------------------
698 
699   -----------------------------------------------------------------------*/
getFootnotes(void)700 Reference< XIndexAccess >  SwXTextDocument::getFootnotes(void) throw( RuntimeException )
701 {
702 	::vos::OGuard aGuard(Application::GetSolarMutex());
703 	if(!IsValid())
704 		throw RuntimeException();
705 	if(!pxXFootnotes)
706 	{
707 		((SwXTextDocument*)this)->pxXFootnotes = new Reference< XIndexAccess > ;
708 		*pxXFootnotes = new SwXFootnotes(sal_False, pDocShell->GetDoc());
709 	}
710 	return *pxXFootnotes;
711 }
712 /*-- 18.12.98 11:55:21---------------------------------------------------
713 
714   -----------------------------------------------------------------------*/
715 Reference< XPropertySet >  SAL_CALL
getFootnoteSettings(void)716 		SwXTextDocument::getFootnoteSettings(void) throw( RuntimeException )
717 {
718 	::vos::OGuard aGuard(Application::GetSolarMutex());
719 	if(!IsValid())
720 		throw RuntimeException();
721 	if(!pxXFootnoteSettings)
722 	{
723 		((SwXTextDocument*)this)->pxXFootnoteSettings = new Reference< XPropertySet > ;
724 		*pxXFootnoteSettings = new SwXFootnoteProperties(pDocShell->GetDoc());
725 	}
726 	return *pxXFootnoteSettings;
727 }
728 /*-- 18.12.98 11:55:21---------------------------------------------------
729 
730   -----------------------------------------------------------------------*/
getEndnotes(void)731 Reference< XIndexAccess >  SwXTextDocument::getEndnotes(void) throw( RuntimeException )
732 {
733 	::vos::OGuard aGuard(Application::GetSolarMutex());
734 	if(!IsValid())
735 		throw RuntimeException();
736 	if(!pxXEndnotes)
737 	{
738 		((SwXTextDocument*)this)->pxXEndnotes = new Reference< XIndexAccess > ;
739 		*pxXEndnotes = new SwXFootnotes(sal_True, pDocShell->GetDoc());
740 	}
741 	return *pxXEndnotes;
742 }
743 /*-- 18.12.98 11:55:22---------------------------------------------------
744 
745   -----------------------------------------------------------------------*/
getEndnoteSettings(void)746 Reference< XPropertySet >  SwXTextDocument::getEndnoteSettings(void) throw( RuntimeException )
747 {
748 	::vos::OGuard aGuard(Application::GetSolarMutex());
749 	if(!IsValid())
750 		throw RuntimeException();
751 	if(!pxXEndnoteSettings)
752 	{
753 		((SwXTextDocument*)this)->pxXEndnoteSettings = new Reference< XPropertySet > ;
754 		*pxXEndnoteSettings = new SwXEndnoteProperties(pDocShell->GetDoc());
755 	}
756 	return *pxXEndnoteSettings;
757 }
758 /*-- 18.12.98 11:55:22---------------------------------------------------
759 
760   -----------------------------------------------------------------------*/
createReplaceDescriptor(void)761 Reference< util::XReplaceDescriptor >  SwXTextDocument::createReplaceDescriptor(void)
762 	throw( RuntimeException )
763 {
764 	::vos::OGuard aGuard(Application::GetSolarMutex());
765 	Reference< util::XReplaceDescriptor >  xRet = new SwXTextSearch;
766 	return xRet;
767 }
768 /* -----------------26.02.99 15:52-------------------
769  *
770  * --------------------------------------------------*/
CreateCursorForSearch(Reference<XTextCursor> & xCrsr)771 SwUnoCrsr* 	SwXTextDocument::CreateCursorForSearch(Reference< XTextCursor > & xCrsr)
772 {
773 	getText();
774     XText *const pText = xBodyText.get();
775 	SwXBodyText* pBText = (SwXBodyText*)pText;
776     SwXTextCursor *const pXTextCursor = pBText->CreateTextCursor(true);
777     xCrsr.set( static_cast<text::XWordCursor*>(pXTextCursor) );
778 
779     SwUnoCrsr *const pUnoCrsr = pXTextCursor->GetCursor();
780 	pUnoCrsr->SetRemainInSection(sal_False);
781 	return pUnoCrsr;
782 }
783 
784 /*-- 18.12.98 11:55:22---------------------------------------------------
785 
786   -----------------------------------------------------------------------*/
replaceAll(const Reference<util::XSearchDescriptor> & xDesc)787 sal_Int32 SwXTextDocument::replaceAll(const Reference< util::XSearchDescriptor > & xDesc)
788 										throw( RuntimeException )
789 {
790 	::vos::OGuard aGuard(Application::GetSolarMutex());
791 	Reference< XUnoTunnel > xDescTunnel(xDesc, UNO_QUERY);
792 	if(!IsValid() || !xDescTunnel.is() || !xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId()))
793 		throw RuntimeException();
794 
795 	Reference< XTextCursor >  xCrsr;
796 	SwUnoCrsr* 	pUnoCrsr = CreateCursorForSearch(xCrsr);
797 
798     const SwXTextSearch* pSearch = reinterpret_cast<const SwXTextSearch*>(
799             xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId()));
800 
801 	int eRanges(FND_IN_BODY|FND_IN_SELALL);
802 
803     util::SearchOptions aSearchOpt;
804 	pSearch->FillSearchOptions( aSearchOpt );
805 
806 	SwDocPositions eStart = pSearch->bBack ? DOCPOS_END : DOCPOS_START;
807 	SwDocPositions eEnd = pSearch->bBack ? DOCPOS_START : DOCPOS_END;
808 
809 	// Suche soll ueberall stattfinden
810 	pUnoCrsr->SetRemainInSection(sal_False);
811 	sal_uInt32 nResult;
812 	UnoActionContext aContext(pDocShell->GetDoc());
813 	//try attribute search first
814 	if(pSearch->HasSearchAttributes()||pSearch->HasReplaceAttributes())
815 	{
816 		SfxItemSet aSearch(pDocShell->GetDoc()->GetAttrPool(),
817 							RES_CHRATR_BEGIN, RES_CHRATR_END-1,
818 							RES_PARATR_BEGIN, RES_PARATR_END-1,
819 							RES_FRMATR_BEGIN, RES_FRMATR_END-1,
820 							0);
821 		SfxItemSet aReplace(pDocShell->GetDoc()->GetAttrPool(),
822 							RES_CHRATR_BEGIN, RES_CHRATR_END-1,
823 							RES_PARATR_BEGIN, RES_PARATR_END-1,
824 							RES_FRMATR_BEGIN, RES_FRMATR_END-1,
825 							0);
826 		pSearch->FillSearchItemSet(aSearch);
827 		pSearch->FillReplaceItemSet(aReplace);
828         sal_Bool bCancel;
829         nResult = (sal_Int32)pUnoCrsr->Find( aSearch, !pSearch->bStyles,
830                     eStart, eEnd, bCancel,
831 					(FindRanges)eRanges,
832 					pSearch->sSearchText.Len() ? &aSearchOpt : 0,
833 					&aReplace );
834 	}
835 	else if(pSearch->bStyles)
836 	{
837 		SwTxtFmtColl *pSearchColl = lcl_GetParaStyle(pSearch->sSearchText, pUnoCrsr->GetDoc());
838 		SwTxtFmtColl *pReplaceColl = lcl_GetParaStyle(pSearch->sReplaceText, pUnoCrsr->GetDoc());;
839 
840         sal_Bool bCancel;
841         nResult = pUnoCrsr->Find( *pSearchColl,
842                     eStart, eEnd, bCancel,
843 					(FindRanges)eRanges, pReplaceColl );
844 
845 	}
846 	else
847 	{
848 		//todo/mba: assuming that notes should be omitted
849 		sal_Bool bSearchInNotes = sal_False;
850         sal_Bool bCancel;
851         nResult = pUnoCrsr->Find( aSearchOpt, bSearchInNotes,
852             eStart, eEnd, bCancel,
853 			(FindRanges)eRanges,
854 			sal_True );
855 	}
856 	return (sal_Int32)nResult;
857 
858 }
859 /*-- 18.12.98 11:55:22---------------------------------------------------
860 
861   -----------------------------------------------------------------------*/
createSearchDescriptor(void)862 Reference< util::XSearchDescriptor >  SwXTextDocument::createSearchDescriptor(void)
863 													throw( RuntimeException )
864 {
865 	::vos::OGuard aGuard(Application::GetSolarMutex());
866 	Reference< util::XSearchDescriptor >  xRet = new SwXTextSearch;
867 	return xRet;
868 
869 }
870 /* -----------------26.02.99 16:08-------------------
871  * wird fuer findAll/First/Next verwendet
872  * --------------------------------------------------*/
FindAny(const Reference<util::XSearchDescriptor> & xDesc,Reference<XTextCursor> & xCrsr,sal_Bool bAll,sal_Int32 & nResult,Reference<XInterface> xLastResult)873 SwUnoCrsr* 	SwXTextDocument::FindAny(const Reference< util::XSearchDescriptor > & xDesc,
874 										Reference< XTextCursor > & xCrsr, sal_Bool bAll,
875 												sal_Int32& nResult,
876 												Reference< XInterface >  xLastResult)
877 {
878 	Reference< XUnoTunnel > xDescTunnel(xDesc, UNO_QUERY);
879 	if(!IsValid() || !xDescTunnel.is() || !xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId()))
880 		return 0;
881 
882 	SwUnoCrsr* 	pUnoCrsr = CreateCursorForSearch(xCrsr);
883     const SwXTextSearch* pSearch = reinterpret_cast<const SwXTextSearch*>(
884         xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId()));
885 
886 	sal_Bool bParentInExtra = sal_False;
887 	if(xLastResult.is())
888 	{
889 		Reference<XUnoTunnel> xCursorTunnel( xLastResult, UNO_QUERY);
890 		OTextCursorHelper* pPosCrsr = 0;
891 		if(xCursorTunnel.is())
892 		{
893             pPosCrsr = reinterpret_cast<OTextCursorHelper*>(xCursorTunnel->getSomething(
894                                     OTextCursorHelper::getUnoTunnelId()));
895 		}
896 		SwPaM* pCrsr = pPosCrsr ? pPosCrsr->GetPaM() : 0;
897 		if(pCrsr)
898 		{
899 			*pUnoCrsr->GetPoint() = *pCrsr->End();
900 			pUnoCrsr->DeleteMark();
901 		}
902 		else
903 		{
904 			SwXTextRange* pRange = 0;
905 			if(xCursorTunnel.is())
906 			{
907                 pRange = reinterpret_cast<SwXTextRange*>(xCursorTunnel->getSomething(
908                                         SwXTextRange::getUnoTunnelId()));
909 			}
910 			if(!pRange)
911 				return 0;
912 			pRange->GetPositions(*pUnoCrsr);
913 			if(pUnoCrsr->HasMark())
914 			{
915 				if(*pUnoCrsr->GetPoint() < *pUnoCrsr->GetMark())
916 					pUnoCrsr->Exchange();
917 				pUnoCrsr->DeleteMark();
918 			}
919 		}
920 		const SwNode* pRangeNode = pUnoCrsr->GetNode();
921         bParentInExtra = pRangeNode->FindFlyStartNode() ||
922                             pRangeNode->FindFootnoteStartNode() ||
923                             pRangeNode->FindHeaderStartNode() ||
924                             pRangeNode->FindFooterStartNode() ;
925 	}
926 
927     util::SearchOptions aSearchOpt;
928 	pSearch->FillSearchOptions( aSearchOpt );
929 
930 /*
931  * folgende Kombinationen sind erlaubt:
932  *  - suche einen im Body:					-> FND_IN_BODY
933  *  - suche alle im Body: 					-> FND_IN_BODYONLY | FND_IN_SELALL
934  *  - suche in Selectionen: einen / alle    -> FND_IN_SEL  [ | FND_IN_SELALL ]
935  *  - suche im nicht Body: einen / alle     -> FND_IN_OTHER [ | FND_IN_SELALL ]
936  *  - suche ueberall alle: 					-> FND_IN_SELALL
937  */
938 	int eRanges(FND_IN_BODY);
939 	if(bParentInExtra)
940 		eRanges = FND_IN_OTHER;
941 	if(bAll) //immer - ueberall?
942 		eRanges = FND_IN_SELALL;
943 	SwDocPositions eStart = !bAll ? DOCPOS_CURR : pSearch->bBack ? DOCPOS_END : DOCPOS_START;
944 	SwDocPositions eEnd = pSearch->bBack ? DOCPOS_START : DOCPOS_END;
945 
946 	nResult = 0;
947 	sal_uInt16 nSearchProc = 0;
948 	while(nSearchProc < 2)
949 	{
950 		//try attribute search first
951 		if(pSearch->HasSearchAttributes())
952 		{
953 			SfxItemSet aSearch(pDocShell->GetDoc()->GetAttrPool(),
954 								RES_CHRATR_BEGIN, RES_CHRATR_END-1,
955 								RES_PARATR_BEGIN, RES_PARATR_END-1,
956 								RES_FRMATR_BEGIN, RES_FRMATR_END-1,
957 								RES_TXTATR_INETFMT,	RES_TXTATR_CHARFMT,
958 								0);
959 			pSearch->FillSearchItemSet(aSearch);
960             sal_Bool bCancel;
961             nResult = (sal_Int32)pUnoCrsr->Find( aSearch, !pSearch->bStyles,
962                         eStart, eEnd, bCancel,
963 						(FindRanges)eRanges,
964 						pSearch->sSearchText.Len() ? &aSearchOpt : 0,
965 						0 );
966 		}
967 		else if(pSearch->bStyles)
968 		{
969 			SwTxtFmtColl *pSearchColl = lcl_GetParaStyle(pSearch->sSearchText, pUnoCrsr->GetDoc());
970 			//pSearch->sReplaceText
971 			SwTxtFmtColl *pReplaceColl = 0;
972             sal_Bool bCancel;
973 			nResult = (sal_Int32)pUnoCrsr->Find( *pSearchColl,
974                         eStart, eEnd, bCancel,
975 						(FindRanges)eRanges, pReplaceColl );
976 		}
977 		else
978 		{
979 			//todo/mba: assuming that notes should be omitted
980 			sal_Bool bSearchInNotes = sal_False;
981 			sal_Bool bCancel;
982 			nResult = (sal_Int32)pUnoCrsr->Find( aSearchOpt, bSearchInNotes,
983                     eStart, eEnd, bCancel,
984 					(FindRanges)eRanges,
985 					/*int bReplace =*/sal_False );
986 		}
987 		nSearchProc++;
988 		if(nResult || (eRanges&(FND_IN_SELALL|FND_IN_OTHER)))
989 			break;
990 		//second step - find in other
991 		eRanges = FND_IN_OTHER;
992 	}
993 	return pUnoCrsr;
994 }
995 /*-- 18.12.98 11:55:23---------------------------------------------------
996 
997   -----------------------------------------------------------------------*/
998 Reference< XIndexAccess >
findAll(const Reference<util::XSearchDescriptor> & xDesc)999 	SwXTextDocument::findAll(const Reference< util::XSearchDescriptor > & xDesc)
1000 												throw( RuntimeException )
1001 {
1002 	::vos::OGuard aGuard(Application::GetSolarMutex());
1003 	Reference< XInterface >  xTmp;
1004 	sal_Int32 nResult = 0;
1005 	Reference< XTextCursor >  xCrsr;
1006 	SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_True, nResult, xTmp);
1007 	if(!pResultCrsr)
1008 		throw RuntimeException();
1009 	Reference< XIndexAccess >  xRet;
1010     xRet = new SwXTextRanges( (nResult) ? pResultCrsr : 0 );
1011     delete pResultCrsr;
1012     return xRet;
1013 }
1014 /*-- 18.12.98 11:55:23---------------------------------------------------
1015 
1016   -----------------------------------------------------------------------*/
findFirst(const Reference<util::XSearchDescriptor> & xDesc)1017 Reference< XInterface >  SwXTextDocument::findFirst(const Reference< util::XSearchDescriptor > & xDesc)
1018 											throw( RuntimeException )
1019 {
1020 	::vos::OGuard aGuard(Application::GetSolarMutex());
1021 	Reference< XInterface >  xTmp;
1022 	sal_Int32 nResult = 0;
1023 	Reference< XTextCursor >  xCrsr;
1024 	SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_False, nResult, xTmp);
1025 	if(!pResultCrsr)
1026 		throw RuntimeException();
1027 	Reference< XInterface >  xRet;
1028 	if(nResult)
1029 	{
1030         const uno::Reference< text::XText >  xParent =
1031             ::sw::CreateParentXText(*pDocShell->GetDoc(),
1032                     *pResultCrsr->GetPoint());
1033         xRet = *new SwXTextCursor(xParent, *pResultCrsr);
1034         delete pResultCrsr;
1035 	}
1036 	return xRet;
1037 }
1038 /*-- 18.12.98 11:55:24---------------------------------------------------
1039 
1040   -----------------------------------------------------------------------*/
findNext(const Reference<XInterface> & xStartAt,const Reference<util::XSearchDescriptor> & xDesc)1041 Reference< XInterface >  SwXTextDocument::findNext(const Reference< XInterface > & xStartAt,
1042 			const Reference< util::XSearchDescriptor > & xDesc)
1043 			throw( RuntimeException )
1044 {
1045 	::vos::OGuard aGuard(Application::GetSolarMutex());
1046 	Reference< XInterface >  xTmp;
1047 	sal_Int32 nResult = 0;
1048 	Reference< XTextCursor >  xCrsr;
1049 	if(!xStartAt.is())
1050 		throw RuntimeException();
1051 	SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_False, nResult, xStartAt);
1052 	if(!pResultCrsr)
1053 		throw RuntimeException();
1054 	Reference< XInterface >  xRet;
1055 	if(nResult)
1056 	{
1057         const uno::Reference< text::XText >  xParent =
1058             ::sw::CreateParentXText(*pDocShell->GetDoc(),
1059                     *pResultCrsr->GetPoint());
1060 
1061         xRet = *new SwXTextCursor(xParent, *pResultCrsr);
1062         delete pResultCrsr;
1063 	}
1064 	return xRet;
1065 }
1066 /*-- 18.12.98 11:55:24---------------------------------------------------
1067 
1068   -----------------------------------------------------------------------*/
getPagePrintSettings(void)1069 Sequence< beans::PropertyValue > SwXTextDocument::getPagePrintSettings(void)
1070 	throw( RuntimeException )
1071 {
1072 	::vos::OGuard aGuard(Application::GetSolarMutex());
1073 	Sequence< beans::PropertyValue > aSeq(9);
1074 	if(IsValid())
1075 	{
1076 		beans::PropertyValue* pArray = aSeq.getArray();
1077 		SwPagePreViewPrtData aData;
1078 		const SwPagePreViewPrtData* pData = pDocShell->GetDoc()->GetPreViewPrtData();
1079 		if(pData)
1080 			aData = *pData;
1081 		Any aVal;
1082 		aVal <<= (sal_Int16)aData.GetRow();
1083 		pArray[0] = beans::PropertyValue(C2U("PageRows"), -1, aVal, PropertyState_DIRECT_VALUE);
1084 		aVal <<= (sal_Int16)aData.GetCol();
1085 		pArray[1] = beans::PropertyValue(C2U("PageColumns"), -1, aVal, PropertyState_DIRECT_VALUE);
1086         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetLeftSpace());
1087 		pArray[2] = beans::PropertyValue(C2U("LeftMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1088         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetRightSpace());
1089 		pArray[3] = beans::PropertyValue(C2U("RightMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1090         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetTopSpace());
1091 		pArray[4] = beans::PropertyValue(C2U("TopMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1092         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetBottomSpace());
1093 		pArray[5] = beans::PropertyValue(C2U("BottomMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1094         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetHorzSpace());
1095 		pArray[6] = beans::PropertyValue(C2U("HoriMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1096         aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetVertSpace());
1097 		pArray[7] = beans::PropertyValue(C2U("VertMargin"), -1, aVal, PropertyState_DIRECT_VALUE);
1098 		sal_Bool bTemp = aData.GetLandscape();
1099 		aVal.setValue(&bTemp, ::getCppuBooleanType());
1100 		pArray[8] = beans::PropertyValue(C2U("IsLandscape"), -1, aVal, PropertyState_DIRECT_VALUE);
1101 	}
1102 	else
1103 		throw RuntimeException();
1104 	return aSeq;
1105 }
1106 /* -----------------24.02.99 10:57-------------------
1107  *
1108  * --------------------------------------------------*/
lcl_Any_To_ULONG(const Any & rValue,sal_Bool & bException)1109 sal_uInt32 lcl_Any_To_ULONG(const Any& rValue, sal_Bool& bException)
1110 {
1111 	bException = sal_False;
1112 	TypeClass eType = rValue.getValueType().getTypeClass();
1113 
1114 	sal_uInt32 nRet = 0;
1115     if( eType == TypeClass_UNSIGNED_LONG )
1116 		rValue >>= nRet;
1117     else
1118 	{
1119          sal_Int32 nVal=0;
1120          bException = !(rValue >>= nVal);
1121          if( !bException )
1122 			nRet = (sal_uInt32)nVal;
1123 	}
1124 
1125 	return nRet;
1126 }
1127 /*-- 09.06.2004 12:18:10---------------------------------------------------
1128 
1129   -----------------------------------------------------------------------*/
lcl_CreateOutlineString(sal_uInt16 nIndex,const SwOutlineNodes & rOutlineNodes,const SwNumRule * pOutlRule)1130 String lcl_CreateOutlineString( sal_uInt16 nIndex,
1131             const SwOutlineNodes& rOutlineNodes, const SwNumRule* pOutlRule)
1132 {
1133     String sEntry;
1134     const SwTxtNode * pTxtNd = rOutlineNodes[ nIndex ]->GetTxtNode();
1135     SwNumberTree::tNumberVector aNumVector = pTxtNd->GetNumberVector();
1136     if( pOutlRule && pTxtNd->GetNumRule())
1137         for( sal_Int8 nLevel = 0;
1138              nLevel <= pTxtNd->GetActualListLevel();
1139              nLevel++ )
1140         {
1141             long nVal = aNumVector[nLevel];
1142             nVal ++;
1143             nVal -= pOutlRule->Get(nLevel).GetStart();
1144             sEntry += String::CreateFromInt32( nVal );
1145             sEntry += '.';
1146         }
1147     sEntry += rOutlineNodes[ nIndex ]->
1148                     GetTxtNode()->GetExpandTxt( 0, STRING_LEN, sal_False );
1149     return sEntry;
1150 }
1151 /*-- 18.12.98 11:55:25---------------------------------------------------
1152 
1153   -----------------------------------------------------------------------*/
setPagePrintSettings(const Sequence<beans::PropertyValue> & aSettings)1154 void SwXTextDocument::setPagePrintSettings(const Sequence< beans::PropertyValue >& aSettings)
1155 	throw( RuntimeException )
1156 {
1157 	::vos::OGuard aGuard(Application::GetSolarMutex());
1158 	if(IsValid())
1159 	{
1160 		SwPagePreViewPrtData aData;
1161 		//falls nur einige Properties kommen, dann die akt. Einstellungen benutzen
1162 		const SwPagePreViewPrtData* pData = pDocShell->GetDoc()->GetPreViewPrtData();
1163 		if(pData)
1164 			aData = *pData;
1165 		const beans::PropertyValue* pProperties = aSettings.getConstArray();
1166 		int nCount = aSettings.getLength();
1167 		for(int i = 0; i < nCount; i++)
1168 		{
1169 			String sName = pProperties[i].Name;
1170 			const Any& rVal = pProperties[i].Value;
1171 			sal_Bool bException;
1172 			sal_uInt32 nVal = lcl_Any_To_ULONG(rVal, bException);
1173 			if( COMPARE_EQUAL == sName.CompareToAscii("PageRows" ) )
1174 			{
1175                 if(!nVal || nVal > 0xff)
1176 					throw RuntimeException();
1177                 aData.SetRow((sal_uInt8)nVal);
1178 			}
1179 			else if(COMPARE_EQUAL == sName.CompareToAscii("PageColumns"))
1180 			{
1181                 if(!nVal  || nVal > 0xff)
1182                     throw RuntimeException();
1183                 aData.SetCol((sal_uInt8)nVal);
1184 			}
1185 			else if(COMPARE_EQUAL == sName.CompareToAscii("LeftMargin"))
1186 			{
1187                 aData.SetLeftSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1188 			}
1189 			else if(COMPARE_EQUAL == sName.CompareToAscii("RightMargin"))
1190 			{
1191                 aData.SetRightSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1192 			}
1193 			else if(COMPARE_EQUAL == sName.CompareToAscii("TopMargin"))
1194 			{
1195                 aData.SetTopSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1196 			}
1197 			else if(COMPARE_EQUAL == sName.CompareToAscii("BottomMargin"))
1198 			{
1199                 aData.SetBottomSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1200 			}
1201 			else if(COMPARE_EQUAL == sName.CompareToAscii("HoriMargin"))
1202 			{
1203                 aData.SetHorzSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1204 			}
1205 			else if(COMPARE_EQUAL == sName.CompareToAscii("VertMargin"))
1206 			{
1207                 aData.SetVertSpace(MM100_TO_TWIP_UNSIGNED(nVal));
1208 			}
1209 			else if(COMPARE_EQUAL == sName.CompareToAscii("IsLandscape"))
1210 			{
1211 				bException =  (::getBooleanCppuType() != rVal.getValueType());
1212 				aData.SetLandscape(*(sal_Bool*)rVal.getValue());
1213 			}
1214 			else
1215 				bException = sal_True;
1216 			if(bException)
1217 				throw RuntimeException();
1218 		}
1219 		pDocShell->GetDoc()->SetPreViewPrtData(&aData);
1220 	}
1221 	else
1222 		throw RuntimeException();
1223 }
1224 /*-- 18.12.98 11:55:25---------------------------------------------------
1225 
1226   -----------------------------------------------------------------------*/
printPages(const Sequence<beans::PropertyValue> & xOptions)1227 void SwXTextDocument::printPages(const Sequence< beans::PropertyValue >& xOptions)
1228 	throw( IllegalArgumentException, RuntimeException )
1229 {
1230 	::vos::OGuard aGuard(Application::GetSolarMutex());
1231 	if(IsValid())
1232 	{
1233         SfxViewFrame* pFrame = SfxViewFrame::LoadHiddenDocument( *pDocShell, 7 );
1234 		SfxRequest aReq(FN_PRINT_PAGEPREVIEW, SFX_CALLMODE_SYNCHRON,
1235 									pDocShell->GetDoc()->GetAttrPool());
1236 			aReq.AppendItem(SfxBoolItem(FN_PRINT_PAGEPREVIEW, sal_True));
1237 
1238 		OUString sFileName( C2U(SW_PROP_NAME_STR(UNO_NAME_FILE_NAME)));
1239 		OUString sCopyCount(C2U(SW_PROP_NAME_STR(UNO_NAME_COPY_COUNT)));
1240 		OUString sCollate(C2U(SW_PROP_NAME_STR(UNO_NAME_COLLATE)));
1241 		OUString sSort(C2U(SW_PROP_NAME_STR(UNO_NAME_SORT)));
1242 		OUString sPages(C2U(SW_PROP_NAME_STR(UNO_NAME_PAGES)));
1243 
1244 		for ( int n = 0; n < xOptions.getLength(); ++n )
1245 		{
1246 			// get Property-Value from options
1247 			const beans::PropertyValue &rProp = xOptions.getConstArray()[n];
1248 			Any aValue( rProp.Value );
1249 
1250 			// FileName-Property?
1251 			if ( rProp.Name == sFileName )
1252 			{
1253 				OUString sFileURL;
1254 				if ( (rProp.Value >>= sFileURL ) )
1255 				{
1256 					// Convert the File URL into a system dependant path, as the SalPrinter expects
1257 					OUString sSystemPath;
1258 					FileBase::getSystemPathFromFileURL ( sFileURL, sSystemPath );
1259 					aReq.AppendItem(SfxStringItem( SID_FILE_NAME, sSystemPath ) );
1260 				}
1261 				else if ( rProp.Value.getValueType() != ::getVoidCppuType() )
1262 					throw IllegalArgumentException();
1263 			}
1264 
1265 			// CopyCount-Property
1266 			else if ( rProp.Name == sCopyCount )
1267 			{
1268 				sal_Int32 nCopies = 0;
1269 				aValue >>= nCopies;
1270                 aReq.AppendItem(SfxInt16Item( SID_PRINT_COPIES, (sal_Int16)nCopies ) );
1271 			}
1272 
1273 			// Collate-Property
1274 			else if ( rProp.Name == sCollate )
1275 			{
1276 				if ( rProp.Value.getValueType() == ::getBooleanCppuType())
1277 
1278 					aReq.AppendItem(SfxBoolItem( SID_PRINT_COLLATE, *(sal_Bool*)rProp.Value.getValue() ) );
1279 				else
1280 					throw IllegalArgumentException();
1281 			}
1282 
1283 			// Sort-Property
1284 			else if ( rProp.Name == sSort )
1285 			{
1286 				if ( rProp.Value.getValueType() == ::getBooleanCppuType() )
1287 					aReq.AppendItem(SfxBoolItem( SID_PRINT_SORT, *(sal_Bool*)rProp.Value.getValue() ) );
1288 				else
1289 					throw IllegalArgumentException();
1290 			}
1291 
1292 			// Pages-Property
1293 			else if ( rProp.Name == sPages )
1294 			{
1295                 OUString sTmp;
1296                 if ( rProp.Value >>= sTmp )
1297                     aReq.AppendItem( SfxStringItem( SID_PRINT_PAGES, sTmp ) );
1298 				else
1299 					throw IllegalArgumentException();
1300 			}
1301 		}
1302 
1303         // --> OD #i117783#
1304         bApplyPagePrintSettingsFromXPagePrintable = sal_True;
1305         // <--
1306 		pFrame->GetViewShell()->ExecuteSlot(aReq);
1307 		// Frame schliessen
1308 		pFrame->DoClose();
1309 
1310 	}
1311 	else
1312 		throw RuntimeException();
1313 }
1314 /*-- 18.12.98 11:55:25---------------------------------------------------
1315 
1316   -----------------------------------------------------------------------*/
getReferenceMarks(void)1317 Reference< XNameAccess >  SwXTextDocument::getReferenceMarks(void)
1318 										throw( RuntimeException )
1319 {
1320 	::vos::OGuard aGuard(Application::GetSolarMutex());
1321 	if(!IsValid())
1322 		throw RuntimeException();
1323 	if(!pxXReferenceMarks)
1324 	{
1325 		((SwXTextDocument*)this)->pxXReferenceMarks = new Reference< XNameAccess > ;
1326 		*pxXReferenceMarks = new SwXReferenceMarks(pDocShell->GetDoc());
1327 	}
1328 	return *pxXReferenceMarks;
1329 }
1330 /* -----------------21.12.98 10:20-------------------
1331  *
1332  * --------------------------------------------------*/
getTextFields(void)1333 Reference< XEnumerationAccess >  SwXTextDocument::getTextFields(void) throw( RuntimeException )
1334 {
1335 	::vos::OGuard aGuard(Application::GetSolarMutex());
1336 	if(!IsValid())
1337 		throw RuntimeException();
1338 	if(!pxXTextFieldTypes)
1339 	{
1340 		((SwXTextDocument*)this)->pxXTextFieldTypes = new Reference< XEnumerationAccess > ;
1341 		*pxXTextFieldTypes = new SwXTextFieldTypes(pDocShell->GetDoc());
1342 	}
1343 	return *pxXTextFieldTypes;
1344 }
1345 /*-- 21.12.98 10:21:12---------------------------------------------------
1346 
1347   -----------------------------------------------------------------------*/
getTextFieldMasters(void)1348 Reference< XNameAccess >  SwXTextDocument::getTextFieldMasters(void)
1349 	throw( RuntimeException )
1350 {
1351 	::vos::OGuard aGuard(Application::GetSolarMutex());
1352 	if(!IsValid())
1353 		throw RuntimeException();
1354 	if(!pxXTextFieldMasters)
1355 	{
1356 		((SwXTextDocument*)this)->pxXTextFieldMasters = new Reference< XNameAccess > ;
1357 		*pxXTextFieldMasters = new SwXTextFieldMasters(pDocShell->GetDoc());
1358 	}
1359 	return *pxXTextFieldMasters;
1360 }
1361 /*-- 21.12.98 10:21:12---------------------------------------------------
1362 
1363   -----------------------------------------------------------------------*/
getEmbeddedObjects(void)1364 Reference< XNameAccess >  SwXTextDocument::getEmbeddedObjects(void) throw( RuntimeException )
1365 {
1366 	::vos::OGuard aGuard(Application::GetSolarMutex());
1367 	if(!IsValid())
1368 		throw RuntimeException();
1369 	if(!pxXEmbeddedObjects)
1370 	{
1371 		((SwXTextDocument*)this)->pxXEmbeddedObjects = new Reference< XNameAccess > ;
1372 		*pxXEmbeddedObjects = new SwXTextEmbeddedObjects(pDocShell->GetDoc());
1373 	}
1374 	return *pxXEmbeddedObjects;
1375 }
1376 /*-- 21.12.98 10:21:13---------------------------------------------------
1377 
1378   -----------------------------------------------------------------------*/
getBookmarks(void)1379 Reference< XNameAccess >  SwXTextDocument::getBookmarks(void) throw( RuntimeException )
1380 {
1381 	::vos::OGuard aGuard(Application::GetSolarMutex());
1382 	if(!IsValid())
1383 		throw RuntimeException();
1384 	if(!pxXBookmarks)
1385 	{
1386 		((SwXTextDocument*)this)->pxXBookmarks = new Reference< XNameAccess > ;
1387 		*pxXBookmarks = new SwXBookmarks(pDocShell->GetDoc());
1388 	}
1389 	return *pxXBookmarks;
1390 }
1391 /*-- 21.12.98 10:21:13---------------------------------------------------
1392 
1393   -----------------------------------------------------------------------*/
getTextSections(void)1394 Reference< XNameAccess >  SwXTextDocument::getTextSections(void) throw( RuntimeException )
1395 {
1396 	::vos::OGuard aGuard(Application::GetSolarMutex());
1397 	if(!IsValid())
1398 		throw RuntimeException();
1399 	if(!pxXTextSections)
1400 	{
1401 		((SwXTextDocument*)this)->pxXTextSections = new Reference< XNameAccess > ;
1402 		*pxXTextSections = new SwXTextSections(pDocShell->GetDoc());
1403 	}
1404 	return *pxXTextSections;
1405 }
1406 /*-- 21.12.98 10:21:13---------------------------------------------------
1407 
1408   -----------------------------------------------------------------------*/
getTextTables(void)1409 Reference< XNameAccess >  SwXTextDocument::getTextTables(void) throw( RuntimeException )
1410 {
1411 	::vos::OGuard aGuard(Application::GetSolarMutex());
1412 	if(!IsValid())
1413 		throw RuntimeException();
1414 	if(!pxXTextTables)
1415 	{
1416 		((SwXTextDocument*)this)->pxXTextTables = new Reference< XNameAccess > ;
1417 		*pxXTextTables = new SwXTextTables(pDocShell->GetDoc());
1418 	}
1419 	return *pxXTextTables;
1420 }
1421 /*-- 21.12.98 10:21:13---------------------------------------------------
1422 
1423   -----------------------------------------------------------------------*/
getGraphicObjects(void)1424 Reference< XNameAccess >  SwXTextDocument::getGraphicObjects(void) throw( RuntimeException )
1425 {
1426 	::vos::OGuard aGuard(Application::GetSolarMutex());
1427 	if(!IsValid())
1428 		throw RuntimeException();
1429 	if(!pxXGraphicObjects)
1430 	{
1431 		((SwXTextDocument*)this)->pxXGraphicObjects = new Reference< XNameAccess > ;
1432 		*pxXGraphicObjects = new SwXTextGraphicObjects(pDocShell->GetDoc());
1433 	}
1434 	return *pxXGraphicObjects;
1435 }
1436 /*-- 21.12.98 10:21:14---------------------------------------------------
1437 
1438   -----------------------------------------------------------------------*/
getTextFrames(void)1439 Reference< XNameAccess >  SwXTextDocument::getTextFrames(void) throw( RuntimeException )
1440 {
1441 	::vos::OGuard aGuard(Application::GetSolarMutex());
1442 	if(!IsValid())
1443 		throw RuntimeException();
1444 	if(!pxXTextFrames)
1445 	{
1446 		((SwXTextDocument*)this)->pxXTextFrames = new Reference< XNameAccess > ;
1447 		*pxXTextFrames = new SwXTextFrames(pDocShell->GetDoc());
1448 	}
1449 	return *pxXTextFrames;
1450 }
1451 /* -----------------21.12.98 10:56-------------------
1452  *
1453  * --------------------------------------------------*/
getStyleFamilies(void)1454 Reference< XNameAccess >  SwXTextDocument::getStyleFamilies(void) throw( RuntimeException )
1455 {
1456 	::vos::OGuard aGuard(Application::GetSolarMutex());
1457 	if(!IsValid())
1458 		throw RuntimeException();
1459 	if(!pxXStyleFamilies)
1460 	{
1461 		((SwXTextDocument*)this)->pxXStyleFamilies = new Reference< XNameAccess > ;
1462 		*pxXStyleFamilies = new SwXStyleFamilies(*pDocShell);
1463 	}
1464 	return *pxXStyleFamilies;
1465 }
1466 /*-- 19.05.06 10:15:22---------------------------------------------------
1467 
1468   -----------------------------------------------------------------------*/
getAutoStyles()1469 uno::Reference< style::XAutoStyles > SwXTextDocument::getAutoStyles(  )
1470     throw (uno::RuntimeException)
1471 {
1472 	::vos::OGuard aGuard(Application::GetSolarMutex());
1473 	if(!IsValid())
1474 		throw RuntimeException();
1475 	if(!pxXAutoStyles)
1476 	{
1477         pxXAutoStyles = new Reference< style::XAutoStyles > ;
1478         *pxXAutoStyles = new SwXAutoStyles(*pDocShell);
1479 	}
1480 	return *pxXAutoStyles;
1481 
1482 }
1483 /*-- 22.01.99 10:18:03---------------------------------------------------
1484 
1485   -----------------------------------------------------------------------*/
getDrawPage(void)1486 Reference< drawing::XDrawPage >  SwXTextDocument::getDrawPage(void) throw( RuntimeException )
1487 {
1488 	::vos::OGuard aGuard(Application::GetSolarMutex());
1489 	if(!IsValid())
1490 		throw RuntimeException();
1491 	if(!pxXDrawPage)
1492 	{
1493         // simplified this creation, keeping original below as reference
1494         // for the case that it did something by purpose
1495 		((SwXTextDocument*)this)->pDrawPage = new SwXDrawPage(pDocShell->GetDoc());
1496         ((SwXTextDocument*)this)->pxXDrawPage = new Reference< drawing::XDrawPage >(pDrawPage);
1497 
1498         //((SwXTextDocument*)this)->pxXDrawPage = new Reference< drawing::XDrawPage > ;
1499 		//((SwXTextDocument*)this)->pDrawPage = new SwXDrawPage(pDocShell->GetDoc());
1500 		//Reference< drawing::XShapes >  xTmp = pDrawPage;
1501 		//*pxXDrawPage = Reference< drawing::XDrawPage>(xTmp, UNO_QUERY);
1502 	}
1503 	return *pxXDrawPage;
1504 }
1505 /* -----------------07.04.99 10:11-------------------
1506  *
1507  * --------------------------------------------------*/
GetDrawPage()1508 SwXDrawPage* SwXTextDocument::GetDrawPage()
1509 {
1510 	if(!IsValid())
1511 		return 0;
1512 	if(!pDrawPage)
1513 		getDrawPage();
1514 	return pDrawPage;
1515 }
1516 /*-- 18.12.98 11:55:26---------------------------------------------------
1517 
1518   -----------------------------------------------------------------------*/
Invalidate()1519 void SwXTextDocument::Invalidate()
1520 {
1521     bObjectValid = sal_False;
1522     if(xNumFmtAgg.is())
1523     {
1524         const uno::Type& rTunnelType = ::getCppuType((Reference <XUnoTunnel>*)0);
1525         Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType);
1526         SvNumberFormatsSupplierObj* pNumFmt = 0;
1527         Reference< XUnoTunnel > xNumTunnel;
1528         if(aNumTunnel >>= xNumTunnel)
1529         {
1530             pNumFmt = reinterpret_cast<SvNumberFormatsSupplierObj*>(
1531                     xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId()));
1532             pNumFmt->SetNumberFormatter(0);
1533         }
1534         DBG_ASSERT(pNumFmt, "No number formatter available");
1535     }
1536     InitNewDoc();
1537     pDocShell = 0;
1538     aRefreshCont.Disposing();
1539 }
1540 /* -----------------------------13.07.00 15:59--------------------------------
1541 
1542  ---------------------------------------------------------------------------*/
Reactivate(SwDocShell * pNewDocShell)1543 void SwXTextDocument::Reactivate(SwDocShell* pNewDocShell)
1544 {
1545 	if(pDocShell && pDocShell != pNewDocShell)
1546 		Invalidate();
1547 	pDocShell = pNewDocShell;
1548 	bObjectValid = sal_True;
1549 }
1550 /*-- 18.12.98 11:55:26---------------------------------------------------
1551 
1552   -----------------------------------------------------------------------*/
InitNewDoc()1553 void	SwXTextDocument::InitNewDoc()
1554 {
1555 	// zunaechst alle Collections invalidieren, dann Referenzen loeschen und Null setzen
1556 	if(pxXTextTables)
1557 	{
1558 		 XNameAccess* pTbls = pxXTextTables->get();
1559 		((SwXTextTables*)pTbls)->Invalidate();
1560 		delete pxXTextTables;
1561 		pxXTextTables = 0;
1562 	}
1563 
1564 	if(pxXTextFrames)
1565 	{
1566 	 	XNameAccess* pFrms = pxXTextFrames->get();
1567 		((SwXTextFrames*)pFrms)->Invalidate();
1568 		delete pxXTextFrames;
1569 		pxXTextFrames = 0;
1570 	}
1571 
1572 	if(pxXGraphicObjects)
1573 	{
1574 	 	XNameAccess* pFrms = pxXGraphicObjects->get();
1575 		((SwXTextGraphicObjects*)pFrms)->Invalidate();
1576 		delete pxXGraphicObjects;
1577 		pxXGraphicObjects = 0;
1578 	}
1579 
1580 	if(pxXEmbeddedObjects)
1581 	{
1582 	 XNameAccess* pOLE = pxXEmbeddedObjects->get();
1583 		((SwXTextEmbeddedObjects*)pOLE)->Invalidate();
1584 		delete pxXEmbeddedObjects;
1585 		pxXEmbeddedObjects = 0;
1586 	}
1587 
1588 	if(xBodyText.is())
1589 	{
1590 		xBodyText = 0;
1591 		pBodyText = 0;
1592 	}
1593 
1594 	if(xNumFmtAgg.is())
1595 	{
1596         const uno::Type& rTunnelType = ::getCppuType((Reference <XUnoTunnel>*)0);
1597         Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType);
1598 		SvNumberFormatsSupplierObj* pNumFmt = 0;
1599         Reference< XUnoTunnel > xNumTunnel;
1600         if(aNumTunnel >>= xNumTunnel)
1601 		{
1602             pNumFmt = reinterpret_cast<SvNumberFormatsSupplierObj*>(
1603                     xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId()));
1604 
1605 		}
1606 		DBG_ASSERT(pNumFmt, "No number formatter available");
1607 		pNumFmt->SetNumberFormatter(0);
1608 	}
1609 
1610 	if(pxXTextFieldTypes)
1611 	{
1612 	 	XEnumerationAccess* pT = pxXTextFieldTypes->get();
1613 		((SwXTextFieldTypes*)pT)->Invalidate();
1614 		delete pxXTextFieldTypes;
1615 		pxXTextFieldTypes = 0;
1616 	}
1617 
1618 	if(pxXTextFieldMasters)
1619 	{
1620 	 	XNameAccess* pT = pxXTextFieldMasters->get();
1621 		((SwXTextFieldMasters*)pT)->Invalidate();
1622 		delete pxXTextFieldMasters;
1623 		pxXTextFieldMasters = 0;
1624 	}
1625 
1626 	if(pxXTextSections)
1627 	{
1628 	 	XNameAccess* pSect = pxXTextSections->get();
1629 		((SwXTextSections*)pSect)->Invalidate();
1630 		delete pxXTextSections;
1631 		pxXTextSections = 0;
1632 	}
1633 
1634     if(pxXDrawPage)
1635     {
1636         // --> OD 2008-07-23 #i91798#, #i91895#
1637         // dispose XDrawPage here. We are the owner and know that it is no longer in a valid condition.
1638         uno::Reference<lang::XComponent> xComp( *pxXDrawPage, uno::UNO_QUERY );
1639         xComp->dispose();
1640         // <--
1641 		pDrawPage->InvalidateSwDoc();
1642         delete pxXDrawPage;
1643         pxXDrawPage = 0;
1644     }
1645 
1646     if ( pxXNumberingRules )
1647     {
1648         XIndexAccess* pNum = pxXNumberingRules->get();
1649         ((SwXNumberingRulesCollection*)pNum)->Invalidate();
1650         delete pxXNumberingRules;
1651         pxXNumberingRules = 0;
1652     }
1653 
1654 	if(pxXFootnotes)
1655 	{
1656 	 	XIndexAccess* pFtn = pxXFootnotes->get();
1657 		((SwXFootnotes*)pFtn)->Invalidate();
1658 		delete pxXFootnotes;
1659 		pxXFootnotes = 0;
1660 	}
1661 
1662 	if(pxXEndnotes)
1663 	{
1664 	 	XIndexAccess* pFtn = pxXEndnotes->get();
1665 		((SwXFootnotes*)pFtn)->Invalidate();
1666 		delete pxXEndnotes;
1667 		pxXEndnotes = 0;
1668 	}
1669 
1670 	if(pxXDocumentIndexes)
1671 	{
1672 	 	XIndexAccess* pIdxs = pxXDocumentIndexes->get();
1673 		((SwXDocumentIndexes*)pIdxs)->Invalidate();
1674 		delete pxXDocumentIndexes;
1675 		pxXDocumentIndexes = 0;
1676 	}
1677 
1678 	if(pxXStyleFamilies)
1679 	{
1680 	 	XNameAccess* pStyles = pxXStyleFamilies->get();
1681 		((SwXStyleFamilies*)pStyles)->Invalidate();
1682 		delete pxXStyleFamilies;
1683 		pxXStyleFamilies = 0;
1684 	}
1685     if(pxXAutoStyles)
1686     {
1687 	 	XNameAccess* pStyles = pxXAutoStyles->get();
1688 		((SwXAutoStyles*)pStyles)->Invalidate();
1689 		delete pxXAutoStyles;
1690 		pxXAutoStyles = 0;
1691     }
1692 
1693 	if(pxXBookmarks)
1694 	{
1695 	 	XNameAccess* pBm = pxXBookmarks->get();
1696 		((SwXBookmarks*)pBm)->Invalidate();
1697 		delete pxXBookmarks;
1698 		pxXBookmarks = 0;
1699 	}
1700 
1701 	if(pxXChapterNumbering)
1702 	{
1703 	 	XIndexReplace* pCh = pxXChapterNumbering->get();
1704 		((SwXChapterNumbering*)pCh)->Invalidate();
1705 		delete pxXChapterNumbering;
1706 		pxXChapterNumbering = 0;
1707 	}
1708 
1709 	if(pxXFootnoteSettings)
1710 	{
1711 	 	XPropertySet* pFntSet = pxXFootnoteSettings->get();
1712 		((SwXFootnoteProperties*)pFntSet)->Invalidate();
1713 		delete pxXFootnoteSettings;
1714 		pxXFootnoteSettings = 0;
1715 	}
1716 
1717 	if(pxXEndnoteSettings)
1718 	{
1719 	 	XPropertySet* pEndSet = pxXEndnoteSettings->get();
1720 		((SwXEndnoteProperties*)pEndSet)->Invalidate();
1721 		delete pxXEndnoteSettings;
1722 		pxXEndnoteSettings = 0;
1723 	}
1724 
1725 	if(pxXLineNumberingProperties)
1726 	{
1727 	 	XPropertySet* pLine = pxXLineNumberingProperties->get();
1728 		((SwXLineNumberingProperties*)pLine)->Invalidate();
1729 		delete pxXLineNumberingProperties;
1730 		pxXLineNumberingProperties = 0;
1731 	}
1732 	if(pxXReferenceMarks)
1733 	{
1734 	 	XNameAccess* pMarks = pxXReferenceMarks->get();
1735 		((SwXReferenceMarks*)pMarks)->Invalidate();
1736 		delete pxXReferenceMarks;
1737 		pxXReferenceMarks = 0;
1738 	}
1739 	if(pxLinkTargetSupplier)
1740 	{
1741 	 	XNameAccess* pAccess = (*pxLinkTargetSupplier).get();
1742 		((SwXLinkTargetSupplier*)pAccess)->Invalidate();
1743 		delete pxLinkTargetSupplier;
1744 		pxLinkTargetSupplier = 0;
1745 	}
1746 	if(pxXRedlines)
1747 	{
1748 		XEnumerationAccess* pMarks = pxXRedlines->get();
1749 		((SwXRedlines*)pMarks)->Invalidate();
1750 		delete pxXRedlines;
1751 		pxXRedlines = 0;
1752 	}
1753 	if(xPropertyHelper.is())
1754 	{
1755 		pPropertyHelper->Invalidate();
1756 		xPropertyHelper = 0;
1757 		pPropertyHelper = 0;
1758 	}
1759 }
1760 
1761 /*-- 11.03.99 11:51:40---------------------------------------------------
1762 
1763   -----------------------------------------------------------------------*/
1764 #define COM_SUN_STAR__DRAWING_LENGTH 13
createInstance(const OUString & rServiceName)1765 Reference< XInterface >  SwXTextDocument::createInstance(const OUString& rServiceName)
1766 										throw( Exception, RuntimeException )
1767 {
1768 	::vos::OGuard aGuard(Application::GetSolarMutex());
1769 	if(!IsValid())
1770 		throw RuntimeException();
1771 	Reference< XInterface >  xRet;
1772 	sal_uInt16 nType = SwXServiceProvider::GetProviderType(rServiceName);
1773 	if(nType != SW_SERVICE_INVALID)
1774 	{
1775 		xRet = SwXServiceProvider::MakeInstance(nType, pDocShell->GetDoc());
1776 	}
1777 	else
1778 	{
1779         if( rServiceName.compareToAscii( "com.sun.star.", 13 ) == 0 )
1780         {
1781             sal_Int32 nIndex = COM_SUN_STAR__DRAWING_LENGTH;
1782 			OUString sCategory = rServiceName.getToken( 0, '.', nIndex );
1783 			sal_Bool bShape = sCategory == C2U("drawing");
1784 			if( bShape || sCategory == C2U("form"))
1785 			{
1786 				if(bShape)
1787 				{
1788                     short nTable = 0;
1789                     if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DashTable") ) )
1790                         nTable = SW_CREATE_DASH_TABLE;
1791                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.GradientTable") ) )
1792                         nTable = SW_CREATE_GRADIENT_TABLE;
1793                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.HatchTable") ) )
1794                         nTable = SW_CREATE_HATCH_TABLE;
1795                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.BitmapTable") ) )
1796                         nTable = SW_CREATE_BITMAP_TABLE;
1797                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TransparencyGradientTable") ) )
1798                         nTable = SW_CREATE_TRANSGRADIENT_TABLE;
1799                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.MarkerTable") ) )
1800                         nTable = SW_CREATE_MARKER_TABLE;
1801                     else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Defaults") ) )
1802                         nTable = SW_CREATE_DRAW_DEFAULTS;
1803                     if(nTable)
1804                     {
1805                         xRet = GetPropertyHelper()->GetDrawTable(nTable);
1806                     }
1807                 }
1808 			}
1809 			else if (sCategory == C2U ("document") )
1810 			{
1811                 if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.Settings") ) )
1812 					xRet = Reference < XInterface > ( *new SwXDocumentSettings ( this ) );
1813                 if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver") ) )
1814                 {
1815                     xRet = (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pDocShell, EMBEDDEDOBJECTHELPER_MODE_READ );
1816                 }
1817 			}
1818 			else if (sCategory == C2U ("text") )
1819 			{
1820                 if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.DocumentSettings") ) )
1821                     xRet = Reference < XInterface > ( *new SwXDocumentSettings ( this ) );
1822             }
1823             else if (sCategory == C2U ("chart2") )
1824             {
1825                 if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.chart2.data.DataProvider") ) )
1826                     xRet = Reference < XInterface > ( dynamic_cast< chart2::data::XDataProvider * >(pDocShell->getIDocumentChartDataProviderAccess()->GetChartDataProvider()) );
1827             }
1828 
1829             if(!xRet.is())
1830 			{
1831 				//! we don't want to insert OLE2 Shapes (e.g. "com.sun.star.drawing.OLE2Shape", ...)
1832 				//! like this (by creating them with the documents factory and
1833 				//! adding the shapes to the draw page).
1834 				//! For inserting OLE objects the proper way is to use
1835 				//! "com.sun.star.text.TextEmbeddedObject"!
1836 				if (rServiceName.lastIndexOf( C2U(".OLE2Shape") ) == rServiceName.getLength() - 10)
1837 					throw ServiceNotRegisteredException();	// declare service to be not registered with this factory
1838 
1839                 // --> OD 2006-02-22 #b6382898#
1840                 // the XML import is allowed to create instances of com.sun.star.drawing.OLE2Shape.
1841                 // Thus, a temporary service name is introduced to make this possible.
1842                 OUString aTmpServiceName( rServiceName );
1843                 if ( bShape &&
1844                      rServiceName.compareToAscii( "com.sun.star.drawing.temporaryForXMLImportOLE2Shape" ) == 0 )
1845                 {
1846                     aTmpServiceName = OUString::createFromAscii( "com.sun.star.drawing.OLE2Shape" );
1847                 }
1848 				//hier den Draw - Service suchen
1849                 Reference< XInterface >  xTmp = SvxFmMSFactory::createInstance(aTmpServiceName);
1850                 // <--
1851                 if(bShape)
1852 				{
1853 					nIndex = COM_SUN_STAR__DRAWING_LENGTH;
1854 					if( 0 == rServiceName.reverseCompareToAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.drawing.GroupShape" ) ) ||
1855 						0 == rServiceName.reverseCompareToAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.drawing.Shape3DSceneObject" ) ) )
1856 						xRet = *new SwXGroupShape( xTmp );
1857 					else
1858 						xRet = *new SwXShape( xTmp );
1859 				}
1860 				else
1861 					xRet = xTmp;
1862 			}
1863 		}
1864 		else
1865 			throw ServiceNotRegisteredException();
1866 	}
1867 	return xRet;
1868 }
1869 /*-- 11.03.99 11:51:40---------------------------------------------------
1870 
1871   -----------------------------------------------------------------------*/
createInstanceWithArguments(const OUString & ServiceSpecifier,const Sequence<Any> &)1872 Reference< XInterface >  SwXTextDocument::createInstanceWithArguments(
1873 		const OUString& ServiceSpecifier,
1874         const Sequence< Any >& /*Arguments*/)
1875 		throw( Exception, RuntimeException )
1876 {
1877 	Reference< XInterface >  xInt = createInstance(ServiceSpecifier);
1878 	//die Any-Sequence dient zur Initialisierung von Objekten, die auf
1879 	//Parameter zwingend angewiesen sind - bis jetzt haben wir das nicht
1880 	return xInt;
1881 }
1882 /*-- 11.03.99 11:51:41---------------------------------------------------
1883 
1884   -----------------------------------------------------------------------*/
getAvailableServiceNames(void)1885 Sequence< OUString > SwXTextDocument::getAvailableServiceNames(void)
1886 										throw( RuntimeException )
1887 {
1888     static Sequence< OUString > aServices;
1889     if ( aServices.getLength() == 0 )
1890     {
1891         Sequence< OUString > aRet =  SvxFmMSFactory::getAvailableServiceNames();
1892         OUString* pRet = aRet.getArray();
1893         for ( sal_Int32 i = 0; i < aRet.getLength(); ++i )
1894         {
1895             if ( pRet[i].compareToAscii( "com.sun.star.drawing.OLE2Shape" ) == 0 )
1896             {
1897                 pRet[i] = pRet[aRet.getLength() - 1];
1898                 aRet.realloc( aRet.getLength() - 1 ); // <pRet> no longer valid.
1899                 break;
1900             }
1901         }
1902         Sequence< OUString > aOwn = SwXServiceProvider::GetAllServiceNames();
1903         aServices = SvxFmMSFactory::concatServiceNames(aRet, aOwn);
1904     }
1905 
1906     return aServices;
1907 }
1908 /* -----------------18.03.99 11:36-------------------
1909  *
1910  * --------------------------------------------------*/
getImplementationName(void)1911 OUString SwXTextDocument::getImplementationName(void) throw( RuntimeException )
1912 {
1913 	return C2U("SwXTextDocument");
1914 }
1915 /* -----------------20.01.04 10:14-------------------
1916  *
1917  * --------------------------------------------------*/
supportsService(const OUString & rServiceName)1918 sal_Bool SwXTextDocument::supportsService(const OUString& rServiceName) throw( RuntimeException )
1919 {
1920     if (
1921         (rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.document.OfficeDocument" ))) ||
1922         (rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.text.GenericTextDocument")))
1923        )
1924     return sal_True;
1925 
1926     sal_Bool bWebDoc    = (0 != PTR_CAST(SwWebDocShell,    pDocShell));
1927     sal_Bool bGlobalDoc = (0 != PTR_CAST(SwGlobalDocShell, pDocShell));
1928     sal_Bool bTextDoc   = (!bWebDoc && !bGlobalDoc);
1929 
1930     return (
1931             (bWebDoc    && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.WebDocument"   ))) ||
1932             (bGlobalDoc && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.GlobalDocument"))) ||
1933             (bTextDoc   && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextDocument"  )))
1934            );
1935 }
1936 /* -----------------20.01.04 10:17-------------------
1937  *
1938  * --------------------------------------------------*/
getSupportedServiceNames(void)1939 Sequence< OUString > SwXTextDocument::getSupportedServiceNames(void) throw( RuntimeException )
1940 {
1941     sal_Bool bWebDoc    = (0 != PTR_CAST(SwWebDocShell,    pDocShell));
1942     sal_Bool bGlobalDoc = (0 != PTR_CAST(SwGlobalDocShell, pDocShell));
1943     sal_Bool bTextDoc   = (!bWebDoc && !bGlobalDoc);
1944 
1945     Sequence< OUString > aRet (3);
1946 	OUString* pArray = aRet.getArray();
1947 
1948     pArray[0] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.document.OfficeDocument"  ) ) );
1949     pArray[1] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.GenericTextDocument" ) ) );
1950 
1951     if (bTextDoc)
1952         pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.TextDocument" ) ) );
1953     else
1954     if (bWebDoc)
1955         pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.WebDocument" ) ) );
1956     else
1957     if (bGlobalDoc)
1958         pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.GlobalDocument" ) ) );
1959 
1960 	return aRet;
1961 }
1962 /* -----------------05.05.99 12:10-------------------
1963  *
1964  * --------------------------------------------------*/
getDocumentIndexes(void)1965 Reference< XIndexAccess >  SwXTextDocument::getDocumentIndexes(void) throw( RuntimeException )
1966 {
1967 	::vos::OGuard aGuard(Application::GetSolarMutex());
1968 	if(!IsValid())
1969 		throw RuntimeException();
1970 	if(!pxXDocumentIndexes)
1971 	{
1972 		((SwXTextDocument*)this)->pxXDocumentIndexes = new Reference< XIndexAccess > ;
1973 		*pxXDocumentIndexes = new SwXDocumentIndexes(pDocShell->GetDoc());
1974 	}
1975 	return *pxXDocumentIndexes;
1976 }
1977 
1978 /*-- 10.05.99 13:58:58---------------------------------------------------
1979 
1980   -----------------------------------------------------------------------*/
getPropertySetInfo(void)1981 Reference< XPropertySetInfo >  SwXTextDocument::getPropertySetInfo(void) throw( RuntimeException )
1982 {
1983     static Reference< XPropertySetInfo >  xRet = pPropSet->getPropertySetInfo();
1984 	return xRet;
1985 }
1986 /*-- 10.05.99 13:58:58---------------------------------------------------
1987 
1988   -----------------------------------------------------------------------*/
setPropertyValue(const OUString & rPropertyName,const Any & aValue)1989 void SwXTextDocument::setPropertyValue(const OUString& rPropertyName,
1990 	const Any& aValue)
1991 	throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException,
1992 										 WrappedTargetException, RuntimeException)
1993 {
1994 	::vos::OGuard aGuard(Application::GetSolarMutex());
1995 	if(!IsValid())
1996 		throw RuntimeException();
1997     const SfxItemPropertySimpleEntry*  pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
1998 
1999     if(!pEntry)
2000 		throw UnknownPropertyException();
2001     if(pEntry->nFlags & PropertyAttribute::READONLY)
2002         throw PropertyVetoException();
2003     switch(pEntry->nWID)
2004 	{
2005 		case  WID_DOC_CHAR_COUNT     :
2006 		case  WID_DOC_PARA_COUNT     :
2007 		case  WID_DOC_WORD_COUNT     :
2008 			throw RuntimeException();
2009 		case  WID_DOC_WORD_SEPARATOR :
2010 		{
2011 			OUString sDelim;
2012 			aValue >>= sDelim;
2013 			SW_MOD()->GetModuleConfig()->SetWordDelimiter(sDelim);
2014 		}
2015 		break;
2016 		case WID_DOC_CHANGES_RECORD:
2017 		case WID_DOC_CHANGES_SHOW:
2018 		{
2019 			sal_Bool bSet = *(sal_Bool*)aValue.getValue();
2020 			sal_uInt16 eMode = pDocShell->GetDoc()->GetRedlineMode();
2021             if(WID_DOC_CHANGES_SHOW == pEntry->nWID)
2022 			{
2023 				eMode &= ~(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE);
2024 				eMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT;
2025 				if( bSet )
2026 					eMode |= nsRedlineMode_t::REDLINE_SHOW_DELETE;
2027 			}
2028             else if(WID_DOC_CHANGES_RECORD == pEntry->nWID)
2029 			{
2030 				eMode = bSet ? eMode|nsRedlineMode_t::REDLINE_ON : eMode&~nsRedlineMode_t::REDLINE_ON;
2031 			}
2032 			pDocShell->GetDoc()->SetRedlineMode( (RedlineMode_t)(eMode ));
2033 		}
2034 		break;
2035         case  WID_DOC_CHANGES_PASSWORD:
2036         {
2037             Sequence <sal_Int8> aNew;
2038             if(aValue >>= aNew)
2039             {
2040                 SwDoc* pDoc = pDocShell->GetDoc();
2041                 pDoc->SetRedlinePassword(aNew);
2042                 if(aNew.getLength())
2043                 {
2044                     sal_uInt16 eMode = pDoc->GetRedlineMode();
2045                     eMode = eMode|nsRedlineMode_t::REDLINE_ON;
2046                     pDoc->SetRedlineMode( (RedlineMode_t)(eMode ));
2047                 }
2048             }
2049         }
2050         break;
2051 		case WID_DOC_AUTO_MARK_URL :
2052 		{
2053 			OUString sURL;
2054 			aValue >>= sURL;
2055 			pDocShell->GetDoc()->SetTOIAutoMarkURL(sURL);
2056 		}
2057 		break;
2058 		case WID_DOC_HIDE_TIPS :
2059 			SW_MOD()->GetModuleConfig()->SetHideFieldTips(*(sal_Bool*)aValue.getValue());
2060 		break;
2061 		case WID_DOC_REDLINE_DISPLAY:
2062 		{
2063 			sal_Int16 eRedMode = pDocShell->GetDoc()->GetRedlineMode();
2064 			eRedMode = eRedMode & (~nsRedlineMode_t::REDLINE_SHOW_MASK);
2065 			sal_Int16 nSet = 0;
2066 			aValue >>= nSet;
2067 			switch(nSet)
2068 			{
2069 				case RedlineDisplayType::NONE: break;
2070                 case RedlineDisplayType::INSERTED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT; break;
2071                 case RedlineDisplayType::REMOVED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_DELETE;  break;
2072 				case RedlineDisplayType::
2073                         INSERTED_AND_REMOVED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT|nsRedlineMode_t::REDLINE_SHOW_DELETE;
2074 				break;
2075 				default: throw IllegalArgumentException();
2076 			}
2077             pDocShell->GetDoc()->SetRedlineMode(eRedMode);
2078 		}
2079 		break;
2080 		case WID_DOC_TWO_DIGIT_YEAR:
2081 		{
2082 			sal_Int16 nYear = 0;
2083 			aValue >>= nYear;
2084 			SfxRequest aRequest ( SID_ATTR_YEAR2000, SFX_CALLMODE_SLOT, pDocShell->GetDoc()->GetAttrPool());
2085 			aRequest.AppendItem(SfxUInt16Item( SID_ATTR_YEAR2000, static_cast < sal_uInt16 > ( nYear ) ) );
2086 			pDocShell->Execute ( aRequest );
2087 		}
2088 		break;
2089 		case WID_DOC_AUTOMATIC_CONTROL_FOCUS:
2090 		{
2091 			SwDrawDocument * pDrawDoc;
2092 			sal_Bool bAuto = *(sal_Bool*) aValue.getValue();
2093 
2094             if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * >( pDocShell->GetDoc()->GetDrawModel() ) ) )
2095 				pDrawDoc->SetAutoControlFocus( bAuto );
2096 			else if (bAuto)
2097 			{
2098 				// if setting to true, and we don't have an
2099 				// SdrModel, then we are changing the default and
2100 				// must thus create an SdrModel, if we don't have an
2101 				// SdrModel and we are leaving the default at false,
2102 				// we don't need to make an SdrModel and can do nothing
2103                 // --> OD 2005-08-08 #i52858# - method name changed
2104                 pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetOrCreateDrawModel() );
2105                 // <--
2106 				pDrawDoc->SetAutoControlFocus ( bAuto );
2107 			}
2108 		}
2109 		break;
2110 		case WID_DOC_APPLY_FORM_DESIGN_MODE:
2111 		{
2112 			SwDrawDocument * pDrawDoc;
2113 			sal_Bool bMode = *(sal_Bool*)aValue.getValue();
2114 
2115             if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) )
2116 				pDrawDoc->SetOpenInDesignMode( bMode );
2117 			else if (!bMode)
2118 			{
2119 				// if setting to false, and we don't have an
2120 				// SdrModel, then we are changing the default and
2121 				// must thus create an SdrModel, if we don't have an
2122 				// SdrModel and we are leaving the default at true,
2123 				// we don't need to make an SdrModel and can do
2124 				// nothing
2125                 // --> OD 2005-08-08 #i52858# - method name changed
2126                 pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetOrCreateDrawModel() );
2127                 // <--
2128 				pDrawDoc->SetOpenInDesignMode ( bMode );
2129 			}
2130 		}
2131 		break;
2132         // --> FME 2005-02-25 #i42634# New property to set the bInReading
2133         // flag at the document, used during binary import
2134         case WID_DOC_LOCK_UPDATES :
2135         {
2136             SwDoc* pDoc = pDocShell->GetDoc();
2137             bool bBool (false);
2138             if( aValue >>= bBool )
2139               pDoc->SetInReading( bBool );
2140         }
2141         break;
2142         // <--
2143 		case WID_DOC_BUILDID:
2144 			aValue >>= maBuildId;
2145 		break;
2146         // --> OD 2006-03-21 #b6375613#
2147         case WID_APPLY_WORKAROUND_FOR_B6375613:
2148         {
2149             bool bApplyWorkaroundForB6375613( false );
2150             aValue >>= bApplyWorkaroundForB6375613;
2151             pDocShell->GetDoc()->SetApplyWorkaroundForB6375613( bApplyWorkaroundForB6375613 );
2152         }
2153         break;
2154         // <--
2155         case WID_DOC_DEFAULT_PAGE_MODE:
2156         {
2157             bool bDefaultPageMode( false );
2158             aValue >>= bDefaultPageMode;
2159             pDocShell->GetDoc()->SetDefaultPageMode( bDefaultPageMode );
2160         }
2161         break;
2162 
2163         default:
2164 		{
2165             const SfxPoolItem& rItem = pDocShell->GetDoc()->GetDefault(pEntry->nWID);
2166 			SfxPoolItem* pNewItem = rItem.Clone();
2167             pNewItem->PutValue(aValue, pEntry->nMemberId);
2168 			pDocShell->GetDoc()->SetDefault(*pNewItem);
2169 			delete pNewItem;
2170 		}
2171 	}
2172 }
2173 /*-- 10.05.99 13:58:59---------------------------------------------------
2174 
2175   -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)2176 Any SwXTextDocument::getPropertyValue(const OUString& rPropertyName)
2177 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
2178 {
2179 	::vos::OGuard aGuard(Application::GetSolarMutex());
2180 	if(!IsValid())
2181 		throw RuntimeException();
2182     const SfxItemPropertySimpleEntry*  pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2183 
2184     if(!pEntry)
2185 		throw UnknownPropertyException();
2186 	Any aAny;
2187     switch(pEntry->nWID)
2188 	{
2189 		case  WID_DOC_CHAR_COUNT     :
2190 		case  WID_DOC_PARA_COUNT     :
2191 		case  WID_DOC_WORD_COUNT     :
2192 		{
2193 			SwDocStat aStat(pDocShell->GetDoc()->GetDocStat());
2194 			if(aStat.bModified)
2195 				pDocShell->GetDoc()->UpdateDocStat( aStat );
2196 			sal_Int32 nValue;
2197             switch(pEntry->nWID)
2198 			{
2199 				case  WID_DOC_CHAR_COUNT     :nValue = aStat.nChar;break;
2200 				case  WID_DOC_PARA_COUNT     :nValue = aStat.nPara;break;
2201 				case  WID_DOC_WORD_COUNT     :nValue = aStat.nWord;break;
2202 			}
2203 			aAny <<= nValue;
2204 		}
2205 		break;
2206 		case  WID_DOC_WORD_SEPARATOR :
2207 		{
2208 			aAny <<= OUString(SW_MOD()->GetDocStatWordDelim());
2209 		}
2210 		break;
2211 		case WID_DOC_CHANGES_RECORD:
2212 		case WID_DOC_CHANGES_SHOW:
2213 		{
2214 			sal_uInt16 eMode = pDocShell->GetDoc()->GetRedlineMode();
2215 			sal_Bool bSet = sal_False;
2216             if(WID_DOC_CHANGES_SHOW == pEntry->nWID)
2217 			{
2218 				sal_uInt16 nMask = nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE;
2219 				bSet = (eMode & nMask) == nMask;
2220 			}
2221             else if(WID_DOC_CHANGES_RECORD == pEntry->nWID)
2222 			{
2223 				bSet = (eMode& nsRedlineMode_t::REDLINE_ON)  != 0;
2224 			}
2225 			aAny.setValue(&bSet, ::getBooleanCppuType());
2226 		}
2227 		break;
2228         case  WID_DOC_CHANGES_PASSWORD:
2229         {
2230             SwDoc* pDoc = pDocShell->GetDoc();
2231             aAny <<= pDoc->GetRedlinePassword();
2232         }
2233         break;
2234 		case WID_DOC_AUTO_MARK_URL :
2235 			aAny <<= OUString(pDocShell->GetDoc()->GetTOIAutoMarkURL());
2236 		break;
2237 		case WID_DOC_HIDE_TIPS :
2238 		{
2239 			sal_Bool bTemp = SW_MOD()->GetModuleConfig()->IsHideFieldTips();
2240 			aAny.setValue(&bTemp, ::getBooleanCppuType());
2241 		}
2242 		break;
2243 		case WID_DOC_REDLINE_DISPLAY:
2244 		{
2245 			sal_Int16 eRedMode = pDocShell->GetDoc()->GetRedlineMode();
2246 			eRedMode = eRedMode & nsRedlineMode_t::REDLINE_SHOW_MASK;
2247 			sal_Int16 nRet = RedlineDisplayType::NONE;
2248 			if(nsRedlineMode_t::REDLINE_SHOW_INSERT == eRedMode)
2249 				nRet = RedlineDisplayType::INSERTED;
2250 			else if(nsRedlineMode_t::REDLINE_SHOW_DELETE == eRedMode)
2251 				nRet = RedlineDisplayType::REMOVED;
2252 			else if(nsRedlineMode_t::REDLINE_SHOW_MASK == eRedMode)
2253 				nRet = RedlineDisplayType::INSERTED_AND_REMOVED;
2254 			aAny <<= nRet;
2255 		}
2256 		break;
2257 		case WID_DOC_FORBIDDEN_CHARS:
2258 		{
2259 			GetPropertyHelper();
2260 			Reference<XForbiddenCharacters> xRet(xPropertyHelper, UNO_QUERY);
2261 			aAny <<= xRet;
2262 		}
2263 		break;
2264 		case WID_DOC_TWO_DIGIT_YEAR:
2265 		{
2266 			aAny <<= static_cast < sal_Int16 > (pDocShell->GetDoc()->GetNumberFormatter ( sal_True )->GetYear2000());
2267 		}
2268 		break;
2269 		case WID_DOC_AUTOMATIC_CONTROL_FOCUS:
2270 		{
2271 			SwDrawDocument * pDrawDoc;
2272 			sal_Bool bAuto;
2273             if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) )
2274 				bAuto = pDrawDoc->GetAutoControlFocus();
2275 			else
2276 				bAuto = sal_False;
2277 			aAny.setValue(&bAuto, ::getBooleanCppuType());
2278 		}
2279 		break;
2280 		case WID_DOC_APPLY_FORM_DESIGN_MODE:
2281 		{
2282 			SwDrawDocument * pDrawDoc;
2283 			sal_Bool bMode;
2284             if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) )
2285 				bMode = pDrawDoc->GetOpenInDesignMode();
2286 			else
2287 				bMode = sal_True;
2288 			aAny.setValue(&bMode, ::getBooleanCppuType());
2289 		}
2290 		break;
2291         case WID_DOC_BASIC_LIBRARIES:
2292             aAny <<= pDocShell->GetBasicContainer();
2293         break;
2294         case WID_DOC_DIALOG_LIBRARIES:
2295             aAny <<= pDocShell->GetDialogContainer();
2296         break;
2297         case WID_DOC_RUNTIME_UID:
2298             aAny <<= getRuntimeUID();
2299         break;
2300         case WID_DOC_LOCK_UPDATES :
2301             aAny <<= static_cast<bool>( pDocShell->GetDoc()->IsInReading() );
2302         break;
2303 		case WID_DOC_BUILDID:
2304 			aAny <<= maBuildId;
2305 		break;
2306         case WID_DOC_HAS_VALID_SIGNATURES:
2307             aAny <<= hasValidSignatures();
2308         break;
2309         // --> OD 2006-03-21 #b6375613#
2310         case WID_APPLY_WORKAROUND_FOR_B6375613:
2311         {
2312             aAny <<= pDocShell->GetDoc()->ApplyWorkaroundForB6375613();
2313         }
2314         break;
2315         // <--
2316 
2317 		default:
2318 		{
2319             const SfxPoolItem& rItem = pDocShell->GetDoc()->GetDefault(pEntry->nWID);
2320             rItem.QueryValue(aAny, pEntry->nMemberId);
2321 		}
2322 	}
2323 	return aAny;
2324 }
2325 /*-- 10.05.99 13:58:59---------------------------------------------------
2326 
2327   -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)2328 void SwXTextDocument::addPropertyChangeListener(const OUString& /*PropertyName*/,
2329     const Reference< XPropertyChangeListener > & /*aListener*/)
2330 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
2331 {
2332 	DBG_WARNING("not implemented");
2333 }
2334 /*-- 10.05.99 13:58:59---------------------------------------------------
2335 
2336   -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)2337 void SwXTextDocument::removePropertyChangeListener(const OUString& /*PropertyName*/,
2338     const Reference< XPropertyChangeListener > & /*aListener*/)
2339 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
2340 {
2341 	DBG_WARNING("not implemented");
2342 }
2343 /*-- 10.05.99 13:59:00---------------------------------------------------
2344 
2345   -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)2346 void SwXTextDocument::addVetoableChangeListener(const OUString& /*PropertyName*/,
2347     const Reference< XVetoableChangeListener > & /*aListener*/)
2348 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
2349 {
2350 	DBG_WARNING("not implemented");
2351 }
2352 /*-- 10.05.99 13:59:00---------------------------------------------------
2353 
2354   -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)2355 void SwXTextDocument::removeVetoableChangeListener(const OUString& /*PropertyName*/,
2356                         const Reference< XVetoableChangeListener > & /*aListener*/)
2357 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
2358 {
2359 	DBG_WARNING("not implemented");
2360 }
2361 /* -----------------25.10.99 10:42-------------------
2362 
2363  --------------------------------------------------*/
getLinks(void)2364 Reference< XNameAccess >  SwXTextDocument::getLinks(void) throw( RuntimeException )
2365 {
2366 	if(!pxLinkTargetSupplier)
2367 	{
2368 		pxLinkTargetSupplier = new Reference< XNameAccess > ;
2369 		(*pxLinkTargetSupplier) = new SwXLinkTargetSupplier(*(SwXTextDocument*)this);
2370 	}
2371 	return (*pxLinkTargetSupplier);
2372 }
2373 /* -----------------------------11.01.01 15:01--------------------------------
2374 
2375  ---------------------------------------------------------------------------*/
getRedlines()2376 Reference< XEnumerationAccess > SwXTextDocument::getRedlines(  ) throw(RuntimeException)
2377 {
2378 	if(!pxXRedlines)
2379 	{
2380 		pxXRedlines = new Reference< XEnumerationAccess > ;
2381 		(*pxXRedlines) = new SwXRedlines(pDocShell->GetDoc());
2382 	}
2383 	return *pxXRedlines;
2384 }
2385 /*-- 21.02.00 08:41:06---------------------------------------------------
2386 
2387   -----------------------------------------------------------------------*/
refresh(void)2388 void SwXTextDocument::refresh(void) throw( RuntimeException )
2389 {
2390 	::vos::OGuard aGuard(Application::GetSolarMutex());
2391 	if(!IsValid())
2392 		throw RuntimeException();
2393 	ViewShell *pViewShell = pDocShell->GetWrtShell();
2394 	notifyRefreshListeners();
2395 	if(pViewShell)
2396 		pViewShell->CalcLayout();
2397 }
2398 /*-- 21.02.00 08:41:06---------------------------------------------------
2399 
2400   -----------------------------------------------------------------------*/
addRefreshListener(const Reference<util::XRefreshListener> & l)2401 void SwXTextDocument::addRefreshListener(const Reference< util::XRefreshListener > & l)
2402 	throw( RuntimeException )
2403 {
2404 	::vos::OGuard aGuard(Application::GetSolarMutex());
2405 	if ( !IsValid() )
2406 		throw RuntimeException();
2407 	aRefreshCont.AddListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l ));
2408 }
2409 /*-- 21.02.00 08:41:07---------------------------------------------------
2410 
2411   -----------------------------------------------------------------------*/
removeRefreshListener(const Reference<util::XRefreshListener> & l)2412 void SwXTextDocument::removeRefreshListener(const Reference< util::XRefreshListener > & l)
2413 	throw( RuntimeException )
2414 {
2415 	::vos::OGuard aGuard(Application::GetSolarMutex());
2416 	if ( !IsValid() || !aRefreshCont.RemoveListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l ) ) )
2417 		throw RuntimeException();
2418 }
2419 /* -----------------------------26.02.01 12:22--------------------------------
2420 
2421  ---------------------------------------------------------------------------*/
updateLinks()2422 void SwXTextDocument::updateLinks(  ) throw(RuntimeException)
2423 {
2424 	::vos::OGuard aGuard(Application::GetSolarMutex());
2425 	if(!IsValid())
2426 		throw RuntimeException();
2427 	SwDoc* pDoc = pDocShell->GetDoc();
2428   	sfx2::LinkManager& rLnkMan = pDoc->GetLinkManager();
2429 	if( rLnkMan.GetLinks().Count() )
2430 	{
2431 		UnoActionContext aAction(pDoc);
2432 		rLnkMan.UpdateAllLinks( sal_False, sal_False, sal_True );
2433 	}
2434 }
2435 //XPropertyState
getPropertyState(const OUString & rPropertyName)2436 PropertyState SAL_CALL SwXTextDocument::getPropertyState( const OUString& rPropertyName )
2437 	throw (UnknownPropertyException, RuntimeException)
2438 {
2439 	::vos::OGuard aGuard(Application::GetSolarMutex());
2440 	PropertyState eRet = PropertyState_DIRECT_VALUE;
2441 	if(!IsValid())
2442 		throw RuntimeException();
2443     const SfxItemPropertySimpleEntry*  pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2444 
2445     if(!pEntry)
2446 		throw UnknownPropertyException();
2447 	Any aAny;
2448     switch(pEntry->nWID)
2449 	{
2450 		case 0:default:break;
2451 	}
2452 	return eRet;
2453 }
getPropertyStates(const Sequence<OUString> & rPropertyNames)2454 Sequence< PropertyState > SAL_CALL SwXTextDocument::getPropertyStates( const Sequence< OUString >& rPropertyNames )
2455 	throw (UnknownPropertyException, RuntimeException)
2456 {
2457     const sal_Int32 nCount = rPropertyNames.getLength();
2458     const OUString * pNames = rPropertyNames.getConstArray();
2459     Sequence < PropertyState > aRet ( nCount );
2460     PropertyState *pState = aRet.getArray();
2461 
2462     for ( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++)
2463         pState[nIndex] = getPropertyState( pNames[nIndex] );
2464 
2465     return aRet;
2466 }
setPropertyToDefault(const OUString & rPropertyName)2467 void SAL_CALL SwXTextDocument::setPropertyToDefault( const OUString& rPropertyName )
2468 	throw (UnknownPropertyException, RuntimeException)
2469 {
2470 	::vos::OGuard aGuard(Application::GetSolarMutex());
2471 	if(!IsValid())
2472 		throw RuntimeException();
2473     const SfxItemPropertySimpleEntry*  pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2474     if(!pEntry)
2475 		throw UnknownPropertyException();
2476     switch(pEntry->nWID)
2477 	{
2478 		case 0:default:break;
2479 	}
2480 }
getPropertyDefault(const OUString & rPropertyName)2481 Any SAL_CALL SwXTextDocument::getPropertyDefault( const OUString& rPropertyName )
2482 	throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
2483 {
2484 	::vos::OGuard aGuard(Application::GetSolarMutex());
2485 	if(!IsValid())
2486 		throw RuntimeException();
2487     const SfxItemPropertySimpleEntry*  pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2488     if(!pEntry)
2489 		throw UnknownPropertyException();
2490 	Any aAny;
2491     switch(pEntry->nWID)
2492 	{
2493 		case 0:default:break;
2494 	}
2495 	return aAny;
2496 }
2497 
lcl_GetOutputDevice(const SwPrintUIOptions & rPrintUIOptions)2498 static OutputDevice * lcl_GetOutputDevice( const SwPrintUIOptions &rPrintUIOptions )
2499 {
2500     OutputDevice *pOut = 0;
2501 
2502     uno::Any aAny( rPrintUIOptions.getValue( C2U( "RenderDevice" ) ));
2503     uno::Reference< awt::XDevice >  xRenderDevice;
2504     aAny >>= xRenderDevice;
2505     if (xRenderDevice.is())
2506     {
2507         VCLXDevice*     pDevice = VCLXDevice::GetImplementation( xRenderDevice );
2508         pOut = pDevice ? pDevice->GetOutputDevice() : 0;
2509     }
2510 
2511     return pOut;
2512 }
2513 
2514 
lcl_SeqHasProperty(const uno::Sequence<beans::PropertyValue> & rOptions,const sal_Char * pPropName)2515 static bool lcl_SeqHasProperty(
2516     const uno::Sequence< beans::PropertyValue >& rOptions,
2517     const sal_Char *pPropName )
2518 {
2519     bool bRes = false;
2520     const sal_Int32 nLen = rOptions.getLength();
2521     const beans::PropertyValue *pProps = rOptions.getConstArray();
2522     for (sal_Int32 i = 0;  i < nLen && !bRes;  ++i)
2523     {
2524         if (pProps[i].Name.equalsAscii( pPropName ))
2525             bRes = true;
2526     }
2527     return bRes;
2528 }
2529 
2530 
GetRenderView(bool & rbIsSwSrcView,const uno::Sequence<beans::PropertyValue> & rOptions,bool bIsPDFExport)2531 SfxViewShell * SwXTextDocument::GetRenderView(
2532     bool &rbIsSwSrcView,
2533     const uno::Sequence< beans::PropertyValue >& rOptions,
2534     bool bIsPDFExport )
2535 {
2536     // get view shell to use
2537     SfxViewShell *pView = 0;
2538     if (bIsPDFExport)
2539         pView = GuessViewShell( rbIsSwSrcView );
2540     else
2541     {
2542         uno::Any aTmp;
2543         const sal_Int32 nLen = rOptions.getLength();
2544         const beans::PropertyValue *pProps = rOptions.getConstArray();
2545         for (sal_Int32 i = 0; i < nLen; ++i)
2546         {
2547             if (pProps[i].Name.equalsAscii( "View" ))
2548             {
2549                 aTmp = pProps[i].Value;
2550                 break;
2551             }
2552         }
2553 
2554         uno::Reference< frame::XController > xController;
2555         if (aTmp >>= xController)
2556         {
2557             DBG_ASSERT( xController.is(), "controller is empty!" );
2558             pView = GuessViewShell( rbIsSwSrcView, xController );
2559         }
2560     }
2561     return pView;
2562 }
2563 
2564 
2565 /*
2566  *  GetRenderDoc:
2567  *  returns the document to be rendered, usually this will be the 'regular'
2568  *  document but in case of PDF export of (multi-)selection it will
2569  *  be a temporary document that gets created if not already done.
2570  *  The rpView variable will be set (if not already done) to the used
2571  *  SfxViewShell.
2572 */
2573 
GetRenderDoc(SfxViewShell * & rpView,const uno::Any & rSelection,bool bIsPDFExport)2574 SwDoc * SwXTextDocument::GetRenderDoc(
2575     SfxViewShell *&rpView,
2576     const uno::Any& rSelection,
2577     bool bIsPDFExport )
2578 {
2579     SwDoc *pDoc = 0;
2580 
2581     uno::Reference< frame::XModel > xModel;
2582     rSelection >>= xModel;
2583     if (xModel == pDocShell->GetModel())
2584         pDoc = pDocShell->GetDoc();
2585     else
2586     {
2587         DBG_ASSERT( !xModel.is(), "unexpected model found" );
2588 
2589         if (rSelection.hasValue())     // is anything selected ?
2590         {
2591             // this part should only be called when a temporary document needs to be created,
2592             // for example for PDF export or printing of (multi-)selection only.
2593 
2594             bool bIsSwSrcView = false;
2595             if (!rpView)
2596             {
2597                 (void) bIsPDFExport;
2598                 // aside from maybe PDF export the view should always have been provided!
2599                 DBG_ASSERT( bIsPDFExport, "view is missing, guessing one..." );
2600 
2601                 rpView = GuessViewShell( bIsSwSrcView );
2602             }
2603             DBG_ASSERT( rpView, "ViewShell missing" );
2604             // the view shell should be SwView for documents PDF export.
2605             // for the page preview no selection should be possible
2606             // (the export dialog does not allow for this option)
2607             const TypeId aSwViewTypeId = TYPE(SwView);
2608             if (rpView  &&  rpView->IsA(aSwViewTypeId))
2609             {
2610                 SfxObjectShellLock xDocSh(((SwView*)rpView)->GetOrCreateTmpSelectionDoc());
2611                 if (xDocSh.Is())
2612                 {
2613                     pDoc = ((SwDocShell*)&xDocSh)->GetDoc();
2614                     rpView = pDoc->GetDocShell()->GetView();
2615                 }
2616             }
2617             else
2618             {
2619                 DBG_ERROR( "unexpected ViewShell" );
2620             }
2621         }
2622     }
2623     return pDoc;
2624 }
2625 
2626 /* -----------------------------23.08.02 16:00--------------------------------
2627 
2628  ---------------------------------------------------------------------------*/
2629 
lcl_SavePrintUIOptionsToDocumentPrintData(SwDoc & rDoc,const SwPrintUIOptions & rPrintUIOptions,bool bIsPDFEXport)2630 static void lcl_SavePrintUIOptionsToDocumentPrintData(
2631     SwDoc &rDoc,
2632     const SwPrintUIOptions &rPrintUIOptions,
2633     bool bIsPDFEXport )
2634 {
2635     SwPrintData aDocPrintData( rDoc.getPrintData() );
2636 
2637     aDocPrintData.SetPrintGraphic( rPrintUIOptions.IsPrintGraphics() );
2638     aDocPrintData.SetPrintTable( rPrintUIOptions.IsPrintTables() );
2639     aDocPrintData.SetPrintDraw( rPrintUIOptions.IsPrintDrawings() );
2640     aDocPrintData.SetPrintControl( rPrintUIOptions.IsPrintFormControls() );
2641     aDocPrintData.SetPrintLeftPage( rPrintUIOptions.IsPrintLeftPages() );
2642     aDocPrintData.SetPrintRightPage( rPrintUIOptions.IsPrintRightPages() );
2643     aDocPrintData.SetPrintReverse( rPrintUIOptions.IsPrintReverse() );
2644     aDocPrintData.SetPaperFromSetup( rPrintUIOptions.IsPaperFromSetup() );
2645     aDocPrintData.SetPrintEmptyPages( rPrintUIOptions.IsPrintEmptyPages( bIsPDFEXport ) );
2646     aDocPrintData.SetPrintPostIts( rPrintUIOptions.GetPrintPostItsType() );
2647     aDocPrintData.SetPrintProspect( rPrintUIOptions.IsPrintProspect() );
2648     aDocPrintData.SetPrintProspect_RTL( rPrintUIOptions.IsPrintProspectRTL() );
2649     aDocPrintData.SetPrintPageBackground( rPrintUIOptions.IsPrintPageBackground() );
2650     aDocPrintData.SetPrintBlackFont( rPrintUIOptions.IsPrintWithBlackTextColor() );
2651     // aDocPrintData.SetPrintSingleJobs( b ); handled by File/Print dialog itself
2652     // arDocPrintData.SetFaxName( s ); n/a in File/Print dialog
2653     aDocPrintData.SetPrintHiddenText( rPrintUIOptions.IsPrintHiddenText() );
2654     aDocPrintData.SetPrintTextPlaceholder( rPrintUIOptions.IsPrintTextPlaceholders() );
2655 
2656     rDoc.setPrintData( aDocPrintData );
2657 }
2658 
2659 
getRendererCount(const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)2660 sal_Int32 SAL_CALL SwXTextDocument::getRendererCount(
2661         const uno::Any& rSelection,
2662         const uno::Sequence< beans::PropertyValue >& rxOptions )
2663     throw (IllegalArgumentException, RuntimeException)
2664 {
2665     ::vos::OGuard aGuard(Application::GetSolarMutex());
2666     if(!IsValid())
2667         throw RuntimeException();
2668 
2669     CleanUpRenderingData();
2670 
2671     const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
2672     bool bIsSwSrcView = false;
2673     SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
2674 
2675     SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
2676     DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
2677     if ( pDoc == 0 || pView == 0 )
2678     {
2679         return 0;
2680     }
2681 
2682     if ( !bIsSwSrcView )
2683     {
2684         m_pRenderData = new SwRenderData;
2685     }
2686     // new <PrintUIOptions>
2687     m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
2688     const bool bFormat = m_pPrintUIOptions->processPropertiesAndCheckFormat( rxOptions );
2689 
2690     // save current UI options from the print dialog for the next call to that dialog
2691     lcl_SavePrintUIOptionsToDocumentPrintData( *pDoc, *m_pPrintUIOptions, bIsPDFExport );
2692 
2693     sal_Int32 nRet = 0;
2694     if ( bIsSwSrcView )
2695     {
2696         SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView);
2697         OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
2698         nRet = pSwSrcView->PrintSource( pOutDev, 1 /* dummy */, true /* get page count only */ );
2699     }
2700     else
2701     {
2702         SwDocShell *pRenderDocShell = pDoc->GetDocShell();
2703 
2704         // TODO/mba: we really need a generic way to get the ViewShell!
2705         ViewShell* pViewShell = 0;
2706         SwView* pSwView = PTR_CAST(SwView, pView);
2707         if ( pSwView )
2708         {
2709             pViewShell = pSwView->GetWrtShellPtr();
2710         }
2711         else
2712         {
2713             if ( bIsPDFExport && bFormat )
2714             {
2715                 //create a hidden view to be able to export as PDF also in print preview
2716                 //pView and pSwView are not changed intentionally!
2717                 m_pHiddenViewFrame = SfxViewFrame::LoadHiddenDocument( *pRenderDocShell, 2 );
2718                 pViewShell = ((SwView*)m_pHiddenViewFrame->GetViewShell())->GetWrtShellPtr();
2719             }
2720             else
2721                 pViewShell = ((SwPagePreView*)pView)->GetViewShell();
2722         }
2723 
2724         if (!pViewShell || !pViewShell->GetLayout())
2725             return 0;
2726 
2727         if ( bFormat )
2728         {
2729             // #i38289
2730             if( pViewShell->GetViewOptions()->getBrowseMode() )
2731             {
2732                 SwViewOption aOpt( *pViewShell->GetViewOptions() );
2733                 aOpt.setBrowseMode( false );
2734                 pViewShell->ApplyViewOptions( aOpt );
2735                 pSwView->RecheckBrowseMode();
2736             }
2737 
2738             // reformating the document for printing will show the changes in the view
2739             // which is likely to produce many unwanted and not nice to view actions.
2740             // We don't want that! Thus we disable updating of the view.
2741             pViewShell->StartAction();
2742 
2743             if ( pSwView )
2744             {
2745                 if (m_pRenderData && m_pRenderData->NeedNewViewOptionAdjust( *pViewShell ) )
2746                     m_pRenderData->ViewOptionAdjustStop();
2747                 if (m_pRenderData && !m_pRenderData->IsViewOptionAdjust())
2748                     m_pRenderData->ViewOptionAdjustStart( *pViewShell, *pViewShell->GetViewOptions() );
2749             }
2750 
2751             m_pRenderData->SetSwPrtOptions( new SwPrintData );
2752             m_pRenderData->MakeSwPrtOptions( m_pRenderData->GetSwPrtOptionsRef(), pRenderDocShell,
2753                     m_pPrintUIOptions, m_pRenderData, bIsPDFExport );
2754 
2755             if ( pSwView )
2756             {
2757                 // PDF export should not make use of the SwPrtOptions
2758                 const SwPrintData *pPrtOptions = (bIsPDFExport)
2759                                                  ? NULL
2760                                                  : m_pRenderData->GetSwPrtOptions();
2761                 m_pRenderData->ViewOptionAdjust( pPrtOptions );
2762             }
2763 
2764             // since printing now also use the API for PDF export this option
2765             // should be set for printing as well ...
2766             pViewShell->SetPDFExportOption( sal_True );
2767             bool bOrigStatus = pRenderDocShell->IsEnableSetModified();
2768             // check configuration: shall update of printing information in DocInfo set the document to "modified"?
2769             bool bStateChanged = false;
2770             if ( bOrigStatus && !SvtPrintWarningOptions().IsModifyDocumentOnPrintingAllowed() )
2771             {
2772                 pRenderDocShell->EnableSetModified( sal_False );
2773                 bStateChanged = true;
2774             }
2775 
2776             // --> FME 2005-05-23 #122919# Force field update before PDF export:
2777             pViewShell->ViewShell::UpdateFlds(sal_True);
2778             // <--
2779             if( bStateChanged )
2780                 pRenderDocShell->EnableSetModified( sal_True );
2781 
2782             // there is some redundancy between those two function calls, but right now
2783             // there is no time to sort this out.
2784             //TODO: check what exatly needs to be done and make just one function for that
2785             pViewShell->CalcLayout();
2786             pViewShell->CalcPagesForPrint( pViewShell->GetPageCount() );
2787 
2788             pViewShell->SetPDFExportOption( sal_False );
2789 
2790             // enable view again
2791             pViewShell->EndAction();
2792         }
2793 
2794         const sal_Int32 nPageCount = pViewShell->GetPageCount();
2795 
2796         //
2797         // get number of pages to be rendered
2798         //
2799         const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
2800         if (bPrintProspect)
2801         {
2802             pDoc->CalculatePagePairsForProspectPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, nPageCount );
2803             nRet = m_pRenderData->GetPagePairsForProspectPrinting().size();
2804         }
2805         else
2806         {
2807             if ( m_pRenderData->HasPostItData() )
2808             {
2809                 m_pRenderData->DeletePostItData();
2810             }
2811             const sal_Int16 nPostItMode = (sal_Int16) m_pPrintUIOptions->getIntValue( "PrintAnnotationMode", 0 );
2812             if (nPostItMode != POSTITS_NONE)
2813             {
2814                 OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
2815                 m_pRenderData->CreatePostItData( pDoc, pViewShell->GetViewOptions(), pOutDev );
2816             }
2817 
2818             // get set of valid document pages (according to the current settings)
2819             // and their start frames
2820             pDoc->CalculatePagesForPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, bIsPDFExport, nPageCount );
2821 
2822             if (nPostItMode != POSTITS_NONE)
2823             {
2824                 pDoc->UpdatePagesForPrintingWithPostItData( *m_pRenderData,
2825                         *m_pPrintUIOptions, bIsPDFExport, nPageCount );
2826             }
2827 
2828             nRet = m_pRenderData->GetPagesToPrint().size();
2829         }
2830     }
2831     DBG_ASSERT( nRet >= 0, "negative number of pages???" );
2832 
2833     return nRet;
2834 }
2835 /* -----------------------------23.08.02 16:00--------------------------------
2836 
2837  ---------------------------------------------------------------------------*/
getRenderer(sal_Int32 nRenderer,const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)2838 uno::Sequence< beans::PropertyValue > SAL_CALL SwXTextDocument::getRenderer(
2839         sal_Int32 nRenderer,
2840         const uno::Any& rSelection,
2841         const uno::Sequence< beans::PropertyValue >& rxOptions )
2842     throw (IllegalArgumentException, RuntimeException)
2843 {
2844     ::vos::OGuard aGuard(Application::GetSolarMutex());
2845     if(!IsValid())
2846         throw RuntimeException();
2847 
2848     const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
2849     bool bIsSwSrcView = false;
2850     SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
2851 
2852     // m_pRenderData should NOT be created here!
2853     // That should only be done in getRendererCount. If this function is called before
2854     // getRendererCount was called then the caller will probably just retrieve the extra UI options
2855     // and is not interested in getting valid information about the other data that would
2856     // otherwise be provided here!
2857 //    if( ! m_pRenderData )
2858 //        m_pRenderData = new SwRenderData;
2859     if (!m_pPrintUIOptions)
2860         m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
2861     m_pPrintUIOptions->processProperties( rxOptions );
2862     const bool bPrintProspect    = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
2863     const bool bIsSkipEmptyPages = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport );
2864     const bool bPrintPaperFromSetup = m_pPrintUIOptions->getBoolValue( "PrintPaperFromSetup", false );
2865 
2866     SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
2867     DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
2868     if (!pDoc || !pView)
2869         return uno::Sequence< beans::PropertyValue >();
2870 
2871     if ( nRenderer < 0 || nRenderer >= SAL_MAX_UINT16 )
2872         throw IllegalArgumentException();
2873 
2874     // TODO/mba: we really need a generic way to get the ViewShell!
2875     ViewShell* pVwSh = 0;
2876     SwView* pSwView = PTR_CAST(SwView, pView);
2877     if ( pSwView )
2878         pVwSh = pSwView->GetWrtShellPtr();
2879     else
2880         pVwSh = ((SwPagePreView*)pView)->GetViewShell();
2881 
2882     sal_Int32 nMaxRenderer = 0;
2883     if (!bIsSwSrcView && m_pRenderData)
2884     {
2885         DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" );
2886         nMaxRenderer = bPrintProspect?
2887             m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 :
2888             m_pRenderData->GetPagesToPrint().size() - 1;
2889     }
2890     // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print
2891     // we obmit checking of the upper bound in this case.
2892     if (!bIsSwSrcView && m_pRenderData && nRenderer > nMaxRenderer)
2893         return uno::Sequence< beans::PropertyValue >();
2894 
2895     uno::Sequence< beans::PropertyValue > aRenderer;
2896     if (m_pRenderData)
2897     {
2898         const sal_Int32 nPage = bPrintProspect
2899                                 ? nRenderer + 1
2900                                 : m_pRenderData->GetPagesToPrint()[ nRenderer ];
2901 
2902         // get paper tray to use ...
2903         sal_Int32 nPrinterPaperTray = -1;
2904         if (! bPrintPaperFromSetup)
2905         {
2906             // ... from individual page style (see the page tab in Format/Page dialog)
2907             const std::map< sal_Int32, sal_Int32 > &rPaperTrays = m_pRenderData->GetPrinterPaperTrays();
2908             std::map< sal_Int32, sal_Int32 >::const_iterator aIt( rPaperTrays.find( nPage ) );
2909             if (aIt != rPaperTrays.end())
2910                 nPrinterPaperTray = aIt->second;
2911         }
2912 
2913         awt::Size aPageSize;
2914         awt::Size aPreferredPageSize;
2915         Size aTmpSize;
2916         if (bIsSwSrcView || bPrintProspect)
2917         {
2918             // for printing of HTML source code and prospect printing we should use
2919             // the printers paper size since
2920             // a) HTML source view has no page size
2921             // b) prospect printing has a different page size from the documents page
2922             //    since two document pages will get rendered on one printer page
2923 
2924             // since PageIncludesNonprintableArea will be set to true we can return the
2925             // printers paper size here.
2926             // Sometimes 'getRenderer' is only called to get "ExtraPrintUIOptions", in this
2927             // case we won't get an OutputDevice here, but then the caller also has no need
2928             // for the correct PageSisze right now...
2929             Printer *pPrinter = dynamic_cast< Printer * >(lcl_GetOutputDevice( *m_pPrintUIOptions ));
2930             if (pPrinter)
2931             {
2932                 // HTML source view and prospect adapt to the printer's paper size
2933                 aTmpSize = pPrinter->GetPaperSize();
2934                 aTmpSize = pPrinter->LogicToLogic( aTmpSize,
2935                             pPrinter->GetMapMode(), MapMode( MAP_100TH_MM ));
2936                 aPageSize = awt::Size( aTmpSize.Width(), aTmpSize.Height() );
2937                 if( bPrintProspect )
2938                 {
2939                     // just switch to an appropriate portrait/landscape format
2940                     // FIXME: brochure printing with landscape pages puts the
2941                     // pages next to each other, so landscape is currently always
2942                     // the better choice
2943                     if( aPageSize.Width < aPageSize.Height )
2944                     {
2945                         aPreferredPageSize.Width = aPageSize.Height;
2946                         aPreferredPageSize.Height = aPageSize.Width;
2947                     }
2948                 }
2949             }
2950         }
2951         else
2952         {
2953             ASSERT( nPage > 0 && nPage <= SAL_MAX_UINT16,
2954                     "<SwXTextDocument::getRenderer(..)> - unexpected value for the page number, it does not fit into sal_uInt16." );
2955             aTmpSize = pVwSh->GetPageSize( static_cast< sal_uInt16 >(nPage), bIsSkipEmptyPages );
2956             aPageSize = awt::Size ( TWIP_TO_MM100( aTmpSize.Width() ),
2957                                     TWIP_TO_MM100( aTmpSize.Height() ));
2958         }
2959 
2960         sal_Int32 nLen = 2;
2961         aRenderer.realloc(2);
2962         aRenderer[0].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) );
2963         aRenderer[0].Value <<= aPageSize;
2964         aRenderer[1].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageIncludesNonprintableArea" ) );
2965         aRenderer[1].Value <<= sal_True;
2966         if (aPreferredPageSize.Width && aPreferredPageSize.Height)
2967         {
2968             ++nLen;
2969             aRenderer.realloc( nLen );
2970             aRenderer[ nLen - 1 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "PreferredPageSize" ) );
2971             aRenderer[ nLen - 1 ].Value <<= aPreferredPageSize;
2972         }
2973         if (nPrinterPaperTray >= 0)
2974         {
2975             ++nLen;
2976             aRenderer.realloc( nLen );
2977             aRenderer[ nLen - 1 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "PrinterPaperTray" ) );
2978             aRenderer[ nLen - 1 ].Value <<= nPrinterPaperTray;
2979         }
2980     }
2981 
2982     if ( bApplyPagePrintSettingsFromXPagePrintable )
2983     {
2984         const SwPagePreViewPrtData* pPagePrintSettings =
2985                                         pDocShell->GetDoc()->GetPreViewPrtData();
2986         if ( pPagePrintSettings &&
2987              ( pPagePrintSettings->GetRow() > 1 ||
2988                pPagePrintSettings->GetCol() > 1 ) )
2989         {
2990             // extend render data by page print settings attributes
2991             sal_Int32 nLen = aRenderer.getLength();
2992             const sal_Int32 nRenderDataIdxStart = nLen;
2993             nLen += 9;
2994             aRenderer.realloc( nLen );
2995             // put page print settings attribute into render data
2996             const sal_Int32 nRow = pPagePrintSettings->GetRow();
2997             aRenderer[ nRenderDataIdxStart + 0 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpRows" ) );
2998             aRenderer[ nRenderDataIdxStart + 0 ].Value <<= ( nRow > 1 ? nRow : 1 );
2999             const sal_Int32 nCol = pPagePrintSettings->GetCol();
3000             aRenderer[ nRenderDataIdxStart + 1 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpColumns" ) );
3001             aRenderer[ nRenderDataIdxStart + 1 ].Value <<= ( nCol > 1 ? nCol : 1 );
3002             aRenderer[ nRenderDataIdxStart + 2 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginLeft" ) );
3003             aRenderer[ nRenderDataIdxStart + 2 ].Value <<= pPagePrintSettings->GetLeftSpace();
3004             aRenderer[ nRenderDataIdxStart + 3 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginRight" ) );
3005             aRenderer[ nRenderDataIdxStart + 3 ].Value <<= pPagePrintSettings->GetRightSpace();
3006             aRenderer[ nRenderDataIdxStart + 4 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginTop" ) );
3007             aRenderer[ nRenderDataIdxStart + 4 ].Value <<= pPagePrintSettings->GetTopSpace();
3008             aRenderer[ nRenderDataIdxStart + 5 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginBottom" ) );
3009             aRenderer[ nRenderDataIdxStart + 5 ].Value <<= pPagePrintSettings->GetBottomSpace();
3010             aRenderer[ nRenderDataIdxStart + 6 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpHorizontalSpacing" ) );
3011             aRenderer[ nRenderDataIdxStart + 6 ].Value <<= pPagePrintSettings->GetHorzSpace();
3012             aRenderer[ nRenderDataIdxStart + 7 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpVerticalSpacing" ) );
3013             aRenderer[ nRenderDataIdxStart + 7 ].Value <<= pPagePrintSettings->GetVertSpace();
3014             {
3015                 Printer* pPrinter = pDocShell->GetDoc()->getPrinter( false );
3016                 if ( pPrinter )
3017                 {
3018                     awt::Size aNewPageSize;
3019                     const Size aPageSize = pPrinter->PixelToLogic( pPrinter->GetPaperSizePixel(), MapMode( MAP_100TH_MM ) );
3020                     aNewPageSize = awt::Size( aPageSize.Width(), aPageSize.Height() );
3021                     if ( ( pPagePrintSettings->GetLandscape() &&
3022                            aPageSize.Width() < aPageSize.Height() ) ||
3023                          ( !pPagePrintSettings->GetLandscape() &&
3024                            aPageSize.Width() > aPageSize.Height() ) )
3025                     {
3026                         aNewPageSize = awt::Size( aPageSize.Height(), aPageSize.Width() );
3027                     }
3028                     aRenderer[ nRenderDataIdxStart + 8 ].Name  = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPaperSize" ) );
3029                     aRenderer[ nRenderDataIdxStart + 8 ].Value <<= aNewPageSize;
3030                 }
3031             }
3032         }
3033 
3034         bApplyPagePrintSettingsFromXPagePrintable = sal_False;
3035     }
3036 
3037     m_pPrintUIOptions->appendPrintUIOptions( aRenderer );
3038 
3039     return aRenderer;
3040 }
3041 /* -----------------------------28.10.02 16:00--------------------------------
3042 
3043  ---------------------------------------------------------------------------*/
GuessViewShell(bool & rbIsSwSrcView,const uno::Reference<css::frame::XController> xController)3044 SfxViewShell * SwXTextDocument::GuessViewShell(
3045     /* out */ bool &rbIsSwSrcView,
3046     const uno::Reference< css::frame::XController > xController )
3047 {
3048     // #130810# SfxViewShell::Current() / SfxViewShell::GetObjectShell()
3049     // must not be used (see comment from MBA)
3050     //
3051     SfxViewShell    *pView = 0;
3052     SwView          *pSwView = 0;
3053     SwPagePreView   *pSwPagePreView = 0;
3054     SwSrcView       *pSwSrcView = 0;
3055     SfxViewFrame    *pFrame = SfxViewFrame::GetFirst( pDocShell, sal_False );
3056 
3057     // look for the view shell with the same controller in use,
3058     // otherwise look for a suitable view
3059     while (pFrame)
3060     {
3061         pView = pFrame->GetViewShell();
3062         pSwView = dynamic_cast< SwView * >(pView);
3063         pSwSrcView = dynamic_cast< SwSrcView * >(pView);
3064         if (!pSwPagePreView)
3065             pSwPagePreView = dynamic_cast< SwPagePreView * >(pView);
3066         if (xController.is())
3067         {
3068             if (pView && pView->GetController() == xController)
3069                 break;
3070         }
3071         else if ( pSwView || pSwSrcView || pSwPagePreView )
3072             break;
3073         pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell,  sal_False );
3074     }
3075 
3076     DBG_ASSERT( pSwView || pSwPagePreView || pSwSrcView, "failed to get view shell" );
3077     if (pView)
3078         rbIsSwSrcView = pSwSrcView != 0;
3079     return pView;
3080 }
3081 
3082 
render(sal_Int32 nRenderer,const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)3083 void SAL_CALL SwXTextDocument::render(
3084         sal_Int32 nRenderer,
3085         const uno::Any& rSelection,
3086         const uno::Sequence< beans::PropertyValue >& rxOptions )
3087     throw (IllegalArgumentException, RuntimeException)
3088 {
3089     ::vos::OGuard aGuard(Application::GetSolarMutex());
3090     if(!IsValid())
3091         throw RuntimeException();
3092 
3093     // due to #110067# (document page count changes sometimes during
3094     // PDF export/printing) we can not check for the upper bound properly.
3095     // Thus instead of throwing the exception we silently return.
3096     if (0 > nRenderer)
3097         throw IllegalArgumentException();
3098 
3099     const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
3100     bool bIsSwSrcView = false;
3101     SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
3102 
3103     // error handling - avoid crash
3104     if ( !bIsSwSrcView && m_pRenderData == NULL )
3105     {
3106         DBG_ASSERT( false, "data should have been created already in getRendererCount..." );
3107         m_pRenderData = new SwRenderData;
3108     }
3109     if ( m_pPrintUIOptions == 0 )
3110     {
3111         DBG_ASSERT( false, "data should have been created already in getRendererCount..." );
3112         m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
3113     }
3114 
3115     m_pPrintUIOptions->processProperties( rxOptions );
3116     const bool bPrintProspect   = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
3117     const bool bLastPage        = m_pPrintUIOptions->getBoolValue( "IsLastPage", sal_False );
3118 
3119     SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
3120     DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
3121     if (pDoc && pView)
3122     {
3123         sal_Int32 nMaxRenderer = 0;
3124         if (!bIsSwSrcView)
3125         {
3126             DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" );
3127             nMaxRenderer = bPrintProspect?
3128                 m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 :
3129                 m_pRenderData->GetPagesToPrint().size() - 1;
3130         }
3131         // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print
3132         // we obmit checking of the upper bound in this case.
3133         if (bIsSwSrcView || nRenderer <= nMaxRenderer)
3134         {
3135             if (bIsSwSrcView)
3136             {
3137                 SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView);
3138                 OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
3139                 pSwSrcView->PrintSource( pOutDev, nRenderer + 1, false );
3140             }
3141             else
3142             {
3143                 // the view shell should be SwView for documents PDF export
3144                 // or SwPagePreView for PDF export of the page preview
3145                 //!! (check for SwView first as in GuessViewShell) !!
3146                 DBG_ASSERT( pView, "!! view missing !!" );
3147                 const TypeId aSwViewTypeId = TYPE(SwView);
3148                 ViewShell* pVwSh = 0;
3149                 if (pView)
3150                 {
3151                     // TODO/mba: we really need a generic way to get the ViewShell!
3152                     SwView* pSwView = PTR_CAST(SwView, pView);
3153                     if ( pSwView )
3154                         pVwSh = pSwView->GetWrtShellPtr();
3155                     else
3156                         pVwSh = ((SwPagePreView*)pView)->GetViewShell();
3157                 }
3158 
3159                 // get output device to use
3160                 OutputDevice * pOut = lcl_GetOutputDevice( *m_pPrintUIOptions );
3161 
3162                 if(pVwSh && pOut && m_pRenderData->HasSwPrtOptions())
3163                 {
3164                     const rtl::OUString aPageRange  = m_pPrintUIOptions->getStringValue( "PageRange", OUString() );
3165                     const bool bFirstPage           = m_pPrintUIOptions->getBoolValue( "IsFirstPage", sal_False );
3166                     bool bIsSkipEmptyPages          = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport );
3167 
3168                     DBG_ASSERT(( pView->IsA(aSwViewTypeId) &&  m_pRenderData->IsViewOptionAdjust())
3169                             || (!pView->IsA(aSwViewTypeId) && !m_pRenderData->IsViewOptionAdjust()),
3170                             "SwView / SwViewOptionAdjust_Impl availability mismatch" );
3171 
3172                     // since printing now also use the API for PDF export this option
3173                     // should be set for printing as well ...
3174                     pVwSh->SetPDFExportOption( sal_True );
3175 
3176                     // --> FME 2004-06-08 #i12836# enhanced pdf export
3177                     //
3178                     // First, we have to export hyperlinks, notes, and outline to pdf.
3179                     // During this process, additional information required for tagging
3180                     // the pdf file are collected, which are evaulated during painting.
3181                     //
3182                     SwWrtShell* pWrtShell = pView->IsA(aSwViewTypeId) ?
3183                                             ((SwView*)pView)->GetWrtShellPtr() :
3184                                             0;
3185 
3186                     if (bIsPDFExport && bFirstPage && pWrtShell)
3187                     {
3188                         SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages, sal_False );
3189                     }
3190                     // <--
3191 
3192                     SwPrintData const& rSwPrtOptions =
3193                         *m_pRenderData->GetSwPrtOptions();
3194                     if (bPrintProspect)
3195                         pVwSh->PrintProspect( pOut, rSwPrtOptions, nRenderer );
3196                     else    // normal printing and PDF export
3197                         pVwSh->PrintOrPDFExport( pOut, rSwPrtOptions, nRenderer );
3198 
3199                     // After printing the last page, we take care for the links coming
3200                     // from the EditEngine. The links are generated during the painting
3201                     // process, but the destinations are still missing.
3202                     //
3203                     if (bIsPDFExport && bLastPage && pWrtShell)
3204                     {
3205                         SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages,  sal_True );
3206                     }
3207 
3208                     pVwSh->SetPDFExportOption( sal_False );
3209                 }
3210             }
3211         }
3212     }
3213     // last page to be rendered? (not necessarily the last page of the document)
3214     // -> do clean-up of data
3215     if ( bLastPage )
3216     {
3217         CleanUpRenderingData();
3218     }
3219 }
3220 /* -----------------------------03.10.04 -------------------------------------
3221 
3222  ---------------------------------------------------------------------------*/
3223     // xforms::XFormsSupplier
getXForms()3224 Reference<XNameContainer> SAL_CALL SwXTextDocument::getXForms()
3225     throw( RuntimeException )
3226 {
3227     if ( !pDocShell )
3228         throw DisposedException( ::rtl::OUString(), static_cast< XTextDocument* >( this ) );
3229     SwDoc* pDoc = pDocShell->GetDoc();
3230     return pDoc->getXForms();
3231 }
3232 
3233 /* -----------------------------25.09.07 -------------------------------------
3234 
3235  ---------------------------------------------------------------------------*/
getFlatParagraphIterator(::sal_Int32 nTextMarkupType,sal_Bool bAutomatic)3236 uno::Reference< text::XFlatParagraphIterator > SAL_CALL SwXTextDocument::getFlatParagraphIterator(::sal_Int32 nTextMarkupType, sal_Bool bAutomatic)
3237     throw ( uno::RuntimeException )
3238 {
3239     return new SwXFlatParagraphIterator( *pDocShell->GetDoc(), nTextMarkupType, bAutomatic );
3240 }
3241 /*-- 07.05.2009 09:21:12---------------------------------------------------
3242 
3243   -----------------------------------------------------------------------*/
createClone()3244 uno::Reference< util::XCloneable > SwXTextDocument::createClone(  ) throw (uno::RuntimeException)
3245 {
3246     ::vos::OGuard aGuard(Application::GetSolarMutex());
3247     if(!IsValid())
3248         throw RuntimeException();
3249 
3250     // create a new document - hidden - copy the storage and return it
3251     // SfxObjectShellRef is used here, since the model should control object lifetime after creation
3252     // and thus SfxObjectShellLock is not allowed here
3253     // the model holds reference to the shell, so the shell will not destructed at the end of method
3254     SfxObjectShellRef pShell = pDocShell->GetDoc()->CreateCopy(false);
3255     uno::Reference< frame::XModel > xNewModel = pShell->GetModel();
3256     uno::Reference< embed::XStorage > xNewStorage = ::comphelper::OStorageHelper::GetTemporaryStorage( );
3257     uno::Sequence< beans::PropertyValue > aTempMediaDescriptor;
3258     storeToStorage( xNewStorage, aTempMediaDescriptor );
3259     uno::Reference< document::XStorageBasedDocument > xStorageDoc( xNewModel, uno::UNO_QUERY );
3260     xStorageDoc->loadFromStorage( xNewStorage, aTempMediaDescriptor );
3261     return uno::Reference< util::XCloneable >( xNewModel, UNO_QUERY );
3262 }
3263 /* -----------------------------20.06.00 09:54--------------------------------
3264 
3265  ---------------------------------------------------------------------------*/
operator new(size_t t)3266 void * SAL_CALL SwXTextDocument::operator new( size_t t) throw()
3267 {
3268 	return SwXTextDocumentBaseClass::operator new(t);
3269 }
3270 /* -----------------------------20.06.00 09:54--------------------------------
3271 
3272  ---------------------------------------------------------------------------*/
operator delete(void * p)3273 void SAL_CALL SwXTextDocument::operator delete( void * p) throw()
3274 {
3275 	SwXTextDocumentBaseClass::operator delete(p);
3276 }
3277 
3278 
3279 /*---------------------------------------------------
3280 retrieve languages already used in current document
3281 -----------------------------------------------------*/
getDocumentLanguages(::sal_Int16 nScriptTypes,::sal_Int16 nMaxCount)3282 uno::Sequence< lang::Locale > SAL_CALL SwXTextDocument::getDocumentLanguages(
3283         ::sal_Int16 nScriptTypes,
3284         ::sal_Int16 nMaxCount )
3285     throw (lang::IllegalArgumentException, uno::RuntimeException)
3286 {
3287 	::vos::OGuard aGuard(Application::GetSolarMutex());
3288 
3289     // possible canonical values for nScriptTypes
3290     // any bit wise combination is allowed
3291     const sal_Int16 nLatin   = 0x001;
3292     const sal_Int16 nAsian   = 0x002;
3293     const sal_Int16 nComplex = 0x004;
3294 
3295     // script types for which to get the languages
3296     const bool bLatin   = 0 != (nScriptTypes & nLatin);
3297     const bool bAsian   = 0 != (nScriptTypes & nAsian);
3298     const bool bComplex = 0 != (nScriptTypes & nComplex);
3299 
3300     if (nScriptTypes < nLatin || nScriptTypes > (nLatin | nAsian | nComplex))
3301         throw IllegalArgumentException(::rtl::OUString::createFromAscii("nScriptTypes ranges from 1 to 7!"), Reference< XInterface >(), 1);
3302     if (!pDocShell)
3303         throw DisposedException();
3304     SwDoc* pDoc = pDocShell->GetDoc();
3305 
3306     // avoid duplicate values
3307     std::set< LanguageType > aAllLangs;
3308 
3309 	//USER STYLES
3310 
3311 	const SwCharFmts *pFmts = pDoc->GetCharFmts();
3312     for(sal_uInt16 i = 0; i < pFmts->Count(); ++i)
3313     {
3314         const SwAttrSet &rAttrSet = (*pFmts)[i]->GetAttrSet();
3315         LanguageType nLang = LANGUAGE_DONTKNOW;
3316         if (bLatin)
3317         {
3318             nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage();
3319             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3320                 aAllLangs.insert( nLang );
3321         }
3322         if (bAsian)
3323         {
3324             nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage();
3325             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3326                 aAllLangs.insert( nLang );
3327         }
3328         if (bComplex)
3329         {
3330             nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage();
3331             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3332                 aAllLangs.insert( nLang );
3333         }
3334 	}
3335 
3336     const SwTxtFmtColls *pColls = pDoc->GetTxtFmtColls();
3337     for (sal_uInt16 i = 0; i < pColls->Count(); ++i)
3338     {
3339         const SwAttrSet &rAttrSet = (*pColls)[i]->GetAttrSet();
3340         LanguageType nLang = LANGUAGE_DONTKNOW;;
3341         if (bLatin)
3342         {
3343             nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage();
3344             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3345                 aAllLangs.insert( nLang );
3346         }
3347         if (bAsian)
3348         {
3349             nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage();
3350             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3351                 aAllLangs.insert( nLang );
3352         }
3353         if (bComplex)
3354         {
3355             nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage();
3356             if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3357                 aAllLangs.insert( nLang );
3358         }
3359 	}
3360 
3361     //AUTO STYLES
3362     const IStyleAccess::SwAutoStyleFamily aFam[2] =
3363     {
3364       IStyleAccess::AUTO_STYLE_CHAR,
3365       IStyleAccess::AUTO_STYLE_PARA
3366     };
3367     for (sal_uInt16 i = 0; i < 2; ++i)
3368 	{
3369         std::vector< SfxItemSet_Pointer_t > rStyles;
3370         pDoc->GetIStyleAccess().getAllStyles(rStyles, aFam[i]);
3371         while (!rStyles.empty())
3372         {
3373             SfxItemSet_Pointer_t pStyle = rStyles.back();
3374 			rStyles.pop_back();
3375 			const SfxItemSet *pSet = dynamic_cast< const SfxItemSet * >(pStyle.get());
3376 
3377             LanguageType nLang = LANGUAGE_DONTKNOW;
3378             if (bLatin)
3379             {
3380                 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_LANGUAGE, sal_False )).GetLanguage();
3381                 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3382                     aAllLangs.insert( nLang );
3383             }
3384             if (bAsian)
3385             {
3386                 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CJK_LANGUAGE, sal_False )).GetLanguage();
3387                 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3388                     aAllLangs.insert( nLang );
3389             }
3390             if (bComplex)
3391             {
3392                 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CTL_LANGUAGE, sal_False )).GetLanguage();
3393                 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3394                     aAllLangs.insert( nLang );
3395             }
3396 	    }
3397 	}
3398 
3399     //TODO/mba: it's a strange concept that a view is needed to retrieve core data
3400 	SwWrtShell *pWrtSh = pDocShell->GetWrtShell();
3401     SdrView	*pSdrView = pWrtSh->GetDrawView();
3402 
3403     if( pSdrView )
3404 	{
3405 		SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner();
3406 		if(pOutliner)
3407 		{
3408 			EditEngine& rEditEng = (EditEngine&)pOutliner->GetEditEngine();
3409 			sal_uLong nParCount = pOutliner->GetParagraphCount();
3410 			for (sal_uLong nPar=0; nPar<nParCount; nPar++)
3411 			{
3412 				//every paragraph
3413 				SvUShorts aPortions;
3414 				rEditEng.GetPortions( (sal_uInt16)nPar, aPortions );
3415 
3416 				for ( sal_uInt16 nPos = aPortions.Count(); nPos; )
3417 				{
3418 					//every position
3419 					--nPos;
3420 					sal_uInt16 nEnd = aPortions.GetObject( nPos );
3421 					sal_uInt16 nStart = nPos ? aPortions.GetObject( nPos - 1 ) : 0;
3422 					ESelection aSelection( (sal_uInt16)nPar, nStart, (sal_uInt16)nPar, nEnd );
3423 					SfxItemSet aAttr = rEditEng.GetAttribs( aSelection );
3424 
3425 					LanguageType nLang = LANGUAGE_DONTKNOW;
3426                     if (bLatin)
3427                     {
3428                         nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE, sal_False )).GetLanguage();
3429                         if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3430                             aAllLangs.insert( nLang );
3431                     }
3432                     if (bAsian)
3433                     {
3434                         nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CJK, sal_False )).GetLanguage();
3435                         if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3436                             aAllLangs.insert( nLang );
3437                     }
3438                     if (bComplex)
3439                     {
3440                         nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CTL, sal_False )).GetLanguage();
3441                         if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3442                             aAllLangs.insert( nLang );
3443                     }
3444 				}
3445 			}
3446 		}
3447 	}
3448     // less than nMaxCount languages
3449     if (nMaxCount > static_cast< sal_Int16 >( aAllLangs.size() ))
3450         nMaxCount = static_cast< sal_Int16 >( aAllLangs.size() );
3451 
3452     // build return value
3453     sal_Int32 nCount = 0;
3454     uno::Sequence< lang::Locale > aLanguages( nMaxCount );
3455     lang::Locale* pLanguage = aLanguages.getArray();
3456     if (nMaxCount > 0)
3457 	{
3458         const SvtLanguageTable aLangTab;
3459         for (std::set< LanguageType >::const_iterator it = aAllLangs.begin(); it != aAllLangs.end(); ++it)
3460         {
3461             if (nCount >= nMaxCount)
3462                 break;
3463             if (LANGUAGE_NONE != *it)
3464 		    {
3465                 MsLangId::convertLanguageToLocale( *it, pLanguage[nCount] );
3466                 pLanguage[nCount].Language = aLangTab.GetString( *it );
3467                 nCount += 1;
3468 			}
3469         }
3470 	}
3471 
3472 	return aLanguages;
3473 }
3474 
3475 // #121125#, #122868#
3476 // method to assure clean up of the rendering data to restore view options
3477 // and to loose hold reference to the ViewShell in SwViewOptionAdjust_Impl.
3478 // also perform clean up for the still existing hidden frame for PDF export from Page Preview
CleanUpRenderingData()3479 void SwXTextDocument::CleanUpRenderingData()
3480 {
3481     if( m_pRenderData != NULL )
3482     {
3483         if ( m_pRenderData->HasPostItData() )
3484         {
3485             m_pRenderData->DeletePostItData();
3486         }
3487         delete m_pRenderData;
3488         m_pRenderData = NULL;
3489     }
3490 
3491     if( m_pPrintUIOptions != NULL )
3492     {
3493         delete m_pPrintUIOptions;
3494         m_pPrintUIOptions = NULL;
3495     }
3496 
3497     if ( IsValid() && m_pHiddenViewFrame )
3498     {
3499         lcl_DisposeView( m_pHiddenViewFrame, pDocShell);
3500         m_pHiddenViewFrame = 0;
3501         SfxItemSet *pSet = pDocShell->GetMedium()->GetItemSet();
3502         pSet->Put( SfxBoolItem( SID_HIDDEN, sal_False ) );
3503     }
3504 }
3505 
3506 /* -----------------25.10.99 11:06-------------------
3507 
3508  --------------------------------------------------*/
SwXLinkTargetSupplier(SwXTextDocument & rxDoc)3509 SwXLinkTargetSupplier::SwXLinkTargetSupplier(SwXTextDocument& rxDoc) :
3510 	pxDoc(&rxDoc)
3511 {
3512 	sTables 	= String(SW_RES(STR_CONTENT_TYPE_TABLE));
3513 	sFrames     = String(SW_RES(STR_CONTENT_TYPE_FRAME));
3514 	sGraphics	= String(SW_RES(STR_CONTENT_TYPE_GRAPHIC));
3515 	sOLEs		= String(SW_RES(STR_CONTENT_TYPE_OLE));
3516 	sSections	= String(SW_RES(STR_CONTENT_TYPE_REGION));
3517 	sOutlines	= String(SW_RES(STR_CONTENT_TYPE_OUTLINE));
3518 	sBookmarks  = String(SW_RES(STR_CONTENT_TYPE_BOOKMARK));
3519 }
3520 /* -----------------25.10.99 11:11-------------------
3521 
3522  --------------------------------------------------*/
~SwXLinkTargetSupplier()3523 SwXLinkTargetSupplier::~SwXLinkTargetSupplier()
3524 {
3525 }
3526 
3527 /*-- 25.10.99 11:12:45---------------------------------------------------
3528 
3529   -----------------------------------------------------------------------*/
getByName(const OUString & rName)3530 Any SwXLinkTargetSupplier::getByName(const OUString& rName)
3531 	throw( NoSuchElementException, WrappedTargetException, RuntimeException )
3532 {
3533 	Any aRet;
3534 	if(!pxDoc)
3535 		throw RuntimeException();
3536 	String sToCompare(rName);
3537 	String sSuffix('|');
3538 	if(sToCompare == sTables)
3539 	{
3540 		sSuffix += UniString::CreateFromAscii(pMarkToTable);
3541 
3542 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3543 										pxDoc->getTextTables(), sToCompare, sSuffix );
3544 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3545 		aRet.setValue(&xRet, ::getCppuType((Reference<XPropertySet>*)0));
3546 	}
3547 	else if(sToCompare == sFrames)
3548 	{
3549 		sSuffix += UniString::CreateFromAscii(pMarkToFrame);
3550 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3551 										pxDoc->getTextFrames(), sToCompare, sSuffix );
3552 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3553 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3554 	}
3555 	else if(sToCompare == sSections)
3556 	{
3557 		sSuffix += UniString::CreateFromAscii(pMarkToRegion);
3558 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3559 										pxDoc->getTextSections(), sToCompare, sSuffix );
3560 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3561 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3562 	}
3563 /*	else if(sToCompare == )
3564 	{
3565 		sSuffix += UniString::CreateFromAscii(pMarkToText);
3566 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3567 										pxDoc->, sSuffix );
3568 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3569 		aRet.setValue(&xRet, ::getCppuType((const XPropertySet*)0));
3570 	}*/
3571 	else if(sToCompare == sGraphics)
3572 	{
3573 		sSuffix += UniString::CreateFromAscii(pMarkToGraphic);
3574 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3575 										pxDoc->getGraphicObjects(), sToCompare, sSuffix );
3576 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3577 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3578 	}
3579 	else if(sToCompare == sOLEs)
3580 	{
3581 		sSuffix += UniString::CreateFromAscii(pMarkToOLE);
3582 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3583 										pxDoc->getEmbeddedObjects(), sToCompare, sSuffix );
3584 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3585 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3586 	}
3587 	else if(sToCompare == sOutlines)
3588 	{
3589 		sSuffix += UniString::CreateFromAscii(pMarkToOutline);
3590 		Reference< XNameAccess >  xTbls = new SwXLinkNameAccessWrapper(
3591 										*pxDoc, sToCompare, sSuffix );
3592 		Reference< XPropertySet >  xRet(xTbls, UNO_QUERY);
3593 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3594 	}
3595 	else if(sToCompare == sBookmarks)
3596 	{
3597 		sSuffix.Erase();
3598 		Reference< XNameAccess >  xBkms = new SwXLinkNameAccessWrapper(
3599 										pxDoc->getBookmarks(), sToCompare, sSuffix );
3600 		Reference< XPropertySet >  xRet(xBkms, UNO_QUERY);
3601 		aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3602 	}
3603 	else
3604 		throw NoSuchElementException();
3605 	return aRet;
3606 }
3607 /*-- 25.10.99 11:12:46---------------------------------------------------
3608 
3609   -----------------------------------------------------------------------*/
getElementNames(void)3610 Sequence< OUString > SwXLinkTargetSupplier::getElementNames(void)
3611 										throw( RuntimeException )
3612 {
3613 	Sequence< OUString > aRet(7);
3614 	OUString* pNames = aRet.getArray();
3615 	pNames[0] = sTables;
3616 	pNames[1] = sFrames  ;
3617 	pNames[2] = sGraphics;
3618 	pNames[3] = sOLEs	;
3619 	pNames[4] = sSections;
3620 	pNames[5] = sOutlines;
3621 	pNames[6] = sBookmarks;
3622 	return aRet;
3623 }
3624 /*-- 25.10.99 11:12:46---------------------------------------------------
3625 
3626   -----------------------------------------------------------------------*/
hasByName(const OUString & rName)3627 sal_Bool SwXLinkTargetSupplier::hasByName(const OUString& rName)
3628 									throw( RuntimeException )
3629 {
3630 	String sToCompare(rName);
3631 	if(	sToCompare == sTables  ||
3632 		sToCompare == sFrames  ||
3633 		sToCompare == sGraphics||
3634 		sToCompare == sOLEs	  ||
3635 		sToCompare == sSections ||
3636 		sToCompare == sOutlines ||
3637 		sToCompare == sBookmarks	)
3638 		return sal_True;
3639 	return sal_False;
3640 }
3641 /*-- 25.10.99 11:12:47---------------------------------------------------
3642 
3643   -----------------------------------------------------------------------*/
getElementType(void)3644 uno::Type  SwXLinkTargetSupplier::getElementType(void)
3645 									throw( RuntimeException )
3646 {
3647 	return ::getCppuType((Reference< XPropertySet>*)0);
3648 
3649 }
3650 /*-- 25.10.99 11:12:47---------------------------------------------------
3651 
3652   -----------------------------------------------------------------------*/
hasElements(void)3653 sal_Bool SwXLinkTargetSupplier::hasElements(void) throw( RuntimeException )
3654 {
3655 	return 0 != pxDoc;
3656 }
3657 /*-- 25.10.99 11:12:47---------------------------------------------------
3658 
3659   -----------------------------------------------------------------------*/
getImplementationName(void)3660 OUString SwXLinkTargetSupplier::getImplementationName(void) throw( RuntimeException )
3661 {
3662 	return C2U("SwXLinkTargetSupplier");
3663 }
3664 /*-- 25.10.99 11:12:48---------------------------------------------------
3665 
3666   -----------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)3667 sal_Bool SwXLinkTargetSupplier::supportsService(const OUString& rServiceName)
3668 												throw( RuntimeException )
3669 {
3670 	return (rServiceName == C2U("com.sun.star.document.LinkTargets"));
3671 }
3672 /*-- 25.10.99 11:12:48---------------------------------------------------
3673 
3674   -----------------------------------------------------------------------*/
getSupportedServiceNames(void)3675 Sequence< OUString > SwXLinkTargetSupplier::getSupportedServiceNames(void)
3676 												throw( RuntimeException )
3677 {
3678 	Sequence< OUString > aRet(1);
3679 	OUString* pNames = aRet.getArray();
3680 	pNames[0] = C2U("com.sun.star.document.LinkTargets");
3681 	return aRet;
3682 }
3683 
3684 /*-- 26.10.99 09:16:23---------------------------------------------------
3685 
3686   -----------------------------------------------------------------------*/
SwXLinkNameAccessWrapper(Reference<XNameAccess> xAccess,const String & rLinkDisplayName,String sSuffix)3687 SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper(
3688 			Reference< XNameAccess >  xAccess, const String& rLinkDisplayName, String sSuffix ) :
3689     xRealAccess(xAccess),
3690     pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
3691     sLinkSuffix(sSuffix),
3692 	sLinkDisplayName(rLinkDisplayName),
3693 	pxDoc(0)
3694 {
3695 }
3696 /* -----------------26.10.99 14:17-------------------
3697 
3698  --------------------------------------------------*/
SwXLinkNameAccessWrapper(SwXTextDocument & rxDoc,const String & rLinkDisplayName,String sSuffix)3699 SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper(SwXTextDocument& rxDoc,
3700 			const String& rLinkDisplayName, String sSuffix) :
3701     pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
3702 	sLinkSuffix(sSuffix),
3703 	sLinkDisplayName(rLinkDisplayName),
3704     xDoc(&rxDoc),
3705     pxDoc(&rxDoc)
3706 {
3707 }
3708 /*-- 26.10.99 09:16:23---------------------------------------------------
3709 
3710   -----------------------------------------------------------------------*/
~SwXLinkNameAccessWrapper()3711 SwXLinkNameAccessWrapper::~SwXLinkNameAccessWrapper()
3712 {
3713 }
3714 /*-- 26.10.99 09:16:24---------------------------------------------------
3715 
3716   -----------------------------------------------------------------------*/
getByName(const OUString & rName)3717 Any SwXLinkNameAccessWrapper::getByName(const OUString& rName)
3718 	throw( NoSuchElementException, WrappedTargetException, RuntimeException )
3719 {
3720 	Any aRet;
3721 	sal_Bool bFound = sal_False;
3722 	//cut link extension and call the real NameAccess
3723 	String sParam = rName;
3724 	String sSuffix(sLinkSuffix);
3725 	if(sParam.Len() > sSuffix.Len() )
3726 	{
3727 		String sCmp = sParam.Copy(sParam.Len() - sSuffix.Len(),
3728 													sSuffix.Len());
3729 		if(sCmp == sSuffix)
3730 		{
3731 			if(pxDoc)
3732 			{
3733 				sParam = sParam.Copy(0, sParam.Len() - sSuffix.Len());
3734 				if(!pxDoc->GetDocShell())
3735 					throw RuntimeException();
3736 				SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3737 				sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count();
3738 
3739 				for (sal_uInt16 i = 0; i < nOutlineCount && !bFound; ++i)
3740 				{
3741                     const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3742                     const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3743                     if(sParam ==
3744                         lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule))
3745 					{
3746 						Reference< XPropertySet >  xOutline = new SwXOutlineTarget(sParam);
3747 						aRet.setValue(&xOutline, ::getCppuType((Reference<XPropertySet>*)0));
3748 						bFound = sal_True;
3749 					}
3750 				}
3751 			}
3752 			else
3753 			{
3754 				aRet = xRealAccess->getByName(sParam.Copy(0, sParam.Len() - sSuffix.Len()));
3755                 Reference< XInterface > xInt;
3756                 if(!(aRet >>= xInt))
3757 					throw RuntimeException();
3758                 Reference< XPropertySet >  xProp(xInt, UNO_QUERY);
3759                 aRet <<= xProp;
3760 				bFound = sal_True;
3761 			}
3762 		}
3763 	}
3764 	if(!bFound)
3765 		throw NoSuchElementException();
3766 	return aRet;
3767 }
3768 /*-- 26.10.99 09:16:24---------------------------------------------------
3769 
3770   -----------------------------------------------------------------------*/
getElementNames(void)3771 Sequence< OUString > SwXLinkNameAccessWrapper::getElementNames(void)
3772 									throw( RuntimeException )
3773 {
3774 	Sequence< OUString > aRet;
3775 	if(pxDoc)
3776 	{
3777 		if(!pxDoc->GetDocShell())
3778 			throw RuntimeException();
3779 
3780 		SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3781         const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3782         sal_uInt16 nOutlineCount = rOutlineNodes.Count();
3783 		aRet.realloc(nOutlineCount);
3784 		OUString* pResArr = aRet.getArray();
3785 		String sSuffix('|');
3786 		sSuffix += UniString::CreateFromAscii(pMarkToOutline);
3787         const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3788         for (sal_uInt16 i = 0; i < nOutlineCount; ++i)
3789 		{
3790             String sEntry = lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule);
3791 			sEntry += sSuffix;
3792 			pResArr[i] = sEntry;
3793 		}
3794 	}
3795 	else
3796 	{
3797 		Sequence< OUString > aOrg = xRealAccess->getElementNames();
3798 		const OUString* pOrgArr = aOrg.getConstArray();
3799 		aRet.realloc(aOrg.getLength());
3800 		OUString* pResArr = aRet.getArray();
3801 		for(long i = 0; i < aOrg.getLength(); i++)
3802 		{
3803 			pResArr[i] = pOrgArr[i] + sLinkSuffix;
3804 		}
3805 	}
3806 	return aRet;
3807 }
3808 /*-- 26.10.99 09:16:25---------------------------------------------------
3809 
3810   -----------------------------------------------------------------------*/
hasByName(const OUString & rName)3811 sal_Bool SwXLinkNameAccessWrapper::hasByName(const OUString& rName)
3812 	throw( RuntimeException )
3813 {
3814 	sal_Bool bRet = sal_False;
3815 	String sParam(rName);
3816 	if(sParam.Len() > sLinkSuffix.Len() )
3817 	{
3818 		String sCmp = sParam.Copy(sParam.Len() - sLinkSuffix.Len(),
3819 													sLinkSuffix.Len());
3820 		if(sCmp == sLinkSuffix)
3821 		{
3822 				sParam = sParam.Copy(0, sParam.Len() - sLinkSuffix.Len());
3823 			if(pxDoc)
3824 			{
3825 				if(!pxDoc->GetDocShell())
3826 					throw RuntimeException();
3827 				SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3828 				sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count();
3829 
3830 				for (sal_uInt16 i = 0; i < nOutlineCount && !bRet; ++i)
3831 				{
3832                     const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3833                     const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3834                     if(sParam ==
3835                         lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule))
3836                     {
3837 						bRet = sal_True;
3838 					}
3839 				}
3840 			}
3841 			else
3842 			{
3843 				bRet = xRealAccess->hasByName(sParam);
3844 			}
3845 		}
3846 	}
3847 	return bRet;
3848 }
3849 /*-- 26.10.99 09:16:25---------------------------------------------------
3850 
3851   -----------------------------------------------------------------------*/
getElementType(void)3852 uno::Type  SwXLinkNameAccessWrapper::getElementType(void)
3853 								throw( RuntimeException )
3854 {
3855 	return ::getCppuType((Reference<XPropertySet>*)0);
3856 }
3857 /*-- 26.10.99 09:16:25---------------------------------------------------
3858 
3859   -----------------------------------------------------------------------*/
hasElements(void)3860 sal_Bool SwXLinkNameAccessWrapper::hasElements(void) throw( RuntimeException )
3861 {
3862 	sal_Bool bRet = sal_False;
3863 	if(pxDoc)
3864 	{
3865 		DBG_ERROR("not implemented");
3866 	}
3867 	else
3868 	{
3869 		bRet = xRealAccess->hasElements();
3870 	}
3871 	return bRet;
3872 }
3873 /*-- 26.10.99 09:16:26---------------------------------------------------
3874 
3875   -----------------------------------------------------------------------*/
getPropertySetInfo(void)3876 Reference< XPropertySetInfo >  SwXLinkNameAccessWrapper::getPropertySetInfo(void)
3877 										throw( RuntimeException )
3878 {
3879     static Reference< XPropertySetInfo >  xRet = pPropSet->getPropertySetInfo();
3880 	return xRet;
3881 }
3882 /*-- 26.10.99 09:16:26---------------------------------------------------
3883 
3884   -----------------------------------------------------------------------*/
setPropertyValue(const OUString &,const Any &)3885 void SwXLinkNameAccessWrapper::setPropertyValue(
3886     const OUString& , const Any& )
3887 	throw( UnknownPropertyException,
3888 			PropertyVetoException,
3889 			IllegalArgumentException,
3890  			WrappedTargetException,
3891 			RuntimeException)
3892 {
3893 	throw UnknownPropertyException();
3894 }
3895 /* -----------------------------08.12.99 11:10--------------------------------
3896 
3897  ---------------------------------------------------------------------------*/
lcl_GetDisplayBitmap(String sLinkSuffix)3898 Any lcl_GetDisplayBitmap(String sLinkSuffix)
3899 {
3900 	Any aRet;
3901 	if(sLinkSuffix.Len())
3902 		sLinkSuffix.Erase(0, 1);
3903 	sal_uInt16 nImgId = USHRT_MAX;
3904 
3905 	if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOutline))
3906 		nImgId = CONTENT_TYPE_OUTLINE;
3907 	else if(COMPARE_EQUAL  == sLinkSuffix.CompareToAscii(pMarkToTable))
3908 		nImgId = CONTENT_TYPE_TABLE;
3909 	else if(COMPARE_EQUAL  == sLinkSuffix.CompareToAscii(pMarkToFrame))
3910 		nImgId = CONTENT_TYPE_FRAME;
3911 	else if(COMPARE_EQUAL  == sLinkSuffix.CompareToAscii(pMarkToGraphic))
3912 		nImgId = CONTENT_TYPE_GRAPHIC;
3913 //	else if(== sLinkSuffix)
3914 //		nImgId = CONTENT_TYPE_BOOKMARK;
3915 	else if(COMPARE_EQUAL  == sLinkSuffix.CompareToAscii(pMarkToRegion))
3916 		nImgId = CONTENT_TYPE_REGION;
3917 	else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOLE))
3918 		nImgId = CONTENT_TYPE_OLE;
3919 	else if(!sLinkSuffix.Len())
3920 		nImgId = CONTENT_TYPE_BOOKMARK;
3921 	if(USHRT_MAX != nImgId)
3922 	{
3923 		nImgId += 20000;
3924         sal_Bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
3925         ImageList aEntryImages( SW_RES(bHighContrast ? IMG_NAVI_ENTRYBMPH : IMG_NAVI_ENTRYBMP) );
3926 		const Image& rImage = aEntryImages.GetImage( nImgId );
3927         Bitmap aBitmap( rImage.GetBitmapEx().GetBitmap() );
3928 		Reference<awt::XBitmap> xBmp = VCLUnoHelper::CreateBitmap( aBitmap );
3929 		aRet.setValue( &xBmp, ::getCppuType((Reference<awt::XBitmap>*)0) );
3930 	}
3931 	return aRet;
3932 }
3933 /*-- 26.10.99 09:16:27---------------------------------------------------
3934 
3935   -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)3936 Any SwXLinkNameAccessWrapper::getPropertyValue(const OUString& rPropertyName)
3937 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3938 {
3939 	Any aRet;
3940 	if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
3941 	{
3942 		aRet <<= OUString(sLinkDisplayName);
3943 	}
3944 	else if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_BITMAP)))
3945 	{
3946 		aRet = lcl_GetDisplayBitmap(sLinkSuffix);
3947 	}
3948 	else
3949 		throw UnknownPropertyException();
3950 	return aRet;
3951 }
3952 /*-- 26.10.99 09:16:27---------------------------------------------------
3953 
3954   -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)3955 void SwXLinkNameAccessWrapper::addPropertyChangeListener(
3956     const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
3957 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3958 {}
3959 /*-- 26.10.99 09:16:28---------------------------------------------------
3960 
3961   -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)3962 void SwXLinkNameAccessWrapper::removePropertyChangeListener(
3963     const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
3964 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3965 {}
3966 /*-- 26.10.99 09:16:28---------------------------------------------------
3967 
3968   -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)3969 void SwXLinkNameAccessWrapper::addVetoableChangeListener(
3970     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
3971 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3972 {}
3973 /*-- 26.10.99 09:16:29---------------------------------------------------
3974 
3975   -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)3976 void SwXLinkNameAccessWrapper::removeVetoableChangeListener(
3977     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
3978 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3979 {}
3980 /*-- 26.10.99 09:16:32---------------------------------------------------
3981 
3982 
3983   -----------------------------------------------------------------------*/
getLinks(void)3984 Reference< XNameAccess >  SwXLinkNameAccessWrapper::getLinks(void)
3985 									throw( RuntimeException )
3986 {
3987 	return (SwXLinkNameAccessWrapper*)this;
3988 }
3989 
3990 /*-- 26.10.99 09:21:48---------------------------------------------------
3991 
3992   -----------------------------------------------------------------------*/
getImplementationName(void)3993 OUString SwXLinkNameAccessWrapper::getImplementationName(void) throw( RuntimeException )
3994 {
3995 	return C2U("SwXLinkNameAccessWrapper");
3996 }
3997 /*-- 26.10.99 09:21:48---------------------------------------------------
3998 
3999   -----------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)4000 sal_Bool SwXLinkNameAccessWrapper::supportsService(const OUString& rServiceName)
4001 													throw( RuntimeException )
4002 {
4003 	return (rServiceName == C2U("com.sun.star.document.LinkTargets"));
4004 }
4005 /*-- 26.10.99 09:21:48---------------------------------------------------
4006 
4007   -----------------------------------------------------------------------*/
getSupportedServiceNames(void)4008 Sequence< OUString > SwXLinkNameAccessWrapper::getSupportedServiceNames(void)
4009 													throw( RuntimeException )
4010 {
4011 	Sequence< OUString > aRet(1);
4012 	OUString* pNames = aRet.getArray();
4013 	pNames[0] = C2U("com.sun.star.document.LinkTargets");
4014 	return aRet;
4015 }
4016 /* -----------------26.10.99 15:50-------------------
4017 
4018  --------------------------------------------------*/
SwXOutlineTarget(const String & rOutlineText)4019 SwXOutlineTarget::SwXOutlineTarget(const String& rOutlineText) :
4020     pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
4021 	sOutlineText(rOutlineText)
4022 {
4023 }
4024 /*-- 26.10.99 15:51:45---------------------------------------------------
4025 
4026   -----------------------------------------------------------------------*/
~SwXOutlineTarget()4027 SwXOutlineTarget::~SwXOutlineTarget()
4028 {
4029 }
4030 /*-- 26.10.99 15:51:46---------------------------------------------------
4031 
4032   -----------------------------------------------------------------------*/
getPropertySetInfo(void)4033 Reference< XPropertySetInfo >  SwXOutlineTarget::getPropertySetInfo(void) throw( RuntimeException )
4034 {
4035     static Reference< XPropertySetInfo >  xRet = pPropSet->getPropertySetInfo();
4036 	return xRet;
4037 }
4038 /*-- 26.10.99 15:51:46---------------------------------------------------
4039 
4040   -----------------------------------------------------------------------*/
setPropertyValue(const OUString &,const Any &)4041 void SwXOutlineTarget::setPropertyValue(
4042     const OUString& /*PropertyName*/, const Any& /*aValue*/)
4043 	throw( UnknownPropertyException, PropertyVetoException,
4044  		IllegalArgumentException, WrappedTargetException, RuntimeException)
4045 {
4046 	throw UnknownPropertyException();
4047 }
4048 /*-- 26.10.99 15:51:46---------------------------------------------------
4049 
4050   -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)4051 Any SwXOutlineTarget::getPropertyValue(const OUString& rPropertyName)
4052 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4053 {
4054 	Any aRet;
4055 	if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
4056 		aRet <<= OUString(sOutlineText);
4057 	else
4058 		throw UnknownPropertyException();
4059 	return aRet;
4060 }
4061 /*-- 26.10.99 15:51:46---------------------------------------------------
4062 
4063   -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)4064 void SwXOutlineTarget::addPropertyChangeListener(
4065     const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
4066 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4067 {
4068 }
4069 /*-- 26.10.99 15:51:47---------------------------------------------------
4070 
4071   -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)4072 void SwXOutlineTarget::removePropertyChangeListener(
4073     const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
4074 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4075 {
4076 }
4077 /*-- 26.10.99 15:51:47---------------------------------------------------
4078 
4079   -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)4080 void SwXOutlineTarget::addVetoableChangeListener(
4081     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
4082 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4083 {
4084 }
4085 /*-- 26.10.99 15:51:47---------------------------------------------------
4086 
4087   -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)4088 void SwXOutlineTarget::removeVetoableChangeListener(
4089     const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
4090 	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4091 {
4092 }
4093 /* -----------------03.05.99 12:28-------------------
4094  *
4095  * --------------------------------------------------*/
getImplementationName(void)4096 OUString SwXOutlineTarget::getImplementationName(void) throw( RuntimeException )
4097 {
4098 	return C2U("SwXOutlineTarget");
4099 }
4100 /* -----------------03.05.99 12:28-------------------
4101  *
4102  * --------------------------------------------------*/
supportsService(const OUString & ServiceName)4103 sal_Bool SwXOutlineTarget::supportsService(const OUString& ServiceName) throw( RuntimeException )
4104 {
4105 	return C2U("com.sun.star.document.LinkTarget") == ServiceName;
4106 }
4107 /* -----------------03.05.99 12:28-------------------
4108  *
4109  * --------------------------------------------------*/
getSupportedServiceNames(void)4110 Sequence< OUString > SwXOutlineTarget::getSupportedServiceNames(void) throw( RuntimeException )
4111 {
4112 	Sequence < OUString > aRet(1);
4113 	OUString* pArray = aRet.getArray();
4114 	pArray[0] = C2U("com.sun.star.document.LinkTarget");
4115 
4116 	return aRet;
4117 }
4118 /* -----------------------------17.01.01 16:06--------------------------------
4119 
4120  ---------------------------------------------------------------------------*/
SwXDocumentPropertyHelper(SwDoc & rDoc)4121 SwXDocumentPropertyHelper::SwXDocumentPropertyHelper(SwDoc& rDoc) :
4122 SvxUnoForbiddenCharsTable ( rDoc.getForbiddenCharacterTable() )
4123 ,m_pDoc(&rDoc)
4124 {
4125 }
4126 /* -----------------------------17.01.01 16:06--------------------------------
4127 
4128  ---------------------------------------------------------------------------*/
~SwXDocumentPropertyHelper()4129 SwXDocumentPropertyHelper::~SwXDocumentPropertyHelper()
4130 {
4131 }
4132 /* -----------------------------17.01.01 16:06--------------------------------
4133 
4134  ---------------------------------------------------------------------------*/
GetDrawTable(short nWhich)4135 Reference<XInterface> SwXDocumentPropertyHelper::GetDrawTable(short nWhich)
4136 {
4137     Reference<XInterface> xRet;
4138     if(m_pDoc)
4139     {
4140         switch(nWhich)
4141         {
4142             // --> OD 2005-08-08 #i52858#
4143             // assure that Draw model is created, if it doesn't exist.
4144             case SW_CREATE_DASH_TABLE         :
4145                 if(!xDashTable.is())
4146                     xDashTable = SvxUnoDashTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4147                 xRet = xDashTable;
4148             break;
4149             case SW_CREATE_GRADIENT_TABLE     :
4150                 if(!xGradientTable.is())
4151                     xGradientTable = SvxUnoGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4152                 xRet = xGradientTable;
4153             break;
4154             case SW_CREATE_HATCH_TABLE        :
4155                 if(!xHatchTable.is())
4156                     xHatchTable = SvxUnoHatchTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4157                 xRet = xHatchTable;
4158             break;
4159             case SW_CREATE_BITMAP_TABLE       :
4160                 if(!xBitmapTable.is())
4161                     xBitmapTable = SvxUnoBitmapTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4162                 xRet = xBitmapTable;
4163             break;
4164             case SW_CREATE_TRANSGRADIENT_TABLE:
4165                 if(!xTransGradientTable.is())
4166                     xTransGradientTable = SvxUnoTransGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4167                 xRet = xTransGradientTable;
4168             break;
4169             case SW_CREATE_MARKER_TABLE       :
4170                 if(!xMarkerTable.is())
4171                     xMarkerTable = SvxUnoMarkerTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4172                 xRet = xMarkerTable;
4173             break;
4174             // <--
4175             case  SW_CREATE_DRAW_DEFAULTS:
4176                 if(!xDrawDefaults.is())
4177                     xDrawDefaults = (cppu::OWeakObject*)new SwSvxUnoDrawPool(m_pDoc);
4178                 xRet = xDrawDefaults;
4179             break;
4180 #ifdef DBG_UTIL
4181             default: DBG_ERROR("which table?");
4182 #endif
4183         }
4184     }
4185     return xRet;
4186 }
4187 
Invalidate()4188 void SwXDocumentPropertyHelper::Invalidate()
4189 {
4190 	xDashTable = 0;
4191 	xGradientTable = 0;
4192 	xHatchTable = 0;
4193 	xBitmapTable = 0;
4194 	xTransGradientTable = 0;
4195 	xMarkerTable = 0;
4196 	xDrawDefaults = 0;
4197 	m_pDoc = 0;
4198 	SvxUnoForbiddenCharsTable::mxForbiddenChars.unbind();
4199 }
4200 /* -----------------13.08.2003 12:43-----------------
4201 
4202  --------------------------------------------------*/
onChange()4203 void SwXDocumentPropertyHelper::onChange()
4204 {
4205     if(m_pDoc)
4206        m_pDoc->SetModified();
4207 }
4208 
4209 
4210 /*****************************************************************************/
4211 
SwViewOptionAdjust_Impl(ViewShell & rSh,const SwViewOption & rViewOptions)4212 SwViewOptionAdjust_Impl::SwViewOptionAdjust_Impl( ViewShell& rSh, const SwViewOption &rViewOptions ) :
4213     m_rShell( rSh ),
4214     m_aOldViewOptions( rViewOptions )
4215 {
4216 }
4217 
4218 
~SwViewOptionAdjust_Impl()4219 SwViewOptionAdjust_Impl::~SwViewOptionAdjust_Impl()
4220 {
4221     m_rShell.ApplyViewOptions( m_aOldViewOptions );
4222 }
4223 
4224 
4225 void
AdjustViewOptions(SwPrintData const * const pPrtOptions)4226 SwViewOptionAdjust_Impl::AdjustViewOptions(SwPrintData const*const pPrtOptions)
4227 {
4228     // to avoid unnecessary reformatting the view options related to the content
4229     // below should only change if necessary, that is if respective content is present
4230     const bool bContainsHiddenChars         = m_rShell.GetDoc()->ContainsHiddenChars();
4231     const SwFieldType* pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENTXTFLD );
4232     const bool bContainsHiddenFields        = pFldType && pFldType->GetDepends();
4233     pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENPARAFLD );
4234     const bool bContainsHiddenParagraphs    = pFldType && pFldType->GetDepends();
4235     pFldType = m_rShell.GetDoc()->GetSysFldType( RES_JUMPEDITFLD );
4236     const bool bContainsPlaceHolders        = pFldType && pFldType->GetDepends();
4237     const bool bContainsFields              = m_rShell.IsAnyFieldInDoc();
4238 
4239     SwViewOption aRenderViewOptions( m_aOldViewOptions );
4240 
4241     // disable anything in the view that should not be printed (or exported to PDF) by default
4242     // (see also dialog "Tools/Options - StarOffice Writer - Formatting Aids"
4243     // in section "Display of ...")
4244     aRenderViewOptions.SetParagraph( sal_False );             // paragraph end
4245     aRenderViewOptions.SetSoftHyph( sal_False );              // aka custom hyphens
4246     aRenderViewOptions.SetBlank( sal_False );                 // spaces
4247     aRenderViewOptions.SetHardBlank( sal_False );             // non-breaking spaces
4248     aRenderViewOptions.SetTab( sal_False );                   // tabs
4249     aRenderViewOptions.SetLineBreak( sal_False );             // breaks (type 1)
4250     aRenderViewOptions.SetPageBreak( sal_False );             // breaks (type 2)
4251     aRenderViewOptions.SetColumnBreak( sal_False );           // breaks (type 3)
4252     sal_Bool bVal = pPrtOptions? pPrtOptions->bPrintHiddenText : sal_False;
4253     if (bContainsHiddenChars)
4254         aRenderViewOptions.SetShowHiddenChar( bVal );     // hidden text
4255     if (bContainsHiddenFields)
4256         aRenderViewOptions.SetShowHiddenField( bVal );
4257     if (bContainsHiddenParagraphs)
4258         aRenderViewOptions.SetShowHiddenPara( bVal );
4259 
4260     if (bContainsPlaceHolders)
4261     {
4262         // should always be printed in PDF export!
4263         bVal = pPrtOptions ? pPrtOptions->bPrintTextPlaceholder : sal_True;
4264         aRenderViewOptions.SetShowPlaceHolderFields( bVal );
4265     }
4266 
4267     if (bContainsFields)
4268         aRenderViewOptions.SetFldName( sal_False );
4269 
4270     // we need to set this flag in order to get to see the visible effect of
4271     // some of the above settings (needed for correct rendering)
4272     aRenderViewOptions.SetViewMetaChars( sal_True );
4273 
4274     if (m_aOldViewOptions != aRenderViewOptions)  // check if reformatting is necessary
4275     {
4276         aRenderViewOptions.SetPrinting( pPrtOptions != NULL );
4277         m_rShell.ApplyViewOptions( aRenderViewOptions );
4278     }
4279 }
4280 
4281 
4282 /*****************************************************************************/
4283 
4284 
4285