/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sw.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // SfxObjectShellRef <-> SV_DECL_REF(SfxObjectShell) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // --> FME 2004-06-08 #i12836# enhanced pdf export #include // <-- #include ///////////////////////////Modified on Jun. 14th////////////////////////// ///////////////////////for getDocumentLanguages/////////////////////////// //--> #include #include #include //SwCharFmts #include #include #include //SwCharFmt #include //SwTxtFmtColl #include //SwAutoStyleFamily #include // handling of automatic styles #include #include #include #include //#include #include #include #include #include #include #include #include #include #include // //<-- using namespace ::com::sun::star; using namespace ::com::sun::star::text; using namespace ::com::sun::star::i18n; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::container; using namespace ::com::sun::star::document; using namespace ::com::sun::star::i18n; using ::rtl::OUString; using ::osl::FileBase; /* -----------------------------17.01.01 15:43-------------------------------- ---------------------------------------------------------------------------*/ #define SW_CREATE_DASH_TABLE 0x01 #define SW_CREATE_GRADIENT_TABLE 0x02 #define SW_CREATE_HATCH_TABLE 0x03 #define SW_CREATE_BITMAP_TABLE 0x04 #define SW_CREATE_TRANSGRADIENT_TABLE 0x05 #define SW_CREATE_MARKER_TABLE 0x06 #define SW_CREATE_DRAW_DEFAULTS 0x07 /****************************************************************************** * ******************************************************************************/ extern bool lcl_GetPostIts( IDocumentFieldsAccess* pIDFA, _SetGetExpFlds * pSrtLst ); SwPrintUIOptions * lcl_GetPrintUIOptions( SwDocShell * pDocShell, const SfxViewShell * pView ) { if (!pDocShell) return NULL; const sal_Bool bWebDoc = NULL != dynamic_cast< const SwWebDocShell * >(pDocShell); const bool bSwSrcView = NULL != dynamic_cast< const SwSrcView * >(pView); const SwView * pSwView = dynamic_cast< const SwView * >(pView); const bool bHasSelection = pSwView ? pSwView->HasSelection( sal_False ) : false; // check for any selection, not just text selection const bool bHasPostIts = lcl_GetPostIts( pDocShell->GetDoc(), 0 ); // get default values to use in dialog from documents SwPrintData const SwPrintData &rPrintData = pDocShell->GetDoc()->getPrintData(); return new SwPrintUIOptions( bWebDoc, bSwSrcView, bHasSelection, bHasPostIts, rPrintData ); } //////////////////////////////////////////////////////////// SwTxtFmtColl *lcl_GetParaStyle(const String& rCollName, SwDoc* pDoc) { SwTxtFmtColl* pColl = pDoc->FindTxtFmtCollByName( rCollName ); if( !pColl ) { sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( rCollName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ); if( USHRT_MAX != nId ) pColl = pDoc->GetTxtCollFromPool( nId ); } return pColl; } void lcl_DisposeView( SfxViewFrame* pToClose, SwDocShell* pDocShell ) { // check if the view frame still exists SfxViewFrame* pFound = SfxViewFrame::GetFirst( pDocShell, sal_False ); while(pFound) { if( pFound == pToClose) { pToClose->DoClose(); break; } pFound = SfxViewFrame::GetNext( *pFound, pDocShell, sal_False ); } } /* -----------------------------10.03.00 18:02-------------------------------- ---------------------------------------------------------------------------*/ const Sequence< sal_Int8 > & SwXTextDocument::getUnoTunnelId() { static Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); return aSeq; } /* -----------------------------10.03.00 18:04-------------------------------- ---------------------------------------------------------------------------*/ sal_Int64 SAL_CALL SwXTextDocument::getSomething( const Sequence< sal_Int8 >& rId ) throw(RuntimeException) { if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) { return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this )); } sal_Int64 nRet = SfxBaseModel::getSomething( rId ); if ( nRet ) return nRet; else { GetNumberFormatter(); Any aNumTunnel = xNumFmtAgg->queryAggregation(::getCppuType((Reference*)0)); Reference xNumTunnel; aNumTunnel >>= xNumTunnel; if(xNumTunnel.is()) return xNumTunnel->getSomething(rId); } return SfxBaseModel::getSomething( rId ); } /* -----------------------------16.03.00 14:12-------------------------------- ---------------------------------------------------------------------------*/ Any SAL_CALL SwXTextDocument::queryInterface( const uno::Type& rType ) throw(RuntimeException) { Any aRet = SwXTextDocumentBaseClass::queryInterface(rType); if ( !aRet.hasValue() ) aRet = SfxBaseModel::queryInterface(rType); if ( !aRet.hasValue() && rType == ::getCppuType((Reference*)0)) { Reference xTmp = this; aRet <<= xTmp; } if ( !aRet.hasValue() && rType != ::getCppuType((Reference< com::sun::star::document::XDocumentEventBroadcaster>*)0) && rType != ::getCppuType((Reference< com::sun::star::frame::XController>*)0) && rType != ::getCppuType((Reference< com::sun::star::frame::XFrame>*)0) && rType != ::getCppuType((Reference< com::sun::star::script::XInvocation>*)0) && rType != ::getCppuType((Reference< com::sun::star::reflection::XIdlClassProvider>*)0) && rType != ::getCppuType((Reference< com::sun::star::beans::XFastPropertySet>*)0) && rType != ::getCppuType((Reference< com::sun::star::awt::XWindow>*)0)) { GetNumberFormatter(); if(xNumFmtAgg.is()) aRet = xNumFmtAgg->queryAggregation(rType); } return aRet; } /* -----------------------------16.03.00 14:12-------------------------------- ---------------------------------------------------------------------------*/ void SAL_CALL SwXTextDocument::acquire()throw() { SfxBaseModel::acquire(); } /* -----------------------------16.03.00 14:12-------------------------------- ---------------------------------------------------------------------------*/ void SAL_CALL SwXTextDocument::release()throw() { SfxBaseModel::release(); } /* -----------------------------07.12.00 11:37-------------------------------- ---------------------------------------------------------------------------*/ Reference< XAdapter > SwXTextDocument::queryAdapter( ) throw(RuntimeException) { return SfxBaseModel::queryAdapter(); } /* -----------------------------16.03.00 14:12-------------------------------- ---------------------------------------------------------------------------*/ Sequence< uno::Type > SAL_CALL SwXTextDocument::getTypes() throw(RuntimeException) { Sequence< uno::Type > aBaseTypes = SfxBaseModel::getTypes(); Sequence< uno::Type > aTextTypes = SwXTextDocumentBaseClass::getTypes(); Sequence< uno::Type > aNumTypes; GetNumberFormatter(); if(xNumFmtAgg.is()) { const uno::Type& rProvType = ::getCppuType((Reference *)0); Any aNumProv = xNumFmtAgg->queryAggregation(rProvType); Reference xNumProv; if(aNumProv >>= xNumProv) { aNumTypes = xNumProv->getTypes(); } } long nIndex = aBaseTypes.getLength(); // don't forget the lang::XMultiServiceFactory aBaseTypes.realloc(aBaseTypes.getLength() + aTextTypes.getLength() + aNumTypes.getLength() + 1); uno::Type* pBaseTypes = aBaseTypes.getArray(); const uno::Type* pTextTypes = aTextTypes.getConstArray(); long nPos; for(nPos = 0; nPos < aTextTypes.getLength(); nPos++) { pBaseTypes[nIndex++] = pTextTypes[nPos]; } const uno::Type* pNumTypes = aNumTypes.getConstArray(); for(nPos = 0; nPos < aNumTypes.getLength(); nPos++) { pBaseTypes[nIndex++] = pNumTypes[nPos]; } pBaseTypes[nIndex++] = ::getCppuType((Reference*)0); return aBaseTypes; } /*-- 18.12.98 11:52:59--------------------------------------------------- -----------------------------------------------------------------------*/ SwXTextDocument::SwXTextDocument(SwDocShell* pShell) : SfxBaseModel(pShell), aRefreshCont ( static_cast < XTextDocument* > ( this ) ), pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_DOCUMENT)), pDocShell(pShell), bObjectValid(pShell != 0), pDrawPage(0), pxXDrawPage(0), pxXNumberingRules(0), pxXFootnotes(0), pxXFootnoteSettings(0), pxXEndnotes(0), pxXEndnoteSettings(0), pxXReferenceMarks(0), pxXTextFieldTypes(0), pxXTextFieldMasters(0), pxXTextSections(0), pxXBookmarks(0), pxXTextTables(0), pxXTextFrames(0), pxXGraphicObjects(0), pxXEmbeddedObjects(0), pxXStyleFamilies(0), pxXAutoStyles(0), pxXChapterNumbering(0), pxXDocumentIndexes(0), pxXLineNumberingProperties(0), pxLinkTargetSupplier(0), pxXRedlines(0), m_pHiddenViewFrame(0), m_pPrintUIOptions( NULL ), m_pRenderData( NULL ), // --> OD #i117783# bApplyPagePrintSettingsFromXPagePrintable( sal_False ) // <-- { } /*-- 18.12.98 11:53:00--------------------------------------------------- -----------------------------------------------------------------------*/ SwXTextDocument::~SwXTextDocument() { InitNewDoc(); if(xNumFmtAgg.is()) { Reference< XInterface > x0; xNumFmtAgg->setDelegator(x0); xNumFmtAgg = 0; } delete m_pPrintUIOptions; delete m_pRenderData; } /*-- 18.12.98 11:55:08--------------------------------------------------- -----------------------------------------------------------------------*/ /* -----------------18.12.98 12:49------------------- * * --------------------------------------------------*/ SwXDocumentPropertyHelper * SwXTextDocument::GetPropertyHelper () { if(!xPropertyHelper.is()) { pPropertyHelper = new SwXDocumentPropertyHelper(*pDocShell->GetDoc()); xPropertyHelper = (cppu::OWeakObject*)pPropertyHelper; } return pPropertyHelper; } void SwXTextDocument::GetNumberFormatter() { if(IsValid()) { if(!xNumFmtAgg.is()) { if ( pDocShell->GetDoc() ) { SvNumberFormatsSupplierObj* pNumFmt = new SvNumberFormatsSupplierObj( pDocShell->GetDoc()->GetNumberFormatter( sal_True )); Reference< util::XNumberFormatsSupplier > xTmp = pNumFmt; xNumFmtAgg = Reference< XAggregation >(xTmp, UNO_QUERY); } if(xNumFmtAgg.is()) xNumFmtAgg->setDelegator((cppu::OWeakObject*)(SwXTextDocumentBaseClass*)this); } else { const uno::Type& rTunnelType = ::getCppuType((Reference *)0); Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType); SvNumberFormatsSupplierObj* pNumFmt = 0; Reference< XUnoTunnel > xNumTunnel; if(aNumTunnel >>= xNumTunnel) { pNumFmt = reinterpret_cast( xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId())); } DBG_ASSERT(pNumFmt, "No number formatter available"); if(!pNumFmt->GetNumberFormatter()) pNumFmt->SetNumberFormatter(pDocShell->GetDoc()->GetNumberFormatter( sal_True )); } } } /*-- 18.12.98 11:55:11--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XText > SwXTextDocument::getText(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!xBodyText.is()) { pBodyText = new SwXBodyText(pDocShell->GetDoc()); xBodyText = pBodyText; } return xBodyText; } /*-- 18.12.98 11:55:11--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::reformat(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); } /*-- 18.12.98 11:55:16--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::lockControllers(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(IsValid()) { UnoActionContext* pContext = new UnoActionContext(pDocShell->GetDoc()); aActionArr.Insert(pContext, 0); } else throw RuntimeException(); } /*-- 18.12.98 11:55:16--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::unlockControllers(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(aActionArr.Count()) { UnoActionContext* pContext = aActionArr.GetObject(0); aActionArr.Remove(0); delete pContext; } else throw RuntimeException(); } /*-- 18.12.98 11:55:17--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXTextDocument::hasControllersLocked(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); return aActionArr.Count() > 0; } /*-- 18.12.98 13:12:23--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< frame::XController > SwXTextDocument::getCurrentController(void) throw( RuntimeException ) { return SfxBaseModel::getCurrentController(); } /*-- 18.12.98 13:12:24--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::setCurrentController(const Reference< frame::XController > & xController) throw( NoSuchElementException, RuntimeException ) { SfxBaseModel::setCurrentController(xController); } /* -----------------27.01.99 11:48------------------- * * --------------------------------------------------*/ Reference< XInterface > SwXTextDocument::getCurrentSelection() throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< XInterface > xRef; if(IsValid()) { const TypeId aTypeId = TYPE(SwView); SwView* pView = (SwView*)SfxViewShell::GetFirst(&aTypeId); while(pView && pView->GetObjectShell() != pDocShell) { pView = (SwView*)SfxViewShell::GetNext(*pView, &aTypeId); } if(pView) { Any aRef = pView->GetUNOObject()->getSelection(); aRef >>= xRef; } } return xRef; } /*-- 18.12.98 13:12:24--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXTextDocument::attachResource(const OUString& aURL, const Sequence< beans::PropertyValue >& aArgs) throw( RuntimeException ) { return SfxBaseModel::attachResource(aURL, aArgs); } /*-- 18.12.98 13:12:24--------------------------------------------------- -----------------------------------------------------------------------*/ OUString SwXTextDocument::getURL(void) throw( RuntimeException ) { return SfxBaseModel::getURL(); } /*-- 18.12.98 13:12:24--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< beans::PropertyValue > SwXTextDocument::getArgs(void) throw( RuntimeException ) { return SfxBaseModel::getArgs(); } /*-- 18.12.98 13:12:24--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::connectController(const Reference< frame::XController > & xController) throw( RuntimeException ) { SfxBaseModel::connectController(xController); } /*-- 18.12.98 13:12:25--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::disconnectController(const Reference< frame::XController > & xController) throw( RuntimeException ) { SfxBaseModel::disconnectController(xController); } /*-- 18.12.98 13:12:25--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::dispose(void) throw( RuntimeException ) { SfxBaseModel::dispose(); } /*-- 10.05.2005 14:14:39--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::close( sal_Bool bDeliverOwnership ) throw( util::CloseVetoException, RuntimeException ) { if ( IsValid() && m_pHiddenViewFrame ) { ASSERT( false, " - rendering data not cleaned up???" ); lcl_DisposeView( m_pHiddenViewFrame, pDocShell); m_pHiddenViewFrame = 0; // prevent crash described in #i108805 SfxItemSet *pSet = pDocShell->GetMedium()->GetItemSet(); pSet->Put( SfxBoolItem( SID_HIDDEN, sal_False ) ); } SfxBaseModel::close(bDeliverOwnership); } /*-- 18.12.98 13:12:25--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::addEventListener(const Reference< lang::XEventListener > & aListener) throw( RuntimeException ) { SfxBaseModel::addEventListener(aListener); } /*-- 18.12.98 13:12:26--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::removeEventListener(const Reference< lang::XEventListener > & aListener) throw( RuntimeException ) { SfxBaseModel::removeEventListener(aListener); } /*-- 18.12.98 11:55:19--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySet > SwXTextDocument::getLineNumberingProperties(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(IsValid()) { if(!pxXLineNumberingProperties) { pxXLineNumberingProperties = new Reference; (*pxXLineNumberingProperties) = new SwXLineNumberingProperties(pDocShell->GetDoc()); } } else throw RuntimeException(); return *pxXLineNumberingProperties; } /*-- 18.12.98 11:55:20--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XIndexReplace > SwXTextDocument::getChapterNumberingRules(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXChapterNumbering) { pxXChapterNumbering = new Reference< XIndexReplace > ; *pxXChapterNumbering = new SwXChapterNumbering(*pDocShell); } return *pxXChapterNumbering; } Reference< XIndexAccess > SwXTextDocument::getNumberingRules(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXNumberingRules ) { ((SwXTextDocument*)this)->pxXNumberingRules = new Reference< XIndexAccess > ; *pxXNumberingRules = new SwXNumberingRulesCollection( pDocShell->GetDoc() ); } return *pxXNumberingRules; } /*-- 18.12.98 11:55:21--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XIndexAccess > SwXTextDocument::getFootnotes(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXFootnotes) { ((SwXTextDocument*)this)->pxXFootnotes = new Reference< XIndexAccess > ; *pxXFootnotes = new SwXFootnotes(sal_False, pDocShell->GetDoc()); } return *pxXFootnotes; } /*-- 18.12.98 11:55:21--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySet > SAL_CALL SwXTextDocument::getFootnoteSettings(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXFootnoteSettings) { ((SwXTextDocument*)this)->pxXFootnoteSettings = new Reference< XPropertySet > ; *pxXFootnoteSettings = new SwXFootnoteProperties(pDocShell->GetDoc()); } return *pxXFootnoteSettings; } /*-- 18.12.98 11:55:21--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XIndexAccess > SwXTextDocument::getEndnotes(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXEndnotes) { ((SwXTextDocument*)this)->pxXEndnotes = new Reference< XIndexAccess > ; *pxXEndnotes = new SwXFootnotes(sal_True, pDocShell->GetDoc()); } return *pxXEndnotes; } /*-- 18.12.98 11:55:22--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySet > SwXTextDocument::getEndnoteSettings(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXEndnoteSettings) { ((SwXTextDocument*)this)->pxXEndnoteSettings = new Reference< XPropertySet > ; *pxXEndnoteSettings = new SwXEndnoteProperties(pDocShell->GetDoc()); } return *pxXEndnoteSettings; } /*-- 18.12.98 11:55:22--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< util::XReplaceDescriptor > SwXTextDocument::createReplaceDescriptor(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< util::XReplaceDescriptor > xRet = new SwXTextSearch; return xRet; } /* -----------------26.02.99 15:52------------------- * * --------------------------------------------------*/ SwUnoCrsr* SwXTextDocument::CreateCursorForSearch(Reference< XTextCursor > & xCrsr) { getText(); XText *const pText = xBodyText.get(); SwXBodyText* pBText = (SwXBodyText*)pText; SwXTextCursor *const pXTextCursor = pBText->CreateTextCursor(true); xCrsr.set( static_cast(pXTextCursor) ); SwUnoCrsr *const pUnoCrsr = pXTextCursor->GetCursor(); pUnoCrsr->SetRemainInSection(sal_False); return pUnoCrsr; } /*-- 18.12.98 11:55:22--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Int32 SwXTextDocument::replaceAll(const Reference< util::XSearchDescriptor > & xDesc) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< XUnoTunnel > xDescTunnel(xDesc, UNO_QUERY); if(!IsValid() || !xDescTunnel.is() || !xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId())) throw RuntimeException(); Reference< XTextCursor > xCrsr; SwUnoCrsr* pUnoCrsr = CreateCursorForSearch(xCrsr); const SwXTextSearch* pSearch = reinterpret_cast( xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId())); int eRanges(FND_IN_BODY|FND_IN_SELALL); util::SearchOptions aSearchOpt; pSearch->FillSearchOptions( aSearchOpt ); SwDocPositions eStart = pSearch->bBack ? DOCPOS_END : DOCPOS_START; SwDocPositions eEnd = pSearch->bBack ? DOCPOS_START : DOCPOS_END; // Suche soll ueberall stattfinden pUnoCrsr->SetRemainInSection(sal_False); sal_uInt32 nResult; UnoActionContext aContext(pDocShell->GetDoc()); //try attribute search first if(pSearch->HasSearchAttributes()||pSearch->HasReplaceAttributes()) { SfxItemSet aSearch(pDocShell->GetDoc()->GetAttrPool(), RES_CHRATR_BEGIN, RES_CHRATR_END-1, RES_PARATR_BEGIN, RES_PARATR_END-1, RES_FRMATR_BEGIN, RES_FRMATR_END-1, 0); SfxItemSet aReplace(pDocShell->GetDoc()->GetAttrPool(), RES_CHRATR_BEGIN, RES_CHRATR_END-1, RES_PARATR_BEGIN, RES_PARATR_END-1, RES_FRMATR_BEGIN, RES_FRMATR_END-1, 0); pSearch->FillSearchItemSet(aSearch); pSearch->FillReplaceItemSet(aReplace); sal_Bool bCancel; nResult = (sal_Int32)pUnoCrsr->Find( aSearch, !pSearch->bStyles, eStart, eEnd, bCancel, (FindRanges)eRanges, pSearch->sSearchText.Len() ? &aSearchOpt : 0, &aReplace ); } else if(pSearch->bStyles) { SwTxtFmtColl *pSearchColl = lcl_GetParaStyle(pSearch->sSearchText, pUnoCrsr->GetDoc()); SwTxtFmtColl *pReplaceColl = lcl_GetParaStyle(pSearch->sReplaceText, pUnoCrsr->GetDoc());; sal_Bool bCancel; nResult = pUnoCrsr->Find( *pSearchColl, eStart, eEnd, bCancel, (FindRanges)eRanges, pReplaceColl ); } else { //todo/mba: assuming that notes should be omitted sal_Bool bSearchInNotes = sal_False; sal_Bool bCancel; nResult = pUnoCrsr->Find( aSearchOpt, bSearchInNotes, eStart, eEnd, bCancel, (FindRanges)eRanges, sal_True ); } return (sal_Int32)nResult; } /*-- 18.12.98 11:55:22--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< util::XSearchDescriptor > SwXTextDocument::createSearchDescriptor(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< util::XSearchDescriptor > xRet = new SwXTextSearch; return xRet; } /* -----------------26.02.99 16:08------------------- * wird fuer findAll/First/Next verwendet * --------------------------------------------------*/ SwUnoCrsr* SwXTextDocument::FindAny(const Reference< util::XSearchDescriptor > & xDesc, Reference< XTextCursor > & xCrsr, sal_Bool bAll, sal_Int32& nResult, Reference< XInterface > xLastResult) { Reference< XUnoTunnel > xDescTunnel(xDesc, UNO_QUERY); if(!IsValid() || !xDescTunnel.is() || !xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId())) return 0; SwUnoCrsr* pUnoCrsr = CreateCursorForSearch(xCrsr); const SwXTextSearch* pSearch = reinterpret_cast( xDescTunnel->getSomething(SwXTextSearch::getUnoTunnelId())); sal_Bool bParentInExtra = sal_False; if(xLastResult.is()) { Reference xCursorTunnel( xLastResult, UNO_QUERY); OTextCursorHelper* pPosCrsr = 0; if(xCursorTunnel.is()) { pPosCrsr = reinterpret_cast(xCursorTunnel->getSomething( OTextCursorHelper::getUnoTunnelId())); } SwPaM* pCrsr = pPosCrsr ? pPosCrsr->GetPaM() : 0; if(pCrsr) { *pUnoCrsr->GetPoint() = *pCrsr->End(); pUnoCrsr->DeleteMark(); } else { SwXTextRange* pRange = 0; if(xCursorTunnel.is()) { pRange = reinterpret_cast(xCursorTunnel->getSomething( SwXTextRange::getUnoTunnelId())); } if(!pRange) return 0; pRange->GetPositions(*pUnoCrsr); if(pUnoCrsr->HasMark()) { if(*pUnoCrsr->GetPoint() < *pUnoCrsr->GetMark()) pUnoCrsr->Exchange(); pUnoCrsr->DeleteMark(); } } const SwNode* pRangeNode = pUnoCrsr->GetNode(); bParentInExtra = pRangeNode->FindFlyStartNode() || pRangeNode->FindFootnoteStartNode() || pRangeNode->FindHeaderStartNode() || pRangeNode->FindFooterStartNode() ; } util::SearchOptions aSearchOpt; pSearch->FillSearchOptions( aSearchOpt ); /* * folgende Kombinationen sind erlaubt: * - suche einen im Body: -> FND_IN_BODY * - suche alle im Body: -> FND_IN_BODYONLY | FND_IN_SELALL * - suche in Selectionen: einen / alle -> FND_IN_SEL [ | FND_IN_SELALL ] * - suche im nicht Body: einen / alle -> FND_IN_OTHER [ | FND_IN_SELALL ] * - suche ueberall alle: -> FND_IN_SELALL */ int eRanges(FND_IN_BODY); if(bParentInExtra) eRanges = FND_IN_OTHER; if(bAll) //immer - ueberall? eRanges = FND_IN_SELALL; SwDocPositions eStart = !bAll ? DOCPOS_CURR : pSearch->bBack ? DOCPOS_END : DOCPOS_START; SwDocPositions eEnd = pSearch->bBack ? DOCPOS_START : DOCPOS_END; nResult = 0; sal_uInt16 nSearchProc = 0; while(nSearchProc < 2) { //try attribute search first if(pSearch->HasSearchAttributes()) { SfxItemSet aSearch(pDocShell->GetDoc()->GetAttrPool(), RES_CHRATR_BEGIN, RES_CHRATR_END-1, RES_PARATR_BEGIN, RES_PARATR_END-1, RES_FRMATR_BEGIN, RES_FRMATR_END-1, RES_TXTATR_INETFMT, RES_TXTATR_CHARFMT, 0); pSearch->FillSearchItemSet(aSearch); sal_Bool bCancel; nResult = (sal_Int32)pUnoCrsr->Find( aSearch, !pSearch->bStyles, eStart, eEnd, bCancel, (FindRanges)eRanges, pSearch->sSearchText.Len() ? &aSearchOpt : 0, 0 ); } else if(pSearch->bStyles) { SwTxtFmtColl *pSearchColl = lcl_GetParaStyle(pSearch->sSearchText, pUnoCrsr->GetDoc()); //pSearch->sReplaceText SwTxtFmtColl *pReplaceColl = 0; sal_Bool bCancel; nResult = (sal_Int32)pUnoCrsr->Find( *pSearchColl, eStart, eEnd, bCancel, (FindRanges)eRanges, pReplaceColl ); } else { //todo/mba: assuming that notes should be omitted sal_Bool bSearchInNotes = sal_False; sal_Bool bCancel; nResult = (sal_Int32)pUnoCrsr->Find( aSearchOpt, bSearchInNotes, eStart, eEnd, bCancel, (FindRanges)eRanges, /*int bReplace =*/sal_False ); } nSearchProc++; if(nResult || (eRanges&(FND_IN_SELALL|FND_IN_OTHER))) break; //second step - find in other eRanges = FND_IN_OTHER; } return pUnoCrsr; } /*-- 18.12.98 11:55:23--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XIndexAccess > SwXTextDocument::findAll(const Reference< util::XSearchDescriptor > & xDesc) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< XInterface > xTmp; sal_Int32 nResult = 0; Reference< XTextCursor > xCrsr; SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_True, nResult, xTmp); if(!pResultCrsr) throw RuntimeException(); Reference< XIndexAccess > xRet; xRet = new SwXTextRanges( (nResult) ? pResultCrsr : 0 ); delete pResultCrsr; return xRet; } /*-- 18.12.98 11:55:23--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XInterface > SwXTextDocument::findFirst(const Reference< util::XSearchDescriptor > & xDesc) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< XInterface > xTmp; sal_Int32 nResult = 0; Reference< XTextCursor > xCrsr; SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_False, nResult, xTmp); if(!pResultCrsr) throw RuntimeException(); Reference< XInterface > xRet; if(nResult) { const uno::Reference< text::XText > xParent = ::sw::CreateParentXText(*pDocShell->GetDoc(), *pResultCrsr->GetPoint()); xRet = *new SwXTextCursor(xParent, *pResultCrsr); delete pResultCrsr; } return xRet; } /*-- 18.12.98 11:55:24--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XInterface > SwXTextDocument::findNext(const Reference< XInterface > & xStartAt, const Reference< util::XSearchDescriptor > & xDesc) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Reference< XInterface > xTmp; sal_Int32 nResult = 0; Reference< XTextCursor > xCrsr; if(!xStartAt.is()) throw RuntimeException(); SwUnoCrsr* pResultCrsr = FindAny(xDesc, xCrsr, sal_False, nResult, xStartAt); if(!pResultCrsr) throw RuntimeException(); Reference< XInterface > xRet; if(nResult) { const uno::Reference< text::XText > xParent = ::sw::CreateParentXText(*pDocShell->GetDoc(), *pResultCrsr->GetPoint()); xRet = *new SwXTextCursor(xParent, *pResultCrsr); delete pResultCrsr; } return xRet; } /*-- 18.12.98 11:55:24--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< beans::PropertyValue > SwXTextDocument::getPagePrintSettings(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); Sequence< beans::PropertyValue > aSeq(9); if(IsValid()) { beans::PropertyValue* pArray = aSeq.getArray(); SwPagePreViewPrtData aData; const SwPagePreViewPrtData* pData = pDocShell->GetDoc()->GetPreViewPrtData(); if(pData) aData = *pData; Any aVal; aVal <<= (sal_Int16)aData.GetRow(); pArray[0] = beans::PropertyValue(C2U("PageRows"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int16)aData.GetCol(); pArray[1] = beans::PropertyValue(C2U("PageColumns"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetLeftSpace()); pArray[2] = beans::PropertyValue(C2U("LeftMargin"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetRightSpace()); pArray[3] = beans::PropertyValue(C2U("RightMargin"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetTopSpace()); pArray[4] = beans::PropertyValue(C2U("TopMargin"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetBottomSpace()); pArray[5] = beans::PropertyValue(C2U("BottomMargin"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetHorzSpace()); pArray[6] = beans::PropertyValue(C2U("HoriMargin"), -1, aVal, PropertyState_DIRECT_VALUE); aVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(aData.GetVertSpace()); pArray[7] = beans::PropertyValue(C2U("VertMargin"), -1, aVal, PropertyState_DIRECT_VALUE); sal_Bool bTemp = aData.GetLandscape(); aVal.setValue(&bTemp, ::getCppuBooleanType()); pArray[8] = beans::PropertyValue(C2U("IsLandscape"), -1, aVal, PropertyState_DIRECT_VALUE); } else throw RuntimeException(); return aSeq; } /* -----------------24.02.99 10:57------------------- * * --------------------------------------------------*/ sal_uInt32 lcl_Any_To_ULONG(const Any& rValue, sal_Bool& bException) { bException = sal_False; TypeClass eType = rValue.getValueType().getTypeClass(); sal_uInt32 nRet = 0; if( eType == TypeClass_UNSIGNED_LONG ) rValue >>= nRet; else { sal_Int32 nVal=0; bException = !(rValue >>= nVal); if( !bException ) nRet = (sal_uInt32)nVal; } return nRet; } /*-- 09.06.2004 12:18:10--------------------------------------------------- -----------------------------------------------------------------------*/ String lcl_CreateOutlineString( sal_uInt16 nIndex, const SwOutlineNodes& rOutlineNodes, const SwNumRule* pOutlRule) { String sEntry; const SwTxtNode * pTxtNd = rOutlineNodes[ nIndex ]->GetTxtNode(); SwNumberTree::tNumberVector aNumVector = pTxtNd->GetNumberVector(); if( pOutlRule && pTxtNd->GetNumRule()) for( sal_Int8 nLevel = 0; nLevel <= pTxtNd->GetActualListLevel(); nLevel++ ) { long nVal = aNumVector[nLevel]; nVal ++; nVal -= pOutlRule->Get(nLevel).GetStart(); sEntry += String::CreateFromInt32( nVal ); sEntry += '.'; } sEntry += rOutlineNodes[ nIndex ]-> GetTxtNode()->GetExpandTxt( 0, STRING_LEN, sal_False ); return sEntry; } /*-- 18.12.98 11:55:25--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::setPagePrintSettings(const Sequence< beans::PropertyValue >& aSettings) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(IsValid()) { SwPagePreViewPrtData aData; //falls nur einige Properties kommen, dann die akt. Einstellungen benutzen const SwPagePreViewPrtData* pData = pDocShell->GetDoc()->GetPreViewPrtData(); if(pData) aData = *pData; const beans::PropertyValue* pProperties = aSettings.getConstArray(); int nCount = aSettings.getLength(); for(int i = 0; i < nCount; i++) { String sName = pProperties[i].Name; const Any& rVal = pProperties[i].Value; sal_Bool bException; sal_uInt32 nVal = lcl_Any_To_ULONG(rVal, bException); if( COMPARE_EQUAL == sName.CompareToAscii("PageRows" ) ) { if(!nVal || nVal > 0xff) throw RuntimeException(); aData.SetRow((sal_uInt8)nVal); } else if(COMPARE_EQUAL == sName.CompareToAscii("PageColumns")) { if(!nVal || nVal > 0xff) throw RuntimeException(); aData.SetCol((sal_uInt8)nVal); } else if(COMPARE_EQUAL == sName.CompareToAscii("LeftMargin")) { aData.SetLeftSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("RightMargin")) { aData.SetRightSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("TopMargin")) { aData.SetTopSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("BottomMargin")) { aData.SetBottomSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("HoriMargin")) { aData.SetHorzSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("VertMargin")) { aData.SetVertSpace(MM100_TO_TWIP_UNSIGNED(nVal)); } else if(COMPARE_EQUAL == sName.CompareToAscii("IsLandscape")) { bException = (::getBooleanCppuType() != rVal.getValueType()); aData.SetLandscape(*(sal_Bool*)rVal.getValue()); } else bException = sal_True; if(bException) throw RuntimeException(); } pDocShell->GetDoc()->SetPreViewPrtData(&aData); } else throw RuntimeException(); } /*-- 18.12.98 11:55:25--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::printPages(const Sequence< beans::PropertyValue >& xOptions) throw( IllegalArgumentException, RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(IsValid()) { SfxViewFrame* pFrame = SfxViewFrame::LoadHiddenDocument( *pDocShell, 7 ); SfxRequest aReq(FN_PRINT_PAGEPREVIEW, SFX_CALLMODE_SYNCHRON, pDocShell->GetDoc()->GetAttrPool()); aReq.AppendItem(SfxBoolItem(FN_PRINT_PAGEPREVIEW, sal_True)); OUString sFileName( C2U(SW_PROP_NAME_STR(UNO_NAME_FILE_NAME))); OUString sCopyCount(C2U(SW_PROP_NAME_STR(UNO_NAME_COPY_COUNT))); OUString sCollate(C2U(SW_PROP_NAME_STR(UNO_NAME_COLLATE))); OUString sSort(C2U(SW_PROP_NAME_STR(UNO_NAME_SORT))); OUString sPages(C2U(SW_PROP_NAME_STR(UNO_NAME_PAGES))); for ( int n = 0; n < xOptions.getLength(); ++n ) { // get Property-Value from options const beans::PropertyValue &rProp = xOptions.getConstArray()[n]; Any aValue( rProp.Value ); // FileName-Property? if ( rProp.Name == sFileName ) { OUString sFileURL; if ( (rProp.Value >>= sFileURL ) ) { // Convert the File URL into a system dependant path, as the SalPrinter expects OUString sSystemPath; FileBase::getSystemPathFromFileURL ( sFileURL, sSystemPath ); aReq.AppendItem(SfxStringItem( SID_FILE_NAME, sSystemPath ) ); } else if ( rProp.Value.getValueType() != ::getVoidCppuType() ) throw IllegalArgumentException(); } // CopyCount-Property else if ( rProp.Name == sCopyCount ) { sal_Int32 nCopies = 0; aValue >>= nCopies; aReq.AppendItem(SfxInt16Item( SID_PRINT_COPIES, (sal_Int16)nCopies ) ); } // Collate-Property else if ( rProp.Name == sCollate ) { if ( rProp.Value.getValueType() == ::getBooleanCppuType()) aReq.AppendItem(SfxBoolItem( SID_PRINT_COLLATE, *(sal_Bool*)rProp.Value.getValue() ) ); else throw IllegalArgumentException(); } // Sort-Property else if ( rProp.Name == sSort ) { if ( rProp.Value.getValueType() == ::getBooleanCppuType() ) aReq.AppendItem(SfxBoolItem( SID_PRINT_SORT, *(sal_Bool*)rProp.Value.getValue() ) ); else throw IllegalArgumentException(); } // Pages-Property else if ( rProp.Name == sPages ) { OUString sTmp; if ( rProp.Value >>= sTmp ) aReq.AppendItem( SfxStringItem( SID_PRINT_PAGES, sTmp ) ); else throw IllegalArgumentException(); } } // --> OD #i117783# bApplyPagePrintSettingsFromXPagePrintable = sal_True; // <-- pFrame->GetViewShell()->ExecuteSlot(aReq); // Frame schliessen pFrame->DoClose(); } else throw RuntimeException(); } /*-- 18.12.98 11:55:25--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getReferenceMarks(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXReferenceMarks) { ((SwXTextDocument*)this)->pxXReferenceMarks = new Reference< XNameAccess > ; *pxXReferenceMarks = new SwXReferenceMarks(pDocShell->GetDoc()); } return *pxXReferenceMarks; } /* -----------------21.12.98 10:20------------------- * * --------------------------------------------------*/ Reference< XEnumerationAccess > SwXTextDocument::getTextFields(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXTextFieldTypes) { ((SwXTextDocument*)this)->pxXTextFieldTypes = new Reference< XEnumerationAccess > ; *pxXTextFieldTypes = new SwXTextFieldTypes(pDocShell->GetDoc()); } return *pxXTextFieldTypes; } /*-- 21.12.98 10:21:12--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getTextFieldMasters(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXTextFieldMasters) { ((SwXTextDocument*)this)->pxXTextFieldMasters = new Reference< XNameAccess > ; *pxXTextFieldMasters = new SwXTextFieldMasters(pDocShell->GetDoc()); } return *pxXTextFieldMasters; } /*-- 21.12.98 10:21:12--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getEmbeddedObjects(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXEmbeddedObjects) { ((SwXTextDocument*)this)->pxXEmbeddedObjects = new Reference< XNameAccess > ; *pxXEmbeddedObjects = new SwXTextEmbeddedObjects(pDocShell->GetDoc()); } return *pxXEmbeddedObjects; } /*-- 21.12.98 10:21:13--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getBookmarks(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXBookmarks) { ((SwXTextDocument*)this)->pxXBookmarks = new Reference< XNameAccess > ; *pxXBookmarks = new SwXBookmarks(pDocShell->GetDoc()); } return *pxXBookmarks; } /*-- 21.12.98 10:21:13--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getTextSections(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXTextSections) { ((SwXTextDocument*)this)->pxXTextSections = new Reference< XNameAccess > ; *pxXTextSections = new SwXTextSections(pDocShell->GetDoc()); } return *pxXTextSections; } /*-- 21.12.98 10:21:13--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getTextTables(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXTextTables) { ((SwXTextDocument*)this)->pxXTextTables = new Reference< XNameAccess > ; *pxXTextTables = new SwXTextTables(pDocShell->GetDoc()); } return *pxXTextTables; } /*-- 21.12.98 10:21:13--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getGraphicObjects(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXGraphicObjects) { ((SwXTextDocument*)this)->pxXGraphicObjects = new Reference< XNameAccess > ; *pxXGraphicObjects = new SwXTextGraphicObjects(pDocShell->GetDoc()); } return *pxXGraphicObjects; } /*-- 21.12.98 10:21:14--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getTextFrames(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXTextFrames) { ((SwXTextDocument*)this)->pxXTextFrames = new Reference< XNameAccess > ; *pxXTextFrames = new SwXTextFrames(pDocShell->GetDoc()); } return *pxXTextFrames; } /* -----------------21.12.98 10:56------------------- * * --------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getStyleFamilies(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXStyleFamilies) { ((SwXTextDocument*)this)->pxXStyleFamilies = new Reference< XNameAccess > ; *pxXStyleFamilies = new SwXStyleFamilies(*pDocShell); } return *pxXStyleFamilies; } /*-- 19.05.06 10:15:22--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Reference< style::XAutoStyles > SwXTextDocument::getAutoStyles( ) throw (uno::RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXAutoStyles) { pxXAutoStyles = new Reference< style::XAutoStyles > ; *pxXAutoStyles = new SwXAutoStyles(*pDocShell); } return *pxXAutoStyles; } /*-- 22.01.99 10:18:03--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< drawing::XDrawPage > SwXTextDocument::getDrawPage(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXDrawPage) { // simplified this creation, keeping original below as reference // for the case that it did something by purpose ((SwXTextDocument*)this)->pDrawPage = new SwXDrawPage(pDocShell->GetDoc()); ((SwXTextDocument*)this)->pxXDrawPage = new Reference< drawing::XDrawPage >(pDrawPage); //((SwXTextDocument*)this)->pxXDrawPage = new Reference< drawing::XDrawPage > ; //((SwXTextDocument*)this)->pDrawPage = new SwXDrawPage(pDocShell->GetDoc()); //Reference< drawing::XShapes > xTmp = pDrawPage; //*pxXDrawPage = Reference< drawing::XDrawPage>(xTmp, UNO_QUERY); } return *pxXDrawPage; } /* -----------------07.04.99 10:11------------------- * * --------------------------------------------------*/ SwXDrawPage* SwXTextDocument::GetDrawPage() { if(!IsValid()) return 0; if(!pDrawPage) getDrawPage(); return pDrawPage; } /*-- 18.12.98 11:55:26--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::Invalidate() { bObjectValid = sal_False; if(xNumFmtAgg.is()) { const uno::Type& rTunnelType = ::getCppuType((Reference *)0); Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType); SvNumberFormatsSupplierObj* pNumFmt = 0; Reference< XUnoTunnel > xNumTunnel; if(aNumTunnel >>= xNumTunnel) { pNumFmt = reinterpret_cast( xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId())); pNumFmt->SetNumberFormatter(0); } DBG_ASSERT(pNumFmt, "No number formatter available"); } InitNewDoc(); pDocShell = 0; aRefreshCont.Disposing(); } /* -----------------------------13.07.00 15:59-------------------------------- ---------------------------------------------------------------------------*/ void SwXTextDocument::Reactivate(SwDocShell* pNewDocShell) { if(pDocShell && pDocShell != pNewDocShell) Invalidate(); pDocShell = pNewDocShell; bObjectValid = sal_True; } /*-- 18.12.98 11:55:26--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::InitNewDoc() { // zunaechst alle Collections invalidieren, dann Referenzen loeschen und Null setzen if(pxXTextTables) { XNameAccess* pTbls = pxXTextTables->get(); ((SwXTextTables*)pTbls)->Invalidate(); delete pxXTextTables; pxXTextTables = 0; } if(pxXTextFrames) { XNameAccess* pFrms = pxXTextFrames->get(); ((SwXTextFrames*)pFrms)->Invalidate(); delete pxXTextFrames; pxXTextFrames = 0; } if(pxXGraphicObjects) { XNameAccess* pFrms = pxXGraphicObjects->get(); ((SwXTextGraphicObjects*)pFrms)->Invalidate(); delete pxXGraphicObjects; pxXGraphicObjects = 0; } if(pxXEmbeddedObjects) { XNameAccess* pOLE = pxXEmbeddedObjects->get(); ((SwXTextEmbeddedObjects*)pOLE)->Invalidate(); delete pxXEmbeddedObjects; pxXEmbeddedObjects = 0; } if(xBodyText.is()) { xBodyText = 0; pBodyText = 0; } if(xNumFmtAgg.is()) { const uno::Type& rTunnelType = ::getCppuType((Reference *)0); Any aNumTunnel = xNumFmtAgg->queryAggregation(rTunnelType); SvNumberFormatsSupplierObj* pNumFmt = 0; Reference< XUnoTunnel > xNumTunnel; if(aNumTunnel >>= xNumTunnel) { pNumFmt = reinterpret_cast( xNumTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId())); } DBG_ASSERT(pNumFmt, "No number formatter available"); pNumFmt->SetNumberFormatter(0); } if(pxXTextFieldTypes) { XEnumerationAccess* pT = pxXTextFieldTypes->get(); ((SwXTextFieldTypes*)pT)->Invalidate(); delete pxXTextFieldTypes; pxXTextFieldTypes = 0; } if(pxXTextFieldMasters) { XNameAccess* pT = pxXTextFieldMasters->get(); ((SwXTextFieldMasters*)pT)->Invalidate(); delete pxXTextFieldMasters; pxXTextFieldMasters = 0; } if(pxXTextSections) { XNameAccess* pSect = pxXTextSections->get(); ((SwXTextSections*)pSect)->Invalidate(); delete pxXTextSections; pxXTextSections = 0; } if(pxXDrawPage) { // --> OD 2008-07-23 #i91798#, #i91895# // dispose XDrawPage here. We are the owner and know that it is no longer in a valid condition. uno::Reference xComp( *pxXDrawPage, uno::UNO_QUERY ); xComp->dispose(); // <-- pDrawPage->InvalidateSwDoc(); delete pxXDrawPage; pxXDrawPage = 0; } if ( pxXNumberingRules ) { XIndexAccess* pNum = pxXNumberingRules->get(); ((SwXNumberingRulesCollection*)pNum)->Invalidate(); delete pxXNumberingRules; pxXNumberingRules = 0; } if(pxXFootnotes) { XIndexAccess* pFtn = pxXFootnotes->get(); ((SwXFootnotes*)pFtn)->Invalidate(); delete pxXFootnotes; pxXFootnotes = 0; } if(pxXEndnotes) { XIndexAccess* pFtn = pxXEndnotes->get(); ((SwXFootnotes*)pFtn)->Invalidate(); delete pxXEndnotes; pxXEndnotes = 0; } if(pxXDocumentIndexes) { XIndexAccess* pIdxs = pxXDocumentIndexes->get(); ((SwXDocumentIndexes*)pIdxs)->Invalidate(); delete pxXDocumentIndexes; pxXDocumentIndexes = 0; } if(pxXStyleFamilies) { XNameAccess* pStyles = pxXStyleFamilies->get(); ((SwXStyleFamilies*)pStyles)->Invalidate(); delete pxXStyleFamilies; pxXStyleFamilies = 0; } if(pxXAutoStyles) { XNameAccess* pStyles = pxXAutoStyles->get(); ((SwXAutoStyles*)pStyles)->Invalidate(); delete pxXAutoStyles; pxXAutoStyles = 0; } if(pxXBookmarks) { XNameAccess* pBm = pxXBookmarks->get(); ((SwXBookmarks*)pBm)->Invalidate(); delete pxXBookmarks; pxXBookmarks = 0; } if(pxXChapterNumbering) { XIndexReplace* pCh = pxXChapterNumbering->get(); ((SwXChapterNumbering*)pCh)->Invalidate(); delete pxXChapterNumbering; pxXChapterNumbering = 0; } if(pxXFootnoteSettings) { XPropertySet* pFntSet = pxXFootnoteSettings->get(); ((SwXFootnoteProperties*)pFntSet)->Invalidate(); delete pxXFootnoteSettings; pxXFootnoteSettings = 0; } if(pxXEndnoteSettings) { XPropertySet* pEndSet = pxXEndnoteSettings->get(); ((SwXEndnoteProperties*)pEndSet)->Invalidate(); delete pxXEndnoteSettings; pxXEndnoteSettings = 0; } if(pxXLineNumberingProperties) { XPropertySet* pLine = pxXLineNumberingProperties->get(); ((SwXLineNumberingProperties*)pLine)->Invalidate(); delete pxXLineNumberingProperties; pxXLineNumberingProperties = 0; } if(pxXReferenceMarks) { XNameAccess* pMarks = pxXReferenceMarks->get(); ((SwXReferenceMarks*)pMarks)->Invalidate(); delete pxXReferenceMarks; pxXReferenceMarks = 0; } if(pxLinkTargetSupplier) { XNameAccess* pAccess = (*pxLinkTargetSupplier).get(); ((SwXLinkTargetSupplier*)pAccess)->Invalidate(); delete pxLinkTargetSupplier; pxLinkTargetSupplier = 0; } if(pxXRedlines) { XEnumerationAccess* pMarks = pxXRedlines->get(); ((SwXRedlines*)pMarks)->Invalidate(); delete pxXRedlines; pxXRedlines = 0; } if(xPropertyHelper.is()) { pPropertyHelper->Invalidate(); xPropertyHelper = 0; pPropertyHelper = 0; } } /*-- 11.03.99 11:51:40--------------------------------------------------- -----------------------------------------------------------------------*/ #define COM_SUN_STAR__DRAWING_LENGTH 13 Reference< XInterface > SwXTextDocument::createInstance(const OUString& rServiceName) throw( Exception, RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); Reference< XInterface > xRet; sal_uInt16 nType = SwXServiceProvider::GetProviderType(rServiceName); if(nType != SW_SERVICE_INVALID) { xRet = SwXServiceProvider::MakeInstance(nType, pDocShell->GetDoc()); } else { if( rServiceName.compareToAscii( "com.sun.star.", 13 ) == 0 ) { sal_Int32 nIndex = COM_SUN_STAR__DRAWING_LENGTH; OUString sCategory = rServiceName.getToken( 0, '.', nIndex ); sal_Bool bShape = sCategory == C2U("drawing"); if( bShape || sCategory == C2U("form")) { if(bShape) { short nTable = 0; if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.DashTable") ) ) nTable = SW_CREATE_DASH_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.GradientTable") ) ) nTable = SW_CREATE_GRADIENT_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.HatchTable") ) ) nTable = SW_CREATE_HATCH_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.BitmapTable") ) ) nTable = SW_CREATE_BITMAP_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.TransparencyGradientTable") ) ) nTable = SW_CREATE_TRANSGRADIENT_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.MarkerTable") ) ) nTable = SW_CREATE_MARKER_TABLE; else if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.drawing.Defaults") ) ) nTable = SW_CREATE_DRAW_DEFAULTS; if(nTable) { xRet = GetPropertyHelper()->GetDrawTable(nTable); } } } else if (sCategory == C2U ("document") ) { if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.Settings") ) ) xRet = Reference < XInterface > ( *new SwXDocumentSettings ( this ) ); if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.document.ImportEmbeddedObjectResolver") ) ) { xRet = (::cppu::OWeakObject * )new SvXMLEmbeddedObjectHelper( *pDocShell, EMBEDDEDOBJECTHELPER_MODE_READ ); } } else if (sCategory == C2U ("text") ) { if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.DocumentSettings") ) ) xRet = Reference < XInterface > ( *new SwXDocumentSettings ( this ) ); } else if (sCategory == C2U ("chart2") ) { if( 0 == rServiceName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.chart2.data.DataProvider") ) ) xRet = Reference < XInterface > ( dynamic_cast< chart2::data::XDataProvider * >(pDocShell->getIDocumentChartDataProviderAccess()->GetChartDataProvider()) ); } if(!xRet.is()) { //! we don't want to insert OLE2 Shapes (e.g. "com.sun.star.drawing.OLE2Shape", ...) //! like this (by creating them with the documents factory and //! adding the shapes to the draw page). //! For inserting OLE objects the proper way is to use //! "com.sun.star.text.TextEmbeddedObject"! if (rServiceName.lastIndexOf( C2U(".OLE2Shape") ) == rServiceName.getLength() - 10) throw ServiceNotRegisteredException(); // declare service to be not registered with this factory // --> OD 2006-02-22 #b6382898# // the XML import is allowed to create instances of com.sun.star.drawing.OLE2Shape. // Thus, a temporary service name is introduced to make this possible. OUString aTmpServiceName( rServiceName ); if ( bShape && rServiceName.compareToAscii( "com.sun.star.drawing.temporaryForXMLImportOLE2Shape" ) == 0 ) { aTmpServiceName = OUString::createFromAscii( "com.sun.star.drawing.OLE2Shape" ); } //hier den Draw - Service suchen Reference< XInterface > xTmp = SvxFmMSFactory::createInstance(aTmpServiceName); // <-- if(bShape) { nIndex = COM_SUN_STAR__DRAWING_LENGTH; if( 0 == rServiceName.reverseCompareToAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.drawing.GroupShape" ) ) || 0 == rServiceName.reverseCompareToAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.drawing.Shape3DSceneObject" ) ) ) xRet = *new SwXGroupShape( xTmp ); else xRet = *new SwXShape( xTmp ); } else xRet = xTmp; } } else throw ServiceNotRegisteredException(); } return xRet; } /*-- 11.03.99 11:51:40--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XInterface > SwXTextDocument::createInstanceWithArguments( const OUString& ServiceSpecifier, const Sequence< Any >& /*Arguments*/) throw( Exception, RuntimeException ) { Reference< XInterface > xInt = createInstance(ServiceSpecifier); //die Any-Sequence dient zur Initialisierung von Objekten, die auf //Parameter zwingend angewiesen sind - bis jetzt haben wir das nicht return xInt; } /*-- 11.03.99 11:51:41--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< OUString > SwXTextDocument::getAvailableServiceNames(void) throw( RuntimeException ) { static Sequence< OUString > aServices; if ( aServices.getLength() == 0 ) { Sequence< OUString > aRet = SvxFmMSFactory::getAvailableServiceNames(); OUString* pRet = aRet.getArray(); for ( sal_Int32 i = 0; i < aRet.getLength(); ++i ) { if ( pRet[i].compareToAscii( "com.sun.star.drawing.OLE2Shape" ) == 0 ) { pRet[i] = pRet[aRet.getLength() - 1]; aRet.realloc( aRet.getLength() - 1 ); // no longer valid. break; } } Sequence< OUString > aOwn = SwXServiceProvider::GetAllServiceNames(); aServices = SvxFmMSFactory::concatServiceNames(aRet, aOwn); } return aServices; } /* -----------------18.03.99 11:36------------------- * * --------------------------------------------------*/ OUString SwXTextDocument::getImplementationName(void) throw( RuntimeException ) { return C2U("SwXTextDocument"); } /* -----------------20.01.04 10:14------------------- * * --------------------------------------------------*/ sal_Bool SwXTextDocument::supportsService(const OUString& rServiceName) throw( RuntimeException ) { if ( (rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.document.OfficeDocument" ))) || (rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM ( "com.sun.star.text.GenericTextDocument"))) ) return sal_True; sal_Bool bWebDoc = (0 != PTR_CAST(SwWebDocShell, pDocShell)); sal_Bool bGlobalDoc = (0 != PTR_CAST(SwGlobalDocShell, pDocShell)); sal_Bool bTextDoc = (!bWebDoc && !bGlobalDoc); return ( (bWebDoc && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.WebDocument" ))) || (bGlobalDoc && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.GlobalDocument"))) || (bTextDoc && rServiceName.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("com.sun.star.text.TextDocument" ))) ); } /* -----------------20.01.04 10:17------------------- * * --------------------------------------------------*/ Sequence< OUString > SwXTextDocument::getSupportedServiceNames(void) throw( RuntimeException ) { sal_Bool bWebDoc = (0 != PTR_CAST(SwWebDocShell, pDocShell)); sal_Bool bGlobalDoc = (0 != PTR_CAST(SwGlobalDocShell, pDocShell)); sal_Bool bTextDoc = (!bWebDoc && !bGlobalDoc); Sequence< OUString > aRet (3); OUString* pArray = aRet.getArray(); pArray[0] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.document.OfficeDocument" ) ) ); pArray[1] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.GenericTextDocument" ) ) ); if (bTextDoc) pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.TextDocument" ) ) ); else if (bWebDoc) pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.WebDocument" ) ) ); else if (bGlobalDoc) pArray[2] = OUString ( RTL_CONSTASCII_USTRINGPARAM ( ( "com.sun.star.text.GlobalDocument" ) ) ); return aRet; } /* -----------------05.05.99 12:10------------------- * * --------------------------------------------------*/ Reference< XIndexAccess > SwXTextDocument::getDocumentIndexes(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); if(!pxXDocumentIndexes) { ((SwXTextDocument*)this)->pxXDocumentIndexes = new Reference< XIndexAccess > ; *pxXDocumentIndexes = new SwXDocumentIndexes(pDocShell->GetDoc()); } return *pxXDocumentIndexes; } /*-- 10.05.99 13:58:58--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySetInfo > SwXTextDocument::getPropertySetInfo(void) throw( RuntimeException ) { static Reference< XPropertySetInfo > xRet = pPropSet->getPropertySetInfo(); return xRet; } /*-- 10.05.99 13:58:58--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::setPropertyValue(const OUString& rPropertyName, const Any& aValue) throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); if(!pEntry) throw UnknownPropertyException(); if(pEntry->nFlags & PropertyAttribute::READONLY) throw PropertyVetoException(); switch(pEntry->nWID) { case WID_DOC_CHAR_COUNT : case WID_DOC_PARA_COUNT : case WID_DOC_WORD_COUNT : throw RuntimeException(); case WID_DOC_WORD_SEPARATOR : { OUString sDelim; aValue >>= sDelim; SW_MOD()->GetModuleConfig()->SetWordDelimiter(sDelim); } break; case WID_DOC_CHANGES_RECORD: case WID_DOC_CHANGES_SHOW: { sal_Bool bSet = *(sal_Bool*)aValue.getValue(); sal_uInt16 eMode = pDocShell->GetDoc()->GetRedlineMode(); if(WID_DOC_CHANGES_SHOW == pEntry->nWID) { eMode &= ~(nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE); eMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT; if( bSet ) eMode |= nsRedlineMode_t::REDLINE_SHOW_DELETE; } else if(WID_DOC_CHANGES_RECORD == pEntry->nWID) { eMode = bSet ? eMode|nsRedlineMode_t::REDLINE_ON : eMode&~nsRedlineMode_t::REDLINE_ON; } pDocShell->GetDoc()->SetRedlineMode( (RedlineMode_t)(eMode )); } break; case WID_DOC_CHANGES_PASSWORD: { Sequence aNew; if(aValue >>= aNew) { SwDoc* pDoc = pDocShell->GetDoc(); pDoc->SetRedlinePassword(aNew); if(aNew.getLength()) { sal_uInt16 eMode = pDoc->GetRedlineMode(); eMode = eMode|nsRedlineMode_t::REDLINE_ON; pDoc->SetRedlineMode( (RedlineMode_t)(eMode )); } } } break; case WID_DOC_AUTO_MARK_URL : { OUString sURL; aValue >>= sURL; pDocShell->GetDoc()->SetTOIAutoMarkURL(sURL); } break; case WID_DOC_HIDE_TIPS : SW_MOD()->GetModuleConfig()->SetHideFieldTips(*(sal_Bool*)aValue.getValue()); break; case WID_DOC_REDLINE_DISPLAY: { sal_Int16 eRedMode = pDocShell->GetDoc()->GetRedlineMode(); eRedMode = eRedMode & (~nsRedlineMode_t::REDLINE_SHOW_MASK); sal_Int16 nSet = 0; aValue >>= nSet; switch(nSet) { case RedlineDisplayType::NONE: break; case RedlineDisplayType::INSERTED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT; break; case RedlineDisplayType::REMOVED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_DELETE; break; case RedlineDisplayType:: INSERTED_AND_REMOVED: eRedMode |= nsRedlineMode_t::REDLINE_SHOW_INSERT|nsRedlineMode_t::REDLINE_SHOW_DELETE; break; default: throw IllegalArgumentException(); } pDocShell->GetDoc()->SetRedlineMode(eRedMode); } break; case WID_DOC_TWO_DIGIT_YEAR: { sal_Int16 nYear = 0; aValue >>= nYear; SfxRequest aRequest ( SID_ATTR_YEAR2000, SFX_CALLMODE_SLOT, pDocShell->GetDoc()->GetAttrPool()); aRequest.AppendItem(SfxUInt16Item( SID_ATTR_YEAR2000, static_cast < sal_uInt16 > ( nYear ) ) ); pDocShell->Execute ( aRequest ); } break; case WID_DOC_AUTOMATIC_CONTROL_FOCUS: { SwDrawDocument * pDrawDoc; sal_Bool bAuto = *(sal_Bool*) aValue.getValue(); if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * >( pDocShell->GetDoc()->GetDrawModel() ) ) ) pDrawDoc->SetAutoControlFocus( bAuto ); else if (bAuto) { // if setting to true, and we don't have an // SdrModel, then we are changing the default and // must thus create an SdrModel, if we don't have an // SdrModel and we are leaving the default at false, // we don't need to make an SdrModel and can do nothing // --> OD 2005-08-08 #i52858# - method name changed pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetOrCreateDrawModel() ); // <-- pDrawDoc->SetAutoControlFocus ( bAuto ); } } break; case WID_DOC_APPLY_FORM_DESIGN_MODE: { SwDrawDocument * pDrawDoc; sal_Bool bMode = *(sal_Bool*)aValue.getValue(); if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) ) pDrawDoc->SetOpenInDesignMode( bMode ); else if (!bMode) { // if setting to false, and we don't have an // SdrModel, then we are changing the default and // must thus create an SdrModel, if we don't have an // SdrModel and we are leaving the default at true, // we don't need to make an SdrModel and can do // nothing // --> OD 2005-08-08 #i52858# - method name changed pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetOrCreateDrawModel() ); // <-- pDrawDoc->SetOpenInDesignMode ( bMode ); } } break; // --> FME 2005-02-25 #i42634# New property to set the bInReading // flag at the document, used during binary import case WID_DOC_LOCK_UPDATES : { SwDoc* pDoc = pDocShell->GetDoc(); bool bBool (false); if( aValue >>= bBool ) pDoc->SetInReading( bBool ); } break; // <-- case WID_DOC_BUILDID: aValue >>= maBuildId; break; // --> OD 2006-03-21 #b6375613# case WID_APPLY_WORKAROUND_FOR_B6375613: { bool bApplyWorkaroundForB6375613( false ); aValue >>= bApplyWorkaroundForB6375613; pDocShell->GetDoc()->SetApplyWorkaroundForB6375613( bApplyWorkaroundForB6375613 ); } break; // <-- case WID_DOC_DEFAULT_PAGE_MODE: { bool bDefaultPageMode( false ); aValue >>= bDefaultPageMode; pDocShell->GetDoc()->SetDefaultPageMode( bDefaultPageMode ); } break; default: { const SfxPoolItem& rItem = pDocShell->GetDoc()->GetDefault(pEntry->nWID); SfxPoolItem* pNewItem = rItem.Clone(); pNewItem->PutValue(aValue, pEntry->nMemberId); pDocShell->GetDoc()->SetDefault(*pNewItem); delete pNewItem; } } } /*-- 10.05.99 13:58:59--------------------------------------------------- -----------------------------------------------------------------------*/ Any SwXTextDocument::getPropertyValue(const OUString& rPropertyName) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); if(!pEntry) throw UnknownPropertyException(); Any aAny; switch(pEntry->nWID) { case WID_DOC_CHAR_COUNT : case WID_DOC_PARA_COUNT : case WID_DOC_WORD_COUNT : { SwDocStat aStat(pDocShell->GetDoc()->GetDocStat()); if(aStat.bModified) pDocShell->GetDoc()->UpdateDocStat( aStat ); sal_Int32 nValue; switch(pEntry->nWID) { case WID_DOC_CHAR_COUNT :nValue = aStat.nChar;break; case WID_DOC_PARA_COUNT :nValue = aStat.nPara;break; case WID_DOC_WORD_COUNT :nValue = aStat.nWord;break; } aAny <<= nValue; } break; case WID_DOC_WORD_SEPARATOR : { aAny <<= OUString(SW_MOD()->GetDocStatWordDelim()); } break; case WID_DOC_CHANGES_RECORD: case WID_DOC_CHANGES_SHOW: { sal_uInt16 eMode = pDocShell->GetDoc()->GetRedlineMode(); sal_Bool bSet = sal_False; if(WID_DOC_CHANGES_SHOW == pEntry->nWID) { sal_uInt16 nMask = nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE; bSet = (eMode & nMask) == nMask; } else if(WID_DOC_CHANGES_RECORD == pEntry->nWID) { bSet = (eMode& nsRedlineMode_t::REDLINE_ON) != 0; } aAny.setValue(&bSet, ::getBooleanCppuType()); } break; case WID_DOC_CHANGES_PASSWORD: { SwDoc* pDoc = pDocShell->GetDoc(); aAny <<= pDoc->GetRedlinePassword(); } break; case WID_DOC_AUTO_MARK_URL : aAny <<= OUString(pDocShell->GetDoc()->GetTOIAutoMarkURL()); break; case WID_DOC_HIDE_TIPS : { sal_Bool bTemp = SW_MOD()->GetModuleConfig()->IsHideFieldTips(); aAny.setValue(&bTemp, ::getBooleanCppuType()); } break; case WID_DOC_REDLINE_DISPLAY: { sal_Int16 eRedMode = pDocShell->GetDoc()->GetRedlineMode(); eRedMode = eRedMode & nsRedlineMode_t::REDLINE_SHOW_MASK; sal_Int16 nRet = RedlineDisplayType::NONE; if(nsRedlineMode_t::REDLINE_SHOW_INSERT == eRedMode) nRet = RedlineDisplayType::INSERTED; else if(nsRedlineMode_t::REDLINE_SHOW_DELETE == eRedMode) nRet = RedlineDisplayType::REMOVED; else if(nsRedlineMode_t::REDLINE_SHOW_MASK == eRedMode) nRet = RedlineDisplayType::INSERTED_AND_REMOVED; aAny <<= nRet; } break; case WID_DOC_FORBIDDEN_CHARS: { GetPropertyHelper(); Reference xRet(xPropertyHelper, UNO_QUERY); aAny <<= xRet; } break; case WID_DOC_TWO_DIGIT_YEAR: { aAny <<= static_cast < sal_Int16 > (pDocShell->GetDoc()->GetNumberFormatter ( sal_True )->GetYear2000()); } break; case WID_DOC_AUTOMATIC_CONTROL_FOCUS: { SwDrawDocument * pDrawDoc; sal_Bool bAuto; if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) ) bAuto = pDrawDoc->GetAutoControlFocus(); else bAuto = sal_False; aAny.setValue(&bAuto, ::getBooleanCppuType()); } break; case WID_DOC_APPLY_FORM_DESIGN_MODE: { SwDrawDocument * pDrawDoc; sal_Bool bMode; if ( 0 != ( pDrawDoc = dynamic_cast< SwDrawDocument * > (pDocShell->GetDoc()->GetDrawModel() ) ) ) bMode = pDrawDoc->GetOpenInDesignMode(); else bMode = sal_True; aAny.setValue(&bMode, ::getBooleanCppuType()); } break; case WID_DOC_BASIC_LIBRARIES: aAny <<= pDocShell->GetBasicContainer(); break; case WID_DOC_DIALOG_LIBRARIES: aAny <<= pDocShell->GetDialogContainer(); break; case WID_DOC_RUNTIME_UID: aAny <<= getRuntimeUID(); break; case WID_DOC_LOCK_UPDATES : aAny <<= static_cast( pDocShell->GetDoc()->IsInReading() ); break; case WID_DOC_BUILDID: aAny <<= maBuildId; break; case WID_DOC_HAS_VALID_SIGNATURES: aAny <<= hasValidSignatures(); break; // --> OD 2006-03-21 #b6375613# case WID_APPLY_WORKAROUND_FOR_B6375613: { aAny <<= pDocShell->GetDoc()->ApplyWorkaroundForB6375613(); } break; // <-- default: { const SfxPoolItem& rItem = pDocShell->GetDoc()->GetDefault(pEntry->nWID); rItem.QueryValue(aAny, pEntry->nMemberId); } } return aAny; } /*-- 10.05.99 13:58:59--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::addPropertyChangeListener(const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { DBG_WARNING("not implemented"); } /*-- 10.05.99 13:58:59--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::removePropertyChangeListener(const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { DBG_WARNING("not implemented"); } /*-- 10.05.99 13:59:00--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::addVetoableChangeListener(const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { DBG_WARNING("not implemented"); } /*-- 10.05.99 13:59:00--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::removeVetoableChangeListener(const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { DBG_WARNING("not implemented"); } /* -----------------25.10.99 10:42------------------- --------------------------------------------------*/ Reference< XNameAccess > SwXTextDocument::getLinks(void) throw( RuntimeException ) { if(!pxLinkTargetSupplier) { pxLinkTargetSupplier = new Reference< XNameAccess > ; (*pxLinkTargetSupplier) = new SwXLinkTargetSupplier(*(SwXTextDocument*)this); } return (*pxLinkTargetSupplier); } /* -----------------------------11.01.01 15:01-------------------------------- ---------------------------------------------------------------------------*/ Reference< XEnumerationAccess > SwXTextDocument::getRedlines( ) throw(RuntimeException) { if(!pxXRedlines) { pxXRedlines = new Reference< XEnumerationAccess > ; (*pxXRedlines) = new SwXRedlines(pDocShell->GetDoc()); } return *pxXRedlines; } /*-- 21.02.00 08:41:06--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::refresh(void) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); ViewShell *pViewShell = pDocShell->GetWrtShell(); notifyRefreshListeners(); if(pViewShell) pViewShell->CalcLayout(); } /*-- 21.02.00 08:41:06--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::addRefreshListener(const Reference< util::XRefreshListener > & l) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if ( !IsValid() ) throw RuntimeException(); aRefreshCont.AddListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l )); } /*-- 21.02.00 08:41:07--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXTextDocument::removeRefreshListener(const Reference< util::XRefreshListener > & l) throw( RuntimeException ) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if ( !IsValid() || !aRefreshCont.RemoveListener ( reinterpret_cast < const Reference < lang::XEventListener > &> ( l ) ) ) throw RuntimeException(); } /* -----------------------------26.02.01 12:22-------------------------------- ---------------------------------------------------------------------------*/ void SwXTextDocument::updateLinks( ) throw(RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); SwDoc* pDoc = pDocShell->GetDoc(); sfx2::LinkManager& rLnkMan = pDoc->GetLinkManager(); if( rLnkMan.GetLinks().Count() ) { UnoActionContext aAction(pDoc); rLnkMan.UpdateAllLinks( sal_False, sal_False, sal_True ); } } //XPropertyState PropertyState SAL_CALL SwXTextDocument::getPropertyState( const OUString& rPropertyName ) throw (UnknownPropertyException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); PropertyState eRet = PropertyState_DIRECT_VALUE; if(!IsValid()) throw RuntimeException(); const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); if(!pEntry) throw UnknownPropertyException(); Any aAny; switch(pEntry->nWID) { case 0:default:break; } return eRet; } Sequence< PropertyState > SAL_CALL SwXTextDocument::getPropertyStates( const Sequence< OUString >& rPropertyNames ) throw (UnknownPropertyException, RuntimeException) { const sal_Int32 nCount = rPropertyNames.getLength(); const OUString * pNames = rPropertyNames.getConstArray(); Sequence < PropertyState > aRet ( nCount ); PropertyState *pState = aRet.getArray(); for ( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++) pState[nIndex] = getPropertyState( pNames[nIndex] ); return aRet; } void SAL_CALL SwXTextDocument::setPropertyToDefault( const OUString& rPropertyName ) throw (UnknownPropertyException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); if(!pEntry) throw UnknownPropertyException(); switch(pEntry->nWID) { case 0:default:break; } } Any SAL_CALL SwXTextDocument::getPropertyDefault( const OUString& rPropertyName ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); const SfxItemPropertySimpleEntry* pEntry = pPropSet->getPropertyMap()->getByName( rPropertyName); if(!pEntry) throw UnknownPropertyException(); Any aAny; switch(pEntry->nWID) { case 0:default:break; } return aAny; } static OutputDevice * lcl_GetOutputDevice( const SwPrintUIOptions &rPrintUIOptions ) { OutputDevice *pOut = 0; uno::Any aAny( rPrintUIOptions.getValue( C2U( "RenderDevice" ) )); uno::Reference< awt::XDevice > xRenderDevice; aAny >>= xRenderDevice; if (xRenderDevice.is()) { VCLXDevice* pDevice = VCLXDevice::GetImplementation( xRenderDevice ); pOut = pDevice ? pDevice->GetOutputDevice() : 0; } return pOut; } static bool lcl_SeqHasProperty( const uno::Sequence< beans::PropertyValue >& rOptions, const sal_Char *pPropName ) { bool bRes = false; const sal_Int32 nLen = rOptions.getLength(); const beans::PropertyValue *pProps = rOptions.getConstArray(); for (sal_Int32 i = 0; i < nLen && !bRes; ++i) { if (pProps[i].Name.equalsAscii( pPropName )) bRes = true; } return bRes; } SfxViewShell * SwXTextDocument::GetRenderView( bool &rbIsSwSrcView, const uno::Sequence< beans::PropertyValue >& rOptions, bool bIsPDFExport ) { // get view shell to use SfxViewShell *pView = 0; if (bIsPDFExport) pView = GuessViewShell( rbIsSwSrcView ); else { uno::Any aTmp; const sal_Int32 nLen = rOptions.getLength(); const beans::PropertyValue *pProps = rOptions.getConstArray(); for (sal_Int32 i = 0; i < nLen; ++i) { if (pProps[i].Name.equalsAscii( "View" )) { aTmp = pProps[i].Value; break; } } uno::Reference< frame::XController > xController; if (aTmp >>= xController) { DBG_ASSERT( xController.is(), "controller is empty!" ); pView = GuessViewShell( rbIsSwSrcView, xController ); } } return pView; } /* * GetRenderDoc: * returns the document to be rendered, usually this will be the 'regular' * document but in case of PDF export of (multi-)selection it will * be a temporary document that gets created if not already done. * The rpView variable will be set (if not already done) to the used * SfxViewShell. */ SwDoc * SwXTextDocument::GetRenderDoc( SfxViewShell *&rpView, const uno::Any& rSelection, bool bIsPDFExport ) { SwDoc *pDoc = 0; uno::Reference< frame::XModel > xModel; rSelection >>= xModel; if (xModel == pDocShell->GetModel()) pDoc = pDocShell->GetDoc(); else { DBG_ASSERT( !xModel.is(), "unexpected model found" ); if (rSelection.hasValue()) // is anything selected ? { // this part should only be called when a temporary document needs to be created, // for example for PDF export or printing of (multi-)selection only. bool bIsSwSrcView = false; if (!rpView) { (void) bIsPDFExport; // aside from maybe PDF export the view should always have been provided! DBG_ASSERT( bIsPDFExport, "view is missing, guessing one..." ); rpView = GuessViewShell( bIsSwSrcView ); } DBG_ASSERT( rpView, "ViewShell missing" ); // the view shell should be SwView for documents PDF export. // for the page preview no selection should be possible // (the export dialog does not allow for this option) const TypeId aSwViewTypeId = TYPE(SwView); if (rpView && rpView->IsA(aSwViewTypeId)) { SfxObjectShellLock xDocSh(((SwView*)rpView)->GetOrCreateTmpSelectionDoc()); if (xDocSh.Is()) { pDoc = ((SwDocShell*)&xDocSh)->GetDoc(); rpView = pDoc->GetDocShell()->GetView(); } } else { DBG_ERROR( "unexpected ViewShell" ); } } } return pDoc; } /* -----------------------------23.08.02 16:00-------------------------------- ---------------------------------------------------------------------------*/ static void lcl_SavePrintUIOptionsToDocumentPrintData( SwDoc &rDoc, const SwPrintUIOptions &rPrintUIOptions, bool bIsPDFEXport ) { SwPrintData aDocPrintData( rDoc.getPrintData() ); aDocPrintData.SetPrintGraphic( rPrintUIOptions.IsPrintGraphics() ); aDocPrintData.SetPrintTable( rPrintUIOptions.IsPrintTables() ); aDocPrintData.SetPrintDraw( rPrintUIOptions.IsPrintDrawings() ); aDocPrintData.SetPrintControl( rPrintUIOptions.IsPrintFormControls() ); aDocPrintData.SetPrintLeftPage( rPrintUIOptions.IsPrintLeftPages() ); aDocPrintData.SetPrintRightPage( rPrintUIOptions.IsPrintRightPages() ); aDocPrintData.SetPrintReverse( rPrintUIOptions.IsPrintReverse() ); aDocPrintData.SetPaperFromSetup( rPrintUIOptions.IsPaperFromSetup() ); aDocPrintData.SetPrintEmptyPages( rPrintUIOptions.IsPrintEmptyPages( bIsPDFEXport ) ); aDocPrintData.SetPrintPostIts( rPrintUIOptions.GetPrintPostItsType() ); aDocPrintData.SetPrintProspect( rPrintUIOptions.IsPrintProspect() ); aDocPrintData.SetPrintProspect_RTL( rPrintUIOptions.IsPrintProspectRTL() ); aDocPrintData.SetPrintPageBackground( rPrintUIOptions.IsPrintPageBackground() ); aDocPrintData.SetPrintBlackFont( rPrintUIOptions.IsPrintWithBlackTextColor() ); // aDocPrintData.SetPrintSingleJobs( b ); handled by File/Print dialog itself // arDocPrintData.SetFaxName( s ); n/a in File/Print dialog aDocPrintData.SetPrintHiddenText( rPrintUIOptions.IsPrintHiddenText() ); aDocPrintData.SetPrintTextPlaceholder( rPrintUIOptions.IsPrintTextPlaceholders() ); rDoc.setPrintData( aDocPrintData ); } sal_Int32 SAL_CALL SwXTextDocument::getRendererCount( const uno::Any& rSelection, const uno::Sequence< beans::PropertyValue >& rxOptions ) throw (IllegalArgumentException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); CleanUpRenderingData(); const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" ); bool bIsSwSrcView = false; SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport ); SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport ); DBG_ASSERT( pDoc && pView, "doc or view shell missing!" ); if ( pDoc == 0 || pView == 0 ) { return 0; } if ( !bIsSwSrcView ) { m_pRenderData = new SwRenderData; } // new m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView ); const bool bFormat = m_pPrintUIOptions->processPropertiesAndCheckFormat( rxOptions ); // save current UI options from the print dialog for the next call to that dialog lcl_SavePrintUIOptionsToDocumentPrintData( *pDoc, *m_pPrintUIOptions, bIsPDFExport ); sal_Int32 nRet = 0; if ( bIsSwSrcView ) { SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView); OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions ); nRet = pSwSrcView->PrintSource( pOutDev, 1 /* dummy */, true /* get page count only */ ); } else { SwDocShell *pRenderDocShell = pDoc->GetDocShell(); // TODO/mba: we really need a generic way to get the ViewShell! ViewShell* pViewShell = 0; SwView* pSwView = PTR_CAST(SwView, pView); if ( pSwView ) { pViewShell = pSwView->GetWrtShellPtr(); } else { if ( bIsPDFExport && bFormat ) { //create a hidden view to be able to export as PDF also in print preview //pView and pSwView are not changed intentionally! m_pHiddenViewFrame = SfxViewFrame::LoadHiddenDocument( *pRenderDocShell, 2 ); pViewShell = ((SwView*)m_pHiddenViewFrame->GetViewShell())->GetWrtShellPtr(); } else pViewShell = ((SwPagePreView*)pView)->GetViewShell(); } if (!pViewShell || !pViewShell->GetLayout()) return 0; if ( bFormat ) { // #i38289 if( pViewShell->GetViewOptions()->getBrowseMode() ) { SwViewOption aOpt( *pViewShell->GetViewOptions() ); aOpt.setBrowseMode( false ); pViewShell->ApplyViewOptions( aOpt ); pSwView->RecheckBrowseMode(); } // reformating the document for printing will show the changes in the view // which is likely to produce many unwanted and not nice to view actions. // We don't want that! Thus we disable updating of the view. pViewShell->StartAction(); if ( pSwView ) { if (m_pRenderData && m_pRenderData->NeedNewViewOptionAdjust( *pViewShell ) ) m_pRenderData->ViewOptionAdjustStop(); if (m_pRenderData && !m_pRenderData->IsViewOptionAdjust()) m_pRenderData->ViewOptionAdjustStart( *pViewShell, *pViewShell->GetViewOptions() ); } m_pRenderData->SetSwPrtOptions( new SwPrintData ); m_pRenderData->MakeSwPrtOptions( m_pRenderData->GetSwPrtOptionsRef(), pRenderDocShell, m_pPrintUIOptions, m_pRenderData, bIsPDFExport ); if ( pSwView ) { // PDF export should not make use of the SwPrtOptions const SwPrintData *pPrtOptions = (bIsPDFExport) ? NULL : m_pRenderData->GetSwPrtOptions(); m_pRenderData->ViewOptionAdjust( pPrtOptions ); } // since printing now also use the API for PDF export this option // should be set for printing as well ... pViewShell->SetPDFExportOption( sal_True ); bool bOrigStatus = pRenderDocShell->IsEnableSetModified(); // check configuration: shall update of printing information in DocInfo set the document to "modified"? bool bStateChanged = false; if ( bOrigStatus && !SvtPrintWarningOptions().IsModifyDocumentOnPrintingAllowed() ) { pRenderDocShell->EnableSetModified( sal_False ); bStateChanged = true; } // --> FME 2005-05-23 #122919# Force field update before PDF export: pViewShell->ViewShell::UpdateFlds(sal_True); // <-- if( bStateChanged ) pRenderDocShell->EnableSetModified( sal_True ); // there is some redundancy between those two function calls, but right now // there is no time to sort this out. //TODO: check what exatly needs to be done and make just one function for that pViewShell->CalcLayout(); pViewShell->CalcPagesForPrint( pViewShell->GetPageCount() ); pViewShell->SetPDFExportOption( sal_False ); // enable view again pViewShell->EndAction(); } const sal_Int32 nPageCount = pViewShell->GetPageCount(); // // get number of pages to be rendered // const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false ); if (bPrintProspect) { pDoc->CalculatePagePairsForProspectPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, nPageCount ); nRet = m_pRenderData->GetPagePairsForProspectPrinting().size(); } else { if ( m_pRenderData->HasPostItData() ) { m_pRenderData->DeletePostItData(); } const sal_Int16 nPostItMode = (sal_Int16) m_pPrintUIOptions->getIntValue( "PrintAnnotationMode", 0 ); if (nPostItMode != POSTITS_NONE) { OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions ); m_pRenderData->CreatePostItData( pDoc, pViewShell->GetViewOptions(), pOutDev ); } // get set of valid document pages (according to the current settings) // and their start frames pDoc->CalculatePagesForPrinting( *pViewShell->GetLayout(), *m_pRenderData, *m_pPrintUIOptions, bIsPDFExport, nPageCount ); if (nPostItMode != POSTITS_NONE) { pDoc->UpdatePagesForPrintingWithPostItData( *m_pRenderData, *m_pPrintUIOptions, bIsPDFExport, nPageCount ); } nRet = m_pRenderData->GetPagesToPrint().size(); } } DBG_ASSERT( nRet >= 0, "negative number of pages???" ); return nRet; } /* -----------------------------23.08.02 16:00-------------------------------- ---------------------------------------------------------------------------*/ uno::Sequence< beans::PropertyValue > SAL_CALL SwXTextDocument::getRenderer( sal_Int32 nRenderer, const uno::Any& rSelection, const uno::Sequence< beans::PropertyValue >& rxOptions ) throw (IllegalArgumentException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" ); bool bIsSwSrcView = false; SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport ); // m_pRenderData should NOT be created here! // That should only be done in getRendererCount. If this function is called before // getRendererCount was called then the caller will probably just retrieve the extra UI options // and is not interested in getting valid information about the other data that would // otherwise be provided here! // if( ! m_pRenderData ) // m_pRenderData = new SwRenderData; if (!m_pPrintUIOptions) m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView ); m_pPrintUIOptions->processProperties( rxOptions ); const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false ); const bool bIsSkipEmptyPages = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport ); const bool bPrintPaperFromSetup = m_pPrintUIOptions->getBoolValue( "PrintPaperFromSetup", false ); SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport ); DBG_ASSERT( pDoc && pView, "doc or view shell missing!" ); if (!pDoc || !pView) return uno::Sequence< beans::PropertyValue >(); if ( nRenderer < 0 || nRenderer >= SAL_MAX_UINT16 ) throw IllegalArgumentException(); // TODO/mba: we really need a generic way to get the ViewShell! ViewShell* pVwSh = 0; SwView* pSwView = PTR_CAST(SwView, pView); if ( pSwView ) pVwSh = pSwView->GetWrtShellPtr(); else pVwSh = ((SwPagePreView*)pView)->GetViewShell(); sal_Int32 nMaxRenderer = 0; if (!bIsSwSrcView && m_pRenderData) { DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" ); nMaxRenderer = bPrintProspect? m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 : m_pRenderData->GetPagesToPrint().size() - 1; } // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print // we obmit checking of the upper bound in this case. if (!bIsSwSrcView && m_pRenderData && nRenderer > nMaxRenderer) return uno::Sequence< beans::PropertyValue >(); uno::Sequence< beans::PropertyValue > aRenderer; if (m_pRenderData) { const sal_Int32 nPage = bPrintProspect ? nRenderer + 1 : m_pRenderData->GetPagesToPrint()[ nRenderer ]; // get paper tray to use ... sal_Int32 nPrinterPaperTray = -1; if (! bPrintPaperFromSetup) { // ... from individual page style (see the page tab in Format/Page dialog) const std::map< sal_Int32, sal_Int32 > &rPaperTrays = m_pRenderData->GetPrinterPaperTrays(); std::map< sal_Int32, sal_Int32 >::const_iterator aIt( rPaperTrays.find( nPage ) ); if (aIt != rPaperTrays.end()) nPrinterPaperTray = aIt->second; } awt::Size aPageSize; awt::Size aPreferredPageSize; Size aTmpSize; if (bIsSwSrcView || bPrintProspect) { // for printing of HTML source code and prospect printing we should use // the printers paper size since // a) HTML source view has no page size // b) prospect printing has a different page size from the documents page // since two document pages will get rendered on one printer page // since PageIncludesNonprintableArea will be set to true we can return the // printers paper size here. // Sometimes 'getRenderer' is only called to get "ExtraPrintUIOptions", in this // case we won't get an OutputDevice here, but then the caller also has no need // for the correct PageSisze right now... Printer *pPrinter = dynamic_cast< Printer * >(lcl_GetOutputDevice( *m_pPrintUIOptions )); if (pPrinter) { // HTML source view and prospect adapt to the printer's paper size aTmpSize = pPrinter->GetPaperSize(); aTmpSize = pPrinter->LogicToLogic( aTmpSize, pPrinter->GetMapMode(), MapMode( MAP_100TH_MM )); aPageSize = awt::Size( aTmpSize.Width(), aTmpSize.Height() ); if( bPrintProspect ) { // just switch to an appropriate portrait/landscape format // FIXME: brochure printing with landscape pages puts the // pages next to each other, so landscape is currently always // the better choice if( aPageSize.Width < aPageSize.Height ) { aPreferredPageSize.Width = aPageSize.Height; aPreferredPageSize.Height = aPageSize.Width; } } } } else { ASSERT( nPage > 0 && nPage <= SAL_MAX_UINT16, " - unexpected value for the page number, it does not fit into sal_uInt16." ); aTmpSize = pVwSh->GetPageSize( static_cast< sal_uInt16 >(nPage), bIsSkipEmptyPages ); aPageSize = awt::Size ( TWIP_TO_MM100( aTmpSize.Width() ), TWIP_TO_MM100( aTmpSize.Height() )); } sal_Int32 nLen = 2; aRenderer.realloc(2); aRenderer[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ); aRenderer[0].Value <<= aPageSize; aRenderer[1].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PageIncludesNonprintableArea" ) ); aRenderer[1].Value <<= sal_True; if (aPreferredPageSize.Width && aPreferredPageSize.Height) { ++nLen; aRenderer.realloc( nLen ); aRenderer[ nLen - 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PreferredPageSize" ) ); aRenderer[ nLen - 1 ].Value <<= aPreferredPageSize; } if (nPrinterPaperTray >= 0) { ++nLen; aRenderer.realloc( nLen ); aRenderer[ nLen - 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "PrinterPaperTray" ) ); aRenderer[ nLen - 1 ].Value <<= nPrinterPaperTray; } } if ( bApplyPagePrintSettingsFromXPagePrintable ) { const SwPagePreViewPrtData* pPagePrintSettings = pDocShell->GetDoc()->GetPreViewPrtData(); if ( pPagePrintSettings && ( pPagePrintSettings->GetRow() > 1 || pPagePrintSettings->GetCol() > 1 ) ) { // extend render data by page print settings attributes sal_Int32 nLen = aRenderer.getLength(); const sal_Int32 nRenderDataIdxStart = nLen; nLen += 9; aRenderer.realloc( nLen ); // put page print settings attribute into render data const sal_Int32 nRow = pPagePrintSettings->GetRow(); aRenderer[ nRenderDataIdxStart + 0 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpRows" ) ); aRenderer[ nRenderDataIdxStart + 0 ].Value <<= ( nRow > 1 ? nRow : 1 ); const sal_Int32 nCol = pPagePrintSettings->GetCol(); aRenderer[ nRenderDataIdxStart + 1 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpColumns" ) ); aRenderer[ nRenderDataIdxStart + 1 ].Value <<= ( nCol > 1 ? nCol : 1 ); aRenderer[ nRenderDataIdxStart + 2 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginLeft" ) ); aRenderer[ nRenderDataIdxStart + 2 ].Value <<= pPagePrintSettings->GetLeftSpace(); aRenderer[ nRenderDataIdxStart + 3 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginRight" ) ); aRenderer[ nRenderDataIdxStart + 3 ].Value <<= pPagePrintSettings->GetRightSpace(); aRenderer[ nRenderDataIdxStart + 4 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginTop" ) ); aRenderer[ nRenderDataIdxStart + 4 ].Value <<= pPagePrintSettings->GetTopSpace(); aRenderer[ nRenderDataIdxStart + 5 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPageMarginBottom" ) ); aRenderer[ nRenderDataIdxStart + 5 ].Value <<= pPagePrintSettings->GetBottomSpace(); aRenderer[ nRenderDataIdxStart + 6 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpHorizontalSpacing" ) ); aRenderer[ nRenderDataIdxStart + 6 ].Value <<= pPagePrintSettings->GetHorzSpace(); aRenderer[ nRenderDataIdxStart + 7 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpVerticalSpacing" ) ); aRenderer[ nRenderDataIdxStart + 7 ].Value <<= pPagePrintSettings->GetVertSpace(); { Printer* pPrinter = pDocShell->GetDoc()->getPrinter( false ); if ( pPrinter ) { awt::Size aNewPageSize; const Size aPageSize = pPrinter->PixelToLogic( pPrinter->GetPaperSizePixel(), MapMode( MAP_100TH_MM ) ); aNewPageSize = awt::Size( aPageSize.Width(), aPageSize.Height() ); if ( ( pPagePrintSettings->GetLandscape() && aPageSize.Width() < aPageSize.Height() ) || ( !pPagePrintSettings->GetLandscape() && aPageSize.Width() > aPageSize.Height() ) ) { aNewPageSize = awt::Size( aPageSize.Height(), aPageSize.Width() ); } aRenderer[ nRenderDataIdxStart + 8 ].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "NUpPaperSize" ) ); aRenderer[ nRenderDataIdxStart + 8 ].Value <<= aNewPageSize; } } } bApplyPagePrintSettingsFromXPagePrintable = sal_False; } m_pPrintUIOptions->appendPrintUIOptions( aRenderer ); return aRenderer; } /* -----------------------------28.10.02 16:00-------------------------------- ---------------------------------------------------------------------------*/ SfxViewShell * SwXTextDocument::GuessViewShell( /* out */ bool &rbIsSwSrcView, const uno::Reference< css::frame::XController > xController ) { // #130810# SfxViewShell::Current() / SfxViewShell::GetObjectShell() // must not be used (see comment from MBA) // SfxViewShell *pView = 0; SwView *pSwView = 0; SwPagePreView *pSwPagePreView = 0; SwSrcView *pSwSrcView = 0; SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pDocShell, sal_False ); // look for the view shell with the same controller in use, // otherwise look for a suitable view while (pFrame) { pView = pFrame->GetViewShell(); pSwView = dynamic_cast< SwView * >(pView); pSwSrcView = dynamic_cast< SwSrcView * >(pView); if (!pSwPagePreView) pSwPagePreView = dynamic_cast< SwPagePreView * >(pView); if (xController.is()) { if (pView && pView->GetController() == xController) break; } else if ( pSwView || pSwSrcView || pSwPagePreView ) break; pFrame = SfxViewFrame::GetNext( *pFrame, pDocShell, sal_False ); } DBG_ASSERT( pSwView || pSwPagePreView || pSwSrcView, "failed to get view shell" ); if (pView) rbIsSwSrcView = pSwSrcView != 0; return pView; } void SAL_CALL SwXTextDocument::render( sal_Int32 nRenderer, const uno::Any& rSelection, const uno::Sequence< beans::PropertyValue >& rxOptions ) throw (IllegalArgumentException, RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); // due to #110067# (document page count changes sometimes during // PDF export/printing) we can not check for the upper bound properly. // Thus instead of throwing the exception we silently return. if (0 > nRenderer) throw IllegalArgumentException(); const bool bIsPDFExport = !lcl_SeqHasProperty( rxOptions, "IsPrinter" ); bool bIsSwSrcView = false; SfxViewShell *pView = GetRenderView( bIsSwSrcView, rxOptions, bIsPDFExport ); // error handling - avoid crash if ( !bIsSwSrcView && m_pRenderData == NULL ) { DBG_ASSERT( false, "data should have been created already in getRendererCount..." ); m_pRenderData = new SwRenderData; } if ( m_pPrintUIOptions == 0 ) { DBG_ASSERT( false, "data should have been created already in getRendererCount..." ); m_pPrintUIOptions = lcl_GetPrintUIOptions( pDocShell, pView ); } m_pPrintUIOptions->processProperties( rxOptions ); const bool bPrintProspect = m_pPrintUIOptions->getBoolValue( "PrintProspect", false ); const bool bLastPage = m_pPrintUIOptions->getBoolValue( "IsLastPage", sal_False ); SwDoc *pDoc = GetRenderDoc( pView, rSelection, bIsPDFExport ); DBG_ASSERT( pDoc && pView, "doc or view shell missing!" ); if (pDoc && pView) { sal_Int32 nMaxRenderer = 0; if (!bIsSwSrcView) { DBG_ASSERT( m_pRenderData, "m_pRenderData missing!!" ); nMaxRenderer = bPrintProspect? m_pRenderData->GetPagePairsForProspectPrinting().size() - 1 : m_pRenderData->GetPagesToPrint().size() - 1; } // since SwSrcView::PrintSource is a poor implementation to get the number of pages to print // we obmit checking of the upper bound in this case. if (bIsSwSrcView || nRenderer <= nMaxRenderer) { if (bIsSwSrcView) { SwSrcView *pSwSrcView = dynamic_cast< SwSrcView * >(pView); OutputDevice *pOutDev = lcl_GetOutputDevice( *m_pPrintUIOptions ); pSwSrcView->PrintSource( pOutDev, nRenderer + 1, false ); } else { // the view shell should be SwView for documents PDF export // or SwPagePreView for PDF export of the page preview //!! (check for SwView first as in GuessViewShell) !! DBG_ASSERT( pView, "!! view missing !!" ); const TypeId aSwViewTypeId = TYPE(SwView); ViewShell* pVwSh = 0; if (pView) { // TODO/mba: we really need a generic way to get the ViewShell! SwView* pSwView = PTR_CAST(SwView, pView); if ( pSwView ) pVwSh = pSwView->GetWrtShellPtr(); else pVwSh = ((SwPagePreView*)pView)->GetViewShell(); } // get output device to use OutputDevice * pOut = lcl_GetOutputDevice( *m_pPrintUIOptions ); if(pVwSh && pOut && m_pRenderData->HasSwPrtOptions()) { const rtl::OUString aPageRange = m_pPrintUIOptions->getStringValue( "PageRange", OUString() ); const bool bFirstPage = m_pPrintUIOptions->getBoolValue( "IsFirstPage", sal_False ); bool bIsSkipEmptyPages = !m_pPrintUIOptions->IsPrintEmptyPages( bIsPDFExport ); DBG_ASSERT(( pView->IsA(aSwViewTypeId) && m_pRenderData->IsViewOptionAdjust()) || (!pView->IsA(aSwViewTypeId) && !m_pRenderData->IsViewOptionAdjust()), "SwView / SwViewOptionAdjust_Impl availability mismatch" ); // since printing now also use the API for PDF export this option // should be set for printing as well ... pVwSh->SetPDFExportOption( sal_True ); // --> FME 2004-06-08 #i12836# enhanced pdf export // // First, we have to export hyperlinks, notes, and outline to pdf. // During this process, additional information required for tagging // the pdf file are collected, which are evaulated during painting. // SwWrtShell* pWrtShell = pView->IsA(aSwViewTypeId) ? ((SwView*)pView)->GetWrtShellPtr() : 0; if (bIsPDFExport && bFirstPage && pWrtShell) { SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages, sal_False ); } // <-- SwPrintData const& rSwPrtOptions = *m_pRenderData->GetSwPrtOptions(); if (bPrintProspect) pVwSh->PrintProspect( pOut, rSwPrtOptions, nRenderer ); else // normal printing and PDF export pVwSh->PrintOrPDFExport( pOut, rSwPrtOptions, nRenderer ); // After printing the last page, we take care for the links coming // from the EditEngine. The links are generated during the painting // process, but the destinations are still missing. // if (bIsPDFExport && bLastPage && pWrtShell) { SwEnhancedPDFExportHelper aHelper( *pWrtShell, *pOut, aPageRange, bIsSkipEmptyPages, sal_True ); } pVwSh->SetPDFExportOption( sal_False ); } } } } // last page to be rendered? (not necessarily the last page of the document) // -> do clean-up of data if ( bLastPage ) { CleanUpRenderingData(); } } /* -----------------------------03.10.04 ------------------------------------- ---------------------------------------------------------------------------*/ // xforms::XFormsSupplier Reference SAL_CALL SwXTextDocument::getXForms() throw( RuntimeException ) { if ( !pDocShell ) throw DisposedException( ::rtl::OUString(), static_cast< XTextDocument* >( this ) ); SwDoc* pDoc = pDocShell->GetDoc(); return pDoc->getXForms(); } /* -----------------------------25.09.07 ------------------------------------- ---------------------------------------------------------------------------*/ uno::Reference< text::XFlatParagraphIterator > SAL_CALL SwXTextDocument::getFlatParagraphIterator(::sal_Int32 nTextMarkupType, sal_Bool bAutomatic) throw ( uno::RuntimeException ) { return new SwXFlatParagraphIterator( *pDocShell->GetDoc(), nTextMarkupType, bAutomatic ); } /*-- 07.05.2009 09:21:12--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Reference< util::XCloneable > SwXTextDocument::createClone( ) throw (uno::RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); if(!IsValid()) throw RuntimeException(); // create a new document - hidden - copy the storage and return it // SfxObjectShellRef is used here, since the model should control object lifetime after creation // and thus SfxObjectShellLock is not allowed here // the model holds reference to the shell, so the shell will not destructed at the end of method SfxObjectShellRef pShell = pDocShell->GetDoc()->CreateCopy(false); uno::Reference< frame::XModel > xNewModel = pShell->GetModel(); uno::Reference< embed::XStorage > xNewStorage = ::comphelper::OStorageHelper::GetTemporaryStorage( ); uno::Sequence< beans::PropertyValue > aTempMediaDescriptor; storeToStorage( xNewStorage, aTempMediaDescriptor ); uno::Reference< document::XStorageBasedDocument > xStorageDoc( xNewModel, uno::UNO_QUERY ); xStorageDoc->loadFromStorage( xNewStorage, aTempMediaDescriptor ); return uno::Reference< util::XCloneable >( xNewModel, UNO_QUERY ); } /* -----------------------------20.06.00 09:54-------------------------------- ---------------------------------------------------------------------------*/ void * SAL_CALL SwXTextDocument::operator new( size_t t) throw() { return SwXTextDocumentBaseClass::operator new(t); } /* -----------------------------20.06.00 09:54-------------------------------- ---------------------------------------------------------------------------*/ void SAL_CALL SwXTextDocument::operator delete( void * p) throw() { SwXTextDocumentBaseClass::operator delete(p); } /*--------------------------------------------------- retrieve languages already used in current document -----------------------------------------------------*/ uno::Sequence< lang::Locale > SAL_CALL SwXTextDocument::getDocumentLanguages( ::sal_Int16 nScriptTypes, ::sal_Int16 nMaxCount ) throw (lang::IllegalArgumentException, uno::RuntimeException) { ::vos::OGuard aGuard(Application::GetSolarMutex()); // possible canonical values for nScriptTypes // any bit wise combination is allowed const sal_Int16 nLatin = 0x001; const sal_Int16 nAsian = 0x002; const sal_Int16 nComplex = 0x004; // script types for which to get the languages const bool bLatin = 0 != (nScriptTypes & nLatin); const bool bAsian = 0 != (nScriptTypes & nAsian); const bool bComplex = 0 != (nScriptTypes & nComplex); if (nScriptTypes < nLatin || nScriptTypes > (nLatin | nAsian | nComplex)) throw IllegalArgumentException(::rtl::OUString::createFromAscii("nScriptTypes ranges from 1 to 7!"), Reference< XInterface >(), 1); if (!pDocShell) throw DisposedException(); SwDoc* pDoc = pDocShell->GetDoc(); // avoid duplicate values std::set< LanguageType > aAllLangs; //USER STYLES const SwCharFmts *pFmts = pDoc->GetCharFmts(); for(sal_uInt16 i = 0; i < pFmts->Count(); ++i) { const SwAttrSet &rAttrSet = (*pFmts)[i]->GetAttrSet(); LanguageType nLang = LANGUAGE_DONTKNOW; if (bLatin) { nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bAsian) { nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bComplex) { nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } } const SwTxtFmtColls *pColls = pDoc->GetTxtFmtColls(); for (sal_uInt16 i = 0; i < pColls->Count(); ++i) { const SwAttrSet &rAttrSet = (*pColls)[i]->GetAttrSet(); LanguageType nLang = LANGUAGE_DONTKNOW;; if (bLatin) { nLang = rAttrSet.GetLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bAsian) { nLang = rAttrSet.GetCJKLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bComplex) { nLang = rAttrSet.GetCTLLanguage( sal_False ).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } } //AUTO STYLES const IStyleAccess::SwAutoStyleFamily aFam[2] = { IStyleAccess::AUTO_STYLE_CHAR, IStyleAccess::AUTO_STYLE_PARA }; for (sal_uInt16 i = 0; i < 2; ++i) { std::vector< SfxItemSet_Pointer_t > rStyles; pDoc->GetIStyleAccess().getAllStyles(rStyles, aFam[i]); while (!rStyles.empty()) { SfxItemSet_Pointer_t pStyle = rStyles.back(); rStyles.pop_back(); const SfxItemSet *pSet = dynamic_cast< const SfxItemSet * >(pStyle.get()); LanguageType nLang = LANGUAGE_DONTKNOW; if (bLatin) { nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_LANGUAGE, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bAsian) { nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CJK_LANGUAGE, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bComplex) { nLang = dynamic_cast< const SvxLanguageItem & >(pSet->Get( RES_CHRATR_CTL_LANGUAGE, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } } } //TODO/mba: it's a strange concept that a view is needed to retrieve core data SwWrtShell *pWrtSh = pDocShell->GetWrtShell(); SdrView *pSdrView = pWrtSh->GetDrawView(); if( pSdrView ) { SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner(); if(pOutliner) { EditEngine& rEditEng = (EditEngine&)pOutliner->GetEditEngine(); sal_uLong nParCount = pOutliner->GetParagraphCount(); for (sal_uLong nPar=0; nPar(aAttr.Get( EE_CHAR_LANGUAGE, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bAsian) { nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CJK, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } if (bComplex) { nLang = dynamic_cast< const SvxLanguageItem & >(aAttr.Get( EE_CHAR_LANGUAGE_CTL, sal_False )).GetLanguage(); if (nLang != LANGUAGE_DONTKNOW && nLang != LANGUAGE_SYSTEM) aAllLangs.insert( nLang ); } } } } } // less than nMaxCount languages if (nMaxCount > static_cast< sal_Int16 >( aAllLangs.size() )) nMaxCount = static_cast< sal_Int16 >( aAllLangs.size() ); // build return value sal_Int32 nCount = 0; uno::Sequence< lang::Locale > aLanguages( nMaxCount ); lang::Locale* pLanguage = aLanguages.getArray(); if (nMaxCount > 0) { const SvtLanguageTable aLangTab; for (std::set< LanguageType >::const_iterator it = aAllLangs.begin(); it != aAllLangs.end(); ++it) { if (nCount >= nMaxCount) break; if (LANGUAGE_NONE != *it) { MsLangId::convertLanguageToLocale( *it, pLanguage[nCount] ); pLanguage[nCount].Language = aLangTab.GetString( *it ); nCount += 1; } } } return aLanguages; } // #121125#, #122868# // method to assure clean up of the rendering data to restore view options // and to loose hold reference to the ViewShell in SwViewOptionAdjust_Impl. // also perform clean up for the still existing hidden frame for PDF export from Page Preview void SwXTextDocument::CleanUpRenderingData() { if( m_pRenderData != NULL ) { if ( m_pRenderData->HasPostItData() ) { m_pRenderData->DeletePostItData(); } delete m_pRenderData; m_pRenderData = NULL; } if( m_pPrintUIOptions != NULL ) { delete m_pPrintUIOptions; m_pPrintUIOptions = NULL; } if ( IsValid() && m_pHiddenViewFrame ) { lcl_DisposeView( m_pHiddenViewFrame, pDocShell); m_pHiddenViewFrame = 0; SfxItemSet *pSet = pDocShell->GetMedium()->GetItemSet(); pSet->Put( SfxBoolItem( SID_HIDDEN, sal_False ) ); } } /* -----------------25.10.99 11:06------------------- --------------------------------------------------*/ SwXLinkTargetSupplier::SwXLinkTargetSupplier(SwXTextDocument& rxDoc) : pxDoc(&rxDoc) { sTables = String(SW_RES(STR_CONTENT_TYPE_TABLE)); sFrames = String(SW_RES(STR_CONTENT_TYPE_FRAME)); sGraphics = String(SW_RES(STR_CONTENT_TYPE_GRAPHIC)); sOLEs = String(SW_RES(STR_CONTENT_TYPE_OLE)); sSections = String(SW_RES(STR_CONTENT_TYPE_REGION)); sOutlines = String(SW_RES(STR_CONTENT_TYPE_OUTLINE)); sBookmarks = String(SW_RES(STR_CONTENT_TYPE_BOOKMARK)); } /* -----------------25.10.99 11:11------------------- --------------------------------------------------*/ SwXLinkTargetSupplier::~SwXLinkTargetSupplier() { } /*-- 25.10.99 11:12:45--------------------------------------------------- -----------------------------------------------------------------------*/ Any SwXLinkTargetSupplier::getByName(const OUString& rName) throw( NoSuchElementException, WrappedTargetException, RuntimeException ) { Any aRet; if(!pxDoc) throw RuntimeException(); String sToCompare(rName); String sSuffix('|'); if(sToCompare == sTables) { sSuffix += UniString::CreateFromAscii(pMarkToTable); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->getTextTables(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference*)0)); } else if(sToCompare == sFrames) { sSuffix += UniString::CreateFromAscii(pMarkToFrame); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->getTextFrames(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } else if(sToCompare == sSections) { sSuffix += UniString::CreateFromAscii(pMarkToRegion); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->getTextSections(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } /* else if(sToCompare == ) { sSuffix += UniString::CreateFromAscii(pMarkToText); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((const XPropertySet*)0)); }*/ else if(sToCompare == sGraphics) { sSuffix += UniString::CreateFromAscii(pMarkToGraphic); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->getGraphicObjects(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } else if(sToCompare == sOLEs) { sSuffix += UniString::CreateFromAscii(pMarkToOLE); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( pxDoc->getEmbeddedObjects(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } else if(sToCompare == sOutlines) { sSuffix += UniString::CreateFromAscii(pMarkToOutline); Reference< XNameAccess > xTbls = new SwXLinkNameAccessWrapper( *pxDoc, sToCompare, sSuffix ); Reference< XPropertySet > xRet(xTbls, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } else if(sToCompare == sBookmarks) { sSuffix.Erase(); Reference< XNameAccess > xBkms = new SwXLinkNameAccessWrapper( pxDoc->getBookmarks(), sToCompare, sSuffix ); Reference< XPropertySet > xRet(xBkms, UNO_QUERY); aRet.setValue(&xRet, ::getCppuType((Reference< XPropertySet>*)0)); } else throw NoSuchElementException(); return aRet; } /*-- 25.10.99 11:12:46--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< OUString > SwXLinkTargetSupplier::getElementNames(void) throw( RuntimeException ) { Sequence< OUString > aRet(7); OUString* pNames = aRet.getArray(); pNames[0] = sTables; pNames[1] = sFrames ; pNames[2] = sGraphics; pNames[3] = sOLEs ; pNames[4] = sSections; pNames[5] = sOutlines; pNames[6] = sBookmarks; return aRet; } /*-- 25.10.99 11:12:46--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkTargetSupplier::hasByName(const OUString& rName) throw( RuntimeException ) { String sToCompare(rName); if( sToCompare == sTables || sToCompare == sFrames || sToCompare == sGraphics|| sToCompare == sOLEs || sToCompare == sSections || sToCompare == sOutlines || sToCompare == sBookmarks ) return sal_True; return sal_False; } /*-- 25.10.99 11:12:47--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Type SwXLinkTargetSupplier::getElementType(void) throw( RuntimeException ) { return ::getCppuType((Reference< XPropertySet>*)0); } /*-- 25.10.99 11:12:47--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkTargetSupplier::hasElements(void) throw( RuntimeException ) { return 0 != pxDoc; } /*-- 25.10.99 11:12:47--------------------------------------------------- -----------------------------------------------------------------------*/ OUString SwXLinkTargetSupplier::getImplementationName(void) throw( RuntimeException ) { return C2U("SwXLinkTargetSupplier"); } /*-- 25.10.99 11:12:48--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkTargetSupplier::supportsService(const OUString& rServiceName) throw( RuntimeException ) { return (rServiceName == C2U("com.sun.star.document.LinkTargets")); } /*-- 25.10.99 11:12:48--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< OUString > SwXLinkTargetSupplier::getSupportedServiceNames(void) throw( RuntimeException ) { Sequence< OUString > aRet(1); OUString* pNames = aRet.getArray(); pNames[0] = C2U("com.sun.star.document.LinkTargets"); return aRet; } /*-- 26.10.99 09:16:23--------------------------------------------------- -----------------------------------------------------------------------*/ SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper( Reference< XNameAccess > xAccess, const String& rLinkDisplayName, String sSuffix ) : xRealAccess(xAccess), pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)), sLinkSuffix(sSuffix), sLinkDisplayName(rLinkDisplayName), pxDoc(0) { } /* -----------------26.10.99 14:17------------------- --------------------------------------------------*/ SwXLinkNameAccessWrapper::SwXLinkNameAccessWrapper(SwXTextDocument& rxDoc, const String& rLinkDisplayName, String sSuffix) : pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)), sLinkSuffix(sSuffix), sLinkDisplayName(rLinkDisplayName), xDoc(&rxDoc), pxDoc(&rxDoc) { } /*-- 26.10.99 09:16:23--------------------------------------------------- -----------------------------------------------------------------------*/ SwXLinkNameAccessWrapper::~SwXLinkNameAccessWrapper() { } /*-- 26.10.99 09:16:24--------------------------------------------------- -----------------------------------------------------------------------*/ Any SwXLinkNameAccessWrapper::getByName(const OUString& rName) throw( NoSuchElementException, WrappedTargetException, RuntimeException ) { Any aRet; sal_Bool bFound = sal_False; //cut link extension and call the real NameAccess String sParam = rName; String sSuffix(sLinkSuffix); if(sParam.Len() > sSuffix.Len() ) { String sCmp = sParam.Copy(sParam.Len() - sSuffix.Len(), sSuffix.Len()); if(sCmp == sSuffix) { if(pxDoc) { sParam = sParam.Copy(0, sParam.Len() - sSuffix.Len()); if(!pxDoc->GetDocShell()) throw RuntimeException(); SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc(); sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count(); for (sal_uInt16 i = 0; i < nOutlineCount && !bFound; ++i) { const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds(); const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule(); if(sParam == lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule)) { Reference< XPropertySet > xOutline = new SwXOutlineTarget(sParam); aRet.setValue(&xOutline, ::getCppuType((Reference*)0)); bFound = sal_True; } } } else { aRet = xRealAccess->getByName(sParam.Copy(0, sParam.Len() - sSuffix.Len())); Reference< XInterface > xInt; if(!(aRet >>= xInt)) throw RuntimeException(); Reference< XPropertySet > xProp(xInt, UNO_QUERY); aRet <<= xProp; bFound = sal_True; } } } if(!bFound) throw NoSuchElementException(); return aRet; } /*-- 26.10.99 09:16:24--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< OUString > SwXLinkNameAccessWrapper::getElementNames(void) throw( RuntimeException ) { Sequence< OUString > aRet; if(pxDoc) { if(!pxDoc->GetDocShell()) throw RuntimeException(); SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc(); const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds(); sal_uInt16 nOutlineCount = rOutlineNodes.Count(); aRet.realloc(nOutlineCount); OUString* pResArr = aRet.getArray(); String sSuffix('|'); sSuffix += UniString::CreateFromAscii(pMarkToOutline); const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule(); for (sal_uInt16 i = 0; i < nOutlineCount; ++i) { String sEntry = lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule); sEntry += sSuffix; pResArr[i] = sEntry; } } else { Sequence< OUString > aOrg = xRealAccess->getElementNames(); const OUString* pOrgArr = aOrg.getConstArray(); aRet.realloc(aOrg.getLength()); OUString* pResArr = aRet.getArray(); for(long i = 0; i < aOrg.getLength(); i++) { pResArr[i] = pOrgArr[i] + sLinkSuffix; } } return aRet; } /*-- 26.10.99 09:16:25--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkNameAccessWrapper::hasByName(const OUString& rName) throw( RuntimeException ) { sal_Bool bRet = sal_False; String sParam(rName); if(sParam.Len() > sLinkSuffix.Len() ) { String sCmp = sParam.Copy(sParam.Len() - sLinkSuffix.Len(), sLinkSuffix.Len()); if(sCmp == sLinkSuffix) { sParam = sParam.Copy(0, sParam.Len() - sLinkSuffix.Len()); if(pxDoc) { if(!pxDoc->GetDocShell()) throw RuntimeException(); SwDoc* pDoc = pxDoc->GetDocShell()->GetDoc(); sal_uInt16 nOutlineCount = pDoc->GetNodes().GetOutLineNds().Count(); for (sal_uInt16 i = 0; i < nOutlineCount && !bRet; ++i) { const SwOutlineNodes& rOutlineNodes = pDoc->GetNodes().GetOutLineNds(); const SwNumRule* pOutlRule = pDoc->GetOutlineNumRule(); if(sParam == lcl_CreateOutlineString(i, rOutlineNodes, pOutlRule)) { bRet = sal_True; } } } else { bRet = xRealAccess->hasByName(sParam); } } } return bRet; } /*-- 26.10.99 09:16:25--------------------------------------------------- -----------------------------------------------------------------------*/ uno::Type SwXLinkNameAccessWrapper::getElementType(void) throw( RuntimeException ) { return ::getCppuType((Reference*)0); } /*-- 26.10.99 09:16:25--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkNameAccessWrapper::hasElements(void) throw( RuntimeException ) { sal_Bool bRet = sal_False; if(pxDoc) { DBG_ERROR("not implemented"); } else { bRet = xRealAccess->hasElements(); } return bRet; } /*-- 26.10.99 09:16:26--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySetInfo > SwXLinkNameAccessWrapper::getPropertySetInfo(void) throw( RuntimeException ) { static Reference< XPropertySetInfo > xRet = pPropSet->getPropertySetInfo(); return xRet; } /*-- 26.10.99 09:16:26--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXLinkNameAccessWrapper::setPropertyValue( const OUString& , const Any& ) throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException) { throw UnknownPropertyException(); } /* -----------------------------08.12.99 11:10-------------------------------- ---------------------------------------------------------------------------*/ Any lcl_GetDisplayBitmap(String sLinkSuffix) { Any aRet; if(sLinkSuffix.Len()) sLinkSuffix.Erase(0, 1); sal_uInt16 nImgId = USHRT_MAX; if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOutline)) nImgId = CONTENT_TYPE_OUTLINE; else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToTable)) nImgId = CONTENT_TYPE_TABLE; else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToFrame)) nImgId = CONTENT_TYPE_FRAME; else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToGraphic)) nImgId = CONTENT_TYPE_GRAPHIC; // else if(== sLinkSuffix) // nImgId = CONTENT_TYPE_BOOKMARK; else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToRegion)) nImgId = CONTENT_TYPE_REGION; else if(COMPARE_EQUAL == sLinkSuffix.CompareToAscii(pMarkToOLE)) nImgId = CONTENT_TYPE_OLE; else if(!sLinkSuffix.Len()) nImgId = CONTENT_TYPE_BOOKMARK; if(USHRT_MAX != nImgId) { nImgId += 20000; sal_Bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode(); ImageList aEntryImages( SW_RES(bHighContrast ? IMG_NAVI_ENTRYBMPH : IMG_NAVI_ENTRYBMP) ); const Image& rImage = aEntryImages.GetImage( nImgId ); Bitmap aBitmap( rImage.GetBitmapEx().GetBitmap() ); Reference xBmp = VCLUnoHelper::CreateBitmap( aBitmap ); aRet.setValue( &xBmp, ::getCppuType((Reference*)0) ); } return aRet; } /*-- 26.10.99 09:16:27--------------------------------------------------- -----------------------------------------------------------------------*/ Any SwXLinkNameAccessWrapper::getPropertyValue(const OUString& rPropertyName) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { Any aRet; if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME))) { aRet <<= OUString(sLinkDisplayName); } else if( rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_BITMAP))) { aRet = lcl_GetDisplayBitmap(sLinkSuffix); } else throw UnknownPropertyException(); return aRet; } /*-- 26.10.99 09:16:27--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXLinkNameAccessWrapper::addPropertyChangeListener( const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) {} /*-- 26.10.99 09:16:28--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXLinkNameAccessWrapper::removePropertyChangeListener( const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) {} /*-- 26.10.99 09:16:28--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXLinkNameAccessWrapper::addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) {} /*-- 26.10.99 09:16:29--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXLinkNameAccessWrapper::removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) {} /*-- 26.10.99 09:16:32--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XNameAccess > SwXLinkNameAccessWrapper::getLinks(void) throw( RuntimeException ) { return (SwXLinkNameAccessWrapper*)this; } /*-- 26.10.99 09:21:48--------------------------------------------------- -----------------------------------------------------------------------*/ OUString SwXLinkNameAccessWrapper::getImplementationName(void) throw( RuntimeException ) { return C2U("SwXLinkNameAccessWrapper"); } /*-- 26.10.99 09:21:48--------------------------------------------------- -----------------------------------------------------------------------*/ sal_Bool SwXLinkNameAccessWrapper::supportsService(const OUString& rServiceName) throw( RuntimeException ) { return (rServiceName == C2U("com.sun.star.document.LinkTargets")); } /*-- 26.10.99 09:21:48--------------------------------------------------- -----------------------------------------------------------------------*/ Sequence< OUString > SwXLinkNameAccessWrapper::getSupportedServiceNames(void) throw( RuntimeException ) { Sequence< OUString > aRet(1); OUString* pNames = aRet.getArray(); pNames[0] = C2U("com.sun.star.document.LinkTargets"); return aRet; } /* -----------------26.10.99 15:50------------------- --------------------------------------------------*/ SwXOutlineTarget::SwXOutlineTarget(const String& rOutlineText) : pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_LINK_TARGET)), sOutlineText(rOutlineText) { } /*-- 26.10.99 15:51:45--------------------------------------------------- -----------------------------------------------------------------------*/ SwXOutlineTarget::~SwXOutlineTarget() { } /*-- 26.10.99 15:51:46--------------------------------------------------- -----------------------------------------------------------------------*/ Reference< XPropertySetInfo > SwXOutlineTarget::getPropertySetInfo(void) throw( RuntimeException ) { static Reference< XPropertySetInfo > xRet = pPropSet->getPropertySetInfo(); return xRet; } /*-- 26.10.99 15:51:46--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXOutlineTarget::setPropertyValue( const OUString& /*PropertyName*/, const Any& /*aValue*/) throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException) { throw UnknownPropertyException(); } /*-- 26.10.99 15:51:46--------------------------------------------------- -----------------------------------------------------------------------*/ Any SwXOutlineTarget::getPropertyValue(const OUString& rPropertyName) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { Any aRet; if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_LINK_DISPLAY_NAME))) aRet <<= OUString(sOutlineText); else throw UnknownPropertyException(); return aRet; } /*-- 26.10.99 15:51:46--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXOutlineTarget::addPropertyChangeListener( const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { } /*-- 26.10.99 15:51:47--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXOutlineTarget::removePropertyChangeListener( const OUString& /*PropertyName*/, const Reference< XPropertyChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { } /*-- 26.10.99 15:51:47--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXOutlineTarget::addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { } /*-- 26.10.99 15:51:47--------------------------------------------------- -----------------------------------------------------------------------*/ void SwXOutlineTarget::removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener > & /*aListener*/) throw( UnknownPropertyException, WrappedTargetException, RuntimeException ) { } /* -----------------03.05.99 12:28------------------- * * --------------------------------------------------*/ OUString SwXOutlineTarget::getImplementationName(void) throw( RuntimeException ) { return C2U("SwXOutlineTarget"); } /* -----------------03.05.99 12:28------------------- * * --------------------------------------------------*/ sal_Bool SwXOutlineTarget::supportsService(const OUString& ServiceName) throw( RuntimeException ) { return C2U("com.sun.star.document.LinkTarget") == ServiceName; } /* -----------------03.05.99 12:28------------------- * * --------------------------------------------------*/ Sequence< OUString > SwXOutlineTarget::getSupportedServiceNames(void) throw( RuntimeException ) { Sequence < OUString > aRet(1); OUString* pArray = aRet.getArray(); pArray[0] = C2U("com.sun.star.document.LinkTarget"); return aRet; } /* -----------------------------17.01.01 16:06-------------------------------- ---------------------------------------------------------------------------*/ SwXDocumentPropertyHelper::SwXDocumentPropertyHelper(SwDoc& rDoc) : SvxUnoForbiddenCharsTable ( rDoc.getForbiddenCharacterTable() ) ,m_pDoc(&rDoc) { } /* -----------------------------17.01.01 16:06-------------------------------- ---------------------------------------------------------------------------*/ SwXDocumentPropertyHelper::~SwXDocumentPropertyHelper() { } /* -----------------------------17.01.01 16:06-------------------------------- ---------------------------------------------------------------------------*/ Reference SwXDocumentPropertyHelper::GetDrawTable(short nWhich) { Reference xRet; if(m_pDoc) { switch(nWhich) { // --> OD 2005-08-08 #i52858# // assure that Draw model is created, if it doesn't exist. case SW_CREATE_DASH_TABLE : if(!xDashTable.is()) xDashTable = SvxUnoDashTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xDashTable; break; case SW_CREATE_GRADIENT_TABLE : if(!xGradientTable.is()) xGradientTable = SvxUnoGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xGradientTable; break; case SW_CREATE_HATCH_TABLE : if(!xHatchTable.is()) xHatchTable = SvxUnoHatchTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xHatchTable; break; case SW_CREATE_BITMAP_TABLE : if(!xBitmapTable.is()) xBitmapTable = SvxUnoBitmapTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xBitmapTable; break; case SW_CREATE_TRANSGRADIENT_TABLE: if(!xTransGradientTable.is()) xTransGradientTable = SvxUnoTransGradientTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xTransGradientTable; break; case SW_CREATE_MARKER_TABLE : if(!xMarkerTable.is()) xMarkerTable = SvxUnoMarkerTable_createInstance( m_pDoc->GetOrCreateDrawModel() ); xRet = xMarkerTable; break; // <-- case SW_CREATE_DRAW_DEFAULTS: if(!xDrawDefaults.is()) xDrawDefaults = (cppu::OWeakObject*)new SwSvxUnoDrawPool(m_pDoc); xRet = xDrawDefaults; break; #ifdef DBG_UTIL default: DBG_ERROR("which table?"); #endif } } return xRet; } void SwXDocumentPropertyHelper::Invalidate() { xDashTable = 0; xGradientTable = 0; xHatchTable = 0; xBitmapTable = 0; xTransGradientTable = 0; xMarkerTable = 0; xDrawDefaults = 0; m_pDoc = 0; SvxUnoForbiddenCharsTable::mxForbiddenChars.unbind(); } /* -----------------13.08.2003 12:43----------------- --------------------------------------------------*/ void SwXDocumentPropertyHelper::onChange() { if(m_pDoc) m_pDoc->SetModified(); } /*****************************************************************************/ SwViewOptionAdjust_Impl::SwViewOptionAdjust_Impl( ViewShell& rSh, const SwViewOption &rViewOptions ) : m_rShell( rSh ), m_aOldViewOptions( rViewOptions ) { } SwViewOptionAdjust_Impl::~SwViewOptionAdjust_Impl() { m_rShell.ApplyViewOptions( m_aOldViewOptions ); } void SwViewOptionAdjust_Impl::AdjustViewOptions(SwPrintData const*const pPrtOptions) { // to avoid unnecessary reformatting the view options related to the content // below should only change if necessary, that is if respective content is present const bool bContainsHiddenChars = m_rShell.GetDoc()->ContainsHiddenChars(); const SwFieldType* pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENTXTFLD ); const bool bContainsHiddenFields = pFldType && pFldType->GetDepends(); pFldType = m_rShell.GetDoc()->GetSysFldType( RES_HIDDENPARAFLD ); const bool bContainsHiddenParagraphs = pFldType && pFldType->GetDepends(); pFldType = m_rShell.GetDoc()->GetSysFldType( RES_JUMPEDITFLD ); const bool bContainsPlaceHolders = pFldType && pFldType->GetDepends(); const bool bContainsFields = m_rShell.IsAnyFieldInDoc(); SwViewOption aRenderViewOptions( m_aOldViewOptions ); // disable anything in the view that should not be printed (or exported to PDF) by default // (see also dialog "Tools/Options - StarOffice Writer - Formatting Aids" // in section "Display of ...") aRenderViewOptions.SetParagraph( sal_False ); // paragraph end aRenderViewOptions.SetSoftHyph( sal_False ); // aka custom hyphens aRenderViewOptions.SetBlank( sal_False ); // spaces aRenderViewOptions.SetHardBlank( sal_False ); // non-breaking spaces aRenderViewOptions.SetTab( sal_False ); // tabs aRenderViewOptions.SetLineBreak( sal_False ); // breaks (type 1) aRenderViewOptions.SetPageBreak( sal_False ); // breaks (type 2) aRenderViewOptions.SetColumnBreak( sal_False ); // breaks (type 3) sal_Bool bVal = pPrtOptions? pPrtOptions->bPrintHiddenText : sal_False; if (bContainsHiddenChars) aRenderViewOptions.SetShowHiddenChar( bVal ); // hidden text if (bContainsHiddenFields) aRenderViewOptions.SetShowHiddenField( bVal ); if (bContainsHiddenParagraphs) aRenderViewOptions.SetShowHiddenPara( bVal ); if (bContainsPlaceHolders) { // should always be printed in PDF export! bVal = pPrtOptions ? pPrtOptions->bPrintTextPlaceholder : sal_True; aRenderViewOptions.SetShowPlaceHolderFields( bVal ); } if (bContainsFields) aRenderViewOptions.SetFldName( sal_False ); // we need to set this flag in order to get to see the visible effect of // some of the above settings (needed for correct rendering) aRenderViewOptions.SetViewMetaChars( sal_True ); if (m_aOldViewOptions != aRenderViewOptions) // check if reformatting is necessary { aRenderViewOptions.SetPrinting( pPrtOptions != NULL ); m_rShell.ApplyViewOptions( aRenderViewOptions ); } } /*****************************************************************************/