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