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