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