Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / ui / uno / unotxvw.cxx
blob: d81f37415ca9959fe6898f1a68ee5977e717d6ce [file] [log] [blame]
/**************************************************************
*
* 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 );
}
}
}
// -----------------------------------------------------------------------------