| /************************************************************** |
| * |
| * 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 "viscrs.hxx" |
| #include <sfx2/frame.hxx> |
| #include <sfx2/printer.hxx> |
| #include <cmdid.h> |
| #include <hintids.hxx> |
| #include <docsh.hxx> |
| #include <rubylist.hxx> |
| #include <doc.hxx> |
| #include <unotxvw.hxx> |
| #include <unodispatch.hxx> |
| #include <unomap.hxx> |
| #include <unostyle.hxx> |
| #include <unoprnms.hxx> |
| #include <view.hxx> |
| #include <viewopt.hxx> |
| #include <unomod.hxx> |
| #include <unoframe.hxx> |
| #include <unocrsr.hxx> |
| #include <wrtsh.hxx> |
| #include <unotbl.hxx> |
| #include <svx/fmshell.hxx> |
| #include <svx/svdview.hxx> |
| #include <svx/svdpage.hxx> |
| #include <svx/svdouno.hxx> |
| #include <svx/svdogrp.hxx> |
| #include <editeng/pbinitem.hxx> |
| #include <pagedesc.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/request.hxx> |
| #include <frmatr.hxx> |
| #include <vos/mutex.hxx> |
| #include <IMark.hxx> |
| #include <unotxdoc.hxx> |
| #include <unodraw.hxx> |
| #include <svx/unoshcol.hxx> |
| #include <svx/unoshape.hxx> |
| #include <svx/svdpagv.hxx> |
| #include <swerror.h> |
| #include <tools/cachestr.hxx> |
| #include <shellio.hxx> |
| #include <ndtxt.hxx> |
| #include <SwStyleNameMapper.hxx> |
| #include <crsskip.hxx> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <editeng/outliner.hxx> |
| #include <editeng/editview.hxx> |
| #include <unobookmark.hxx> |
| #include <unoparagraph.hxx> |
| #include <unocrsrhelper.hxx> |
| #include <unotextrange.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <switerator.hxx> |
| #include "swdtflvr.hxx" |
| #include <vcl/svapp.hxx> |
| |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::text; |
| using namespace ::com::sun::star::view; |
| using namespace ::com::sun::star::frame; |
| using namespace rtl; |
| |
| using ::com::sun::star::util::URL; |
| using comphelper::HelperBaseNoState; |
| |
| SV_IMPL_PTRARR( SelectionChangeListenerArr, XSelectionChangeListenerPtr ); |
| |
| /* -----------------22.05.98 12:20------------------- |
| * |
| * --------------------------------------------------*/ |
| SwPaM* lcl_createPamCopy(const SwPaM& rPam) |
| { |
| SwPaM *const pRet = new SwPaM(*rPam.GetPoint()); |
| ::sw::DeepCopyPaM(rPam, *pRet); |
| return pRet; |
| } |
| /****************************************************************** |
| * SwXTextView |
| ******************************************************************/ |
| /*-- 17.12.98 09:34:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXTextView::SwXTextView(SwView* pSwView) : |
| SfxBaseController(pSwView), |
| m_pView(pSwView), |
| m_pPropSet( aSwMapProvider.GetPropertySet( PROPERTY_MAP_TEXT_VIEW ) ), |
| pxViewSettings(0), |
| pxTextViewCursor(0) |
| { |
| |
| } |
| /*-- 17.12.98 09:34:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXTextView::~SwXTextView() |
| { |
| Invalidate(); |
| } |
| /* -----------------------------09.03.01 15:47-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SwXTextView::Invalidate() |
| { |
| if(pxViewSettings) |
| { |
| HelperBaseNoState *pSettings = static_cast < HelperBaseNoState * > ( pxViewSettings->get() ); |
| static_cast < SwXViewSettings* > ( pSettings )->Invalidate(); |
| DELETEZ(pxViewSettings); |
| } |
| if(pxTextViewCursor) |
| { |
| text::XTextViewCursor* pCrsr = pxTextViewCursor->get(); |
| ((SwXTextViewCursor*)pCrsr)->Invalidate(); |
| DELETEZ(pxTextViewCursor); |
| } |
| |
| m_refCount++; //prevent second d'tor call |
| |
| sal_uInt16 nCount = aSelChangedListeners.Count(); |
| if(nCount) |
| { |
| uno::Reference< uno::XInterface > xInt = (cppu::OWeakObject*)(SfxBaseController*)this; |
| lang::EventObject aEvent(xInt); |
| for ( sal_uInt16 i = nCount; i--; ) |
| { |
| uno::Reference< view::XSelectionChangeListener > *pObj = aSelChangedListeners[i]; |
| (*pObj)->disposing(aEvent); |
| } |
| } |
| |
| // #i85580: now clean up any possibly remaining entries in the array... |
| // (i.e. listeners that did not call removeSelectionChangeListener in their disposing.) |
| while ((nCount = aSelChangedListeners.Count()) != 0) |
| { |
| removeSelectionChangeListener( *aSelChangedListeners[0] ); |
| } |
| |
| m_refCount--; |
| m_pView = 0; |
| } |
| |
| /* -----------------------------18.05.00 10:18-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| Sequence< uno::Type > SAL_CALL SwXTextView::getTypes( ) throw(uno::RuntimeException) |
| { |
| // uno::Sequence< uno::Type > aViewTypes = SwXTextViewBaseClass::getTypes(); |
| uno::Sequence< uno::Type > aBaseTypes = SfxBaseController::getTypes(); |
| |
| long nIndex = aBaseTypes.getLength(); |
| aBaseTypes.realloc( |
| aBaseTypes.getLength() + 8 ); |
| |
| uno::Type* pBaseTypes = aBaseTypes.getArray(); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XSelectionSupplier >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XServiceInfo >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XFormLayerAccess >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XTextViewCursorSupplier>*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XViewSettingsSupplier >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XRubySelection >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<XPropertySet >*)0); |
| pBaseTypes[nIndex++] = ::getCppuType((uno::Reference<datatransfer::XTransferableSupplier >*)0); |
| return aBaseTypes; |
| } |
| /* -----------------------------18.05.00 10:18-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| Sequence< sal_Int8 > SAL_CALL SwXTextView::getImplementationId( ) throw(uno::RuntimeException) |
| { |
| vos::OGuard aGuard(Application::GetSolarMutex()); |
| static Sequence< sal_Int8 > aId( 16 ); |
| static sal_Bool bInit = sal_False; |
| if(!bInit) |
| { |
| rtl_createUuid( (sal_uInt8 *)(aId.getArray() ), 0, sal_True ); |
| bInit = sal_True; |
| } |
| return aId; |
| } |
| /* -----------------------------18.05.00 10:18-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SAL_CALL SwXTextView::acquire( )throw() |
| { |
| SfxBaseController::acquire(); |
| } |
| /* -----------------------------18.05.00 10:18-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SAL_CALL SwXTextView::release( )throw() |
| { |
| SfxBaseController::release(); |
| } |
| /* -----------------------------18.05.00 10:23-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| uno::Any SAL_CALL SwXTextView::queryInterface( const uno::Type& aType ) |
| throw (RuntimeException) |
| { |
| uno::Any aRet; |
| if(aType == ::getCppuType((uno::Reference<view::XSelectionSupplier >*)0)) |
| { |
| uno::Reference<view::XSelectionSupplier> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<lang::XServiceInfo >*)0)) |
| { |
| uno::Reference<lang::XServiceInfo> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<view::XControlAccess >*)0)) |
| { |
| uno::Reference<view::XControlAccess> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<view::XFormLayerAccess >*)0)) |
| { |
| uno::Reference<view::XFormLayerAccess> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<text::XTextViewCursorSupplier>*)0)) |
| { |
| uno::Reference<text::XTextViewCursorSupplier> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<view::XViewSettingsSupplier >*)0)) |
| { |
| uno::Reference<view::XViewSettingsSupplier> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<XRubySelection>*)0)) |
| { |
| uno::Reference<XRubySelection> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<XPropertySet>*)0)) |
| { |
| uno::Reference<XPropertySet> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else if(aType == ::getCppuType((uno::Reference<datatransfer::XTransferableSupplier >*)0)) |
| { |
| uno::Reference<datatransfer::XTransferableSupplier> xRet = this; |
| aRet.setValue(&xRet, aType); |
| } |
| else |
| aRet = SfxBaseController::queryInterface(aType); |
| return aRet; |
| } |
| /*-- 17.12.98 09:34:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextView::select(const uno::Any& aInterface) throw( lang::IllegalArgumentException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< uno::XInterface > xInterface; |
| if(GetView() && (aInterface >>= xInterface)) |
| { |
| SwWrtShell& rSh = GetView()->GetWrtShell(); |
| SwDoc* pDoc = GetView()->GetDocShell()->GetDoc(); |
| uno::Reference< lang::XUnoTunnel > xIfcTunnel(xInterface, uno::UNO_QUERY); |
| uno::Reference< text::XTextCursor > xCrsr(xInterface, uno::UNO_QUERY); |
| uno::Reference< container::XIndexAccess > xPosN(xInterface, uno::UNO_QUERY); |
| uno::Reference< text::XTextRange > xPos(xInterface, uno::UNO_QUERY); |
| SwXFrame* pFrame = xIfcTunnel.is() ? reinterpret_cast<SwXFrame*>( |
| xIfcTunnel->getSomething(SwXFrame::getUnoTunnelId())) : 0; |
| |
| SwXCell* pCell = xIfcTunnel.is() ? reinterpret_cast<SwXCell*>( |
| xIfcTunnel->getSomething(SwXCell::getUnoTunnelId())) : 0; |
| |
| SwPaM * pPam = 0; |
| SwXTextRanges* pPosN = 0; |
| if(xCrsr.is()) |
| { |
| // |
| OTextCursorHelper* pCursor = |
| xIfcTunnel.is() ? |
| reinterpret_cast<OTextCursorHelper*>(xIfcTunnel->getSomething(OTextCursorHelper::getUnoTunnelId())) |
| : 0; |
| |
| if(pCursor && pCursor->GetDoc() == GetView()->GetDocShell()->GetDoc()) |
| { |
| pPam = lcl_createPamCopy(*pCursor->GetPaM()); |
| } |
| } |
| else if(xPosN.is() && |
| xIfcTunnel.is() && |
| 0 != (pPosN = reinterpret_cast<SwXTextRanges*>(xIfcTunnel->getSomething(SwXTextRanges::getUnoTunnelId())))) |
| { |
| const SwUnoCrsr* pUnoCrsr = pPosN->GetCursor(); |
| if(pUnoCrsr) |
| { |
| pPam = lcl_createPamCopy(*pUnoCrsr); |
| } |
| } |
| // prevent misinterpretation of text frames that provide a XTextRange interface, too |
| else if(!pFrame && !pCell && xPos.is()) |
| { |
| SwUnoInternalPaM aPam(*pDoc); |
| if (::sw::XTextRangeToSwPaM(aPam, xPos)) |
| { |
| pPam = lcl_createPamCopy(aPam); |
| } |
| } |
| if(pPam) |
| { |
| rSh.EnterStdMode(); |
| rSh.SetSelection(*pPam); |
| while( pPam->GetNext() != pPam ) |
| delete pPam->GetNext(); |
| delete pPam; |
| return sal_True; |
| } |
| if(pFrame) |
| { |
| |
| SwFrmFmt* pFrmFmt = pFrame->GetFrmFmt(); |
| if(pFrmFmt && pFrmFmt->GetDoc() == pDoc) |
| { |
| sal_Bool bSuccess = rSh.GotoFly( pFrmFmt->GetName(), pFrame->GetFlyCntType()); |
| if (bSuccess) |
| { |
| rSh.HideCrsr(); |
| rSh.EnterSelFrmMode(); |
| } |
| return sal_True; |
| } |
| } |
| |
| uno::Reference< text::XTextTable > xTbl(xInterface, uno::UNO_QUERY);; |
| |
| if(xTbl.is() && xIfcTunnel.is()) |
| { |
| SwXTextTable* pTable = reinterpret_cast<SwXTextTable*>( |
| xIfcTunnel->getSomething(SwXTextTable::getUnoTunnelId())); |
| |
| SwFrmFmt* pTblFrmFmt = pTable ? ((SwXTextTable*)pTable)->GetFrmFmt() : 0; |
| if(pTblFrmFmt &&pTblFrmFmt->GetDoc() == pDoc) |
| { |
| rSh.EnterStdMode(); |
| rSh.GotoTable(pTblFrmFmt->GetName()); |
| } |
| return sal_True; |
| } |
| |
| if(pCell) |
| { |
| SwFrmFmt* pTblFrmFmt = pCell->GetFrmFmt(); |
| if(pTblFrmFmt && pTblFrmFmt->GetDoc() == pDoc) |
| { |
| SwTableBox* pBox = pCell->GetTblBox(); |
| SwTable* pTable = SwTable::FindTable( pTblFrmFmt ); |
| pBox = pCell->FindBox(pTable, pBox); |
| if(pBox) |
| { |
| const SwStartNode* pSttNd = pBox->GetSttNd(); |
| SwPosition aPos(*pSttNd); |
| SwPaM aPam(aPos); |
| aPam.Move(fnMoveForward, fnGoNode); |
| rSh.EnterStdMode(); |
| rSh.SetSelection(aPam); |
| return sal_True; |
| } |
| } |
| } |
| SwXCellRange* pRange = xIfcTunnel.is() ? reinterpret_cast<SwXCellRange*>( |
| xIfcTunnel->getSomething(SwXCellRange::getUnoTunnelId())) : 0; |
| if(pRange) |
| { |
| const SwUnoCrsr* pUnoCrsr = pRange->GetTblCrsr(); |
| if(pUnoCrsr) |
| { |
| UnoActionRemoveContext aContext(pDoc); |
| rSh.EnterStdMode(); |
| rSh.SetSelection(*pUnoCrsr); |
| return sal_True; |
| } |
| } |
| uno::Reference< text::XTextContent > xBkm(xInterface, uno::UNO_QUERY);; |
| |
| if(xBkm.is() && xIfcTunnel.is()) |
| { |
| ::sw::mark::IMark const*const pMark( |
| SwXBookmark::GetBookmarkInDoc(pDoc, xIfcTunnel) ); |
| if (pMark) |
| { |
| rSh.EnterStdMode(); |
| rSh.GotoMark(pMark); |
| return sal_True; |
| } |
| } |
| // IndexMark, Index, TextField, Draw, Section, Footnote, Paragraph |
| // |
| |
| // detect controls |
| |
| uno::Reference< awt::XControlModel > xCtrlModel(xInterface, UNO_QUERY); |
| if(xCtrlModel.is()) |
| { |
| uno::Reference<awt::XControl> XControl; |
| SdrObject* pObj = GetControl(xCtrlModel, XControl); |
| if(pObj) |
| { |
| SdrView* pDrawView = rSh.GetDrawView(); |
| SdrPageView* pPV = pDrawView->GetSdrPageView(); |
| if ( pPV && pObj->GetPage() == pPV->GetPage() ) |
| { |
| pDrawView->SdrEndTextEdit(); |
| pDrawView->UnmarkAll(); |
| pDrawView->MarkObj( pObj, pPV ); |
| } |
| return sal_True; |
| } |
| } |
| |
| uno::Reference< drawing::XShapes > xShapeColl( xInterface, uno::UNO_QUERY ); |
| uno::Reference< beans::XPropertySet > xTmpProp(xInterface, uno::UNO_QUERY); |
| SwXShape* pSwXShape = 0; |
| if(xIfcTunnel.is()) |
| pSwXShape = reinterpret_cast<SwXShape*>(xIfcTunnel->getSomething(SwXShape::getUnoTunnelId())); |
| SvxShape* pSvxShape = 0; |
| if(pSwXShape) |
| { |
| uno::Reference< uno::XAggregation > xAgg = pSwXShape->GetAggregationInterface(); |
| if(xAgg.is()) |
| { |
| pSvxShape = reinterpret_cast<SvxShape*>(xIfcTunnel->getSomething(SvxShape::getUnoTunnelId())); |
| } |
| } |
| |
| if ( pSvxShape || xShapeColl.is() ) // Drawing drawing::Layer |
| { |
| SdrView* pDrawView = rSh.GetDrawView(); |
| if (pDrawView) |
| { |
| pDrawView->SdrEndTextEdit(); |
| pDrawView->UnmarkAll(); |
| |
| if (pSvxShape) // einzelnes Shape |
| { |
| SdrObject *pObj = pSvxShape->GetSdrObject(); |
| if (pObj) |
| { |
| // lcl_ShowObject( *m_pViewSh, *pDrawView, pObj ); |
| SdrPageView* pPV = pDrawView->GetSdrPageView(); |
| if ( pPV && pObj->GetPage() == pPV->GetPage() ) |
| { |
| pDrawView->MarkObj( pObj, pPV ); |
| return sal_True; |
| } |
| } |
| } |
| else // Shape Collection |
| { |
| sal_Bool bSelected = sal_False; |
| SdrPageView* pPV = NULL; |
| long nCount = xShapeColl->getCount(); |
| for ( long i = 0; i < nCount; i++ ) |
| { |
| uno::Reference< drawing::XShape > xShapeInt; |
| uno::Any aAny = xShapeColl->getByIndex(i); |
| aAny >>= xShapeInt; |
| if (xShapeInt.is()) |
| { |
| uno::Reference< lang::XUnoTunnel> xShapeTunnel(xShapeInt, uno::UNO_QUERY); |
| |
| SvxShape* pShape = xShapeTunnel.is() ? |
| reinterpret_cast<SvxShape*>(xShapeTunnel->getSomething(SvxShape::getUnoTunnelId())) : 0; |
| |
| if (pShape) |
| { |
| SdrObject *pObj = pShape->GetSdrObject(); |
| if (pObj) |
| { |
| if (!pPV) // erstes Objekt |
| { |
| // lcl_ShowObject( *m_pViewSh, *pDrawView, pObj ); |
| pPV = pDrawView->GetSdrPageView(); |
| } |
| if ( pPV && pObj->GetPage() == pPV->GetPage() ) |
| { |
| pDrawView->MarkObj( pObj, pPV ); |
| bSelected = sal_True; |
| } |
| } |
| } |
| } |
| } |
| return bSelected; |
| } |
| } |
| } |
| } |
| return sal_False; |
| |
| } |
| /*-- 17.12.98 09:34:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Any SwXTextView::getSelection(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< uno::XInterface > aRef; |
| if(GetView()) |
| { |
| //force immediat shell update |
| m_pView->StopShellTimer(); |
| // ein interface aus der aktuellen Selektion erzeugen |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| switch(eSelMode) |
| { |
| case SHELL_MODE_TABLE_TEXT : |
| { |
| if(rSh.GetTableCrsr()) |
| { |
| DBG_ASSERT(rSh.GetTableFmt(), "kein Tabellenformat?"); |
| uno::Reference< text::XTextTableCursor > xCrsr = new SwXTextTableCursor(*rSh.GetTableFmt(), |
| rSh.GetTableCrsr()); |
| aRef = uno::Reference< uno::XInterface > (xCrsr, uno::UNO_QUERY);; |
| break; |
| } |
| |
| } |
| // ohne Tabellenselektion wird der Text geliefert |
| //break; |
| case SHELL_MODE_LIST_TEXT : |
| case SHELL_MODE_TABLE_LIST_TEXT: |
| case SHELL_MODE_TEXT : |
| { |
| uno::Reference< container::XIndexAccess > xPos = new SwXTextRanges(rSh.GetCrsr()); |
| aRef = uno::Reference< uno::XInterface >(xPos, uno::UNO_QUERY); |
| } |
| break; |
| case SHELL_MODE_FRAME : |
| case SHELL_MODE_GRAPHIC : |
| case SHELL_MODE_OBJECT : |
| { |
| //Get FlyFrameFormat; fuer UI Macro Anbindung an Flys |
| const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt(); |
| if (pFmt) |
| { |
| SwXFrame* pxFrame = SwIterator<SwXFrame,SwFmt>::FirstElement(*pFmt); |
| if(pxFrame) //das einzige gemeinsame interface fuer alle Frames |
| { |
| aRef = uno::Reference< uno::XInterface >((cppu::OWeakObject*)pxFrame, uno::UNO_QUERY); |
| } |
| else |
| { |
| if(SHELL_MODE_FRAME == eSelMode) |
| { |
| uno::Reference< text::XTextFrame > xFrm = new SwXTextFrame((SwFrmFmt&)*pFmt); |
| aRef = uno::Reference< uno::XInterface >(xFrm, uno::UNO_QUERY); |
| } |
| else if(SHELL_MODE_GRAPHIC == eSelMode) |
| { |
| uno::Reference< text::XTextContent > xFrm = new SwXTextGraphicObject((SwFrmFmt&)*pFmt); |
| aRef = xFrm; |
| } |
| else |
| { |
| uno::Reference< text::XTextContent > xFrm = new SwXTextEmbeddedObject((SwFrmFmt&)*pFmt); |
| aRef = xFrm; |
| } |
| } |
| } |
| } |
| break; |
| case SHELL_MODE_DRAW : |
| case SHELL_MODE_DRAW_CTRL : |
| case SHELL_MODE_DRAW_FORM : |
| case SHELL_MODE_DRAWTEXT : |
| case SHELL_MODE_BEZIER : |
| { |
| uno::Reference< drawing::XDrawPageSupplier > xPageSupp; |
| uno::Reference< frame::XModel > xModel = m_pView->GetDocShell()->GetBaseModel(); |
| uno::Reference< lang::XUnoTunnel > xModelTunnel(xModel, uno::UNO_QUERY); |
| SwXTextDocument* pTextDoc = reinterpret_cast<SwXTextDocument*>(xModelTunnel-> |
| getSomething(SwXTextDocument::getUnoTunnelId())); |
| |
| SwFmDrawPage* pSvxDrawPage = pTextDoc->GetDrawPage()->GetSvxPage(); |
| uno::Reference< drawing::XShapes > xShCol = new SvxShapeCollection(); |
| |
| const SdrMarkList& rMarkList = rSh.GetDrawView()->GetMarkedObjectList(); |
| for(sal_uInt16 i = 0; i < rMarkList.GetMarkCount(); i++) |
| { |
| SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); |
| uno::Reference< uno::XInterface > xInt = pSvxDrawPage->GetInterface( pObj ); |
| uno::Reference< drawing::XShape > xShape(xInt, uno::UNO_QUERY);; |
| xShCol->add(xShape); |
| } |
| aRef = uno::Reference< uno::XInterface >(xShCol, uno::UNO_QUERY); |
| } |
| break; |
| default:;//prevent warning |
| } |
| } |
| uno::Any aRet(&aRef, ::getCppuType((uno::Reference<uno::XInterface>*)0)); |
| return aRet; |
| } |
| /*-- 17.12.98 09:34:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextView::addSelectionChangeListener( |
| const uno::Reference< view::XSelectionChangeListener > & rxListener) |
| throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< view::XSelectionChangeListener > * pInsert = new uno::Reference< view::XSelectionChangeListener > ; |
| *pInsert = rxListener; |
| aSelChangedListeners.Insert(pInsert, aSelChangedListeners.Count()); |
| } |
| /*-- 17.12.98 09:34:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextView::removeSelectionChangeListener( |
| const uno::Reference< view::XSelectionChangeListener > & rxListener) |
| throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| view::XSelectionChangeListener* pLeft = rxListener.get(); |
| for(sal_uInt16 i = 0; i < aSelChangedListeners.Count(); i++) |
| { |
| uno::Reference< view::XSelectionChangeListener > * pElem = aSelChangedListeners.GetObject(i); |
| view::XSelectionChangeListener* pRight = pElem->get(); |
| if(pLeft == pRight) |
| { |
| aSelChangedListeners.Remove(i); |
| delete pElem; |
| break; |
| } |
| } |
| } |
| /* -----------------------------01.06.01 14:41-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SdrObject* SwXTextView::GetControl( |
| const uno::Reference< awt::XControlModel > & xModel, |
| uno::Reference< awt::XControl >& xToFill ) |
| { |
| SwView* pView2 = GetView(); |
| FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : NULL; |
| SdrView* pDrawView = pView2 ? pView2->GetDrawView() : NULL; |
| Window* pWindow = pView2 ? pView2->GetWrtShell().GetWin() : NULL; |
| |
| DBG_ASSERT( pFormShell && pDrawView && pWindow, "SwXTextView::GetControl: how could I?" ); |
| |
| SdrObject* pControl = NULL; |
| if ( pFormShell && pDrawView && pWindow ) |
| pControl = pFormShell->GetFormControl( xModel, *pDrawView, *pWindow, xToFill ); |
| return pControl; |
| } |
| /*-- 17.12.98 09:34:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< awt::XControl > SwXTextView::getControl(const uno::Reference< awt::XControlModel > & xModel) |
| throw( container::NoSuchElementException, uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< awt::XControl > xRet; |
| GetControl(xModel, xRet); |
| return xRet; |
| } |
| |
| /*-- 08.03.07 13:55------------------------------------------------------ |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< form::runtime::XFormController > SAL_CALL SwXTextView::getFormController( const uno::Reference< form::XForm >& _Form ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| SwView* pView2 = GetView(); |
| FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : NULL; |
| SdrView* pDrawView = pView2 ? pView2->GetDrawView() : NULL; |
| Window* pWindow = pView2 ? pView2->GetWrtShell().GetWin() : NULL; |
| DBG_ASSERT( pFormShell && pDrawView && pWindow, "SwXTextView::getFormController: how could I?" ); |
| |
| uno::Reference< form::runtime::XFormController > xController; |
| if ( pFormShell && pDrawView && pWindow ) |
| xController = pFormShell->GetFormController( _Form, *pDrawView, *pWindow ); |
| return xController; |
| } |
| |
| /*-- 08.03.07 13:55------------------------------------------------------ |
| |
| -----------------------------------------------------------------------*/ |
| ::sal_Bool SAL_CALL SwXTextView::isFormDesignMode( ) throw (uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| SwView* pView2 = GetView(); |
| FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : NULL; |
| return pFormShell ? pFormShell->IsDesignMode() : sal_True; |
| } |
| |
| /*-- 08.03.07 13:55------------------------------------------------------ |
| |
| -----------------------------------------------------------------------*/ |
| void SAL_CALL SwXTextView::setFormDesignMode( ::sal_Bool _DesignMode ) throw (RuntimeException) |
| { |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); |
| SwView* pView2 = GetView(); |
| FmFormShell* pFormShell = pView2 ? pView2->GetFormShell() : NULL; |
| if ( pFormShell ) |
| pFormShell->SetDesignMode( _DesignMode ); |
| } |
| |
| /*-- 17.12.98 09:34:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextViewCursor > SwXTextView::getViewCursor(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(GetView()) |
| { |
| if(!pxTextViewCursor) |
| { |
| ((SwXTextView*)this)->pxTextViewCursor = new uno::Reference< text::XTextViewCursor > ; |
| *pxTextViewCursor = new SwXTextViewCursor(GetView()); |
| } |
| return *pxTextViewCursor; |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 17.12.98 09:34:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< beans::XPropertySet > SwXTextView::getViewSettings(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if(!pxViewSettings) |
| { |
| ((SwXTextView*)this)->pxViewSettings = new uno::Reference< beans::XPropertySet > ; |
| *pxViewSettings = static_cast < HelperBaseNoState * > ( new SwXViewSettings( sal_False, m_pView ) ); |
| } |
| } |
| else |
| throw uno::RuntimeException(); |
| return *pxViewSettings; |
| } |
| /* -----------------------------30.01.01 15:01-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| Sequence< Sequence< PropertyValue > > SwXTextView::getRubyList( sal_Bool /*bAutomatic*/ ) throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| if(!GetView()) |
| throw RuntimeException(); |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| if (eSelMode != SHELL_MODE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_TEXT && |
| eSelMode != SHELL_MODE_TEXT ) |
| return Sequence< Sequence< PropertyValue > > (); |
| |
| SwDoc* pDoc = m_pView->GetDocShell()->GetDoc(); |
| SwRubyList aList; |
| |
| sal_uInt16 nCount = pDoc->FillRubyList( *rSh.GetCrsr(), aList, 0 ); |
| Sequence< Sequence< PropertyValue > > aRet(nCount); |
| Sequence< PropertyValue >* pRet = aRet.getArray(); |
| String aString; |
| for(sal_uInt16 n = 0; n < nCount; n++) |
| { |
| const SwRubyListEntryPtr pEntry = aList[n]; |
| |
| const String& rEntryText = pEntry->GetText(); |
| const SwFmtRuby& rAttr = pEntry->GetRubyAttr(); |
| |
| pRet[n].realloc(5); |
| PropertyValue* pValues = pRet[n].getArray(); |
| pValues[0].Name = C2U(SW_PROP_NAME_STR(UNO_NAME_RUBY_BASE_TEXT)); |
| pValues[0].Value <<= OUString(rEntryText); |
| pValues[1].Name = C2U(SW_PROP_NAME_STR(UNO_NAME_RUBY_TEXT)); |
| pValues[1].Value <<= OUString(rAttr.GetText()); |
| pValues[2].Name = C2U(SW_PROP_NAME_STR(UNO_NAME_RUBY_CHAR_STYLE_NAME)); |
| SwStyleNameMapper::FillProgName(rAttr.GetCharFmtName(), aString, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True ); |
| pValues[2].Value <<= OUString( aString ); |
| pValues[3].Name = C2U(SW_PROP_NAME_STR(UNO_NAME_RUBY_ADJUST)); |
| pValues[3].Value <<= (sal_Int16)rAttr.GetAdjustment(); |
| pValues[4].Name = C2U(SW_PROP_NAME_STR(UNO_NAME_RUBY_IS_ABOVE)); |
| sal_Bool bVal = !rAttr.GetPosition(); |
| pValues[4].Value.setValue(&bVal, ::getBooleanCppuType()); |
| } |
| return aRet; |
| } |
| /* -----------------------------30.01.01 15:02-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SAL_CALL SwXTextView::setRubyList( |
| const Sequence< Sequence< PropertyValue > >& rRubyList, sal_Bool /*bAutomatic*/ ) |
| throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| if(!GetView() || !rRubyList.getLength()) |
| throw RuntimeException(); |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| if (eSelMode != SHELL_MODE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_TEXT && |
| eSelMode != SHELL_MODE_TEXT ) |
| throw RuntimeException(); |
| |
| SwRubyList aList; |
| |
| const Sequence<PropertyValue>* pRubyList = rRubyList.getConstArray(); |
| for(sal_Int32 nPos = 0; nPos < rRubyList.getLength(); nPos++) |
| { |
| SwRubyListEntryPtr pEntry = new SwRubyListEntry; |
| const PropertyValue* pProperties = pRubyList[nPos].getConstArray(); |
| OUString sTmp; |
| for(sal_Int32 nProp = 0; nProp < pRubyList[nPos].getLength(); nProp++) |
| { |
| if(pProperties[nProp].Name.equalsAsciiL( |
| SW_PROP_NAME(UNO_NAME_RUBY_BASE_TEXT))) |
| { |
| pProperties[nProp].Value >>= sTmp; |
| pEntry->SetText(sTmp); |
| } |
| else if(pProperties[nProp].Name.equalsAsciiL( |
| SW_PROP_NAME(UNO_NAME_RUBY_TEXT))) |
| { |
| pProperties[nProp].Value >>= sTmp; |
| pEntry->GetRubyAttr().SetText(sTmp); |
| } |
| else if(pProperties[nProp].Name.equalsAsciiL( |
| SW_PROP_NAME(UNO_NAME_RUBY_CHAR_STYLE_NAME))) |
| { |
| if((pProperties[nProp].Value >>= sTmp)) |
| { |
| String sName; |
| SwStyleNameMapper::FillUIName(sTmp, sName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True ); |
| sal_uInt16 nPoolId = sName.Len() ? |
| SwStyleNameMapper::GetPoolIdFromUIName( sName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT ) : 0; |
| |
| pEntry->GetRubyAttr().SetCharFmtName( sName ); |
| pEntry->GetRubyAttr().SetCharFmtId( nPoolId ); |
| } |
| } |
| else if(pProperties[nProp].Name.equalsAsciiL( |
| SW_PROP_NAME(UNO_NAME_RUBY_ADJUST))) |
| { |
| sal_Int16 nTmp = 0; |
| if((pProperties[nProp].Value >>= nTmp)) |
| pEntry->GetRubyAttr().SetAdjustment(nTmp); |
| } |
| else if(pProperties[nProp].Name.equalsAsciiL( |
| SW_PROP_NAME(UNO_NAME_RUBY_IS_ABOVE))) |
| { |
| sal_Bool bValue = pProperties[nProp].Value.hasValue() ? |
| *(sal_Bool*)pProperties[nProp].Value.getValue() : sal_True; |
| pEntry->GetRubyAttr().SetPosition(bValue ? 0 : 1); |
| } |
| } |
| aList.Insert(pEntry, (sal_uInt16)nPos); |
| } |
| SwDoc* pDoc = m_pView->GetDocShell()->GetDoc(); |
| pDoc->SetRubyList( *rSh.GetCrsr(), aList, 0 ); |
| } |
| /*-- 29.12.02 15:45:29--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SfxObjectShellLock SwXTextView::BuildTmpSelectionDoc() |
| { |
| SwWrtShell& rOldSh = m_pView->GetWrtShell(); |
| SfxPrinter *pPrt = rOldSh.getIDocumentDeviceAccess()->getPrinter( false ); |
| SwDocShell* pDocSh; |
| SfxObjectShellLock xDocSh( pDocSh = new SwDocShell( /*pPrtDoc, */SFX_CREATE_MODE_STANDARD ) ); |
| xDocSh->DoInitNew( 0 ); |
| SwDoc *const pTempDoc( pDocSh->GetDoc() ); |
| // #i103634#, #i112425#: do not expand numbering and fields on PDF export |
| pTempDoc->SetClipBoard(true); |
| rOldSh.FillPrtDoc(pTempDoc, pPrt); |
| SfxViewFrame* pDocFrame = SfxViewFrame::LoadHiddenDocument( *xDocSh, 0 ); |
| SwView* pDocView = (SwView*) pDocFrame->GetViewShell(); |
| pDocView->AttrChangedNotify( &pDocView->GetWrtShell() );//Damit SelectShell gerufen wird. |
| SwWrtShell* pSh = pDocView->GetWrtShellPtr(); |
| |
| IDocumentDeviceAccess* pIDDA = pSh->getIDocumentDeviceAccess(); |
| SfxPrinter* pTempPrinter = pIDDA->getPrinter( true ); |
| |
| const SwPageDesc& rCurPageDesc = rOldSh.GetPageDesc(rOldSh.GetCurPageDesc()); |
| |
| IDocumentDeviceAccess* pIDDA_old = rOldSh.getIDocumentDeviceAccess(); |
| |
| if( pIDDA_old->getPrinter( false ) ) |
| { |
| pIDDA->setJobsetup( *pIDDA_old->getJobsetup() ); |
| //#69563# if it isn't the same printer then the pointer has been invalidated! |
| pTempPrinter = pIDDA->getPrinter( true ); |
| } |
| |
| pTempPrinter->SetPaperBin(rCurPageDesc.GetMaster().GetPaperBin().GetValue()); |
| |
| return xDocSh; |
| } |
| |
| /*-- 17.12.98 09:34:29--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextView::NotifySelChanged() |
| { |
| DBG_ASSERT( m_pView, "view is missing" ); |
| |
| // destroy temporary document with selected text that is used |
| // in PDF export of (multi-)selections and on print of (multi-)selections |
| if (m_pView && m_pView->GetTmpSelectionDoc().Is()) |
| { |
| // do not destroy the temporary document, if an action is pending |
| bool bActionPending = false; |
| { |
| SfxObjectShellLock& xDocSh = m_pView->GetTmpSelectionDoc(); |
| SwDoc* pDoc = static_cast< SwDocShell* >(&xDocSh)->GetDoc(); |
| SwView* pView = pDoc ? pDoc->GetDocShell()->GetView() : 0; |
| bActionPending = pView ? pView->GetWrtShell().ActionPend() : false; |
| } |
| if ( !bActionPending ) |
| { |
| m_pView->GetTmpSelectionDoc()->DoClose(); |
| m_pView->GetTmpSelectionDoc() = 0; |
| } |
| } |
| |
| uno::Reference< uno::XInterface > xInt = (cppu::OWeakObject*)(SfxBaseController*)this; |
| |
| lang::EventObject aEvent(xInt); |
| |
| sal_uInt16 nCount = aSelChangedListeners.Count(); |
| for ( sal_uInt16 i = nCount; i--; ) |
| { |
| uno::Reference< view::XSelectionChangeListener > *pObj = aSelChangedListeners[i]; |
| (*pObj)->selectionChanged(aEvent); |
| } |
| } |
| /* -----------------------------12.07.01 13:26-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SwXTextView::NotifyDBChanged() |
| { |
| URL aURL; |
| aURL.Complete = C2U(SwXDispatch::GetDBChangeURL()); |
| |
| sal_uInt16 nCount = aSelChangedListeners.Count(); |
| for ( sal_uInt16 i = nCount; i--; ) |
| { |
| uno::Reference< view::XSelectionChangeListener > *pObj = aSelChangedListeners[i]; |
| uno::Reference<XDispatch> xDispatch((*pObj), UNO_QUERY); |
| if(xDispatch.is()) |
| xDispatch->dispatch(aURL, Sequence<PropertyValue>(0)); |
| } |
| } |
| |
| /* -----------------------------10.12.04 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| |
| uno::Reference< beans::XPropertySetInfo > SAL_CALL SwXTextView::getPropertySetInfo( ) |
| throw (uno::RuntimeException) |
| { |
| vos::OGuard aGuard( Application::GetSolarMutex() ); |
| static uno::Reference< XPropertySetInfo > aRef = m_pPropSet->getPropertySetInfo(); |
| return aRef; |
| } |
| |
| |
| void SAL_CALL SwXTextView::setPropertyValue( |
| const OUString& rPropertyName, const uno::Any& rValue ) |
| throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard( Application::GetSolarMutex() ); |
| const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName ); |
| if (!pEntry) |
| throw UnknownPropertyException(); |
| else if (pEntry->nFlags & PropertyAttribute::READONLY) |
| throw PropertyVetoException(); |
| else |
| { |
| switch (pEntry->nWID) |
| { |
| case WID_IS_HIDE_SPELL_MARKS : |
| // deprecated #i91949 |
| break; |
| case WID_IS_CONSTANT_SPELLCHECK : |
| { |
| sal_Bool bVal = sal_False; |
| const SwViewOption *pOpt = m_pView->GetWrtShell().GetViewOptions(); |
| if (!pOpt || !(rValue >>= bVal)) |
| throw RuntimeException(); |
| SwViewOption aNewOpt( *pOpt ); |
| if (pEntry->nWID == WID_IS_CONSTANT_SPELLCHECK) |
| aNewOpt.SetOnlineSpell(bVal); |
| m_pView->GetWrtShell().ApplyViewOptions( aNewOpt ); |
| } |
| break; |
| default : |
| DBG_ERROR("unknown WID"); |
| } |
| } |
| } |
| |
| |
| uno::Any SAL_CALL SwXTextView::getPropertyValue( |
| const OUString& rPropertyName ) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| vos::OGuard aGuard( Application::GetSolarMutex() ); |
| |
| Any aRet; |
| |
| const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName ); |
| if (!pEntry) |
| throw UnknownPropertyException(); |
| else |
| { |
| sal_Int16 nWID = pEntry->nWID; |
| switch (nWID) |
| { |
| case WID_PAGE_COUNT : |
| case WID_LINE_COUNT : |
| { |
| // format document completely in order to get meaningful |
| // values for page count and line count |
| m_pView->GetWrtShell().CalcLayout(); |
| |
| sal_Int32 nCount = -1; |
| if (nWID == WID_PAGE_COUNT) |
| nCount = m_pView->GetWrtShell().GetPageCount(); |
| else // WID_LINE_COUNT |
| nCount = m_pView->GetWrtShell().GetLineCount( sal_False /*of whole document*/ ); |
| aRet <<= nCount; |
| } |
| break; |
| case WID_IS_HIDE_SPELL_MARKS : |
| // deprecated #i91949 |
| break; |
| case WID_IS_CONSTANT_SPELLCHECK : |
| { |
| const SwViewOption *pOpt = m_pView->GetWrtShell().GetViewOptions(); |
| if (!pOpt) |
| throw RuntimeException(); |
| sal_uInt32 nFlag = VIEWOPT_1_ONLINESPELL; |
| sal_Bool bVal = 0 != (pOpt->GetCoreOptions() & nFlag); |
| aRet <<= bVal; |
| } |
| break; |
| default : |
| DBG_ERROR("unknown WID"); |
| } |
| } |
| |
| return aRet; |
| } |
| |
| |
| void SAL_CALL SwXTextView::addPropertyChangeListener( |
| const OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XPropertyChangeListener >& /*rxListener*/ ) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_WARNING("not implemented"); |
| } |
| |
| |
| void SAL_CALL SwXTextView::removePropertyChangeListener( |
| const OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XPropertyChangeListener >& /*rxListener*/ ) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_WARNING("not implemented"); |
| } |
| |
| |
| void SAL_CALL SwXTextView::addVetoableChangeListener( |
| const OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XVetoableChangeListener >& /*rxListener*/ ) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_WARNING("not implemented"); |
| } |
| |
| |
| void SAL_CALL SwXTextView::removeVetoableChangeListener( |
| const OUString& /*rPropertyName*/, |
| const uno::Reference< beans::XVetoableChangeListener >& /*rxListener*/ ) |
| throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_WARNING("not implemented"); |
| } |
| |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwXTextView::getImplementationName(void) throw( RuntimeException ) |
| { |
| return C2U("SwXTextView"); |
| } |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SwXTextView::supportsService(const OUString& rServiceName) throw( RuntimeException ) |
| { |
| return rServiceName.equalsAscii("com.sun.star.text.TextDocumentView") || |
| rServiceName.equalsAscii("com.sun.star.view.OfficeDocumentView"); |
| } |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| Sequence< OUString > SwXTextView::getSupportedServiceNames(void) throw( RuntimeException ) |
| { |
| Sequence< OUString > aRet(2); |
| OUString* pArray = aRet.getArray(); |
| pArray[0] = C2U("com.sun.star.text.TextDocumentView"); |
| pArray[1] = C2U("com.sun.star.view.OfficeDocumentView"); |
| return aRet; |
| } |
| |
| /****************************************************************** |
| * SwXTextViewCursor |
| ******************************************************************/ |
| /*-- 17.12.98 09:36:23--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXTextViewCursor::SwXTextViewCursor(SwView* pVw) : |
| m_pView(pVw), |
| m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR)) |
| { |
| } |
| /*-- 17.12.98 09:36:24--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| SwXTextViewCursor::~SwXTextViewCursor() |
| { |
| } |
| /*-- 06.10.04 09:36:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| |
| // used to determine if there is a text selction or not. |
| // If there is no text selection the functions that need a working |
| // cursor will be disabled (throw RuntimeException). This will be the case |
| // for the following interfaces: |
| // - XViewCursor |
| // - XTextCursor |
| // - XTextRange |
| // - XLineCursor |
| |
| sal_Bool SwXTextViewCursor::IsTextSelection( sal_Bool bAllowTables ) const |
| { |
| |
| sal_Bool bRes = sal_False; |
| DBG_ASSERT(m_pView, "m_pView is NULL ???"); |
| if(m_pView) |
| { |
| //! m_pView->GetShellMode() will only work after the shell |
| //! has already changed and thus can not be used here! |
| SelectionType eSelType = m_pView->GetWrtShell().GetSelectionType(); |
| bRes = ( (nsSelectionType::SEL_TXT & eSelType) || |
| (nsSelectionType::SEL_NUM & eSelType) ) && |
| (!(nsSelectionType::SEL_TBL_CELLS & eSelType) || bAllowTables); |
| } |
| return bRes; |
| } |
| |
| /*-- 17.12.98 09:36:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::isVisible(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| DBG_WARNING("not implemented"); |
| return sal_True; |
| } |
| /*-- 17.12.98 09:36:25--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::setVisible(sal_Bool /*bVisible*/) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| DBG_WARNING("not implemented"); |
| } |
| /*-- 17.12.98 09:36:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| awt::Point SwXTextViewCursor::getPosition(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| awt::Point aRet; |
| if(m_pView) |
| { |
| const SwWrtShell& rSh = m_pView->GetWrtShell(); |
| const SwRect aCharRect(rSh.GetCharRect()); |
| |
| const SwFrmFmt& rMaster = rSh.GetPageDesc( rSh.GetCurPageDesc() ).GetMaster(); |
| |
| const SvxULSpaceItem& rUL = rMaster.GetULSpace(); |
| const long nY = aCharRect.Top() - (rUL.GetUpper() + DOCUMENTBORDER); |
| aRet.Y = TWIP_TO_MM100(nY); |
| |
| const SvxLRSpaceItem& rLR = rMaster.GetLRSpace(); |
| const long nX = aCharRect.Left() - (rLR.GetLeft() + DOCUMENTBORDER); |
| aRet.X = TWIP_TO_MM100(nX); |
| } |
| else |
| throw uno::RuntimeException(); |
| return aRet; |
| } |
| /*-- 17.12.98 09:36:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::collapseToStart(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| if(rSh.HasSelection()) |
| { |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| if(*pShellCrsr->GetPoint() > *pShellCrsr->GetMark()) |
| pShellCrsr->Exchange(); |
| pShellCrsr->DeleteMark(); |
| rSh.EnterStdMode(); |
| rSh.SetSelection(*pShellCrsr); |
| } |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 17.12.98 09:36:26--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::collapseToEnd(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| if(rSh.HasSelection()) |
| { |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| if(*pShellCrsr->GetPoint() < *pShellCrsr->GetMark()) |
| pShellCrsr->Exchange(); |
| pShellCrsr->DeleteMark(); |
| rSh.EnterStdMode(); |
| rSh.SetSelection(*pShellCrsr); |
| } |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 17.12.98 09:36:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::isCollapsed(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| const SwWrtShell& rSh = m_pView->GetWrtShell(); |
| bRet = !rSh.HasSelection(); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| |
| } |
| /*-- 17.12.98 09:36:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::goLeft(sal_Int16 nCount, sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| bRet = m_pView->GetWrtShell().Left( CRSR_SKIP_CHARS, bExpand, 1, sal_True ); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:27--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::goRight(sal_Int16 nCount, sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| bRet = m_pView->GetWrtShell().Right( CRSR_SKIP_CHARS, bExpand, 1, sal_True ); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| |
| } |
| /* -----------------08.03.99 11:18------------------- |
| * |
| * --------------------------------------------------*/ |
| void SwXTextViewCursor::gotoRange( |
| const uno::Reference< text::XTextRange > & xRange, |
| sal_Bool bExpand) |
| throw(RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView && xRange.is()) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwUnoInternalPaM rDestPam(*m_pView->GetDocShell()->GetDoc()); |
| if (!::sw::XTextRangeToSwPaM(rDestPam, xRange)) |
| { |
| throw uno::RuntimeException(); |
| } |
| |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| // call EnterStdMode in non-text selections only |
| if(!bExpand || |
| (eSelMode != SHELL_MODE_TABLE_TEXT && |
| eSelMode != SHELL_MODE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TEXT )) |
| rSh.EnterStdMode(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwPaM aOwnPaM(*pShellCrsr->GetPoint()); |
| if(pShellCrsr->HasMark()) |
| { |
| aOwnPaM.SetMark(); |
| *aOwnPaM.GetMark() = *pShellCrsr->GetMark(); |
| } |
| |
| uno::Reference<lang::XUnoTunnel> xRangeTunnel( xRange, uno::UNO_QUERY); |
| SwXTextRange* pRange = 0; |
| SwXParagraph* pPara = 0; |
| OTextCursorHelper* pCursor = 0; |
| if(xRangeTunnel.is()) |
| { |
| pRange = reinterpret_cast<SwXTextRange*>(xRangeTunnel->getSomething( |
| SwXTextRange::getUnoTunnelId())); |
| pCursor = reinterpret_cast<OTextCursorHelper*>(xRangeTunnel->getSomething( |
| OTextCursorHelper::getUnoTunnelId())); |
| pPara = reinterpret_cast<SwXParagraph*>(xRangeTunnel->getSomething( |
| SwXParagraph::getUnoTunnelId())); |
| } |
| |
| const sal_uInt16 nFrmType = rSh.GetFrmType(0,sal_True); |
| |
| SwStartNodeType eSearchNodeType = SwNormalStartNode; |
| if(nFrmType & FRMTYPE_FLY_ANY) |
| eSearchNodeType = SwFlyStartNode; |
| else if(nFrmType &FRMTYPE_HEADER) |
| eSearchNodeType = SwHeaderStartNode; |
| else if(nFrmType & FRMTYPE_FOOTER) |
| eSearchNodeType = SwFooterStartNode; |
| else if(nFrmType & FRMTYPE_TABLE) |
| eSearchNodeType = SwTableBoxStartNode; |
| else if(nFrmType & FRMTYPE_FOOTNOTE) |
| eSearchNodeType = SwFootnoteStartNode; |
| |
| const SwStartNode* pOwnStartNode = aOwnPaM.GetNode()-> |
| FindSttNodeByType(eSearchNodeType); |
| |
| const SwNode* pSrcNode = 0; |
| if(pCursor && pCursor->GetPaM()) |
| { |
| pSrcNode = pCursor->GetPaM()->GetNode(); |
| } |
| else if (pRange) |
| { |
| SwPaM aPam(pRange->GetDoc()->GetNodes()); |
| if (pRange->GetPositions(aPam)) |
| { |
| pSrcNode = aPam.GetNode(); |
| } |
| } |
| else if (pPara && pPara->GetTxtNode()) |
| { |
| pSrcNode = pPara->GetTxtNode(); |
| } |
| const SwStartNode* pTmp = pSrcNode ? pSrcNode->FindSttNodeByType(eSearchNodeType) : 0; |
| |
| //SectionNodes ueberspringen |
| while(pTmp && pTmp->IsSectionNode()) |
| { |
| pTmp = pTmp->StartOfSectionNode(); |
| } |
| while(pOwnStartNode && pOwnStartNode->IsSectionNode()) |
| { |
| pOwnStartNode = pOwnStartNode->StartOfSectionNode(); |
| } |
| //ohne Expand darf mit dem ViewCursor ueberall hingesprungen werden |
| //mit Expand nur in der gleichen Umgebung |
| if(bExpand && |
| (pOwnStartNode != pTmp || |
| (eSelMode != SHELL_MODE_TABLE_TEXT && |
| eSelMode != SHELL_MODE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TABLE_LIST_TEXT && |
| eSelMode != SHELL_MODE_TEXT))) |
| throw uno::RuntimeException(); |
| |
| //jetzt muss die Selektion erweitert werden |
| if(bExpand) |
| { |
| // der Cursor soll alles einschliessen, was bisher von ihm und dem uebergebenen |
| // Range eingeschlossen wurde |
| SwPosition aOwnLeft(*aOwnPaM.Start()); |
| SwPosition aOwnRight(*aOwnPaM.End()); |
| SwPosition* pParamLeft = rDestPam.Start(); |
| SwPosition* pParamRight = rDestPam.End(); |
| // jetzt sind vier SwPositions da, zwei davon werden gebraucht, also welche? |
| if(aOwnRight > *pParamRight) |
| *aOwnPaM.GetPoint() = aOwnRight; |
| else |
| *aOwnPaM.GetPoint() = *pParamRight; |
| aOwnPaM.SetMark(); |
| if(aOwnLeft < *pParamLeft) |
| *aOwnPaM.GetMark() = aOwnLeft; |
| else |
| *aOwnPaM.GetMark() = *pParamLeft; |
| } |
| else |
| { |
| //der Cursor soll dem uebergebenen Range entsprechen |
| *aOwnPaM.GetPoint() = *rDestPam.GetPoint(); |
| if(rDestPam.HasMark()) |
| { |
| aOwnPaM.SetMark(); |
| *aOwnPaM.GetMark() = *rDestPam.GetMark(); |
| } |
| else |
| aOwnPaM.DeleteMark(); |
| } |
| rSh.SetSelection(aOwnPaM); |
| } |
| else |
| throw uno::RuntimeException(); |
| |
| } |
| /*-- 17.12.98 09:36:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::gotoStart(sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| m_pView->GetWrtShell().SttDoc( bExpand ); |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 17.12.98 09:36:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::gotoEnd(sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| m_pView->GetWrtShell().EndDoc( bExpand ); |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 17.12.98 09:36:28--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToFirstPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| if (rSh.IsSelFrmMode()) |
| { |
| rSh.UnSelectFrm(); |
| rSh.LeaveSelFrmMode(); |
| } |
| rSh.EnterStdMode(); |
| bRet = rSh.SttEndDoc(sal_True); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:29--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToLastPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| if (rSh.IsSelFrmMode()) |
| { |
| rSh.UnSelectFrm(); |
| rSh.LeaveSelFrmMode(); |
| } |
| rSh.EnterStdMode(); |
| bRet = rSh.SttEndDoc(sal_False); |
| rSh.SttPg(); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:30--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToPage(sal_Int16 nPage) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| bRet = m_pView->GetWrtShell().GotoPage(nPage, sal_True); |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:30--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToNextPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| bRet = m_pView->GetWrtShell().SttNxtPg(); |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:31--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToPreviousPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| bRet = m_pView->GetWrtShell().EndPrvPg(); |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:32--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToEndOfPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| bRet = m_pView->GetWrtShell().EndPg(); |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:32--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::jumpToStartOfPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| bRet = m_pView->GetWrtShell().SttPg(); |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /* -----------------04.10.99 14:21------------------- |
| |
| --------------------------------------------------*/ |
| sal_Int16 SwXTextViewCursor::getPage(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| short nRet = 0; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| nRet = (short)pShellCrsr->GetPageNum( sal_True, 0 ); |
| } |
| else |
| throw uno::RuntimeException(); |
| return nRet; |
| } |
| /*-- 17.12.98 09:36:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::screenDown(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| SfxRequest aReq(FN_PAGEDOWN, SFX_CALLMODE_SLOT, m_pView->GetPool()); |
| m_pView->Execute(aReq); |
| const SfxPoolItem* pRet = aReq.GetReturnValue(); |
| bRet = pRet && ((const SfxBoolItem*)pRet)->GetValue(); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 09:36:33--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::screenUp(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| SfxRequest aReq(FN_PAGEUP, SFX_CALLMODE_SLOT, m_pView->GetPool()); |
| m_pView->Execute(aReq); |
| const SfxPoolItem* pRet = aReq.GetReturnValue(); |
| bRet = pRet && ((const SfxBoolItem*)pRet)->GetValue(); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 17.12.98 11:59:05--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XText > SwXTextViewCursor::getText(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< text::XText > xRet; |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwDoc* pDoc = m_pView->GetDocShell()->GetDoc(); |
| xRet = ::sw::CreateParentXText(*pDoc, *pShellCrsr->Start()); |
| } |
| else |
| throw uno::RuntimeException(); |
| return xRet; |
| } |
| /*-- 17.12.98 11:59:05--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextRange > SwXTextViewCursor::getStart(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< text::XTextRange > xRet; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwDoc* pDoc = m_pView->GetDocShell()->GetDoc(); |
| xRet = SwXTextRange::CreateXTextRange(*pDoc, *pShellCrsr->Start(), 0); |
| } |
| else |
| throw uno::RuntimeException(); |
| return xRet; |
| } |
| /*-- 17.12.98 11:59:06--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< text::XTextRange > SwXTextViewCursor::getEnd(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| uno::Reference< text::XTextRange > xRet; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwDoc* pDoc = m_pView->GetDocShell()->GetDoc(); |
| xRet = SwXTextRange::CreateXTextRange(*pDoc, *pShellCrsr->End(), 0); |
| } |
| else |
| throw uno::RuntimeException(); |
| return xRet; |
| } |
| /* -----------------12.10.99 09:03------------------- |
| |
| --------------------------------------------------*/ |
| OUString SwXTextViewCursor::getString(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| OUString uRet; |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| switch(eSelMode) |
| { |
| //! since setString for SEL_TABLE_TEXT (with possible |
| //! multi selection of cells) would not work properly we |
| //! will ignore this case for both |
| //! functions (setString AND getString) because of symmetrie. |
| |
| case SHELL_MODE_LIST_TEXT : |
| case SHELL_MODE_TABLE_LIST_TEXT: |
| case SHELL_MODE_TEXT : |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwUnoCursorHelper::GetTextFromPam(*pShellCrsr, uRet); |
| } |
| default:;//prevent warning |
| } |
| } |
| return uRet; |
| } |
| /*-- 17.12.98 11:59:06--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::setString(const OUString& aString) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| ShellModes eSelMode = m_pView->GetShellMode(); |
| switch(eSelMode) |
| { |
| //! since setString for SEL_TABLE_TEXT (with possible |
| //! multi selection of cells) would not work properly we |
| //! will ignore this case for both |
| //! functions (setString AND getString) because of symmetrie. |
| |
| case SHELL_MODE_LIST_TEXT : |
| case SHELL_MODE_TABLE_LIST_TEXT : |
| case SHELL_MODE_TEXT : |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwCursor* pShellCrsr = rSh.GetSwCrsr(); |
| SwUnoCursorHelper::SetString(*pShellCrsr, aString); |
| } |
| default:;//prevent warning |
| } |
| } |
| } |
| |
| /*-- 29.06.00 17:33:38--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| uno::Reference< XPropertySetInfo > SwXTextViewCursor::getPropertySetInfo( ) throw(RuntimeException) |
| { |
| static uno::Reference< XPropertySetInfo > xRef = m_pPropSet->getPropertySetInfo(); |
| return xRef; |
| } |
| /*-- 29.06.00 17:33:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::setPropertyValue( const OUString& rPropertyName, const Any& aValue ) |
| throw(UnknownPropertyException, PropertyVetoException, |
| IllegalArgumentException, WrappedTargetException, RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwNode *pNode = pShellCrsr->GetNode(); |
| if (pNode && pNode->IsTxtNode()) |
| { |
| SwUnoCursorHelper::SetPropertyValue( |
| *pShellCrsr, *m_pPropSet, rPropertyName, aValue ); |
| } |
| else |
| throw RuntimeException(); |
| } |
| else |
| throw RuntimeException(); |
| } |
| /*-- 29.06.00 17:33:39--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Any SwXTextViewCursor::getPropertyValue( const OUString& rPropertyName ) |
| throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| Any aRet; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| aRet = SwUnoCursorHelper::GetPropertyValue( |
| *pShellCrsr, *m_pPropSet, rPropertyName); |
| } |
| else |
| throw RuntimeException(); |
| return aRet; |
| } |
| /*-- 29.06.00 17:33:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::addPropertyChangeListener( |
| const OUString& /*aPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) |
| throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| } |
| /*-- 29.06.00 17:33:40--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::removePropertyChangeListener( |
| const OUString& /*aPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*aListener*/ ) |
| throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| } |
| /*-- 29.06.00 17:33:41--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::addVetoableChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< XVetoableChangeListener >& /*aListener*/ ) |
| throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| } |
| /*-- 29.06.00 17:33:41--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::removeVetoableChangeListener( |
| const OUString& /*PropertyName*/, const uno::Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| } |
| /*-- 29.06.00 17:33:41--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| PropertyState SwXTextViewCursor::getPropertyState( const OUString& rPropertyName ) |
| throw(UnknownPropertyException, RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| PropertyState eState; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| eState = SwUnoCursorHelper::GetPropertyState( |
| *pShellCrsr, *m_pPropSet, rPropertyName); |
| } |
| else |
| throw RuntimeException(); |
| return eState; |
| } |
| /*-- 29.06.00 17:33:42--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Sequence< PropertyState > SwXTextViewCursor::getPropertyStates( |
| const Sequence< OUString >& rPropertyNames ) throw(UnknownPropertyException, RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| Sequence< PropertyState > aRet; |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| aRet = SwUnoCursorHelper::GetPropertyStates( |
| *pShellCrsr, *m_pPropSet, rPropertyNames); |
| } |
| return aRet; |
| } |
| /*-- 29.06.00 17:33:42--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::setPropertyToDefault( const OUString& rPropertyName ) |
| throw(UnknownPropertyException, RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| SwUnoCursorHelper::SetPropertyToDefault( |
| *pShellCrsr, *m_pPropSet, rPropertyName); |
| } |
| } |
| /*-- 29.06.00 17:33:43--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| Any SwXTextViewCursor::getPropertyDefault( const OUString& rPropertyName ) |
| throw(UnknownPropertyException, WrappedTargetException, RuntimeException) |
| { |
| Any aRet; |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| SwPaM* pShellCrsr = rSh.GetCrsr(); |
| aRet = SwUnoCursorHelper::GetPropertyDefault( |
| *pShellCrsr, *m_pPropSet, rPropertyName); |
| } |
| return aRet; |
| } |
| /*-- 28.09.99 08:31:19--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::goDown(sal_Int16 nCount, sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| bRet = m_pView->GetWrtShell().Down( bExpand, 1, sal_True ); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 28.09.99 08:31:20--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::goUp(sal_Int16 nCount, sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection()) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| for( sal_uInt16 i = 0; i < nCount; i++ ) |
| bRet = m_pView->GetWrtShell().Up( bExpand, 1, sal_True ); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 28.09.99 08:31:20--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::isAtStartOfLine(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| bRet = m_pView->GetWrtShell().IsAtLeftMargin(); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 28.09.99 08:31:21--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::isAtEndOfLine(void) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| sal_Bool bRet = sal_False; |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| bRet = m_pView->GetWrtShell().IsAtRightMargin(sal_True); |
| } |
| else |
| throw uno::RuntimeException(); |
| return bRet; |
| } |
| /*-- 28.09.99 08:31:21--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::gotoEndOfLine(sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| m_pView->GetWrtShell().RightMargin(bExpand, sal_True); |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /*-- 28.09.99 08:31:22--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SwXTextViewCursor::gotoStartOfLine(sal_Bool bExpand) throw( uno::RuntimeException ) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| if(m_pView) |
| { |
| if (!IsTextSelection( sal_False )) |
| throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "no text selection" ) ), static_cast < cppu::OWeakObject * > ( this ) ); |
| |
| m_pView->GetWrtShell().LeftMargin(bExpand, sal_True); |
| } |
| else |
| throw uno::RuntimeException(); |
| } |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| OUString SwXTextViewCursor::getImplementationName(void) throw( RuntimeException ) |
| { |
| return C2U("SwXTextViewCursor"); |
| } |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SwXTextViewCursor::supportsService(const OUString& rServiceName) throw( RuntimeException ) |
| { |
| return !rServiceName.compareToAscii("com.sun.star.text.TextViewCursor") || |
| !rServiceName.compareToAscii("com.sun.star.style.CharacterProperties") || |
| !rServiceName.compareToAscii("com.sun.star.style.CharacterPropertiesAsian") || |
| !rServiceName.compareToAscii("com.sun.star.style.CharacterPropertiesComplex") || |
| !rServiceName.compareToAscii("com.sun.star.style.ParagraphProperties") || |
| !rServiceName.compareToAscii("com.sun.star.style.ParagraphPropertiesAsian") || |
| !rServiceName.compareToAscii("com.sun.star.style.ParagraphPropertiesComplex"); |
| } |
| /* -----------------------------06.04.00 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| Sequence< OUString > SwXTextViewCursor::getSupportedServiceNames(void) throw( RuntimeException ) |
| { |
| Sequence< OUString > aRet(7); |
| OUString* pArray = aRet.getArray(); |
| pArray[0] = C2U("com.sun.star.text.TextViewCursor"); |
| pArray[1] = C2U("com.sun.star.style.CharacterProperties"); |
| pArray[2] = C2U("com.sun.star.style.CharacterPropertiesAsian"); |
| pArray[3] = C2U("com.sun.star.style.CharacterPropertiesComplex"); |
| pArray[4] = C2U("com.sun.star.style.ParagraphProperties"); |
| pArray[5] = C2U("com.sun.star.style.ParagraphPropertiesAsian"); |
| pArray[6] = C2U("com.sun.star.style.ParagraphPropertiesComplex"); |
| return aRet; |
| } |
| /* -----------------------------03.03.03 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| const uno::Sequence< sal_Int8 > & SwXTextViewCursor::getUnoTunnelId() |
| { |
| static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); |
| return aSeq; |
| } |
| /* -----------------------------03.03.03 11:07-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| //XUnoTunnel |
| sal_Int64 SAL_CALL SwXTextViewCursor::getSomething( |
| const uno::Sequence< sal_Int8 >& rId ) |
| throw(uno::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 )); |
| } |
| return OTextCursorHelper::getSomething(rId);; |
| } |
| // ----------------------------------------------------------------------------- |
| |
| IMPLEMENT_FORWARD_XINTERFACE2(SwXTextViewCursor,SwXTextViewCursor_Base,OTextCursorHelper) |
| const SwDoc* SwXTextViewCursor::GetDoc() const |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| return rSh.GetCrsr() ? rSh.GetCrsr()->GetDoc() : 0; |
| } |
| // ----------------------------------------------------------------------------- |
| SwDoc* SwXTextViewCursor::GetDoc() |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| return rSh.GetCrsr() ? rSh.GetCrsr()->GetDoc() : 0; |
| } |
| // ----------------------------------------------------------------------------- |
| const SwPaM* SwXTextViewCursor::GetPaM() const |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| return rSh.GetCrsr(); |
| } |
| // ----------------------------------------------------------------------------- |
| SwPaM* SwXTextViewCursor::GetPaM() |
| { |
| SwWrtShell& rSh = m_pView->GetWrtShell(); |
| return rSh.GetCrsr(); |
| } |
| |
| uno::Reference< datatransfer::XTransferable > SAL_CALL SwXTextView::getTransferable( ) throw (uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| //force immediat shell update |
| GetView()->StopShellTimer(); |
| SwWrtShell& rSh = GetView()->GetWrtShell(); |
| if ( GetView()->GetShellMode() == SHELL_MODE_DRAWTEXT ) |
| { |
| SdrView *pSdrView = rSh.GetDrawView(); |
| OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView(); |
| return pOLV->GetEditView().GetTransferable(); |
| } |
| else |
| { |
| SwTransferable* pTransfer = new SwTransferable( rSh ); |
| const sal_Bool bLockedView = rSh.IsViewLocked(); |
| rSh.LockView( sal_True ); //lock visible section |
| pTransfer->PrepareForCopy(); |
| rSh.LockView( bLockedView ); |
| return uno::Reference< datatransfer::XTransferable >( pTransfer ); |
| } |
| } |
| |
| void SAL_CALL SwXTextView::insertTransferable( const uno::Reference< datatransfer::XTransferable >& xTrans ) throw (datatransfer::UnsupportedFlavorException, uno::RuntimeException) |
| { |
| ::vos::OGuard aGuard(Application::GetSolarMutex()); |
| |
| //force immediat shell update |
| GetView()->StopShellTimer(); |
| SwWrtShell& rSh = GetView()->GetWrtShell(); |
| if ( GetView()->GetShellMode() == SHELL_MODE_DRAWTEXT ) |
| { |
| SdrView *pSdrView = rSh.GetDrawView(); |
| OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView(); |
| pOLV->GetEditView().InsertText( xTrans, GetView()->GetDocShell()->GetMedium()->GetBaseURL(), sal_False ); |
| } |
| else |
| { |
| TransferableDataHelper aDataHelper( xTrans ); |
| if ( SwTransferable::IsPaste( rSh, aDataHelper ) ) |
| { |
| SwTransferable::Paste( rSh, aDataHelper ); |
| if( rSh.IsFrmSelected() || rSh.IsObjSelected() ) |
| rSh.EnterSelFrmMode(); |
| GetView()->AttrChangedNotify( &rSh ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |