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
authorizeLinks(const::rtl::OUString & rURL)2362 sal_Bool SwXTextDocument::authorizeLinks( const ::rtl::OUString& rURL ) throw( RuntimeException )
2363 {
2364 SwDoc *doc = pDocShell->GetDoc();
2365 if ( doc ) {
2366 // The following access to the window is copied from SwDoc::UpdateLinks()
2367 SfxMedium* pMedium = pDocShell->GetMedium();
2368 SfxFrame* pFrm = pMedium ? pMedium->GetLoadTargetFrame() : 0;
2369 sfx2::LinkManager &pLinkMgr = doc->GetLinkManager();
2370 if ( pLinkMgr.urlIsVendor( rURL ) ) {
2371 return sal_False;
2372 } else if ( pLinkMgr.urlIsSafe( rURL ) ) {
2373 return sal_True;
2374 }
2375 Window* pDlgParent = 0;
2376 if ( pFrm )
2377 pDlgParent = &pFrm->GetWindow();
2378 if ( !pDlgParent )
2379 pDlgParent = pDocShell->GetDialogParent( pMedium );
2380 if ( pDlgParent )
2381 return pLinkMgr.GetUserAllowsLinkUpdate( pDlgParent );
2382 }
2383 return sal_False;
2384 }
2385 /* -----------------25.10.99 10:42-------------------
2386
2387 --------------------------------------------------*/
getLinks(void)2388 Reference< XNameAccess > SwXTextDocument::getLinks(void) throw( RuntimeException )
2389 {
2390 if(!pxLinkTargetSupplier)
2391 {
2392 pxLinkTargetSupplier = new Reference< XNameAccess > ;
2393 (*pxLinkTargetSupplier) = new SwXLinkTargetSupplier(*(SwXTextDocument*)this);
2394 }
2395 return (*pxLinkTargetSupplier);
2396 }
2397 /* -----------------------------11.01.01 15:01--------------------------------
2398
2399 ---------------------------------------------------------------------------*/
getRedlines()2400 Reference< XEnumerationAccess > SwXTextDocument::getRedlines( ) throw(RuntimeException)
2401 {
2402 if(!pxXRedlines)
2403 {
2404 pxXRedlines = new Reference< XEnumerationAccess > ;
2405 (*pxXRedlines) = new SwXRedlines(pDocShell->GetDoc());
2406 }
2407 return *pxXRedlines;
2408 }
2409 /*-- 21.02.00 08:41:06---------------------------------------------------
2410
2411 -----------------------------------------------------------------------*/
refresh(void)2412 void SwXTextDocument::refresh(void) throw( RuntimeException )
2413 {
2414 ::vos::OGuard aGuard(Application::GetSolarMutex());
2415 if(!IsValid())
2416 throw RuntimeException();
2417 ViewShell *pViewShell = pDocShell->GetWrtShell();
2418 notifyRefreshListeners();
2419 if(pViewShell)
2420 pViewShell->CalcLayout();
2421 }
2422 /*-- 21.02.00 08:41:06---------------------------------------------------
2423
2424 -----------------------------------------------------------------------*/
addRefreshListener(const Reference<util::XRefreshListener> & l)2425 void SwXTextDocument::addRefreshListener(const Reference< util::XRefreshListener > & l)
2426 throw( RuntimeException )
2427 {
2428 ::vos::OGuard aGuard(Application::GetSolarMutex());
2429 if ( !IsValid() )
2430 throw RuntimeException();
2431 aRefreshCont.AddListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l ));
2432 }
2433 /*-- 21.02.00 08:41:07---------------------------------------------------
2434
2435 -----------------------------------------------------------------------*/
removeRefreshListener(const Reference<util::XRefreshListener> & l)2436 void SwXTextDocument::removeRefreshListener(const Reference< util::XRefreshListener > & l)
2437 throw( RuntimeException )
2438 {
2439 ::vos::OGuard aGuard(Application::GetSolarMutex());
2440 if ( !IsValid() || !aRefreshCont.RemoveListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l ) ) )
2441 throw RuntimeException();
2442 }
2443 /* -----------------------------26.02.01 12:22--------------------------------
2444
2445 ---------------------------------------------------------------------------*/
updateLinks()2446 void SwXTextDocument::updateLinks( ) throw(RuntimeException)
2447 {
2448 ::vos::OGuard aGuard(Application::GetSolarMutex());
2449 if(!IsValid())
2450 throw RuntimeException();
2451 SwDoc* pDoc = pDocShell->GetDoc();
2452 sfx2::LinkManager& rLnkMan = pDoc->GetLinkManager();
2453 if( rLnkMan.GetLinks().Count() )
2454 {
2455 UnoActionContext aAction(pDoc);
2456 rLnkMan.UpdateAllLinks( sal_False, sal_False, sal_True );
2457 }
2458 }
2459 //XPropertyState
getPropertyState(const OUString & rPropertyName)2460 PropertyState SAL_CALL SwXTextDocument::getPropertyState( const OUString& rPropertyName )
2461 throw (UnknownPropertyException, RuntimeException)
2462 {
2463 ::vos::OGuard aGuard(Application::GetSolarMutex());
2464 PropertyState eRet = PropertyState_DIRECT_VALUE;
2465 if(!IsValid())
2466 throw RuntimeException();
2467 const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2468
2469 if(!pEntry)
2470 throw UnknownPropertyException();
2471 Any aAny;
2472 switch(pEntry->nWID)
2473 {
2474 case 0:default:break;
2475 }
2476 return eRet;
2477 }
getPropertyStates(const Sequence<OUString> & rPropertyNames)2478 Sequence< PropertyState > SAL_CALL SwXTextDocument::getPropertyStates( const Sequence< OUString >& rPropertyNames )
2479 throw (UnknownPropertyException, RuntimeException)
2480 {
2481 const sal_Int32 nCount = rPropertyNames.getLength();
2482 const OUString * pNames = rPropertyNames.getConstArray();
2483 Sequence < PropertyState > aRet ( nCount );
2484 PropertyState *pState = aRet.getArray();
2485
2486 for ( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++)
2487 pState[nIndex] = getPropertyState( pNames[nIndex] );
2488
2489 return aRet;
2490 }
setPropertyToDefault(const OUString & rPropertyName)2491 void SAL_CALL SwXTextDocument::setPropertyToDefault( const OUString& rPropertyName )
2492 throw (UnknownPropertyException, RuntimeException)
2493 {
2494 ::vos::OGuard aGuard(Application::GetSolarMutex());
2495 if(!IsValid())
2496 throw RuntimeException();
2497 const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2498 if(!pEntry)
2499 throw UnknownPropertyException();
2500 switch(pEntry->nWID)
2501 {
2502 case 0:default:break;
2503 }
2504 }
getPropertyDefault(const OUString & rPropertyName)2505 Any SAL_CALL SwXTextDocument::getPropertyDefault( const OUString& rPropertyName )
2506 throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
2507 {
2508 ::vos::OGuard aGuard(Application::GetSolarMutex());
2509 if(!IsValid())
2510 throw RuntimeException();
2511 const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName);
2512 if(!pEntry)
2513 throw UnknownPropertyException();
2514 Any aAny;
2515 switch(pEntry->nWID)
2516 {
2517 case 0:default:break;
2518 }
2519 return aAny;
2520 }
2521
lcl_GetOutputDevice(const SwPrintUIOptions & rPrintUIOptions)2522 static OutputDevice * lcl_GetOutputDevice( const SwPrintUIOptions &rPrintUIOptions )
2523 {
2524 OutputDevice *pOut = 0;
2525
2526 uno::Any aAny( rPrintUIOptions.getValue( C2U( "RenderDevice" ) ));
2527 uno::Reference< awt::XDevice > xRenderDevice;
2528 aAny >>= xRenderDevice;
2529 if (xRenderDevice.is())
2530 {
2531 VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice );
2532 pOut = pDevice ? pDevice->GetOutputDevice() : 0;
2533 }
2534
2535 return pOut;
2536 }
2537
2538
lcl_SeqHasProperty(const uno::Sequence<beans::PropertyValue> & rOptions,const sal_Char * pPropName)2539 static bool lcl_SeqHasProperty(
2540 const uno::Sequence< beans::PropertyValue >& rOptions,
2541 const sal_Char *pPropName )
2542 {
2543 bool bRes = false;
2544 const sal_Int32 nLen = rOptions.getLength();
2545 const beans::PropertyValue *pProps = rOptions.getConstArray();
2546 for (sal_Int32 i = 0; i < nLen && !bRes; ++i)
2547 {
2548 if (pProps[i].Name.equalsAscii( pPropName ))
2549 bRes = true;
2550 }
2551 return bRes;
2552 }
2553
2554
GetRenderView(bool & rbIsSwSrcView,const uno::Sequence<beans::PropertyValue> & rOptions,bool bIsPDFExport)2555 SfxViewShell * SwXTextDocument::GetRenderView(
2556 bool &rbIsSwSrcView,
2557 const uno::Sequence< beans::PropertyValue >& rOptions,
2558 bool bIsPDFExport )
2559 {
2560 // get view shell to use
2561 SfxViewShell *pView = 0;
2562 if (bIsPDFExport)
2563 pView = GuessViewShell( rbIsSwSrcView );
2564 else
2565 {
2566 uno::Any aTmp;
2567 const sal_Int32 nLen = rOptions.getLength();
2568 const beans::PropertyValue *pProps = rOptions.getConstArray();
2569 for (sal_Int32 i = 0; i < nLen; ++i)
2570 {
2571 if (pProps[i].Name.equalsAscii( "View" ))
2572 {
2573 aTmp = pProps[i].Value;
2574 break;
2575 }
2576 }
2577
2578 uno::Reference< frame::XController > xController;
2579 if (aTmp >>= xController)
2580 {
2581 DBG_ASSERT( xController.is(), "controller is empty!" );
2582 pView = GuessViewShell( rbIsSwSrcView, xController );
2583 }
2584 }
2585 return pView;
2586 }
2587
2588
2589 /*
2590 * GetRenderDoc:
2591 * returns the document to be rendered, usually this will be the 'regular'
2592 * document but in case of PDF export of (multi-)selection it will
2593 * be a temporary document that gets created if not already done.
2594 * The rpView variable will be set (if not already done) to the used
2595 * SfxViewShell.
2596 */
2597
GetRenderDoc(SfxViewShell * & rpView,const uno::Any & rSelection,bool bIsPDFExport)2598 SwDoc * SwXTextDocument::GetRenderDoc(
2599 SfxViewShell *&rpView,
2600 const uno::Any& rSelection,
2601 bool bIsPDFExport )
2602 {
2603 SwDoc *pDoc = 0;
2604
2605 uno::Reference< frame::XModel > xModel;
2606 rSelection >>= xModel;
2607 if (xModel == pDocShell->GetModel())
2608 pDoc = pDocShell->GetDoc();
2609 else
2610 {
2611 DBG_ASSERT( !xModel.is(), "unexpected model found" );
2612
2613 if (rSelection.hasValue()) // is anything selected ?
2614 {
2615 // this part should only be called when a temporary document needs to be created,
2616 // for example for PDF export or printing of (multi-)selection only.
2617
2618 bool bIsSwSrcView = false;
2619 if (!rpView)
2620 {
2621 (void) bIsPDFExport;
2622 // aside from maybe PDF export the view should always have been provided!
2623 DBG_ASSERT( bIsPDFExport, "view is missing, guessing one..." );
2624
2625 rpView = GuessViewShell( bIsSwSrcView );
2626 }
2627 DBG_ASSERT( rpView, "ViewShell missing" );
2628 // the view shell should be SwView for documents PDF export.
2629 // for the page preview no selection should be possible
2630 // (the export dialog does not allow for this option)
2631 const TypeId aSwViewTypeId = TYPE(SwView);
2632 if (rpView && rpView->IsA(aSwViewTypeId))
2633 {
2634 SfxObjectShellLock xDocSh(((SwView*)rpView)->GetOrCreateTmpSelectionDoc());
2635 if (xDocSh.Is())
2636 {
2637 pDoc = ((SwDocShell*)&xDocSh)->GetDoc();
2638 rpView = pDoc->GetDocShell()->GetView();
2639 }
2640 }
2641 else
2642 {
2643 DBG_ERROR( "unexpected ViewShell" );
2644 }
2645 }
2646 }
2647 return pDoc;
2648 }
2649
2650 /* -----------------------------23.08.02 16:00--------------------------------
2651
2652 ---------------------------------------------------------------------------*/
2653
lcl_SavePrintUIOptionsToDocumentPrintData(SwDoc & rDoc,const SwPrintUIOptions & rPrintUIOptions,bool bIsPDFEXport)2654 static void lcl_SavePrintUIOptionsToDocumentPrintData(
2655 SwDoc &rDoc,
2656 const SwPrintUIOptions &rPrintUIOptions,
2657 bool bIsPDFEXport )
2658 {
2659 SwPrintData aDocPrintData( rDoc.getPrintData() );
2660
2661 aDocPrintData.SetPrintGraphic( rPrintUIOptions.IsPrintGraphics() );
2662 aDocPrintData.SetPrintTable( rPrintUIOptions.IsPrintTables() );
2663 aDocPrintData.SetPrintDraw( rPrintUIOptions.IsPrintDrawings() );
2664 aDocPrintData.SetPrintControl( rPrintUIOptions.IsPrintFormControls() );
2665 aDocPrintData.SetPrintLeftPage( rPrintUIOptions.IsPrintLeftPages() );
2666 aDocPrintData.SetPrintRightPage( rPrintUIOptions.IsPrintRightPages() );
2667 aDocPrintData.SetPrintReverse( rPrintUIOptions.IsPrintReverse() );
2668 aDocPrintData.SetPaperFromSetup( rPrintUIOptions.IsPaperFromSetup() );
2669 aDocPrintData.SetPrintEmptyPages( rPrintUIOptions.IsPrintEmptyPages( bIsPDFEXport ) );
2670 aDocPrintData.SetPrintPostIts( rPrintUIOptions.GetPrintPostItsType() );
2671 aDocPrintData.SetPrintProspect( rPrintUIOptions.IsPrintProspect() );
2672 aDocPrintData.SetPrintProspect_RTL( rPrintUIOptions.IsPrintProspectRTL() );
2673 aDocPrintData.SetPrintPageBackground( rPrintUIOptions.IsPrintPageBackground() );
2674 aDocPrintData.SetPrintBlackFont( rPrintUIOptions.IsPrintWithBlackTextColor() );
2675 // aDocPrintData.SetPrintSingleJobs( b ); handled by File/Print dialog itself
2676 // arDocPrintData.SetFaxName( s ); n/a in File/Print dialog
2677 aDocPrintData.SetPrintHiddenText( rPrintUIOptions.IsPrintHiddenText() );
2678 aDocPrintData.SetPrintTextPlaceholder( rPrintUIOptions.IsPrintTextPlaceholders() );
2679
2680 rDoc.setPrintData( aDocPrintData );
2681 }
2682
2683
getRendererCount(const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)2684 sal_Int32 SAL_CALL SwXTextDocument::getRendererCount(
2685 const uno::Any& rSelection,
2686 const uno::Sequence< beans::PropertyValue >& rxOptions )
2687 throw (IllegalArgumentException, RuntimeException)
2688 {
2689 ::vos::OGuard aGuard(Application::GetSolarMutex());
2690 if(!IsValid())
2691 throw RuntimeException();
2692
2693 CleanUpRenderingData();
2694
2695 const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
2696 bool bIsSwSrcView = false;
2697 SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
2698
2699 SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
2700 DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
2701 if ( pDoc == 0 || pView == 0 )
2702 {
2703 return 0;
2704 }
2705
2706 if ( !bIsSwSrcView )
2707 {
2708 m_pRenderData = new SwRenderData;
2709 }
2710 // new <PrintUIOptions>
2711 m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
2712 const bool bFormat = m_pPrintUIOptions->processPropertiesAndCheckFormat( rxOptions );
2713
2714 // save current UI options from the print dialog for the next call to that dialog
2715 lcl_SavePrintUIOptionsToDocumentPrintData( *pDoc, *m_pPrintUIOptions, bIsPDFExport );
2716
2717 sal_Int32 nRet = 0;
2718 if ( bIsSwSrcView )
2719 {
2720 SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView);
2721 OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
2722 nRet = pSwSrcView->PrintSource( pOutDev, 1 /* dummy */, true /* get page count only */ );
2723 }
2724 else
2725 {
2726 SwDocShell *pRenderDocShell = pDoc->GetDocShell();
2727
2728 // TODO/mba: we really need a generic way to get the ViewShell!
2729 ViewShell* pViewShell = 0;
2730 SwView* pSwView = PTR_CAST(SwView, pView);
2731 if ( pSwView )
2732 {
2733 pViewShell = pSwView->GetWrtShellPtr();
2734 }
2735 else
2736 {
2737 if ( bIsPDFExport && bFormat )
2738 {
2739 //create a hidden view to be able to export as PDF also in print preview
2740 //pView and pSwView are not changed intentionally!
2741 m_pHiddenViewFrame = SfxViewFrame::LoadHiddenDocument( *pRenderDocShell, 2 );
2742 pViewShell = ((SwView*)m_pHiddenViewFrame->GetViewShell())->GetWrtShellPtr();
2743 }
2744 else
2745 pViewShell = ((SwPagePreView*)pView)->GetViewShell();
2746 }
2747
2748 if (!pViewShell || !pViewShell->GetLayout())
2749 return 0;
2750
2751 if ( bFormat )
2752 {
2753 // #i38289
2754 if( pViewShell->GetViewOptions()->getBrowseMode() )
2755 {
2756 SwViewOption aOpt( *pViewShell->GetViewOptions() );
2757 aOpt.setBrowseMode( false );
2758 pViewShell->ApplyViewOptions( aOpt );
2759 pSwView->RecheckBrowseMode();
2760 }
2761
2762 // reformating the document for printing will show the changes in the view
2763 // which is likely to produce many unwanted and not nice to view actions.
2764 // We don't want that! Thus we disable updating of the view.
2765 pViewShell->StartAction();
2766
2767 if ( pSwView )
2768 {
2769 if (m_pRenderData && m_pRenderData->NeedNewViewOptionAdjust( *pViewShell ) )
2770 m_pRenderData->ViewOptionAdjustStop();
2771 if (m_pRenderData && !m_pRenderData->IsViewOptionAdjust())
2772 m_pRenderData->ViewOptionAdjustStart( *pViewShell, *pViewShell->GetViewOptions() );
2773 }
2774
2775 m_pRenderData->SetSwPrtOptions( new SwPrintData );
2776 m_pRenderData->MakeSwPrtOptions( m_pRenderData->GetSwPrtOptionsRef(), pRenderDocShell,
2777 m_pPrintUIOptions, m_pRenderData, bIsPDFExport );
2778
2779 if ( pSwView )
2780 {
2781 // PDF export should not make use of the SwPrtOptions
2782 const SwPrintData *pPrtOptions = (bIsPDFExport)
2783 ? NULL
2784 : m_pRenderData->GetSwPrtOptions();
2785 m_pRenderData->ViewOptionAdjust( pPrtOptions );
2786 }
2787
2788 // since printing now also use the API for PDF export this option
2789 // should be set for printing as well ...
2790 pViewShell->SetPDFExportOption( sal_True );
2791 bool bOrigStatus = pRenderDocShell->IsEnableSetModified();
2792 // check configuration: shall update of printing information in DocInfo set the document to "modified"?
2793 bool bStateChanged = false;
2794 if ( bOrigStatus && !SvtPrintWarningOptions().IsModifyDocumentOnPrintingAllowed() )
2795 {
2796 pRenderDocShell->EnableSetModified( sal_False );
2797 bStateChanged = true;
2798 }
2799
2800 // --> FME 2005-05-23 #122919# Force field update before PDF export:
2801 pViewShell->ViewShell::UpdateFlds(sal_True);
2802 // <--
2803 if( bStateChanged )
2804 pRenderDocShell->EnableSetModified( sal_True );
2805
2806 // there is some redundancy between those two function calls, but right now
2807 // there is no time to sort this out.
2808 //TODO: check what exatly needs to be done and make just one function for that
2809 pViewShell->CalcLayout();
2810 pViewShell->CalcPagesForPrint( pViewShell->GetPageCount() );
2811
2812 pViewShell->SetPDFExportOption( sal_False );
2813
2814 // enable view again
2815 pViewShell->EndAction();
2816 }
2817
2818 const sal_Int32 nPageCount = pViewShell->GetPageCount();
2819
2820 //
2821 // get number of pages to be rendered
2822 //
2823 const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
2824 if (bPrintProspect)
2825 {
2826 pDoc->CalculatePagePairsForProspectPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, nPageCount );
2827 nRet = m_pRenderData->GetPagePairsForProspectPrinting().size();
2828 }
2829 else
2830 {
2831 if ( m_pRenderData->HasPostItData() )
2832 {
2833 m_pRenderData->DeletePostItData();
2834 }
2835 const sal_Int16 nPostItMode = (sal_Int16) m_pPrintUIOptions->getIntValue( "PrintAnnotationMode", 0 );
2836 if (nPostItMode != POSTITS_NONE)
2837 {
2838 OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
2839 m_pRenderData->CreatePostItData( pDoc, pViewShell->GetViewOptions(), pOutDev );
2840 }
2841
2842 // get set of valid document pages (according to the current settings)
2843 // and their start frames
2844 pDoc->CalculatePagesForPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, bIsPDFExport, nPageCount );
2845
2846 if (nPostItMode != POSTITS_NONE)
2847 {
2848 pDoc->UpdatePagesForPrintingWithPostItData( *m_pRenderData,
2849 *m_pPrintUIOptions, bIsPDFExport, nPageCount );
2850 }
2851
2852 nRet = m_pRenderData->GetPagesToPrint().size();
2853 }
2854 }
2855 DBG_ASSERT( nRet >= 0, "negative number of pages???" );
2856
2857 return nRet;
2858 }
2859 /* -----------------------------23.08.02 16:00--------------------------------
2860
2861 ---------------------------------------------------------------------------*/
getRenderer(sal_Int32 nRenderer,const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)2862 uno::Sequence< beans::PropertyValue > SAL_CALL SwXTextDocument::getRenderer(
2863 sal_Int32 nRenderer,
2864 const uno::Any& rSelection,
2865 const uno::Sequence< beans::PropertyValue >& rxOptions )
2866 throw (IllegalArgumentException, RuntimeException)
2867 {
2868 ::vos::OGuard aGuard(Application::GetSolarMutex());
2869 if(!IsValid())
2870 throw RuntimeException();
2871
2872 const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
2873 bool bIsSwSrcView = false;
2874 SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
2875
2876 // m_pRenderData should NOT be created here!
2877 // That should only be done in getRendererCount. If this function is called before
2878 // getRendererCount was called then the caller will probably just retrieve the extra UI options
2879 // and is not interested in getting valid information about the other data that would
2880 // otherwise be provided here!
2881 // if( ! m_pRenderData )
2882 // m_pRenderData = new SwRenderData;
2883 if (!m_pPrintUIOptions)
2884 m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
2885 m_pPrintUIOptions->processProperties( rxOptions );
2886 const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
2887 const bool bIsSkipEmptyPages = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport );
2888 const bool bPrintPaperFromSetup = m_pPrintUIOptions->getBoolValue( "PrintPaperFromSetup", false );
2889
2890 SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
2891 DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
2892 if (!pDoc || !pView)
2893 return uno::Sequence< beans::PropertyValue >();
2894
2895 if ( nRenderer < 0 || nRenderer >= SAL_MAX_UINT16 )
2896 throw IllegalArgumentException();
2897
2898 // TODO/mba: we really need a generic way to get the ViewShell!
2899 ViewShell* pVwSh = 0;
2900 SwView* pSwView = PTR_CAST(SwView, pView);
2901 if ( pSwView )
2902 pVwSh = pSwView->GetWrtShellPtr();
2903 else
2904 pVwSh = ((SwPagePreView*)pView)->GetViewShell();
2905
2906 sal_Int32 nMaxRenderer = 0;
2907 if (!bIsSwSrcView && m_pRenderData)
2908 {
2909 DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" );
2910 nMaxRenderer = bPrintProspect?
2911 m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 :
2912 m_pRenderData->GetPagesToPrint().size() - 1;
2913 }
2914 // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print
2915 // we obmit checking of the upper bound in this case.
2916 if (!bIsSwSrcView && m_pRenderData && nRenderer > nMaxRenderer)
2917 return uno::Sequence< beans::PropertyValue >();
2918
2919 uno::Sequence< beans::PropertyValue > aRenderer;
2920 if (m_pRenderData)
2921 {
2922 const sal_Int32 nPage = bPrintProspect
2923 ? nRenderer + 1
2924 : m_pRenderData->GetPagesToPrint()[ nRenderer ];
2925
2926 // get paper tray to use ...
2927 sal_Int32 nPrinterPaperTray = -1;
2928 if (! bPrintPaperFromSetup)
2929 {
2930 // ... from individual page style (see the page tab in Format/Page dialog)
2931 const std::map< sal_Int32, sal_Int32 > &rPaperTrays = m_pRenderData->GetPrinterPaperTrays();
2932 std::map< sal_Int32, sal_Int32 >::const_iterator aIt( rPaperTrays.find( nPage ) );
2933 if (aIt != rPaperTrays.end())
2934 nPrinterPaperTray = aIt->second;
2935 }
2936
2937 awt::Size aPageSize;
2938 awt::Size aPreferredPageSize;
2939 Size aTmpSize;
2940 if (bIsSwSrcView || bPrintProspect)
2941 {
2942 // for printing of HTML source code and prospect printing we should use
2943 // the printers paper size since
2944 // a) HTML source view has no page size
2945 // b) prospect printing has a different page size from the documents page
2946 // since two document pages will get rendered on one printer page
2947
2948 // since PageIncludesNonprintableArea will be set to true we can return the
2949 // printers paper size here.
2950 // Sometimes 'getRenderer' is only called to get "ExtraPrintUIOptions", in this
2951 // case we won't get an OutputDevice here, but then the caller also has no need
2952 // for the correct PageSisze right now...
2953 Printer *pPrinter = dynamic_cast< Printer * >(lcl_GetOutputDevice( *m_pPrintUIOptions ));
2954 if (pPrinter)
2955 {
2956 // HTML source view and prospect adapt to the printer's paper size
2957 aTmpSize = pPrinter->GetPaperSize();
2958 aTmpSize = pPrinter->LogicToLogic( aTmpSize,
2959 pPrinter->GetMapMode(), MapMode( MAP_100TH_MM ));
2960 aPageSize = awt::Size( aTmpSize.Width(), aTmpSize.Height() );
2961 if( bPrintProspect )
2962 {
2963 // just switch to an appropriate portrait/landscape format
2964 // FIXME: brochure printing with landscape pages puts the
2965 // pages next to each other, so landscape is currently always
2966 // the better choice
2967 if( aPageSize.Width < aPageSize.Height )
2968 {
2969 aPreferredPageSize.Width = aPageSize.Height;
2970 aPreferredPageSize.Height = aPageSize.Width;
2971 }
2972 }
2973 }
2974 }
2975 else
2976 {
2977 ASSERT( nPage > 0 && nPage <= SAL_MAX_UINT16,
2978 "<SwXTextDocument::getRenderer(..)> - unexpected value for the page number, it does not fit into sal_uInt16." );
2979 aTmpSize = pVwSh->GetPageSize( static_cast< sal_uInt16 >(nPage), bIsSkipEmptyPages );
2980 aPageSize = awt::Size ( TWIP_TO_MM100( aTmpSize.Width() ),
2981 TWIP_TO_MM100( aTmpSize.Height() ));
2982 }
2983
2984 sal_Int32 nLen = 2;
2985 aRenderer.realloc(2);
2986 aRenderer[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) );
2987 aRenderer[0].Value <<= aPageSize;
2988 aRenderer[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageIncludesNonprintableArea" ) );
2989 aRenderer[1].Value <<= sal_True;
2990 if (aPreferredPageSize.Width && aPreferredPageSize.Height)
2991 {
2992 ++nLen;
2993 aRenderer.realloc( nLen );
2994 aRenderer[ nLen - 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PreferredPageSize" ) );
2995 aRenderer[ nLen - 1 ].Value <<= aPreferredPageSize;
2996 }
2997 if (nPrinterPaperTray >= 0)
2998 {
2999 ++nLen;
3000 aRenderer.realloc( nLen );
3001 aRenderer[ nLen - 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PrinterPaperTray" ) );
3002 aRenderer[ nLen - 1 ].Value <<= nPrinterPaperTray;
3003 }
3004 }
3005
3006 if ( bApplyPagePrintSettingsFromXPagePrintable )
3007 {
3008 const SwPagePreViewPrtData* pPagePrintSettings =
3009 pDocShell->GetDoc()->GetPreViewPrtData();
3010 if ( pPagePrintSettings &&
3011 ( pPagePrintSettings->GetRow() > 1 ||
3012 pPagePrintSettings->GetCol() > 1 ) )
3013 {
3014 // extend render data by page print settings attributes
3015 sal_Int32 nLen = aRenderer.getLength();
3016 const sal_Int32 nRenderDataIdxStart = nLen;
3017 nLen += 9;
3018 aRenderer.realloc( nLen );
3019 // put page print settings attribute into render data
3020 const sal_Int32 nRow = pPagePrintSettings->GetRow();
3021 aRenderer[ nRenderDataIdxStart + 0 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpRows" ) );
3022 aRenderer[ nRenderDataIdxStart + 0 ].Value <<= ( nRow > 1 ? nRow : 1 );
3023 const sal_Int32 nCol = pPagePrintSettings->GetCol();
3024 aRenderer[ nRenderDataIdxStart + 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpColumns" ) );
3025 aRenderer[ nRenderDataIdxStart + 1 ].Value <<= ( nCol > 1 ? nCol : 1 );
3026 aRenderer[ nRenderDataIdxStart + 2 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginLeft" ) );
3027 aRenderer[ nRenderDataIdxStart + 2 ].Value <<= pPagePrintSettings->GetLeftSpace();
3028 aRenderer[ nRenderDataIdxStart + 3 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginRight" ) );
3029 aRenderer[ nRenderDataIdxStart + 3 ].Value <<= pPagePrintSettings->GetRightSpace();
3030 aRenderer[ nRenderDataIdxStart + 4 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginTop" ) );
3031 aRenderer[ nRenderDataIdxStart + 4 ].Value <<= pPagePrintSettings->GetTopSpace();
3032 aRenderer[ nRenderDataIdxStart + 5 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginBottom" ) );
3033 aRenderer[ nRenderDataIdxStart + 5 ].Value <<= pPagePrintSettings->GetBottomSpace();
3034 aRenderer[ nRenderDataIdxStart + 6 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpHorizontalSpacing" ) );
3035 aRenderer[ nRenderDataIdxStart + 6 ].Value <<= pPagePrintSettings->GetHorzSpace();
3036 aRenderer[ nRenderDataIdxStart + 7 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpVerticalSpacing" ) );
3037 aRenderer[ nRenderDataIdxStart + 7 ].Value <<= pPagePrintSettings->GetVertSpace();
3038 {
3039 Printer* pPrinter = pDocShell->GetDoc()->getPrinter( false );
3040 if ( pPrinter )
3041 {
3042 awt::Size aNewPageSize;
3043 const Size aPageSize = pPrinter->PixelToLogic( pPrinter->GetPaperSizePixel(), MapMode( MAP_100TH_MM ) );
3044 aNewPageSize = awt::Size( aPageSize.Width(), aPageSize.Height() );
3045 if ( ( pPagePrintSettings->GetLandscape() &&
3046 aPageSize.Width() < aPageSize.Height() ) ||
3047 ( !pPagePrintSettings->GetLandscape() &&
3048 aPageSize.Width() > aPageSize.Height() ) )
3049 {
3050 aNewPageSize = awt::Size( aPageSize.Height(), aPageSize.Width() );
3051 }
3052 aRenderer[ nRenderDataIdxStart + 8 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPaperSize" ) );
3053 aRenderer[ nRenderDataIdxStart + 8 ].Value <<= aNewPageSize;
3054 }
3055 }
3056 }
3057
3058 bApplyPagePrintSettingsFromXPagePrintable = sal_False;
3059 }
3060
3061 m_pPrintUIOptions->appendPrintUIOptions( aRenderer );
3062
3063 return aRenderer;
3064 }
3065 /* -----------------------------28.10.02 16:00--------------------------------
3066
3067 ---------------------------------------------------------------------------*/
GuessViewShell(bool & rbIsSwSrcView,const uno::Reference<css::frame::XController> xController)3068 SfxViewShell * SwXTextDocument::GuessViewShell(
3069 /* out */ bool &rbIsSwSrcView,
3070 const uno::Reference< css::frame::XController > xController )
3071 {
3072 // #130810# SfxViewShell::Current() / SfxViewShell::GetObjectShell()
3073 // must not be used (see comment from MBA)
3074 //
3075 SfxViewShell *pView = 0;
3076 SwView *pSwView = 0;
3077 SwPagePreView *pSwPagePreView = 0;
3078 SwSrcView *pSwSrcView = 0;
3079 SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pDocShell, sal_False );
3080
3081 // look for the view shell with the same controller in use,
3082 // otherwise look for a suitable view
3083 while (pFrame)
3084 {
3085 pView = pFrame->GetViewShell();
3086 pSwView = dynamic_cast< SwView * >(pView);
3087 pSwSrcView = dynamic_cast< SwSrcView * >(pView);
3088 if (!pSwPagePreView)
3089 pSwPagePreView = dynamic_cast< SwPagePreView * >(pView);
3090 if (xController.is())
3091 {
3092 if (pView && pView->GetController() == xController)
3093 break;
3094 }
3095 else if ( pSwView || pSwSrcView || pSwPagePreView )
3096 break;
3097 pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell, sal_False );
3098 }
3099
3100 DBG_ASSERT( pSwView || pSwPagePreView || pSwSrcView, "failed to get view shell" );
3101 if (pView)
3102 rbIsSwSrcView = pSwSrcView != 0;
3103 return pView;
3104 }
3105
3106
render(sal_Int32 nRenderer,const uno::Any & rSelection,const uno::Sequence<beans::PropertyValue> & rxOptions)3107 void SAL_CALL SwXTextDocument::render(
3108 sal_Int32 nRenderer,
3109 const uno::Any& rSelection,
3110 const uno::Sequence< beans::PropertyValue >& rxOptions )
3111 throw (IllegalArgumentException, RuntimeException)
3112 {
3113 ::vos::OGuard aGuard(Application::GetSolarMutex());
3114 if(!IsValid())
3115 throw RuntimeException();
3116
3117 // due to #110067# (document page count changes sometimes during
3118 // PDF export/printing) we can not check for the upper bound properly.
3119 // Thus instead of throwing the exception we silently return.
3120 if (0 > nRenderer)
3121 throw IllegalArgumentException();
3122
3123 const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" );
3124 bool bIsSwSrcView = false;
3125 SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport );
3126
3127 // error handling - avoid crash
3128 if ( !bIsSwSrcView && m_pRenderData == NULL )
3129 {
3130 DBG_ASSERT( false, "data should have been created already in getRendererCount..." );
3131 m_pRenderData = new SwRenderData;
3132 }
3133 if ( m_pPrintUIOptions == 0 )
3134 {
3135 DBG_ASSERT( false, "data should have been created already in getRendererCount..." );
3136 m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView );
3137 }
3138
3139 m_pPrintUIOptions->processProperties( rxOptions );
3140 const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false );
3141 const bool bLastPage = m_pPrintUIOptions->getBoolValue( "IsLastPage", sal_False );
3142
3143 SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport );
3144 DBG_ASSERT( pDoc && pView, "doc or view shell missing!" );
3145 if (pDoc && pView)
3146 {
3147 sal_Int32 nMaxRenderer = 0;
3148 if (!bIsSwSrcView)
3149 {
3150 DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" );
3151 nMaxRenderer = bPrintProspect?
3152 m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 :
3153 m_pRenderData->GetPagesToPrint().size() - 1;
3154 }
3155 // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print
3156 // we obmit checking of the upper bound in this case.
3157 if (bIsSwSrcView || nRenderer <= nMaxRenderer)
3158 {
3159 if (bIsSwSrcView)
3160 {
3161 SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView);
3162 OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions );
3163 pSwSrcView->PrintSource( pOutDev, nRenderer + 1, false );
3164 }
3165 else
3166 {
3167 // the view shell should be SwView for documents PDF export
3168 // or SwPagePreView for PDF export of the page preview
3169 //!! (check for SwView first as in GuessViewShell) !!
3170 DBG_ASSERT( pView, "!! view missing !!" );
3171 const TypeId aSwViewTypeId = TYPE(SwView);
3172 ViewShell* pVwSh = 0;
3173 if (pView)
3174 {
3175 // TODO/mba: we really need a generic way to get the ViewShell!
3176 SwView* pSwView = PTR_CAST(SwView, pView);
3177 if ( pSwView )
3178 pVwSh = pSwView->GetWrtShellPtr();
3179 else
3180 pVwSh = ((SwPagePreView*)pView)->GetViewShell();
3181 }
3182
3183 // get output device to use
3184 OutputDevice * pOut = lcl_GetOutputDevice( *m_pPrintUIOptions );
3185
3186 if(pVwSh && pOut && m_pRenderData->HasSwPrtOptions())
3187 {
3188 const rtl::OUString aPageRange = m_pPrintUIOptions->getStringValue( "PageRange", OUString() );
3189 const bool bFirstPage = m_pPrintUIOptions->getBoolValue( "IsFirstPage", sal_False );
3190 bool bIsSkipEmptyPages = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport );
3191
3192 DBG_ASSERT(( pView->IsA(aSwViewTypeId) && m_pRenderData->IsViewOptionAdjust())
3193 || (!pView->IsA(aSwViewTypeId) && !m_pRenderData->IsViewOptionAdjust()),
3194 "SwView / SwViewOptionAdjust_Impl availability mismatch" );
3195
3196 // since printing now also use the API for PDF export this option
3197 // should be set for printing as well ...
3198 pVwSh->SetPDFExportOption( sal_True );
3199
3200 // --> FME 2004-06-08 #i12836# enhanced pdf export
3201 //
3202 // First, we have to export hyperlinks, notes, and outline to pdf.
3203 // During this process, additional information required for tagging
3204 // the pdf file are collected, which are evaulated during painting.
3205 //
3206 SwWrtShell* pWrtShell = pView->IsA(aSwViewTypeId) ?
3207 ((SwView*)pView)->GetWrtShellPtr() :
3208 0;
3209
3210 if (bIsPDFExport && bFirstPage && pWrtShell)
3211 {
3212 SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages, sal_False );
3213 }
3214 // <--
3215
3216 SwPrintData const& rSwPrtOptions =
3217 *m_pRenderData->GetSwPrtOptions();
3218 if (bPrintProspect)
3219 pVwSh->PrintProspect( pOut, rSwPrtOptions, nRenderer );
3220 else // normal printing and PDF export
3221 pVwSh->PrintOrPDFExport( pOut, rSwPrtOptions, nRenderer );
3222
3223 // After printing the last page, we take care for the links coming
3224 // from the EditEngine. The links are generated during the painting
3225 // process, but the destinations are still missing.
3226 //
3227 if (bIsPDFExport && bLastPage && pWrtShell)
3228 {
3229 SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages, sal_True );
3230 }
3231
3232 pVwSh->SetPDFExportOption( sal_False );
3233 }
3234 }
3235 }
3236 }
3237 // last page to be rendered? (not necessarily the last page of the document)
3238 // -> do clean-up of data
3239 if ( bLastPage )
3240 {
3241 CleanUpRenderingData();
3242 }
3243 }
3244 /* -----------------------------03.10.04 -------------------------------------
3245
3246 ---------------------------------------------------------------------------*/
3247 // xforms::XFormsSupplier
getXForms()3248 Reference<XNameContainer> SAL_CALL SwXTextDocument::getXForms()
3249 throw( RuntimeException )
3250 {
3251 if ( !pDocShell )
3252 throw DisposedException( ::rtl::OUString(), static_cast< XTextDocument* >( this ) );
3253 SwDoc* pDoc = pDocShell->GetDoc();
3254 return pDoc->getXForms();
3255 }
3256
3257 /* -----------------------------25.09.07 -------------------------------------
3258
3259 ---------------------------------------------------------------------------*/
getFlatParagraphIterator(::sal_Int32 nTextMarkupType,sal_Bool bAutomatic)3260 uno::Reference< text::XFlatParagraphIterator > SAL_CALL SwXTextDocument::getFlatParagraphIterator(::sal_Int32 nTextMarkupType, sal_Bool bAutomatic)
3261 throw ( uno::RuntimeException )
3262 {
3263 return new SwXFlatParagraphIterator( *pDocShell->GetDoc(), nTextMarkupType, bAutomatic );
3264 }
3265 /*-- 07.05.2009 09:21:12---------------------------------------------------
3266
3267 -----------------------------------------------------------------------*/
createClone()3268 uno::Reference< util::XCloneable > SwXTextDocument::createClone( ) throw (uno::RuntimeException)
3269 {
3270 ::vos::OGuard aGuard(Application::GetSolarMutex());
3271 if(!IsValid())
3272 throw RuntimeException();
3273
3274 // create a new document - hidden - copy the storage and return it
3275 // SfxObjectShellRef is used here, since the model should control object lifetime after creation
3276 // and thus SfxObjectShellLock is not allowed here
3277 // the model holds reference to the shell, so the shell will not destructed at the end of method
3278 SfxObjectShellRef pShell = pDocShell->GetDoc()->CreateCopy(false);
3279 uno::Reference< frame::XModel > xNewModel = pShell->GetModel();
3280 uno::Reference< embed::XStorage > xNewStorage = ::comphelper::OStorageHelper::GetTemporaryStorage( );
3281 uno::Sequence< beans::PropertyValue > aTempMediaDescriptor;
3282 storeToStorage( xNewStorage, aTempMediaDescriptor );
3283 uno::Reference< document::XStorageBasedDocument > xStorageDoc( xNewModel, uno::UNO_QUERY );
3284 xStorageDoc->loadFromStorage( xNewStorage, aTempMediaDescriptor );
3285 return uno::Reference< util::XCloneable >( xNewModel, UNO_QUERY );
3286 }
3287 /* -----------------------------20.06.00 09:54--------------------------------
3288
3289 ---------------------------------------------------------------------------*/
operator new(size_t t)3290 void * SAL_CALL SwXTextDocument::operator new( size_t t) throw()
3291 {
3292 return SwXTextDocumentBaseClass::operator new(t);
3293 }
3294 /* -----------------------------20.06.00 09:54--------------------------------
3295
3296 ---------------------------------------------------------------------------*/
operator delete(void * p)3297 void SAL_CALL SwXTextDocument::operator delete( void * p) throw()
3298 {
3299 SwXTextDocumentBaseClass::operator delete(p);
3300 }
3301
3302
3303 /*---------------------------------------------------
3304 retrieve languages already used in current document
3305 -----------------------------------------------------*/
getDocumentLanguages(::sal_Int16 nScriptTypes,::sal_Int16 nMaxCount)3306 uno::Sequence< lang::Locale > SAL_CALL SwXTextDocument::getDocumentLanguages(
3307 ::sal_Int16 nScriptTypes,
3308 ::sal_Int16 nMaxCount )
3309 throw (lang::IllegalArgumentException, uno::RuntimeException)
3310 {
3311 ::vos::OGuard aGuard(Application::GetSolarMutex());
3312
3313 // possible canonical values for nScriptTypes
3314 // any bit wise combination is allowed
3315 const sal_Int16 nLatin = 0x001;
3316 const sal_Int16 nAsian = 0x002;
3317 const sal_Int16 nComplex = 0x004;
3318
3319 // script types for which to get the languages
3320 const bool bLatin = 0 != (nScriptTypes & nLatin);
3321 const bool bAsian = 0 != (nScriptTypes & nAsian);
3322 const bool bComplex = 0 != (nScriptTypes & nComplex);
3323
3324 if (nScriptTypes < nLatin || nScriptTypes > (nLatin | nAsian | nComplex))
3325 throw IllegalArgumentException(::rtl::OUString::createFromAscii("nScriptTypes ranges from 1 to 7!"), Reference< XInterface >(), 1);
3326 if (!pDocShell)
3327 throw DisposedException();
3328 SwDoc* pDoc = pDocShell->GetDoc();
3329
3330 // avoid duplicate values
3331 std::set< LanguageType > aAllLangs;
3332
3333 //USER STYLES
3334
3335 const SwCharFmts *pFmts = pDoc->GetCharFmts();
3336 for(sal_uInt16 i = 0; i < pFmts->Count(); ++i)
3337 {
3338 const SwAttrSet &rAttrSet = (*pFmts)[i]->GetAttrSet();
3339 LanguageType nLang = LANGUAGE_DONTKNOW;
3340 if (bLatin)
3341 {
3342 nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage();
3343 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3344 aAllLangs.insert( nLang );
3345 }
3346 if (bAsian)
3347 {
3348 nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage();
3349 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3350 aAllLangs.insert( nLang );
3351 }
3352 if (bComplex)
3353 {
3354 nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage();
3355 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3356 aAllLangs.insert( nLang );
3357 }
3358 }
3359
3360 const SwTxtFmtColls *pColls = pDoc->GetTxtFmtColls();
3361 for (sal_uInt16 i = 0; i < pColls->Count(); ++i)
3362 {
3363 const SwAttrSet &rAttrSet = (*pColls)[i]->GetAttrSet();
3364 LanguageType nLang = LANGUAGE_DONTKNOW;;
3365 if (bLatin)
3366 {
3367 nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage();
3368 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3369 aAllLangs.insert( nLang );
3370 }
3371 if (bAsian)
3372 {
3373 nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage();
3374 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3375 aAllLangs.insert( nLang );
3376 }
3377 if (bComplex)
3378 {
3379 nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage();
3380 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3381 aAllLangs.insert( nLang );
3382 }
3383 }
3384
3385 //AUTO STYLES
3386 const IStyleAccess::SwAutoStyleFamily aFam[2] =
3387 {
3388 IStyleAccess::AUTO_STYLE_CHAR,
3389 IStyleAccess::AUTO_STYLE_PARA
3390 };
3391 for (sal_uInt16 i = 0; i < 2; ++i)
3392 {
3393 std::vector< SfxItemSet_Pointer_t > rStyles;
3394 pDoc->GetIStyleAccess().getAllStyles(rStyles, aFam[i]);
3395 while (!rStyles.empty())
3396 {
3397 SfxItemSet_Pointer_t pStyle = rStyles.back();
3398 rStyles.pop_back();
3399 const SfxItemSet *pSet = dynamic_cast< const SfxItemSet * >(pStyle.get());
3400
3401 LanguageType nLang = LANGUAGE_DONTKNOW;
3402 if (bLatin)
3403 {
3404 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_LANGUAGE, sal_False )).GetLanguage();
3405 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3406 aAllLangs.insert( nLang );
3407 }
3408 if (bAsian)
3409 {
3410 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CJK_LANGUAGE, sal_False )).GetLanguage();
3411 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3412 aAllLangs.insert( nLang );
3413 }
3414 if (bComplex)
3415 {
3416 nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CTL_LANGUAGE, sal_False )).GetLanguage();
3417 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3418 aAllLangs.insert( nLang );
3419 }
3420 }
3421 }
3422
3423 //TODO/mba: it's a strange concept that a view is needed to retrieve core data
3424 SwWrtShell *pWrtSh = pDocShell->GetWrtShell();
3425 SdrView *pSdrView = pWrtSh->GetDrawView();
3426
3427 if( pSdrView )
3428 {
3429 SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner();
3430 if(pOutliner)
3431 {
3432 EditEngine& rEditEng = (EditEngine&)pOutliner->GetEditEngine();
3433 sal_uLong nParCount = pOutliner->GetParagraphCount();
3434 for (sal_uLong nPar=0; nPar<nParCount; nPar++)
3435 {
3436 //every paragraph
3437 SvUShorts aPortions;
3438 rEditEng.GetPortions( (sal_uInt16)nPar, aPortions );
3439
3440 for ( sal_uInt16 nPos = aPortions.Count(); nPos; )
3441 {
3442 //every position
3443 --nPos;
3444 sal_uInt16 nEnd = aPortions.GetObject( nPos );
3445 sal_uInt16 nStart = nPos ? aPortions.GetObject( nPos - 1 ) : 0;
3446 ESelection aSelection( (sal_uInt16)nPar, nStart, (sal_uInt16)nPar, nEnd );
3447 SfxItemSet aAttr = rEditEng.GetAttribs( aSelection );
3448
3449 LanguageType nLang = LANGUAGE_DONTKNOW;
3450 if (bLatin)
3451 {
3452 nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE, sal_False )).GetLanguage();
3453 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3454 aAllLangs.insert( nLang );
3455 }
3456 if (bAsian)
3457 {
3458 nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CJK, sal_False )).GetLanguage();
3459 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3460 aAllLangs.insert( nLang );
3461 }
3462 if (bComplex)
3463 {
3464 nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CTL, sal_False )).GetLanguage();
3465 if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM)
3466 aAllLangs.insert( nLang );
3467 }
3468 }
3469 }
3470 }
3471 }
3472 // less than nMaxCount languages
3473 if (nMaxCount > static_cast< sal_Int16 >( aAllLangs.size() ))
3474 nMaxCount = static_cast< sal_Int16 >( aAllLangs.size() );
3475
3476 // build return value
3477 sal_Int32 nCount = 0;
3478 uno::Sequence< lang::Locale > aLanguages( nMaxCount );
3479 lang::Locale* pLanguage = aLanguages.getArray();
3480 if (nMaxCount > 0)
3481 {
3482 const SvtLanguageTable aLangTab;
3483 for (std::set< LanguageType >::const_iterator it = aAllLangs.begin(); it != aAllLangs.end(); ++it)
3484 {
3485 if (nCount >= nMaxCount)
3486 break;
3487 if (LANGUAGE_NONE != *it)
3488 {
3489 MsLangId::convertLanguageToLocale( *it, pLanguage[nCount] );
3490 pLanguage[nCount].Language = aLangTab.GetString( *it );
3491 nCount += 1;
3492 }
3493 }
3494 }
3495
3496 return aLanguages;
3497 }
3498
3499 // #121125#, #122868#
3500 // method to assure clean up of the rendering data to restore view options
3501 // and to loose hold reference to the ViewShell in SwViewOptionAdjust_Impl.
3502 // also perform clean up for the still existing hidden frame for PDF export from Page Preview
CleanUpRenderingData()3503 void SwXTextDocument::CleanUpRenderingData()
3504 {
3505 if( m_pRenderData != NULL )
3506 {
3507 if ( m_pRenderData->HasPostItData() )
3508 {
3509 m_pRenderData->DeletePostItData();
3510 }
3511 delete m_pRenderData;
3512 m_pRenderData = NULL;
3513 }
3514
3515 if( m_pPrintUIOptions != NULL )
3516 {
3517 delete m_pPrintUIOptions;
3518 m_pPrintUIOptions = NULL;
3519 }
3520
3521 if ( IsValid() && m_pHiddenViewFrame )
3522 {
3523 lcl_DisposeView( m_pHiddenViewFrame, pDocShell);
3524 m_pHiddenViewFrame = 0;
3525 SfxItemSet *pSet = pDocShell->GetMedium()->GetItemSet();
3526 pSet->Put( SfxBoolItem( SID_HIDDEN, sal_False ) );
3527 }
3528 }
3529
3530 /* -----------------25.10.99 11:06-------------------
3531
3532 --------------------------------------------------*/
SwXLinkTargetSupplier(SwXTextDocument & rxDoc)3533 SwXLinkTargetSupplier::SwXLinkTargetSupplier(SwXTextDocument& rxDoc) :
3534 pxDoc(&rxDoc)
3535 {
3536 sTables = String(SW_RES(STR_CONTENT_TYPE_TABLE));
3537 sFrames = String(SW_RES(STR_CONTENT_TYPE_FRAME));
3538 sGraphics = String(SW_RES(STR_CONTENT_TYPE_GRAPHIC));
3539 sOLEs = String(SW_RES(STR_CONTENT_TYPE_OLE));
3540 sSections = String(SW_RES(STR_CONTENT_TYPE_REGION));
3541 sOutlines = String(SW_RES(STR_CONTENT_TYPE_OUTLINE));
3542 sBookmarks = String(SW_RES(STR_CONTENT_TYPE_BOOKMARK));
3543 }
3544 /* -----------------25.10.99 11:11-------------------
3545
3546 --------------------------------------------------*/
~SwXLinkTargetSupplier()3547 SwXLinkTargetSupplier::~SwXLinkTargetSupplier()
3548 {
3549 }
3550
3551 /*-- 25.10.99 11:12:45---------------------------------------------------
3552
3553 -----------------------------------------------------------------------*/
getByName(const OUString & rName)3554 Any SwXLinkTargetSupplier::getByName(const OUString& rName)
3555 throw( NoSuchElementException, WrappedTargetException, RuntimeException )
3556 {
3557 Any aRet;
3558 if(!pxDoc)
3559 throw RuntimeException();
3560 String sToCompare(rName);
3561 String sSuffix('|');
3562 if(sToCompare == sTables)
3563 {
3564 sSuffix += UniString::CreateFromAscii(pMarkToTable);
3565
3566 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3567 pxDoc->getTextTables(), sToCompare, sSuffix );
3568 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3569 aRet.setValue(&xRet, ::getCppuType((Reference<XPropertySet>*)0));
3570 }
3571 else if(sToCompare == sFrames)
3572 {
3573 sSuffix += UniString::CreateFromAscii(pMarkToFrame);
3574 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3575 pxDoc->getTextFrames(), sToCompare, sSuffix );
3576 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3577 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3578 }
3579 else if(sToCompare == sSections)
3580 {
3581 sSuffix += UniString::CreateFromAscii(pMarkToRegion);
3582 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3583 pxDoc->getTextSections(), sToCompare, sSuffix );
3584 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3585 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3586 }
3587 /* else if(sToCompare == )
3588 {
3589 sSuffix += UniString::CreateFromAscii(pMarkToText);
3590 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3591 pxDoc->, sSuffix );
3592 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3593 aRet.setValue(&xRet, ::getCppuType((const XPropertySet*)0));
3594 }*/
3595 else if(sToCompare == sGraphics)
3596 {
3597 sSuffix += UniString::CreateFromAscii(pMarkToGraphic);
3598 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3599 pxDoc->getGraphicObjects(), sToCompare, sSuffix );
3600 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3601 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3602 }
3603 else if(sToCompare == sOLEs)
3604 {
3605 sSuffix += UniString::CreateFromAscii(pMarkToOLE);
3606 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3607 pxDoc->getEmbeddedObjects(), sToCompare, sSuffix );
3608 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3609 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3610 }
3611 else if(sToCompare == sOutlines)
3612 {
3613 sSuffix += UniString::CreateFromAscii(pMarkToOutline);
3614 Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper(
3615 *pxDoc, sToCompare, sSuffix );
3616 Reference< XPropertySet > xRet(xTbls, UNO_QUERY);
3617 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3618 }
3619 else if(sToCompare == sBookmarks)
3620 {
3621 sSuffix.Erase();
3622 Reference< XNameAccess > xBkms = new SwXLinkNameAccessWrapper(
3623 pxDoc->getBookmarks(), sToCompare, sSuffix );
3624 Reference< XPropertySet > xRet(xBkms, UNO_QUERY);
3625 aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0));
3626 }
3627 else
3628 throw NoSuchElementException();
3629 return aRet;
3630 }
3631 /*-- 25.10.99 11:12:46---------------------------------------------------
3632
3633 -----------------------------------------------------------------------*/
getElementNames(void)3634 Sequence< OUString > SwXLinkTargetSupplier::getElementNames(void)
3635 throw( RuntimeException )
3636 {
3637 Sequence< OUString > aRet(7);
3638 OUString* pNames = aRet.getArray();
3639 pNames[0] = sTables;
3640 pNames[1] = sFrames ;
3641 pNames[2] = sGraphics;
3642 pNames[3] = sOLEs ;
3643 pNames[4] = sSections;
3644 pNames[5] = sOutlines;
3645 pNames[6] = sBookmarks;
3646 return aRet;
3647 }
3648 /*-- 25.10.99 11:12:46---------------------------------------------------
3649
3650 -----------------------------------------------------------------------*/
hasByName(const OUString & rName)3651 sal_Bool SwXLinkTargetSupplier::hasByName(const OUString& rName)
3652 throw( RuntimeException )
3653 {
3654 String sToCompare(rName);
3655 if( sToCompare == sTables ||
3656 sToCompare == sFrames ||
3657 sToCompare == sGraphics||
3658 sToCompare == sOLEs ||
3659 sToCompare == sSections ||
3660 sToCompare == sOutlines ||
3661 sToCompare == sBookmarks )
3662 return sal_True;
3663 return sal_False;
3664 }
3665 /*-- 25.10.99 11:12:47---------------------------------------------------
3666
3667 -----------------------------------------------------------------------*/
getElementType(void)3668 uno::Type SwXLinkTargetSupplier::getElementType(void)
3669 throw( RuntimeException )
3670 {
3671 return ::getCppuType((Reference< XPropertySet>*)0);
3672
3673 }
3674 /*-- 25.10.99 11:12:47---------------------------------------------------
3675
3676 -----------------------------------------------------------------------*/
hasElements(void)3677 sal_Bool SwXLinkTargetSupplier::hasElements(void) throw( RuntimeException )
3678 {
3679 return 0 != pxDoc;
3680 }
3681 /*-- 25.10.99 11:12:47---------------------------------------------------
3682
3683 -----------------------------------------------------------------------*/
getImplementationName(void)3684 OUString SwXLinkTargetSupplier::getImplementationName(void) throw( RuntimeException )
3685 {
3686 return C2U("SwXLinkTargetSupplier");
3687 }
3688 /*-- 25.10.99 11:12:48---------------------------------------------------
3689
3690 -----------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)3691 sal_Bool SwXLinkTargetSupplier::supportsService(const OUString& rServiceName)
3692 throw( RuntimeException )
3693 {
3694 return (rServiceName == C2U("com.sun.star.document.LinkTargets"));
3695 }
3696 /*-- 25.10.99 11:12:48---------------------------------------------------
3697
3698 -----------------------------------------------------------------------*/
getSupportedServiceNames(void)3699 Sequence< OUString > SwXLinkTargetSupplier::getSupportedServiceNames(void)
3700 throw( RuntimeException )
3701 {
3702 Sequence< OUString > aRet(1);
3703 OUString* pNames = aRet.getArray();
3704 pNames[0] = C2U("com.sun.star.document.LinkTargets");
3705 return aRet;
3706 }
3707
3708 /*-- 26.10.99 09:16:23---------------------------------------------------
3709
3710 -----------------------------------------------------------------------*/
SwXLinkNameAccessWrapper(Reference<XNameAccess> xAccess,const String & rLinkDisplayName,String sSuffix)3711 SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper(
3712 Reference< XNameAccess > xAccess, const String& rLinkDisplayName, String sSuffix ) :
3713 xRealAccess(xAccess),
3714 pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
3715 sLinkSuffix(sSuffix),
3716 sLinkDisplayName(rLinkDisplayName),
3717 pxDoc(0)
3718 {
3719 }
3720 /* -----------------26.10.99 14:17-------------------
3721
3722 --------------------------------------------------*/
SwXLinkNameAccessWrapper(SwXTextDocument & rxDoc,const String & rLinkDisplayName,String sSuffix)3723 SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper(SwXTextDocument& rxDoc,
3724 const String& rLinkDisplayName, String sSuffix) :
3725 pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
3726 sLinkSuffix(sSuffix),
3727 sLinkDisplayName(rLinkDisplayName),
3728 xDoc(&rxDoc),
3729 pxDoc(&rxDoc)
3730 {
3731 }
3732 /*-- 26.10.99 09:16:23---------------------------------------------------
3733
3734 -----------------------------------------------------------------------*/
~SwXLinkNameAccessWrapper()3735 SwXLinkNameAccessWrapper::~SwXLinkNameAccessWrapper()
3736 {
3737 }
3738 /*-- 26.10.99 09:16:24---------------------------------------------------
3739
3740 -----------------------------------------------------------------------*/
getByName(const OUString & rName)3741 Any SwXLinkNameAccessWrapper::getByName(const OUString& rName)
3742 throw( NoSuchElementException, WrappedTargetException, RuntimeException )
3743 {
3744 Any aRet;
3745 sal_Bool bFound = sal_False;
3746 //cut link extension and call the real NameAccess
3747 String sParam = rName;
3748 String sSuffix(sLinkSuffix);
3749 if(sParam.Len() > sSuffix.Len() )
3750 {
3751 String sCmp = sParam.Copy(sParam.Len() - sSuffix.Len(),
3752 sSuffix.Len());
3753 if(sCmp == sSuffix)
3754 {
3755 if(pxDoc)
3756 {
3757 sParam = sParam.Copy(0, sParam.Len() - sSuffix.Len());
3758 if(!pxDoc->GetDocShell())
3759 throw RuntimeException();
3760 SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3761 sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count();
3762
3763 for (sal_uInt16 i = 0; i < nOutlineCount && !bFound; ++i)
3764 {
3765 const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3766 const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3767 if(sParam ==
3768 lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule))
3769 {
3770 Reference< XPropertySet > xOutline = new SwXOutlineTarget(sParam);
3771 aRet.setValue(&xOutline, ::getCppuType((Reference<XPropertySet>*)0));
3772 bFound = sal_True;
3773 }
3774 }
3775 }
3776 else
3777 {
3778 aRet = xRealAccess->getByName(sParam.Copy(0, sParam.Len() - sSuffix.Len()));
3779 Reference< XInterface > xInt;
3780 if(!(aRet >>= xInt))
3781 throw RuntimeException();
3782 Reference< XPropertySet > xProp(xInt, UNO_QUERY);
3783 aRet <<= xProp;
3784 bFound = sal_True;
3785 }
3786 }
3787 }
3788 if(!bFound)
3789 throw NoSuchElementException();
3790 return aRet;
3791 }
3792 /*-- 26.10.99 09:16:24---------------------------------------------------
3793
3794 -----------------------------------------------------------------------*/
getElementNames(void)3795 Sequence< OUString > SwXLinkNameAccessWrapper::getElementNames(void)
3796 throw( RuntimeException )
3797 {
3798 Sequence< OUString > aRet;
3799 if(pxDoc)
3800 {
3801 if(!pxDoc->GetDocShell())
3802 throw RuntimeException();
3803
3804 SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3805 const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3806 sal_uInt16 nOutlineCount = rOutlineNodes.Count();
3807 aRet.realloc(nOutlineCount);
3808 OUString* pResArr = aRet.getArray();
3809 String sSuffix('|');
3810 sSuffix += UniString::CreateFromAscii(pMarkToOutline);
3811 const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3812 for (sal_uInt16 i = 0; i < nOutlineCount; ++i)
3813 {
3814 String sEntry = lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule);
3815 sEntry += sSuffix;
3816 pResArr[i] = sEntry;
3817 }
3818 }
3819 else
3820 {
3821 Sequence< OUString > aOrg = xRealAccess->getElementNames();
3822 const OUString* pOrgArr = aOrg.getConstArray();
3823 aRet.realloc(aOrg.getLength());
3824 OUString* pResArr = aRet.getArray();
3825 for(long i = 0; i < aOrg.getLength(); i++)
3826 {
3827 pResArr[i] = pOrgArr[i] + sLinkSuffix;
3828 }
3829 }
3830 return aRet;
3831 }
3832 /*-- 26.10.99 09:16:25---------------------------------------------------
3833
3834 -----------------------------------------------------------------------*/
hasByName(const OUString & rName)3835 sal_Bool SwXLinkNameAccessWrapper::hasByName(const OUString& rName)
3836 throw( RuntimeException )
3837 {
3838 sal_Bool bRet = sal_False;
3839 String sParam(rName);
3840 if(sParam.Len() > sLinkSuffix.Len() )
3841 {
3842 String sCmp = sParam.Copy(sParam.Len() - sLinkSuffix.Len(),
3843 sLinkSuffix.Len());
3844 if(sCmp == sLinkSuffix)
3845 {
3846 sParam = sParam.Copy(0, sParam.Len() - sLinkSuffix.Len());
3847 if(pxDoc)
3848 {
3849 if(!pxDoc->GetDocShell())
3850 throw RuntimeException();
3851 SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc();
3852 sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count();
3853
3854 for (sal_uInt16 i = 0; i < nOutlineCount && !bRet; ++i)
3855 {
3856 const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds();
3857 const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule();
3858 if(sParam ==
3859 lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule))
3860 {
3861 bRet = sal_True;
3862 }
3863 }
3864 }
3865 else
3866 {
3867 bRet = xRealAccess->hasByName(sParam);
3868 }
3869 }
3870 }
3871 return bRet;
3872 }
3873 /*-- 26.10.99 09:16:25---------------------------------------------------
3874
3875 -----------------------------------------------------------------------*/
getElementType(void)3876 uno::Type SwXLinkNameAccessWrapper::getElementType(void)
3877 throw( RuntimeException )
3878 {
3879 return ::getCppuType((Reference<XPropertySet>*)0);
3880 }
3881 /*-- 26.10.99 09:16:25---------------------------------------------------
3882
3883 -----------------------------------------------------------------------*/
hasElements(void)3884 sal_Bool SwXLinkNameAccessWrapper::hasElements(void) throw( RuntimeException )
3885 {
3886 sal_Bool bRet = sal_False;
3887 if(pxDoc)
3888 {
3889 DBG_ERROR("not implemented");
3890 }
3891 else
3892 {
3893 bRet = xRealAccess->hasElements();
3894 }
3895 return bRet;
3896 }
3897 /*-- 26.10.99 09:16:26---------------------------------------------------
3898
3899 -----------------------------------------------------------------------*/
getPropertySetInfo(void)3900 Reference< XPropertySetInfo > SwXLinkNameAccessWrapper::getPropertySetInfo(void)
3901 throw( RuntimeException )
3902 {
3903 static Reference< XPropertySetInfo > xRet = pPropSet->getPropertySetInfo();
3904 return xRet;
3905 }
3906 /*-- 26.10.99 09:16:26---------------------------------------------------
3907
3908 -----------------------------------------------------------------------*/
setPropertyValue(const OUString &,const Any &)3909 void SwXLinkNameAccessWrapper::setPropertyValue(
3910 const OUString& , const Any& )
3911 throw( UnknownPropertyException,
3912 PropertyVetoException,
3913 IllegalArgumentException,
3914 WrappedTargetException,
3915 RuntimeException)
3916 {
3917 throw UnknownPropertyException();
3918 }
3919 /* -----------------------------08.12.99 11:10--------------------------------
3920
3921 ---------------------------------------------------------------------------*/
lcl_GetDisplayBitmap(String sLinkSuffix)3922 Any lcl_GetDisplayBitmap(String sLinkSuffix)
3923 {
3924 Any aRet;
3925 if(sLinkSuffix.Len())
3926 sLinkSuffix.Erase(0, 1);
3927 sal_uInt16 nImgId = USHRT_MAX;
3928
3929 if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOutline))
3930 nImgId = CONTENT_TYPE_OUTLINE;
3931 else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToTable))
3932 nImgId = CONTENT_TYPE_TABLE;
3933 else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToFrame))
3934 nImgId = CONTENT_TYPE_FRAME;
3935 else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToGraphic))
3936 nImgId = CONTENT_TYPE_GRAPHIC;
3937 // else if(== sLinkSuffix)
3938 // nImgId = CONTENT_TYPE_BOOKMARK;
3939 else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToRegion))
3940 nImgId = CONTENT_TYPE_REGION;
3941 else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOLE))
3942 nImgId = CONTENT_TYPE_OLE;
3943 else if(!sLinkSuffix.Len())
3944 nImgId = CONTENT_TYPE_BOOKMARK;
3945 if(USHRT_MAX != nImgId)
3946 {
3947 nImgId += 20000;
3948 sal_Bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
3949 ImageList aEntryImages( SW_RES(bHighContrast ? IMG_NAVI_ENTRYBMPH : IMG_NAVI_ENTRYBMP) );
3950 const Image& rImage = aEntryImages.GetImage( nImgId );
3951 Bitmap aBitmap( rImage.GetBitmapEx().GetBitmap() );
3952 Reference<awt::XBitmap> xBmp = VCLUnoHelper::CreateBitmap( aBitmap );
3953 aRet.setValue( &xBmp, ::getCppuType((Reference<awt::XBitmap>*)0) );
3954 }
3955 return aRet;
3956 }
3957 /*-- 26.10.99 09:16:27---------------------------------------------------
3958
3959 -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)3960 Any SwXLinkNameAccessWrapper::getPropertyValue(const OUString& rPropertyName)
3961 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3962 {
3963 Any aRet;
3964 if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
3965 {
3966 aRet <<= OUString(sLinkDisplayName);
3967 }
3968 else if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_BITMAP)))
3969 {
3970 aRet = lcl_GetDisplayBitmap(sLinkSuffix);
3971 }
3972 else
3973 throw UnknownPropertyException();
3974 return aRet;
3975 }
3976 /*-- 26.10.99 09:16:27---------------------------------------------------
3977
3978 -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)3979 void SwXLinkNameAccessWrapper::addPropertyChangeListener(
3980 const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
3981 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3982 {}
3983 /*-- 26.10.99 09:16:28---------------------------------------------------
3984
3985 -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)3986 void SwXLinkNameAccessWrapper::removePropertyChangeListener(
3987 const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
3988 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3989 {}
3990 /*-- 26.10.99 09:16:28---------------------------------------------------
3991
3992 -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)3993 void SwXLinkNameAccessWrapper::addVetoableChangeListener(
3994 const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
3995 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
3996 {}
3997 /*-- 26.10.99 09:16:29---------------------------------------------------
3998
3999 -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)4000 void SwXLinkNameAccessWrapper::removeVetoableChangeListener(
4001 const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
4002 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4003 {}
4004 /*-- 26.10.99 09:16:32---------------------------------------------------
4005
4006
4007 -----------------------------------------------------------------------*/
getLinks(void)4008 Reference< XNameAccess > SwXLinkNameAccessWrapper::getLinks(void)
4009 throw( RuntimeException )
4010 {
4011 return (SwXLinkNameAccessWrapper*)this;
4012 }
4013
4014 /*-- 26.10.99 09:21:48---------------------------------------------------
4015
4016 -----------------------------------------------------------------------*/
getImplementationName(void)4017 OUString SwXLinkNameAccessWrapper::getImplementationName(void) throw( RuntimeException )
4018 {
4019 return C2U("SwXLinkNameAccessWrapper");
4020 }
4021 /*-- 26.10.99 09:21:48---------------------------------------------------
4022
4023 -----------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)4024 sal_Bool SwXLinkNameAccessWrapper::supportsService(const OUString& rServiceName)
4025 throw( RuntimeException )
4026 {
4027 return (rServiceName == C2U("com.sun.star.document.LinkTargets"));
4028 }
4029 /*-- 26.10.99 09:21:48---------------------------------------------------
4030
4031 -----------------------------------------------------------------------*/
getSupportedServiceNames(void)4032 Sequence< OUString > SwXLinkNameAccessWrapper::getSupportedServiceNames(void)
4033 throw( RuntimeException )
4034 {
4035 Sequence< OUString > aRet(1);
4036 OUString* pNames = aRet.getArray();
4037 pNames[0] = C2U("com.sun.star.document.LinkTargets");
4038 return aRet;
4039 }
4040 /* -----------------26.10.99 15:50-------------------
4041
4042 --------------------------------------------------*/
SwXOutlineTarget(const String & rOutlineText)4043 SwXOutlineTarget::SwXOutlineTarget(const String& rOutlineText) :
4044 pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)),
4045 sOutlineText(rOutlineText)
4046 {
4047 }
4048 /*-- 26.10.99 15:51:45---------------------------------------------------
4049
4050 -----------------------------------------------------------------------*/
~SwXOutlineTarget()4051 SwXOutlineTarget::~SwXOutlineTarget()
4052 {
4053 }
4054 /*-- 26.10.99 15:51:46---------------------------------------------------
4055
4056 -----------------------------------------------------------------------*/
getPropertySetInfo(void)4057 Reference< XPropertySetInfo > SwXOutlineTarget::getPropertySetInfo(void) throw( RuntimeException )
4058 {
4059 static Reference< XPropertySetInfo > xRet = pPropSet->getPropertySetInfo();
4060 return xRet;
4061 }
4062 /*-- 26.10.99 15:51:46---------------------------------------------------
4063
4064 -----------------------------------------------------------------------*/
setPropertyValue(const OUString &,const Any &)4065 void SwXOutlineTarget::setPropertyValue(
4066 const OUString& /*PropertyName*/, const Any& /*aValue*/)
4067 throw( UnknownPropertyException, PropertyVetoException,
4068 IllegalArgumentException, WrappedTargetException, RuntimeException)
4069 {
4070 throw UnknownPropertyException();
4071 }
4072 /*-- 26.10.99 15:51:46---------------------------------------------------
4073
4074 -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)4075 Any SwXOutlineTarget::getPropertyValue(const OUString& rPropertyName)
4076 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4077 {
4078 Any aRet;
4079 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME)))
4080 aRet <<= OUString(sOutlineText);
4081 else
4082 throw UnknownPropertyException();
4083 return aRet;
4084 }
4085 /*-- 26.10.99 15:51:46---------------------------------------------------
4086
4087 -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)4088 void SwXOutlineTarget::addPropertyChangeListener(
4089 const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
4090 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4091 {
4092 }
4093 /*-- 26.10.99 15:51:47---------------------------------------------------
4094
4095 -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)4096 void SwXOutlineTarget::removePropertyChangeListener(
4097 const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/)
4098 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4099 {
4100 }
4101 /*-- 26.10.99 15:51:47---------------------------------------------------
4102
4103 -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)4104 void SwXOutlineTarget::addVetoableChangeListener(
4105 const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
4106 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4107 {
4108 }
4109 /*-- 26.10.99 15:51:47---------------------------------------------------
4110
4111 -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)4112 void SwXOutlineTarget::removeVetoableChangeListener(
4113 const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/)
4114 throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
4115 {
4116 }
4117 /* -----------------03.05.99 12:28-------------------
4118 *
4119 * --------------------------------------------------*/
getImplementationName(void)4120 OUString SwXOutlineTarget::getImplementationName(void) throw( RuntimeException )
4121 {
4122 return C2U("SwXOutlineTarget");
4123 }
4124 /* -----------------03.05.99 12:28-------------------
4125 *
4126 * --------------------------------------------------*/
supportsService(const OUString & ServiceName)4127 sal_Bool SwXOutlineTarget::supportsService(const OUString& ServiceName) throw( RuntimeException )
4128 {
4129 return C2U("com.sun.star.document.LinkTarget") == ServiceName;
4130 }
4131 /* -----------------03.05.99 12:28-------------------
4132 *
4133 * --------------------------------------------------*/
getSupportedServiceNames(void)4134 Sequence< OUString > SwXOutlineTarget::getSupportedServiceNames(void) throw( RuntimeException )
4135 {
4136 Sequence < OUString > aRet(1);
4137 OUString* pArray = aRet.getArray();
4138 pArray[0] = C2U("com.sun.star.document.LinkTarget");
4139
4140 return aRet;
4141 }
4142 /* -----------------------------17.01.01 16:06--------------------------------
4143
4144 ---------------------------------------------------------------------------*/
SwXDocumentPropertyHelper(SwDoc & rDoc)4145 SwXDocumentPropertyHelper::SwXDocumentPropertyHelper(SwDoc& rDoc) :
4146 SvxUnoForbiddenCharsTable ( rDoc.getForbiddenCharacterTable() )
4147 ,m_pDoc(&rDoc)
4148 {
4149 }
4150 /* -----------------------------17.01.01 16:06--------------------------------
4151
4152 ---------------------------------------------------------------------------*/
~SwXDocumentPropertyHelper()4153 SwXDocumentPropertyHelper::~SwXDocumentPropertyHelper()
4154 {
4155 }
4156 /* -----------------------------17.01.01 16:06--------------------------------
4157
4158 ---------------------------------------------------------------------------*/
GetDrawTable(short nWhich)4159 Reference<XInterface> SwXDocumentPropertyHelper::GetDrawTable(short nWhich)
4160 {
4161 Reference<XInterface> xRet;
4162 if(m_pDoc)
4163 {
4164 switch(nWhich)
4165 {
4166 // --> OD 2005-08-08 #i52858#
4167 // assure that Draw model is created, if it doesn't exist.
4168 case SW_CREATE_DASH_TABLE :
4169 if(!xDashTable.is())
4170 xDashTable = SvxUnoDashTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4171 xRet = xDashTable;
4172 break;
4173 case SW_CREATE_GRADIENT_TABLE :
4174 if(!xGradientTable.is())
4175 xGradientTable = SvxUnoGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4176 xRet = xGradientTable;
4177 break;
4178 case SW_CREATE_HATCH_TABLE :
4179 if(!xHatchTable.is())
4180 xHatchTable = SvxUnoHatchTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4181 xRet = xHatchTable;
4182 break;
4183 case SW_CREATE_BITMAP_TABLE :
4184 if(!xBitmapTable.is())
4185 xBitmapTable = SvxUnoBitmapTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4186 xRet = xBitmapTable;
4187 break;
4188 case SW_CREATE_TRANSGRADIENT_TABLE:
4189 if(!xTransGradientTable.is())
4190 xTransGradientTable = SvxUnoTransGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4191 xRet = xTransGradientTable;
4192 break;
4193 case SW_CREATE_MARKER_TABLE :
4194 if(!xMarkerTable.is())
4195 xMarkerTable = SvxUnoMarkerTable_createInstance( m_pDoc->GetOrCreateDrawModel() );
4196 xRet = xMarkerTable;
4197 break;
4198 // <--
4199 case SW_CREATE_DRAW_DEFAULTS:
4200 if(!xDrawDefaults.is())
4201 xDrawDefaults = (cppu::OWeakObject*)new SwSvxUnoDrawPool(m_pDoc);
4202 xRet = xDrawDefaults;
4203 break;
4204 #ifdef DBG_UTIL
4205 default: DBG_ERROR("which table?");
4206 #endif
4207 }
4208 }
4209 return xRet;
4210 }
4211
Invalidate()4212 void SwXDocumentPropertyHelper::Invalidate()
4213 {
4214 xDashTable = 0;
4215 xGradientTable = 0;
4216 xHatchTable = 0;
4217 xBitmapTable = 0;
4218 xTransGradientTable = 0;
4219 xMarkerTable = 0;
4220 xDrawDefaults = 0;
4221 m_pDoc = 0;
4222 SvxUnoForbiddenCharsTable::mxForbiddenChars.unbind();
4223 }
4224 /* -----------------13.08.2003 12:43-----------------
4225
4226 --------------------------------------------------*/
onChange()4227 void SwXDocumentPropertyHelper::onChange()
4228 {
4229 if(m_pDoc)
4230 m_pDoc->SetModified();
4231 }
4232
4233
4234 /*****************************************************************************/
4235
SwViewOptionAdjust_Impl(ViewShell & rSh,const SwViewOption & rViewOptions)4236 SwViewOptionAdjust_Impl::SwViewOptionAdjust_Impl( ViewShell& rSh, const SwViewOption &rViewOptions ) :
4237 m_rShell( rSh ),
4238 m_aOldViewOptions( rViewOptions )
4239 {
4240 }
4241
4242
~SwViewOptionAdjust_Impl()4243 SwViewOptionAdjust_Impl::~SwViewOptionAdjust_Impl()
4244 {
4245 m_rShell.ApplyViewOptions( m_aOldViewOptions );
4246 }
4247
4248
4249 void
AdjustViewOptions(SwPrintData const * const pPrtOptions)4250 SwViewOptionAdjust_Impl::AdjustViewOptions(SwPrintData const*const pPrtOptions)
4251 {
4252 // to avoid unnecessary reformatting the view options related to the content
4253 // below should only change if necessary, that is if respective content is present
4254 const bool bContainsHiddenChars = m_rShell.GetDoc()->ContainsHiddenChars();
4255 const SwFieldType* pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENTXTFLD );
4256 const bool bContainsHiddenFields = pFldType && pFldType->GetDepends();
4257 pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENPARAFLD );
4258 const bool bContainsHiddenParagraphs = pFldType && pFldType->GetDepends();
4259 pFldType = m_rShell.GetDoc()->GetSysFldType( RES_JUMPEDITFLD );
4260 const bool bContainsPlaceHolders = pFldType && pFldType->GetDepends();
4261 const bool bContainsFields = m_rShell.IsAnyFieldInDoc();
4262
4263 SwViewOption aRenderViewOptions( m_aOldViewOptions );
4264
4265 // disable anything in the view that should not be printed (or exported to PDF) by default
4266 // (see also dialog "Tools/Options - StarOffice Writer - Formatting Aids"
4267 // in section "Display of ...")
4268 aRenderViewOptions.SetParagraph( sal_False ); // paragraph end
4269 aRenderViewOptions.SetSoftHyph( sal_False ); // aka custom hyphens
4270 aRenderViewOptions.SetBlank( sal_False ); // spaces
4271 aRenderViewOptions.SetHardBlank( sal_False ); // non-breaking spaces
4272 aRenderViewOptions.SetTab( sal_False ); // tabs
4273 aRenderViewOptions.SetLineBreak( sal_False ); // breaks (type 1)
4274 aRenderViewOptions.SetPageBreak( sal_False ); // breaks (type 2)
4275 aRenderViewOptions.SetColumnBreak( sal_False ); // breaks (type 3)
4276 sal_Bool bVal = pPrtOptions? pPrtOptions->bPrintHiddenText : sal_False;
4277 if (bContainsHiddenChars)
4278 aRenderViewOptions.SetShowHiddenChar( bVal ); // hidden text
4279 if (bContainsHiddenFields)
4280 aRenderViewOptions.SetShowHiddenField( bVal );
4281 if (bContainsHiddenParagraphs)
4282 aRenderViewOptions.SetShowHiddenPara( bVal );
4283
4284 if (bContainsPlaceHolders)
4285 {
4286 // should always be printed in PDF export!
4287 bVal = pPrtOptions ? pPrtOptions->bPrintTextPlaceholder : sal_True;
4288 aRenderViewOptions.SetShowPlaceHolderFields( bVal );
4289 }
4290
4291 if (bContainsFields)
4292 aRenderViewOptions.SetFldName( sal_False );
4293
4294 // we need to set this flag in order to get to see the visible effect of
4295 // some of the above settings (needed for correct rendering)
4296 aRenderViewOptions.SetViewMetaChars( sal_True );
4297
4298 if (m_aOldViewOptions != aRenderViewOptions) // check if reformatting is necessary
4299 {
4300 aRenderViewOptions.SetPrinting( pPrtOptions != NULL );
4301 m_rShell.ApplyViewOptions( aRenderViewOptions );
4302 }
4303 }
4304
4305
4306 /*****************************************************************************/
4307
4308
4309