summaryrefslogtreecommitdiff
path: root/editeng/source/editeng/editeng.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'editeng/source/editeng/editeng.cxx')
-rw-r--r--editeng/source/editeng/editeng.cxx2939
1 files changed, 2939 insertions, 0 deletions
diff --git a/editeng/source/editeng/editeng.cxx b/editeng/source/editeng/editeng.cxx
new file mode 100644
index 000000000000..212fb8ff9446
--- /dev/null
+++ b/editeng/source/editeng/editeng.cxx
@@ -0,0 +1,2939 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_editeng.hxx"
+
+#include <vcl/wrkwin.hxx>
+#include <vcl/dialog.hxx>
+#include <vcl/msgbox.hxx>
+#include <vcl/svapp.hxx>
+
+#define USE_SVXFONT
+
+#define _SVSTDARR_USHORTS
+#include <svl/svstdarr.hxx>
+#include <svl/ctloptions.hxx>
+#include <svtools/ctrltool.hxx>
+
+#include <editeng/svxfont.hxx>
+#include <impedit.hxx>
+#include <editeng/editeng.hxx>
+#include <editeng/editview.hxx>
+#include <editeng/editstat.hxx>
+#include <editdbg.hxx>
+#include <eerdll2.hxx>
+#include <editeng/eerdll.hxx>
+#include <editeng.hrc>
+#include <editeng/flditem.hxx>
+#include <editeng/txtrange.hxx>
+#include <vcl/graph.hxx>
+
+#include <editeng/akrnitem.hxx>
+#include <editeng/cntritem.hxx>
+#include <editeng/colritem.hxx>
+#include <editeng/crsditem.hxx>
+#include <editeng/escpitem.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/fontitem.hxx>
+#include <editeng/kernitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/postitem.hxx>
+#include <editeng/shdditem.hxx>
+#include <editeng/udlnitem.hxx>
+#include <editeng/wghtitem.hxx>
+#include <editeng/wrlmitem.hxx>
+#include <editeng/brshitem.hxx>
+#include <editeng/cscoitem.hxx>
+#include <editeng/langitem.hxx>
+#include <editeng/emphitem.hxx>
+#include <editeng/charscaleitem.hxx>
+#include <editeng/charreliefitem.hxx>
+
+#include <sot/exchange.hxx>
+#include <sot/formats.hxx>
+
+#include <editeng/numitem.hxx>
+#include <editeng/bulitem.hxx>
+#include <editeng/unolingu.hxx>
+#include <linguistic/lngprops.hxx>
+#include <i18npool/mslangid.hxx>
+#include <vcl/help.hxx>
+#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
+#include <com/sun/star/i18n/InputSequenceCheckMode.hpp>
+
+#include <svl/srchdefs.hxx>
+
+#if OSL_DEBUG_LEVEL > 1
+#include <editeng/frmdiritem.hxx>
+#endif
+#include <basegfx/polygon/b2dpolygon.hxx>
+
+// Spaeter -> TOOLS\STRING.H (fuer Grep: WS_TARGET)
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::linguistic2;
+
+
+DBG_NAME( EditEngine )
+DBG_NAMEEX( EditView )
+
+#if (OSL_DEBUG_LEVEL > 1) || defined ( DBG_UTIL )
+static sal_Bool bDebugPaint = sal_False;
+#endif
+
+SV_IMPL_VARARR( EECharAttribArray, EECharAttrib );
+
+static SfxItemPool* pGlobalPool=0;
+
+ // ----------------------------------------------------------------------
+// EditEngine
+// ----------------------------------------------------------------------
+EditEngine::EditEngine( SfxItemPool* pItemPool )
+{
+ DBG_CTOR( EditEngine, 0 );
+ pImpEditEngine = new ImpEditEngine( this, pItemPool );
+}
+
+EditEngine::~EditEngine()
+{
+ DBG_DTOR( EditEngine, 0 );
+ delete pImpEditEngine;
+}
+
+void EditEngine::EnableUndo( sal_Bool bEnable )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->EnableUndo( bEnable );
+}
+
+sal_Bool EditEngine::IsUndoEnabled()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsUndoEnabled();
+}
+
+sal_Bool EditEngine::IsInUndo()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsInUndo();
+}
+
+SfxUndoManager& EditEngine::GetUndoManager()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetUndoManager();
+}
+
+void EditEngine::UndoActionStart( sal_uInt16 nId )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( !pImpEditEngine->IsInUndo(), "Aufruf von UndoActionStart im Undomodus!" );
+ if ( !pImpEditEngine->IsInUndo() )
+ pImpEditEngine->UndoActionStart( nId );
+}
+
+void EditEngine::UndoActionEnd( sal_uInt16 nId )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( !pImpEditEngine->IsInUndo(), "Aufruf von UndoActionEnd im Undomodus!" );
+ if ( !pImpEditEngine->IsInUndo() )
+ pImpEditEngine->UndoActionEnd( nId );
+}
+
+BOOL EditEngine::HasTriedMergeOnLastAddUndo() const
+{
+ return pImpEditEngine->mbLastTryMerge;
+}
+
+void EditEngine::SetRefDevice( OutputDevice* pRefDev )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetRefDevice( pRefDev );
+}
+
+OutputDevice* EditEngine::GetRefDevice() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetRefDevice();
+}
+
+void EditEngine::SetRefMapMode( const MapMode& rMapMode )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetRefMapMode( rMapMode );
+}
+
+MapMode EditEngine::GetRefMapMode()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetRefMapMode();
+}
+
+void EditEngine::SetBackgroundColor( const Color& rColor )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetBackgroundColor( rColor );
+}
+
+Color EditEngine::GetBackgroundColor() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetBackgroundColor();
+}
+
+Color EditEngine::GetAutoColor() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetAutoColor();
+}
+
+void EditEngine::EnableAutoColor( BOOL b )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->EnableAutoColor( b );
+}
+
+BOOL EditEngine::IsAutoColorEnabled() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsAutoColorEnabled();
+}
+
+void EditEngine::ForceAutoColor( BOOL b )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->ForceAutoColor( b );
+}
+
+BOOL EditEngine::IsForceAutoColor() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsForceAutoColor();
+}
+
+const SfxItemSet& EditEngine::GetEmptyItemSet()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEmptyItemSet();
+}
+
+void EditEngine::Draw( OutputDevice* pOutDev, const Rectangle& rOutRect )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ Draw( pOutDev, rOutRect, Point( 0, 0 ) );
+}
+
+void EditEngine::Draw( OutputDevice* pOutDev, const Point& rStartPos, short nOrientation )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ // Mit 2 Punkten erzeugen, da bei Positivem Punkt, LONGMAX als Size
+ // Bottom und Right im Bereich > LONGMAX landen.
+ Rectangle aBigRec( -0x3FFFFFFF, -0x3FFFFFFF, 0x3FFFFFFF, 0x3FFFFFFF );
+ if( pOutDev->GetConnectMetaFile() )
+ pOutDev->Push();
+ Point aStartPos( rStartPos );
+ if ( IsVertical() )
+ {
+ aStartPos.X() += GetPaperSize().Width();
+ aStartPos = Rotate( aStartPos, nOrientation, rStartPos );
+ }
+ pImpEditEngine->Paint( pOutDev, aBigRec, aStartPos, sal_False, nOrientation );
+ if( pOutDev->GetConnectMetaFile() )
+ pOutDev->Pop();
+}
+
+void EditEngine::Draw( OutputDevice* pOutDev, const Rectangle& rOutRect, const Point& rStartDocPos )
+{
+ Draw( pOutDev, rOutRect, rStartDocPos, sal_True );
+}
+
+void EditEngine::Draw( OutputDevice* pOutDev, const Rectangle& rOutRect, const Point& rStartDocPos, sal_Bool bClip )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+#if defined( DBG_UTIL ) || (OSL_DEBUG_LEVEL > 1)
+ if ( bDebugPaint )
+ EditDbg::ShowEditEngineData( this, sal_False );
+#endif
+
+ // Auf Pixelgrenze ausrichten, damit genau das gleiche
+ // wie bei Paint().
+ Rectangle aOutRect( pOutDev->LogicToPixel( rOutRect ) );
+ aOutRect = pOutDev->PixelToLogic( aOutRect );
+
+ Point aStartPos;
+ if ( !IsVertical() )
+ {
+ aStartPos.X() = aOutRect.Left() - rStartDocPos.X();
+ aStartPos.Y() = aOutRect.Top() - rStartDocPos.Y();
+ }
+ else
+ {
+ aStartPos.X() = aOutRect.Right() + rStartDocPos.Y();
+ aStartPos.Y() = aOutRect.Top() - rStartDocPos.X();
+ }
+
+ sal_Bool bClipRegion = pOutDev->IsClipRegion();
+ sal_Bool bMetafile = pOutDev->GetConnectMetaFile() ? sal_True : sal_False;
+ Region aOldRegion = pOutDev->GetClipRegion();
+
+#ifdef EDIT_PRINTER_LOG
+ if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
+ {
+ SvFileStream aLog( "d:\\editprn.log", STREAM_WRITE );
+ aLog.Seek( STREAM_SEEK_TO_END );
+ aLog << ' ' << endl << "Printing: ";
+ aLog << GetText( "\n\r" ).GetStr();
+ aLog << endl << endl;
+ aLog << "Ref-Device: " << String( (sal_uInt32)GetRefDevice() ).GetStr() << " Type=" << String( (sal_uInt16)GetRefDevice()->GetOutDevType() ).GetStr() << ", MapX=" << String( GetRefDevice()->GetMapMode().GetScaleX().GetNumerator() ).GetStr() << "/" << String( GetRefDevice()->GetMapMode().GetScaleX().GetDenominator() ).GetStr() <<endl;
+ aLog << "Paper-Width: " << String( GetPaperSize().Width() ).GetStr() << ",\tOut-Width: " << String( rOutRect.GetWidth() ).GetStr() << ",\tCalculated: " << String( CalcTextWidth() ).GetStr() << endl;
+ aLog << "Paper-Height: " << String( GetPaperSize().Height() ).GetStr() << ",\tOut-Height: " << String( rOutRect.GetHeight() ).GetStr() << ",\tCalculated: " << String( GetTextHeight() ).GetStr() << endl;
+
+ aLog << endl;
+ }
+#endif
+
+ // Wenn es eine gab => Schnittmenge !
+ // Bei der Metafileaufzeichnung Push/Pop verwenden.
+ if ( bMetafile )
+ pOutDev->Push();
+
+ // Immer die Intersect-Methode, weil beim Metafile ein Muss!
+ if ( bClip )
+ {
+ // Clip only if neccesary...
+ if ( !rStartDocPos.X() && !rStartDocPos.Y() &&
+ ( rOutRect.GetHeight() >= (long)GetTextHeight() ) &&
+ ( rOutRect.GetWidth() >= (long)CalcTextWidth() ) )
+ {
+ bClip = FALSE;
+ }
+ else
+ {
+ // Einige Druckertreiber bereiten Probleme, wenn Buchstaben die
+ // ClipRegion streifen, deshalb lieber ein Pixel mehr...
+ Rectangle aClipRect( aOutRect );
+ if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
+ {
+ Size aPixSz( 1, 0 );
+ aPixSz = pOutDev->PixelToLogic( aPixSz );
+ aClipRect.Right() += aPixSz.Width();
+ aClipRect.Bottom() += aPixSz.Width();
+ }
+ pOutDev->IntersectClipRegion( aClipRect );
+ }
+ }
+
+ pImpEditEngine->Paint( pOutDev, aOutRect, aStartPos );
+
+ if ( bMetafile )
+ pOutDev->Pop();
+ else if ( bClipRegion )
+ pOutDev->SetClipRegion( aOldRegion );
+ else
+ pOutDev->SetClipRegion();
+}
+
+void EditEngine::InsertView( EditView* pEditView, sal_uInt16 nIndex )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_CHKOBJ( pEditView, EditView, 0 );
+
+ if ( nIndex > pImpEditEngine->GetEditViews().Count() )
+ nIndex = pImpEditEngine->GetEditViews().Count();
+
+ pImpEditEngine->GetEditViews().Insert( pEditView, nIndex );
+ EditSelection aStartSel;
+ aStartSel = pImpEditEngine->GetEditDoc().GetStartPaM();
+ pEditView->pImpEditView->SetEditSelection( aStartSel );
+ if ( !pImpEditEngine->GetActiveView() )
+ pImpEditEngine->SetActiveView( pEditView );
+
+ pEditView->pImpEditView->AddDragAndDropListeners();
+}
+
+EditView* EditEngine::RemoveView( EditView* pView )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_CHKOBJ( pView, EditView, 0 );
+
+ pView->HideCursor();
+ EditView* pRemoved = 0;
+ sal_uInt16 nPos = pImpEditEngine->GetEditViews().GetPos( pView );
+ DBG_ASSERT( nPos != USHRT_MAX, "RemoveView mit ungueltigem Index" );
+ if ( nPos != USHRT_MAX )
+ {
+ pRemoved = pImpEditEngine->GetEditViews().GetObject( nPos );
+ pImpEditEngine->GetEditViews().Remove( nPos );
+ if ( pImpEditEngine->GetActiveView() == pView )
+ {
+ pImpEditEngine->SetActiveView( 0 );
+ pImpEditEngine->GetSelEngine().SetCurView( 0 );
+ }
+ pView->pImpEditView->RemoveDragAndDropListeners();
+
+ }
+ return pRemoved;
+}
+
+EditView* EditEngine::RemoveView( sal_uInt16 nIndex )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditView* pView = pImpEditEngine->GetEditViews().GetObject( nIndex );
+ if ( pView )
+ return RemoveView( pView );
+ return NULL;
+}
+
+EditView* EditEngine::GetView( sal_uInt16 nIndex ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditViews().GetObject( nIndex );
+}
+
+sal_uInt16 EditEngine::GetViewCount() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditViews().Count();
+}
+
+sal_Bool EditEngine::HasView( EditView* pView ) const
+{
+ return pImpEditEngine->GetEditViews().GetPos( pView ) != USHRT_MAX;
+}
+
+EditView* EditEngine::GetActiveView() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetActiveView();
+}
+
+void EditEngine::SetActiveView( EditView* pView )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( pView )
+ {
+ DBG_CHKOBJ( pView, EditView, 0 );
+ }
+ pImpEditEngine->SetActiveView( pView );
+}
+
+void EditEngine::SetDefTab( sal_uInt16 nDefTab )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->GetEditDoc().SetDefTab( nDefTab );
+ if ( pImpEditEngine->IsFormatted() )
+ {
+ pImpEditEngine->FormatFullDoc();
+ pImpEditEngine->UpdateViews( (EditView*) 0 );
+ }
+}
+
+sal_uInt16 EditEngine::GetDefTab() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditDoc().GetDefTab();
+}
+
+void EditEngine::SetPaperSize( const Size& rNewSize )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ Size aOldSize( pImpEditEngine->GetPaperSize() );
+ pImpEditEngine->SetValidPaperSize( rNewSize );
+ Size aNewSize( pImpEditEngine->GetPaperSize() );
+
+ sal_Bool bAutoPageSize = pImpEditEngine->GetStatus().AutoPageSize();
+ if ( bAutoPageSize || ( aNewSize.Width() != aOldSize.Width() ) )
+ {
+ for ( sal_uInt16 nView = 0; nView < pImpEditEngine->aEditViews.Count(); nView++ )
+ {
+ EditView* pView = pImpEditEngine->aEditViews[nView];
+ DBG_CHKOBJ( pView, EditView, 0 );
+ if ( bAutoPageSize )
+ pView->pImpEditView->RecalcOutputArea();
+ else if ( pView->pImpEditView->DoAutoSize() )
+ {
+ pView->pImpEditView->ResetOutputArea( Rectangle(
+ pView->pImpEditView->GetOutputArea().TopLeft(), aNewSize ) );
+ }
+ }
+
+ if ( bAutoPageSize || pImpEditEngine->IsFormatted() )
+ {
+ // Aendern der Breite hat bei AutoPageSize keine Wirkung, da durch
+ // Textbreite bestimmt.
+ // Optimierung erst nach Vobis-Auslieferung aktivieren...
+// if ( !bAutoPageSize )
+ pImpEditEngine->FormatFullDoc();
+// else
+// {
+// pImpEditEngine->FormatDoc(); // PageSize, falls Aenderung
+// pImpEditEngine->CheckAutoPageSize(); // Falls nichts formatiert wurde
+// }
+
+ pImpEditEngine->UpdateViews( pImpEditEngine->GetActiveView() );
+
+ if ( pImpEditEngine->GetUpdateMode() && pImpEditEngine->GetActiveView() )
+ pImpEditEngine->pActiveView->ShowCursor( sal_False, sal_False );
+ }
+ }
+}
+
+const Size& EditEngine::GetPaperSize() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetPaperSize();
+}
+
+void EditEngine::SetVertical( BOOL bVertical )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetVertical( bVertical );
+}
+
+BOOL EditEngine::IsVertical() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsVertical();
+}
+
+void EditEngine::SetFixedCellHeight( BOOL bUseFixedCellHeight )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetFixedCellHeight( bUseFixedCellHeight );
+}
+
+BOOL EditEngine::IsFixedCellHeight() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsFixedCellHeight();
+}
+
+void EditEngine::SetDefaultHorizontalTextDirection( EEHorizontalTextDirection eHTextDir )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetDefaultHorizontalTextDirection( eHTextDir );
+}
+
+EEHorizontalTextDirection EditEngine::GetDefaultHorizontalTextDirection() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetDefaultHorizontalTextDirection();
+}
+
+USHORT EditEngine::GetScriptType( const ESelection& rSelection ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection aSel( pImpEditEngine->CreateSel( rSelection ) );
+ return pImpEditEngine->GetScriptType( aSel );
+}
+
+LanguageType EditEngine::GetLanguage( USHORT nPara, USHORT nPos ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ DBG_ASSERT( pNode, "GetLanguage - nPara is invalid!" );
+ return pNode ? pImpEditEngine->GetLanguage( EditPaM( pNode, nPos ) ) : LANGUAGE_DONTKNOW;
+}
+
+
+void EditEngine::TransliterateText( const ESelection& rSelection, sal_Int32 nTransliterationMode )
+{
+ DBG_CHKTHIS( EditView, 0 );
+ pImpEditEngine->TransliterateText( pImpEditEngine->CreateSel( rSelection ), nTransliterationMode );
+}
+
+void EditEngine::SetAsianCompressionMode( USHORT n )
+{
+ DBG_CHKTHIS( EditView, 0 );
+ pImpEditEngine->SetAsianCompressionMode( n );
+}
+
+USHORT EditEngine::GetAsianCompressionMode() const
+{
+ DBG_CHKTHIS( EditView, 0 );
+ return pImpEditEngine->GetAsianCompressionMode();
+}
+
+void EditEngine::SetKernAsianPunctuation( BOOL b )
+{
+ DBG_CHKTHIS( EditView, 0 );
+ pImpEditEngine->SetKernAsianPunctuation( b );
+}
+
+BOOL EditEngine::IsKernAsianPunctuation() const
+{
+ DBG_CHKTHIS( EditView, 0 );
+ return pImpEditEngine->IsKernAsianPunctuation();
+}
+
+void EditEngine::SetAddExtLeading( BOOL b )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetAddExtLeading( b );
+}
+
+BOOL EditEngine::IsAddExtLeading() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsAddExtLeading();
+}
+
+void EditEngine::SetPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ SetPolygon( rPolyPolygon, 0L );
+}
+
+void EditEngine::SetPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DPolyPolygon* pLinePolyPolygon)
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ sal_Bool bSimple(sal_False);
+
+ if(pLinePolyPolygon && 1L == rPolyPolygon.count())
+ {
+ if(rPolyPolygon.getB2DPolygon(0L).isClosed())
+ {
+ // open polygon
+ bSimple = sal_True;
+ }
+ }
+
+ TextRanger* pRanger = new TextRanger( rPolyPolygon, pLinePolyPolygon, 30, 2, 2, bSimple, sal_True );
+ pImpEditEngine->SetTextRanger( pRanger );
+ pImpEditEngine->SetPaperSize( pRanger->GetBoundRect().GetSize() );
+}
+
+void EditEngine::ClearPolygon()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetTextRanger( 0 );
+}
+
+const PolyPolygon* EditEngine::GetPolygon()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetTextRanger() ?
+ &pImpEditEngine->GetTextRanger()->GetPolyPolygon() : NULL;
+}
+
+const Size& EditEngine::GetMinAutoPaperSize() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetMinAutoPaperSize();
+}
+
+void EditEngine::SetMinAutoPaperSize( const Size& rSz )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetMinAutoPaperSize( rSz );
+}
+
+const Size& EditEngine::GetMaxAutoPaperSize() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetMaxAutoPaperSize();
+}
+
+void EditEngine::SetMaxAutoPaperSize( const Size& rSz )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetMaxAutoPaperSize( rSz );
+}
+
+XubString EditEngine::GetText( LineEnd eEnd ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditDoc().GetText( eEnd );
+}
+
+XubString EditEngine::GetText( const ESelection& rESelection, const LineEnd eEnd ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection aSel( pImpEditEngine->CreateSel( rESelection ) );
+ return pImpEditEngine->GetSelected( aSel, eEnd );
+}
+
+sal_uInt32 EditEngine::GetTextLen() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditDoc().GetTextLen();
+}
+
+sal_uInt16 EditEngine::GetParagraphCount() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->aEditDoc.Count();
+}
+
+sal_uInt16 EditEngine::GetLineCount( sal_uInt16 nParagraph ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ return pImpEditEngine->GetLineCount( nParagraph );
+}
+
+sal_uInt16 EditEngine::GetLineLen( sal_uInt16 nParagraph, sal_uInt16 nLine ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ return pImpEditEngine->GetLineLen( nParagraph, nLine );
+}
+
+void EditEngine::GetLineBoundaries( /*out*/USHORT &rStart, /*out*/USHORT &rEnd, USHORT nParagraph, USHORT nLine ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ return pImpEditEngine->GetLineBoundaries( rStart, rEnd, nParagraph, nLine );
+}
+
+USHORT EditEngine::GetLineNumberAtIndex( USHORT nPara, USHORT nIndex ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ return pImpEditEngine->GetLineNumberAtIndex( nPara, nIndex );
+}
+
+sal_uInt32 EditEngine::GetLineHeight( sal_uInt16 nParagraph, sal_uInt16 nLine )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ // Falls jemand mit einer leeren Engine ein GetLineHeight() macht.
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ return pImpEditEngine->GetLineHeight( nParagraph, nLine );
+}
+
+sal_uInt16 EditEngine::GetFirstLineOffset( sal_uInt16 nParagraph )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ ParaPortion* pPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nParagraph );
+ return ( pPortion ? pPortion->GetFirstLineOffset() : 0 );
+}
+
+sal_uInt32 EditEngine::GetTextHeight( sal_uInt16 nParagraph ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+
+ sal_uInt32 nHeight = pImpEditEngine->GetParaHeight( nParagraph );
+ return nHeight;
+}
+
+XubString EditEngine::GetWord( sal_uInt16 nPara, sal_uInt16 nIndex )
+{
+ ESelection aESel( nPara, nIndex, nPara, nIndex );
+ EditSelection aSel( pImpEditEngine->CreateSel( aESel ) );
+ aSel = pImpEditEngine->SelectWord( aSel );
+ return pImpEditEngine->GetSelected( aSel );
+}
+
+ESelection EditEngine::GetWord( const ESelection& rSelection, USHORT nWordType ) const
+{
+ // ImpEditEngine-Iteration-Methods should be const!
+ EditEngine* pE = (EditEngine*)this;
+
+ EditSelection aSel( pE->pImpEditEngine->CreateSel( rSelection ) );
+ aSel = pE->pImpEditEngine->SelectWord( aSel, nWordType );
+ return pE->pImpEditEngine->CreateESel( aSel );
+}
+
+ESelection EditEngine::WordLeft( const ESelection& rSelection, USHORT nWordType ) const
+{
+ // ImpEditEngine-Iteration-Methods should be const!
+ EditEngine* pE = (EditEngine*)this;
+
+ EditSelection aSel( pE->pImpEditEngine->CreateSel( rSelection ) );
+ aSel = pE->pImpEditEngine->WordLeft( aSel.Min(), nWordType );
+ return pE->pImpEditEngine->CreateESel( aSel );
+}
+
+ESelection EditEngine::WordRight( const ESelection& rSelection, USHORT nWordType ) const
+{
+ // ImpEditEngine-Iteration-Methods should be const!
+ EditEngine* pE = (EditEngine*)this;
+
+ EditSelection aSel( pE->pImpEditEngine->CreateSel( rSelection ) );
+ aSel = pE->pImpEditEngine->WordRight( aSel.Max(), nWordType );
+ return pE->pImpEditEngine->CreateESel( aSel );
+}
+
+ESelection EditEngine::CursorLeft( const ESelection& rSelection, USHORT nCharacterIteratorMode ) const
+{
+ // ImpEditEngine-Iteration-Methods should be const!
+ EditEngine* pE = (EditEngine*)this;
+
+ EditSelection aSel( pE->pImpEditEngine->CreateSel( rSelection ) );
+ aSel = pE->pImpEditEngine->CursorLeft( aSel.Min(), nCharacterIteratorMode );
+ return pE->pImpEditEngine->CreateESel( aSel );
+}
+
+ESelection EditEngine::CursorRight( const ESelection& rSelection, USHORT nCharacterIteratorMode ) const
+{
+ // ImpEditEngine-Iteration-Methods should be const!
+ EditEngine* pE = (EditEngine*)this;
+
+ EditSelection aSel( pE->pImpEditEngine->CreateSel( rSelection ) );
+ aSel = pE->pImpEditEngine->CursorRight( aSel.Max(), nCharacterIteratorMode );
+ return pE->pImpEditEngine->CreateESel( aSel );
+}
+
+sal_Bool EditEngine::PostKeyEvent( const KeyEvent& rKeyEvent, EditView* pEditView )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_CHKOBJ( pEditView, EditView, 0 );
+ DBG_ASSERT( pEditView, "Keine View - keine Kekse !" );
+
+ sal_Bool bDone = sal_True;
+
+ sal_Bool bModified = sal_False;
+ sal_Bool bMoved = sal_False;
+ sal_Bool bAllowIdle = sal_True;
+ sal_Bool bReadOnly = pEditView->IsReadOnly();
+
+ USHORT nNewCursorFlags = 0;
+ BOOL bSetCursorFlags = TRUE;
+
+ EditSelection aCurSel( pEditView->pImpEditView->GetEditSelection() );
+ DBG_ASSERT( !aCurSel.IsInvalid(), "Blinde Selection in EditEngine::PostKeyEvent" );
+
+ String aAutoText( pImpEditEngine->GetAutoCompleteText() );
+ if ( pImpEditEngine->GetAutoCompleteText().Len() )
+ pImpEditEngine->SetAutoCompleteText( String(), sal_True );
+
+ sal_uInt16 nCode = rKeyEvent.GetKeyCode().GetCode();
+ KeyFuncType eFunc = rKeyEvent.GetKeyCode().GetFunction();
+ if ( eFunc != KEYFUNC_DONTKNOW )
+ {
+ switch ( eFunc )
+ {
+ case KEYFUNC_UNDO:
+ {
+ if ( !bReadOnly )
+ pEditView->Undo();
+ return sal_True;
+ }
+ // break;
+ case KEYFUNC_REDO:
+ {
+ if ( !bReadOnly )
+ pEditView->Redo();
+ return sal_True;
+ }
+ // break;
+
+ default: // wird dann evtl. unten bearbeitet.
+ eFunc = KEYFUNC_DONTKNOW;
+ }
+ }
+
+ pImpEditEngine->EnterBlockNotifications();
+
+ if ( GetNotifyHdl().IsSet() )
+ {
+ EENotify aNotify( EE_NOTIFY_INPUT_START );
+ aNotify.pEditEngine = this;
+ pImpEditEngine->CallNotify( aNotify );
+ }
+
+ if ( eFunc == KEYFUNC_DONTKNOW )
+ {
+ switch ( nCode )
+ {
+ #if defined( DBG_UTIL ) || (OSL_DEBUG_LEVEL > 1)
+ case KEY_F1:
+ {
+ if ( rKeyEvent.GetKeyCode().IsMod1() && rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ USHORT nParas = GetParagraphCount();
+ Point aPos;
+ Point aViewStart( pEditView->GetOutputArea().TopLeft() );
+ long n20 = 40 * pImpEditEngine->nOnePixelInRef;
+ for ( USHORT n = 0; n < nParas; n++ )
+ {
+ long nH = GetTextHeight( n );
+ Point P1( aViewStart.X() + n20 + n20*(n%2), aViewStart.Y() + aPos.Y() );
+ Point P2( P1 );
+ P2.X() += n20;
+ P2.Y() += nH;
+ pEditView->GetWindow()->SetLineColor();
+ pEditView->GetWindow()->SetFillColor( Color( (n%2) ? COL_YELLOW : COL_LIGHTGREEN ) );
+ pEditView->GetWindow()->DrawRect( Rectangle( P1, P2 ) );
+ aPos.Y() += nH;
+ }
+ }
+ bDone = FALSE;
+ }
+ break;
+ case KEY_F11:
+ {
+ if ( rKeyEvent.GetKeyCode().IsMod1() && rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ bDebugPaint = !bDebugPaint;
+ ByteString aInfo( "DebugPaint: " );
+ aInfo += bDebugPaint ? "On" : "Off";
+ InfoBox( NULL, String( aInfo, RTL_TEXTENCODING_ASCII_US ) ).Execute();
+ }
+ bDone = FALSE;
+ }
+ break;
+ case KEY_F12:
+ {
+ if ( rKeyEvent.GetKeyCode().IsMod1() && rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ EditDbg::ShowEditEngineData( this );
+ #ifdef EDIT_PRINTER_LOG
+ SvFileStream aLog( "d:\\editprn.log", STREAM_WRITE );
+ aLog.Seek( STREAM_SEEK_TO_END );
+ aLog << ' ' << endl << "Debug: ";
+ aLog << GetText( "\n\r" ).GetStr();
+ aLog << endl << endl;
+ aLog << "Ref-Device: " << String( (sal_uInt32)GetRefDevice() ).GetStr() << " Type=" << String( (sal_uInt16)GetRefDevice()->GetOutDevType() ).GetStr() << ", MapX=" << String( GetRefDevice()->GetMapMode().GetScaleX().GetNumerator() ).GetStr() << "/" << String( GetRefDevice()->GetMapMode().GetScaleX().GetDenominator() ).GetStr() <<endl;
+ aLog << "Paper-Width: " << String( GetPaperSize().Width() ).GetStr() << ",\tCalculated: " << String( CalcTextWidth() ).GetStr() << endl;
+ aLog << "Paper-Height: " << String( GetPaperSize().Height() ).GetStr() << ",\tCalculated: " << String( GetTextHeight() ).GetStr() << endl;
+ aLog << endl;
+ #endif
+ }
+ bDone = FALSE;
+ }
+ break;
+ #endif
+ case KEY_UP:
+ case KEY_DOWN:
+ case KEY_LEFT:
+ case KEY_RIGHT:
+ case KEY_HOME:
+ case KEY_END:
+ case KEY_PAGEUP:
+ case KEY_PAGEDOWN:
+ case com::sun::star::awt::Key::MOVE_WORD_FORWARD:
+ case com::sun::star::awt::Key::SELECT_WORD_FORWARD:
+ case com::sun::star::awt::Key::MOVE_WORD_BACKWARD:
+ case com::sun::star::awt::Key::SELECT_WORD_BACKWARD:
+ case com::sun::star::awt::Key::MOVE_TO_BEGIN_OF_LINE:
+ case com::sun::star::awt::Key::MOVE_TO_END_OF_LINE:
+ case com::sun::star::awt::Key::SELECT_TO_BEGIN_OF_LINE:
+ case com::sun::star::awt::Key::SELECT_TO_END_OF_LINE:
+ case com::sun::star::awt::Key::MOVE_TO_BEGIN_OF_PARAGRAPH:
+ case com::sun::star::awt::Key::MOVE_TO_END_OF_PARAGRAPH:
+ case com::sun::star::awt::Key::SELECT_TO_BEGIN_OF_PARAGRAPH:
+ case com::sun::star::awt::Key::SELECT_TO_END_OF_PARAGRAPH:
+ case com::sun::star::awt::Key::MOVE_TO_BEGIN_OF_DOCUMENT:
+ case com::sun::star::awt::Key::MOVE_TO_END_OF_DOCUMENT:
+ case com::sun::star::awt::Key::SELECT_TO_BEGIN_OF_DOCUMENT:
+ case com::sun::star::awt::Key::SELECT_TO_END_OF_DOCUMENT:
+ {
+ if ( !rKeyEvent.GetKeyCode().IsMod2() || ( nCode == KEY_LEFT ) || ( nCode == KEY_RIGHT ) )
+ {
+ if ( pImpEditEngine->DoVisualCursorTraveling( aCurSel.Max().GetNode() ) && ( ( nCode == KEY_LEFT ) || ( nCode == KEY_RIGHT ) /* || ( nCode == KEY_HOME ) || ( nCode == KEY_END ) */ ) )
+ bSetCursorFlags = FALSE; // Will be manipulated within visual cursor move
+
+ aCurSel = pImpEditEngine->MoveCursor( rKeyEvent, pEditView );
+
+ if ( aCurSel.HasRange() ) {
+ Reference<com::sun::star::datatransfer::clipboard::XClipboard> aSelection(pEditView->GetWindow()->GetPrimarySelection());
+ pEditView->pImpEditView->CutCopy( aSelection, FALSE );
+ }
+
+ bMoved = sal_True;
+ if ( nCode == KEY_HOME )
+ nNewCursorFlags |= GETCRSR_STARTOFLINE;
+ else if ( nCode == KEY_END )
+ nNewCursorFlags |= GETCRSR_ENDOFLINE;
+
+ }
+#if OSL_DEBUG_LEVEL > 1
+ GetLanguage( pImpEditEngine->GetEditDoc().GetPos( aCurSel.Max().GetNode() ), aCurSel.Max().GetIndex() );
+#endif
+ }
+ break;
+ case KEY_BACKSPACE:
+ case KEY_DELETE:
+ case com::sun::star::awt::Key::DELETE_WORD_BACKWARD:
+ case com::sun::star::awt::Key::DELETE_WORD_FORWARD:
+ case com::sun::star::awt::Key::DELETE_TO_BEGIN_OF_PARAGRAPH:
+ case com::sun::star::awt::Key::DELETE_TO_END_OF_PARAGRAPH:
+ {
+ if ( !bReadOnly && !rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ // check if we are behind a bullet and using the backspace key
+ ContentNode *pNode = aCurSel.Min().GetNode();
+ const SvxNumberFormat *pFmt = pImpEditEngine->GetNumberFormat( pNode );
+ if (pFmt && nCode == KEY_BACKSPACE &&
+ !aCurSel.HasRange() && aCurSel.Min().GetIndex() == 0)
+ {
+ // if the bullet is still visible just do not paint it from
+ // now on and that will be all. Otherwise continue as usual.
+ // ...
+
+ USHORT nPara = pImpEditEngine->GetEditDoc().GetPos( pNode );
+ SfxBoolItem aBulletState( (const SfxBoolItem&) pImpEditEngine->GetParaAttrib( nPara, EE_PARA_BULLETSTATE ) );
+ bool bBulletIsVisible = aBulletState.GetValue() ? true : false;
+
+ // just toggling EE_PARA_BULLETSTATE should be fine for both cases...
+ aBulletState.SetValue( !bBulletIsVisible );
+ SfxItemSet aSet( pImpEditEngine->GetParaAttribs( nPara ) );
+ aSet.Put( aBulletState );
+ pImpEditEngine->SetParaAttribs( nPara, aSet );
+
+ // have this and the following paragraphs formatted and repainted.
+ // (not painting a numbering in the list may cause the following
+ // numberings to have different numbers than before and thus the
+ // length may have changed as well )
+ pImpEditEngine->FormatAndUpdate( pImpEditEngine->GetActiveView() );
+
+ if (bBulletIsVisible) // bullet just turned invisible...
+ break;
+ }
+
+ BYTE nDel = 0, nMode = 0;
+ switch( nCode )
+ {
+ case com::sun::star::awt::Key::DELETE_WORD_BACKWARD:
+ nMode = DELMODE_RESTOFWORD;
+ nDel = DEL_LEFT;
+ break;
+ case com::sun::star::awt::Key::DELETE_WORD_FORWARD:
+ nMode = DELMODE_RESTOFWORD;
+ nDel = DEL_RIGHT;
+ break;
+ case com::sun::star::awt::Key::DELETE_TO_BEGIN_OF_PARAGRAPH:
+ nMode = DELMODE_RESTOFCONTENT;
+ nDel = DEL_LEFT;
+ break;
+ case com::sun::star::awt::Key::DELETE_TO_END_OF_PARAGRAPH:
+ nMode = DELMODE_RESTOFCONTENT;
+ nDel = DEL_RIGHT;
+ break;
+ default:
+ nDel = ( nCode == KEY_DELETE ) ? DEL_RIGHT : DEL_LEFT;
+ nMode = rKeyEvent.GetKeyCode().IsMod1() ? DELMODE_RESTOFWORD : DELMODE_SIMPLE;
+ if ( ( nMode == DELMODE_RESTOFWORD ) && rKeyEvent.GetKeyCode().IsShift() )
+ nMode = DELMODE_RESTOFCONTENT;
+ break;
+ }
+
+ pEditView->pImpEditView->DrawSelection();
+ pImpEditEngine->UndoActionStart( EDITUNDO_DELETE );
+ aCurSel = pImpEditEngine->DeleteLeftOrRight( aCurSel, nDel, nMode );
+ pImpEditEngine->UndoActionEnd( EDITUNDO_DELETE );
+ bModified = sal_True;
+ bAllowIdle = sal_False;
+ }
+ }
+ break;
+ case KEY_TAB:
+ {
+ if ( !bReadOnly && !rKeyEvent.GetKeyCode().IsMod1() && !rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ sal_Bool bShift = rKeyEvent.GetKeyCode().IsShift();
+ if ( pImpEditEngine->GetStatus().DoTabIndenting() &&
+ ( aCurSel.Min().GetNode() != aCurSel.Max().GetNode() ) )
+ {
+ pImpEditEngine->IndentBlock( pEditView, !bShift );
+ }
+ else if ( !bShift )
+ {
+ sal_Bool bSel = pEditView->HasSelection();
+ if ( bSel )
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+ if ( pImpEditEngine->GetStatus().DoAutoCorrect() )
+ aCurSel = pImpEditEngine->AutoCorrect( aCurSel, 0, !pEditView->IsInsertMode() );
+ aCurSel = pImpEditEngine->InsertTab( aCurSel );
+ if ( bSel )
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+ bModified = sal_True;
+ }
+ }
+ else
+ bDone = sal_False;
+ }
+ break;
+ case KEY_RETURN:
+ {
+ if ( !bReadOnly )
+ {
+ pEditView->pImpEditView->DrawSelection();
+ if ( !rKeyEvent.GetKeyCode().IsMod1() && !rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+ if ( rKeyEvent.GetKeyCode().IsShift() )
+ {
+ aCurSel = pImpEditEngine->AutoCorrect( aCurSel, 0, !pEditView->IsInsertMode() );
+ aCurSel = pImpEditEngine->InsertLineBreak( aCurSel );
+ }
+ else
+ {
+ if ( !aAutoText.Len() )
+ {
+ if ( pImpEditEngine->GetStatus().DoAutoCorrect() )
+ aCurSel = pImpEditEngine->AutoCorrect( aCurSel, 0, !pEditView->IsInsertMode() );
+ aCurSel = pImpEditEngine->InsertParaBreak( aCurSel );
+ }
+ else
+ {
+ DBG_ASSERT( !aCurSel.HasRange(), "Selektion bei Complete?!" );
+ EditPaM aStart( pImpEditEngine->WordLeft( aCurSel.Max() ) );
+ aCurSel = pImpEditEngine->InsertText(
+ EditSelection( aStart, aCurSel.Max() ), aAutoText );
+ pImpEditEngine->SetAutoCompleteText( String(), sal_True );
+ }
+ }
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+ bModified = sal_True;
+ }
+ }
+ }
+ break;
+ case KEY_INSERT:
+ {
+ if ( !rKeyEvent.GetKeyCode().IsMod1() && !rKeyEvent.GetKeyCode().IsMod2() )
+ pEditView->SetInsertMode( !pEditView->IsInsertMode() );
+ }
+ break;
+ default:
+ {
+ #if (OSL_DEBUG_LEVEL > 1) && defined(DBG_UTIL)
+ if ( ( nCode == KEY_W ) && rKeyEvent.GetKeyCode().IsMod1() && rKeyEvent.GetKeyCode().IsMod2() )
+ {
+ SfxItemSet aAttribs = pEditView->GetAttribs();
+ const SvxFrameDirectionItem& rCurrentWritingMode = (const SvxFrameDirectionItem&)aAttribs.Get( EE_PARA_WRITINGDIR );
+ SvxFrameDirectionItem aNewItem( FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR );
+ if ( rCurrentWritingMode.GetValue() != FRMDIR_HORI_RIGHT_TOP )
+ aNewItem.SetValue( FRMDIR_HORI_RIGHT_TOP );
+ aAttribs.Put( aNewItem );
+ pEditView->SetAttribs( aAttribs );
+ }
+ #endif
+ if ( !bReadOnly && IsSimpleCharInput( rKeyEvent ) )
+ {
+ xub_Unicode nCharCode = rKeyEvent.GetCharCode();
+ pEditView->pImpEditView->DrawSelection();
+ // Autokorrektur ?
+ if ( ( pImpEditEngine->GetStatus().DoAutoCorrect() ) &&
+ SvxAutoCorrect::IsAutoCorrectChar( nCharCode ) )
+ {
+ aCurSel = pImpEditEngine->AutoCorrect( aCurSel, nCharCode, !pEditView->IsInsertMode() );
+ }
+ else
+ {
+ aCurSel = pImpEditEngine->InsertText( (const EditSelection&)aCurSel, nCharCode, !pEditView->IsInsertMode(), sal_True );
+ }
+ // AutoComplete ???
+ if ( pImpEditEngine->GetStatus().DoAutoComplete() && ( nCharCode != ' ' ) )
+ {
+ // Aber nur wenn Wort-Ende...
+ sal_uInt16 nIndex = aCurSel.Max().GetIndex();
+ if ( ( nIndex >= aCurSel.Max().GetNode()->Len() ) ||
+ ( pImpEditEngine->aWordDelimiters.Search( aCurSel.Max().GetNode()->GetChar( nIndex ) ) != STRING_NOTFOUND ) )
+ {
+ EditPaM aStart( pImpEditEngine->WordLeft( aCurSel.Max() ) );
+ String aWord = pImpEditEngine->GetSelected( EditSelection( aStart, aCurSel.Max() ) );
+ if ( aWord.Len() >= 3 )
+ {
+ String aComplete;
+
+ LanguageType eLang = pImpEditEngine->GetLanguage( EditPaM( aStart.GetNode(), aStart.GetIndex()+1));
+ lang::Locale aLocale( MsLangId::convertLanguageToLocale( eLang));
+
+ if (!pImpEditEngine->xLocaleDataWrapper.isInitialized())
+ pImpEditEngine->xLocaleDataWrapper.init( SvtSysLocale().GetLocaleData().getServiceFactory(), aLocale, eLang);
+ else
+ pImpEditEngine->xLocaleDataWrapper.changeLocale( aLocale, eLang);
+
+ if (!pImpEditEngine->xTransliterationWrapper.isInitialized())
+ pImpEditEngine->xTransliterationWrapper.init( SvtSysLocale().GetLocaleData().getServiceFactory(), eLang, i18n::TransliterationModules_IGNORE_CASE);
+ else
+ pImpEditEngine->xTransliterationWrapper.changeLocale( eLang);
+
+ const ::utl::TransliterationWrapper* pTransliteration = pImpEditEngine->xTransliterationWrapper.get();
+ Sequence< i18n::CalendarItem > xItem = pImpEditEngine->xLocaleDataWrapper->getDefaultCalendarDays();
+ sal_Int32 nCount = xItem.getLength();
+ const i18n::CalendarItem* pArr = xItem.getArray();
+ for( sal_Int32 n = 0; n <= nCount; ++n )
+ {
+ const ::rtl::OUString& rDay = pArr[n].FullName;
+ if( pTransliteration->isMatch( aWord, rDay) )
+ {
+ aComplete = rDay;
+ break;
+ }
+ }
+
+ if ( !aComplete.Len() )
+ {
+ xItem = pImpEditEngine->xLocaleDataWrapper->getDefaultCalendarMonths();
+ sal_Int32 nMonthCount = xItem.getLength();
+ const i18n::CalendarItem* pMonthArr = xItem.getArray();
+ for( sal_Int32 n = 0; n <= nMonthCount; ++n )
+ {
+ const ::rtl::OUString& rMon = pMonthArr[n].FullName;
+ if( pTransliteration->isMatch( aWord, rMon) )
+ {
+ aComplete = rMon;
+ break;
+ }
+ }
+ }
+
+ if( aComplete.Len() && ( ( aWord.Len() + 1 ) < aComplete.Len() ) )
+ {
+ pImpEditEngine->SetAutoCompleteText( aComplete, sal_False );
+ Point aPos = pImpEditEngine->PaMtoEditCursor( aCurSel.Max() ).TopLeft();
+ aPos = pEditView->pImpEditView->GetWindowPos( aPos );
+ aPos = pEditView->pImpEditView->GetWindow()->LogicToPixel( aPos );
+ aPos = pEditView->GetWindow()->OutputToScreenPixel( aPos );
+ aPos.Y() -= 3;
+ Help::ShowQuickHelp( pEditView->GetWindow(), Rectangle( aPos, Size( 1, 1 ) ), aComplete, QUICKHELP_BOTTOM|QUICKHELP_LEFT );
+ }
+ }
+ }
+ }
+ bModified = sal_True;
+ }
+ else
+ bDone = sal_False;
+ }
+ }
+ }
+
+ pEditView->pImpEditView->SetEditSelection( aCurSel );
+ pImpEditEngine->UpdateSelections();
+
+ if ( ( !IsVertical() && ( nCode != KEY_UP ) && ( nCode != KEY_DOWN ) ) ||
+ ( IsVertical() && ( nCode != KEY_LEFT ) && ( nCode != KEY_RIGHT ) ))
+ {
+ pEditView->pImpEditView->nTravelXPos = TRAVEL_X_DONTKNOW;
+ }
+
+ if ( /* ( nCode != KEY_HOME ) && ( nCode != KEY_END ) && */
+ ( !IsVertical() && ( nCode != KEY_LEFT ) && ( nCode != KEY_RIGHT ) ) ||
+ ( IsVertical() && ( nCode != KEY_UP ) && ( nCode != KEY_DOWN ) ))
+ {
+ pEditView->pImpEditView->SetCursorBidiLevel( 0xFFFF );
+ }
+
+ if ( bSetCursorFlags )
+ pEditView->pImpEditView->nExtraCursorFlags = nNewCursorFlags;
+
+ if ( bModified )
+ {
+ DBG_ASSERT( !bReadOnly, "ReadOnly but modified???" );
+ // Idle-Formatter nur, wenn AnyInput.
+ if ( bAllowIdle && pImpEditEngine->GetStatus().UseIdleFormatter()
+ && Application::AnyInput( INPUT_KEYBOARD) )
+ pImpEditEngine->IdleFormatAndUpdate( pEditView );
+ else
+ pImpEditEngine->FormatAndUpdate( pEditView );
+ }
+ else if ( bMoved )
+ {
+ sal_Bool bGotoCursor = pEditView->pImpEditView->DoAutoScroll();
+ pEditView->pImpEditView->ShowCursor( bGotoCursor, sal_True );
+ pImpEditEngine->CallStatusHdl();
+ }
+
+ if ( GetNotifyHdl().IsSet() )
+ {
+ EENotify aNotify( EE_NOTIFY_INPUT_END );
+ aNotify.pEditEngine = this;
+ pImpEditEngine->CallNotify( aNotify );
+ }
+
+ pImpEditEngine->LeaveBlockNotifications();
+
+ return bDone;
+}
+
+sal_uInt32 EditEngine::GetTextHeight() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+
+ sal_uInt32 nHeight = !IsVertical() ? pImpEditEngine->GetTextHeight() : pImpEditEngine->CalcTextWidth( TRUE );
+ return nHeight;
+}
+
+sal_uInt32 EditEngine::CalcTextWidth()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+
+ sal_uInt32 nWidth = !IsVertical() ? pImpEditEngine->CalcTextWidth( TRUE ) : pImpEditEngine->GetTextHeight();
+ return nWidth;
+}
+
+void EditEngine::SetUpdateMode( sal_Bool bUpdate )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetUpdateMode( bUpdate );
+ if ( pImpEditEngine->pActiveView )
+ pImpEditEngine->pActiveView->ShowCursor( sal_False, sal_False );
+}
+
+sal_Bool EditEngine::GetUpdateMode() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetUpdateMode();
+}
+
+void EditEngine::Clear()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->Clear();
+}
+
+void EditEngine::SetText( const XubString& rText )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetText( rText );
+ if ( rText.Len() )
+ pImpEditEngine->FormatAndUpdate();
+}
+
+ULONG EditEngine::Read( SvStream& rInput, const String& rBaseURL, EETextFormat eFormat, SvKeyValueIterator* pHTTPHeaderAttrs /* = NULL */ )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ sal_Bool bUndoEnabled = pImpEditEngine->IsUndoEnabled();
+ pImpEditEngine->EnableUndo( sal_False );
+ pImpEditEngine->SetText( XubString() );
+ EditPaM aPaM( pImpEditEngine->GetEditDoc().GetStartPaM() );
+ pImpEditEngine->Read( rInput, rBaseURL, eFormat, EditSelection( aPaM, aPaM ), pHTTPHeaderAttrs );
+ pImpEditEngine->EnableUndo( bUndoEnabled );
+ return rInput.GetError();
+}
+
+ULONG EditEngine::Write( SvStream& rOutput, EETextFormat eFormat )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditPaM aStartPaM( pImpEditEngine->GetEditDoc().GetStartPaM() );
+ EditPaM aEndPaM( pImpEditEngine->GetEditDoc().GetEndPaM() );
+ pImpEditEngine->Write( rOutput, eFormat, EditSelection( aStartPaM, aEndPaM ) );
+ return rOutput.GetError();
+}
+
+EditTextObject* EditEngine::CreateTextObject()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->CreateTextObject();
+}
+
+EditTextObject* EditEngine::CreateTextObject( const ESelection& rESelection )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection aSel( pImpEditEngine->CreateSel( rESelection ) );
+ return pImpEditEngine->CreateTextObject( aSel );
+}
+
+void EditEngine::SetText( const EditTextObject& rTextObject )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->EnterBlockNotifications();
+ pImpEditEngine->SetText( rTextObject );
+ pImpEditEngine->FormatAndUpdate();
+ pImpEditEngine->LeaveBlockNotifications();
+}
+
+void EditEngine::ShowParagraph( sal_uInt16 nParagraph, sal_Bool bShow )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->ShowParagraph( nParagraph, bShow );
+}
+
+sal_Bool EditEngine::IsParagraphVisible( sal_uInt16 nParagraph )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsParagraphVisible( nParagraph );
+}
+
+void EditEngine::SetNotifyHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetNotifyHdl( rLink );
+}
+
+Link EditEngine::GetNotifyHdl() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetNotifyHdl();
+}
+
+void EditEngine::SetStatusEventHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetStatusEventHdl( rLink );
+}
+
+Link EditEngine::GetStatusEventHdl() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetStatusEventHdl();
+}
+
+void EditEngine::SetImportHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->aImportHdl = rLink;
+}
+
+Link EditEngine::GetImportHdl() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->aImportHdl;
+}
+
+void EditEngine::SetBeginMovingParagraphsHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->aBeginMovingParagraphsHdl = rLink;
+}
+
+void EditEngine::SetEndMovingParagraphsHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->aEndMovingParagraphsHdl = rLink;
+}
+
+void EditEngine::SetBeginPasteOrDropHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ pImpEditEngine->aBeginPasteOrDropHdl = rLink;
+}
+
+void EditEngine::SetEndPasteOrDropHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->aEndPasteOrDropHdl = rLink;
+}
+
+EditTextObject* EditEngine::CreateTextObject( sal_uInt16 nPara, sal_uInt16 nParas )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( nPara < pImpEditEngine->GetEditDoc().Count(), "CreateTextObject: Startpara out of Range" );
+ DBG_ASSERT( nPara+nParas-1 < pImpEditEngine->GetEditDoc().Count(), "CreateTextObject: Endpara out of Range" );
+
+ ContentNode* pStartNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ ContentNode* pEndNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara+nParas-1 );
+ DBG_ASSERT( pStartNode, "Start-Absatz existiert nicht: CreateTextObject" );
+ DBG_ASSERT( pEndNode, "End-Absatz existiert nicht: CreateTextObject" );
+
+ if ( pStartNode && pEndNode )
+ {
+ EditSelection aTmpSel;
+ aTmpSel.Min() = EditPaM( pStartNode, 0 );
+ aTmpSel.Max() = EditPaM( pEndNode, pEndNode->Len() );
+ return pImpEditEngine->CreateTextObject( aTmpSel );
+ }
+ return 0;
+}
+
+void EditEngine::RemoveParagraph( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( pImpEditEngine->GetEditDoc().Count() > 1, "Der erste Absatz darf nicht geloescht werden!" );
+ if( pImpEditEngine->GetEditDoc().Count() <= 1 )
+ return;
+
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ ParaPortion* pPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nPara );
+ DBG_ASSERT( pPortion && pNode, "Absatz nicht gefunden: RemoveParagraph" );
+ if ( pNode && pPortion )
+ {
+ // Keine Undokappselung noetig.
+ pImpEditEngine->ImpRemoveParagraph( nPara );
+ pImpEditEngine->InvalidateFromParagraph( nPara );
+ pImpEditEngine->UpdateSelections();
+ pImpEditEngine->FormatAndUpdate();
+ }
+}
+
+sal_uInt16 EditEngine::GetTextLen( sal_uInt16 nPara ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ DBG_ASSERT( pNode, "Absatz nicht gefunden: GetTextLen" );
+ if ( pNode )
+ return pNode->Len();
+ return 0;
+}
+
+XubString EditEngine::GetText( sal_uInt16 nPara ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ XubString aStr;
+ if ( nPara < pImpEditEngine->GetEditDoc().Count() )
+ aStr = pImpEditEngine->GetEditDoc().GetParaAsString( nPara );
+ return aStr;
+}
+
+void EditEngine::SetModifyHdl( const Link& rLink )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetModifyHdl( rLink );
+}
+
+Link EditEngine::GetModifyHdl() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetModifyHdl();
+}
+
+
+void EditEngine::ClearModifyFlag()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetModifyFlag( sal_False );
+}
+
+void EditEngine::SetModified()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetModifyFlag( sal_True );
+}
+
+sal_Bool EditEngine::IsModified() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsModified();
+}
+
+sal_Bool EditEngine::IsInSelectionMode() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return ( pImpEditEngine->IsInSelectionMode() ||
+ pImpEditEngine->GetSelEngine().IsInSelection() );
+}
+
+void EditEngine::StopSelectionMode()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->StopSelectionMode();
+}
+
+void EditEngine::InsertParagraph( sal_uInt16 nPara, const EditTextObject& rTxtObj )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( nPara > GetParagraphCount() )
+ {
+ DBG_ASSERTWARNING( nPara == USHRT_MAX, "AbsatzNr zu Gro???, aber nicht LIST_APPEND! " );
+ nPara = GetParagraphCount();
+ }
+
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+
+ // Keine Undoklammerung noetig.
+ EditPaM aPaM( pImpEditEngine->InsertParagraph( nPara ) );
+ // Bei einem InsertParagraph von aussen sollen keine Harten
+ // Attribute uebernommen werden !
+ pImpEditEngine->RemoveCharAttribs( nPara );
+ pImpEditEngine->InsertText( rTxtObj, EditSelection( aPaM, aPaM ) );
+
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+
+ pImpEditEngine->FormatAndUpdate();
+}
+
+void EditEngine::InsertParagraph( sal_uInt16 nPara, const XubString& rTxt )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( nPara > GetParagraphCount() )
+ {
+ DBG_ASSERTWARNING( nPara == USHRT_MAX, "AbsatzNr zu Gro???, aber nicht LIST_APPEND! " );
+ nPara = GetParagraphCount();
+ }
+
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+ EditPaM aPaM( pImpEditEngine->InsertParagraph( nPara ) );
+ // Bei einem InsertParagraph von aussen sollen keine Harten
+ // Attribute uebernommen werden !
+ pImpEditEngine->RemoveCharAttribs( nPara );
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+ pImpEditEngine->ImpInsertText( EditSelection( aPaM, aPaM ), rTxt );
+ pImpEditEngine->FormatAndUpdate();
+}
+
+void EditEngine::SetText( sal_uInt16 nPara, const EditTextObject& rTxtObj )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection* pSel = pImpEditEngine->SelectParagraph( nPara );
+ if ( pSel )
+ {
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+ pImpEditEngine->InsertText( rTxtObj, *pSel );
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+ pImpEditEngine->FormatAndUpdate();
+ delete pSel;
+ }
+}
+
+void EditEngine::SetText( sal_uInt16 nPara, const XubString& rTxt )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection* pSel = pImpEditEngine->SelectParagraph( nPara );
+ if ( pSel )
+ {
+ pImpEditEngine->UndoActionStart( EDITUNDO_INSERT );
+ pImpEditEngine->ImpInsertText( *pSel, rTxt );
+ pImpEditEngine->UndoActionEnd( EDITUNDO_INSERT );
+ pImpEditEngine->FormatAndUpdate();
+ delete pSel;
+ }
+}
+
+void EditEngine::SetParaAttribs( sal_uInt16 nPara, const SfxItemSet& rSet )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ // Keine Undoklammerung noetig.
+ pImpEditEngine->SetParaAttribs( nPara, rSet );
+ pImpEditEngine->FormatAndUpdate();
+}
+
+const SfxItemSet& EditEngine::GetParaAttribs( sal_uInt16 nPara ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetParaAttribs( nPara );
+}
+
+sal_Bool EditEngine::HasParaAttrib( sal_uInt16 nPara, sal_uInt16 nWhich ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->HasParaAttrib( nPara, nWhich );
+}
+
+const SfxPoolItem& EditEngine::GetParaAttrib( sal_uInt16 nPara, sal_uInt16 nWhich )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetParaAttrib( nPara, nWhich );
+}
+
+void EditEngine::GetCharAttribs( sal_uInt16 nPara, EECharAttribArray& rLst ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->GetCharAttribs( nPara, rLst );
+}
+
+SfxItemSet EditEngine::GetAttribs( const ESelection& rSel, BOOL bOnlyHardAttrib )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+ return pImpEditEngine->GetAttribs( aSel, bOnlyHardAttrib );
+}
+
+SfxItemSet EditEngine::GetAttribs( USHORT nPara, USHORT nStart, USHORT nEnd, sal_uInt8 nFlags ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetAttribs( nPara, nStart, nEnd, nFlags );
+}
+
+void EditEngine::RemoveAttribs( const ESelection& rSelection, sal_Bool bRemoveParaAttribs, sal_uInt16 nWhich )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ pImpEditEngine->UndoActionStart( EDITUNDO_RESETATTRIBS );
+ EditSelection aSel( pImpEditEngine->ConvertSelection( rSelection.nStartPara, rSelection.nStartPos, rSelection.nEndPara, rSelection.nEndPos ) );
+ pImpEditEngine->RemoveCharAttribs( aSel, bRemoveParaAttribs, nWhich );
+ pImpEditEngine->UndoActionEnd( EDITUNDO_RESETATTRIBS );
+ pImpEditEngine->FormatAndUpdate();
+}
+
+// MT: Can be removed after 6.x?
+Font EditEngine::GetStandardFont( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return GetStandardSvxFont( nPara );
+}
+
+SvxFont EditEngine::GetStandardSvxFont( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ return pNode->GetCharAttribs().GetDefFont();
+}
+
+void EditEngine::StripPortions()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ VirtualDevice aTmpDev;
+ Rectangle aBigRec( Point( 0, 0 ), Size( 0x7FFFFFFF, 0x7FFFFFFF ) );
+ if ( IsVertical() )
+ {
+ aBigRec.Right() = 0;
+ aBigRec.Left() = -0x7FFFFFFF;
+ }
+ pImpEditEngine->Paint( &aTmpDev, aBigRec, Point(), sal_True );
+}
+
+void EditEngine::GetPortions( sal_uInt16 nPara, SvUShorts& rList )
+{
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatFullDoc();
+
+ ParaPortion* pParaPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nPara );
+ if ( pParaPortion )
+ {
+ sal_uInt16 nEnd = 0;
+ sal_uInt16 nTextPortions = pParaPortion->GetTextPortions().Count();
+ for ( sal_uInt16 n = 0; n < nTextPortions; n++ )
+ {
+ nEnd = nEnd + pParaPortion->GetTextPortions()[n]->GetLen();
+ rList.Insert( nEnd, rList.Count() );
+ }
+ }
+}
+
+void EditEngine::SetFlatMode( sal_Bool bFlat)
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetFlatMode( bFlat );
+}
+
+sal_Bool EditEngine::IsFlatMode() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return !( pImpEditEngine->aStatus.UseCharAttribs() );
+}
+
+void EditEngine::SetControlWord( sal_uInt32 nWord )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( nWord != pImpEditEngine->aStatus.GetControlWord() )
+ {
+ sal_uInt32 nPrev = pImpEditEngine->aStatus.GetControlWord();
+ pImpEditEngine->aStatus.GetControlWord() = nWord;
+
+ sal_uInt32 nChanges = nPrev ^ nWord;
+ if ( pImpEditEngine->IsFormatted() )
+ {
+ // ggf. neu formatieren:
+ if ( ( nChanges & EE_CNTRL_USECHARATTRIBS ) ||
+ ( nChanges & EE_CNTRL_USEPARAATTRIBS ) ||
+ ( nChanges & EE_CNTRL_ONECHARPERLINE ) ||
+ ( nChanges & EE_CNTRL_STRETCHING ) ||
+ ( nChanges & EE_CNTRL_OUTLINER ) ||
+ ( nChanges & EE_CNTRL_NOCOLORS ) ||
+ ( nChanges & EE_CNTRL_OUTLINER2 ) )
+ {
+ if ( ( nChanges & EE_CNTRL_USECHARATTRIBS ) ||
+ ( nChanges & EE_CNTRL_USEPARAATTRIBS ) )
+ {
+ sal_Bool bUseCharAttribs = ( nWord & EE_CNTRL_USECHARATTRIBS ) ? sal_True : sal_False;
+ pImpEditEngine->GetEditDoc().CreateDefFont( bUseCharAttribs );
+ }
+
+ pImpEditEngine->FormatFullDoc();
+ pImpEditEngine->UpdateViews( pImpEditEngine->GetActiveView() );
+ }
+ }
+
+ sal_Bool bSpellingChanged = nChanges & EE_CNTRL_ONLINESPELLING ? sal_True : sal_False;
+
+ if ( bSpellingChanged )
+ {
+ pImpEditEngine->StopOnlineSpellTimer();
+ if ( bSpellingChanged && ( nWord & EE_CNTRL_ONLINESPELLING ) )
+ {
+ // WrongListen anlegen, Timer starten...
+ sal_uInt16 nNodes = pImpEditEngine->GetEditDoc().Count();
+ for ( sal_uInt16 n = 0; n < nNodes; n++ )
+ {
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().GetObject( n );
+ pNode->CreateWrongList();
+ }
+ pImpEditEngine->StartOnlineSpellTimer();
+ }
+ else
+ {
+ long nY = 0;
+ sal_uInt16 nNodes = pImpEditEngine->GetEditDoc().Count();
+ for ( sal_uInt16 n = 0; n < nNodes; n++ )
+ {
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().GetObject( n );
+ ParaPortion* pPortion = pImpEditEngine->GetParaPortions().GetObject( n );
+ sal_Bool bWrongs = ( bSpellingChanged || ( nWord & EE_CNTRL_ONLINESPELLING ) ) ? pNode->GetWrongList()->HasWrongs() : sal_False;
+ if ( bSpellingChanged ) // Also aus
+ pNode->DestroyWrongList(); // => vorm Paint weghaun.
+ if ( bWrongs )
+ {
+ pImpEditEngine->aInvalidRec.Left() = 0;
+ pImpEditEngine->aInvalidRec.Right() = pImpEditEngine->GetPaperSize().Width();
+ pImpEditEngine->aInvalidRec.Top() = nY+1;
+ pImpEditEngine->aInvalidRec.Bottom() = nY+pPortion->GetHeight()-1;
+ pImpEditEngine->UpdateViews( pImpEditEngine->pActiveView );
+ }
+ nY += pPortion->GetHeight();
+ }
+ }
+ }
+ }
+}
+
+sal_uInt32 EditEngine::GetControlWord() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->aStatus.GetControlWord();
+}
+
+long EditEngine::GetFirstLineStartX( sal_uInt16 nParagraph )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ long nX = 0;
+ ParaPortion* pPPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nParagraph );
+ if ( pPPortion )
+ {
+ DBG_ASSERT( pImpEditEngine->IsFormatted() || !pImpEditEngine->IsFormatting(), "GetFirstLineStartX: Doc not formatted - unable to format!" );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+ EditLine* pFirstLine = pPPortion->GetLines()[0];
+ nX = pFirstLine->GetStartPosX();
+ }
+ return nX;
+}
+
+Point EditEngine::GetDocPos( const Point& rPaperPos ) const
+{
+ Point aDocPos( rPaperPos );
+ if ( IsVertical() )
+ {
+ aDocPos.X() = rPaperPos.Y();
+ aDocPos.Y() = GetPaperSize().Width() - rPaperPos.X();
+ }
+ return aDocPos;
+}
+
+Point EditEngine::GetDocPosTopLeft( sal_uInt16 nParagraph )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ ParaPortion* pPPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nParagraph );
+ DBG_ASSERT( pPPortion, "Absatz nicht gefunden: GetWindowPosTopLeft" );
+ Point aPoint;
+ if ( pPPortion )
+ {
+ // Falls jemand mit einer leeren Engine ein GetLineHeight() macht.
+ DBG_ASSERT( pImpEditEngine->IsFormatted() || !pImpEditEngine->IsFormatting(), "GetDocPosTopLeft: Doc not formatted - unable to format!" );
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatAndUpdate();
+ if ( pPPortion->GetLines().Count() )
+ {
+ // So richtiger, falls grosses Bullet.
+ EditLine* pFirstLine = pPPortion->GetLines()[0];
+ aPoint.X() = pFirstLine->GetStartPosX();
+ }
+ else
+ {
+ const SvxLRSpaceItem& rLRItem = pImpEditEngine->GetLRSpaceItem( pPPortion->GetNode() );
+// TL_NF_LR aPoint.X() = pImpEditEngine->GetXValue( (short)(rLRItem.GetTxtLeft() + rLRItem.GetTxtFirstLineOfst()) );
+ sal_Int32 nSpaceBefore = 0;
+ pImpEditEngine->GetSpaceBeforeAndMinLabelWidth( pPPortion->GetNode(), &nSpaceBefore );
+ short nX = (short)(rLRItem.GetTxtLeft()
+ + rLRItem.GetTxtFirstLineOfst()
+ + nSpaceBefore);
+ aPoint.X() = pImpEditEngine->GetXValue( nX
+ );
+ }
+ aPoint.Y() = pImpEditEngine->GetParaPortions().GetYOffset( pPPortion );
+ }
+ return aPoint;
+}
+
+const SvxNumberFormat* EditEngine::GetNumberFormat( USHORT nPara ) const
+{
+ // derived objects may overload this function to give access to
+ // bullet information (see Outliner)
+ (void) nPara;
+ return 0;
+}
+
+BOOL EditEngine::IsRightToLeft( USHORT nPara ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->IsRightToLeft( nPara );
+}
+
+sal_Bool EditEngine::IsTextPos( const Point& rPaperPos, sal_uInt16 nBorder )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+
+ sal_Bool bTextPos = sal_False;
+ // #90780# take unrotated positions for calculation here
+ Point aDocPos = GetDocPos( rPaperPos );
+
+ if ( ( aDocPos.Y() > 0 ) && ( aDocPos.Y() < (long)pImpEditEngine->GetTextHeight() ) )
+ {
+ EditPaM aPaM = pImpEditEngine->GetPaM( aDocPos, sal_False );
+ if ( aPaM.GetNode() )
+ {
+ ParaPortion* pParaPortion = pImpEditEngine->FindParaPortion( aPaM.GetNode() );
+ DBG_ASSERT( pParaPortion, "ParaPortion?" );
+
+ sal_uInt16 nLine = pParaPortion->GetLineNumber( aPaM.GetIndex() );
+ EditLine* pLine = pParaPortion->GetLines().GetObject( nLine );
+ Range aLineXPosStartEnd = pImpEditEngine->GetLineXPosStartEnd( pParaPortion, pLine );
+ if ( ( aDocPos.X() >= aLineXPosStartEnd.Min() - nBorder ) &&
+ ( aDocPos.X() <= aLineXPosStartEnd.Max() + nBorder ) )
+ {
+ bTextPos = sal_True;
+ }
+ }
+ }
+ return bTextPos;
+}
+
+void EditEngine::SetEditTextObjectPool( SfxItemPool* pPool )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetEditTextObjectPool( pPool );
+}
+
+SfxItemPool* EditEngine::GetEditTextObjectPool() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetEditTextObjectPool();
+}
+
+void EditEngine::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+
+ pImpEditEngine->SetAttribs( aSel, rSet );
+}
+
+void EditEngine::QuickMarkInvalid( const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( rSel.nStartPara < pImpEditEngine->GetEditDoc().Count(), "MarkInvalid: Start out of Range!" );
+ DBG_ASSERT( rSel.nEndPara < pImpEditEngine->GetEditDoc().Count(), "MarkInvalid: End out of Range!" );
+ for ( sal_uInt16 nPara = rSel.nStartPara; nPara <= rSel.nEndPara; nPara++ )
+ {
+ ParaPortion* pPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nPara );
+ if ( pPortion )
+ pPortion->MarkSelectionInvalid( 0, pPortion->GetNode()->Len() );
+ }
+}
+
+void EditEngine::QuickInsertText( const XubString& rText, const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+
+ pImpEditEngine->ImpInsertText( aSel, rText );
+}
+
+void EditEngine::QuickDelete( const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+
+ pImpEditEngine->ImpDeleteSelection( aSel );
+}
+
+void EditEngine::QuickMarkToBeRepainted( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ ParaPortion* pPortion = pImpEditEngine->GetParaPortions().SaveGetObject( nPara );
+ if ( pPortion )
+ pPortion->SetMustRepaint( sal_True );
+}
+
+void EditEngine::QuickInsertLineBreak( const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+
+ pImpEditEngine->InsertLineBreak( aSel );
+}
+
+void EditEngine::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ EditSelection aSel( pImpEditEngine->
+ ConvertSelection( rSel.nStartPara, rSel.nStartPos, rSel.nEndPara, rSel.nEndPos ) );
+
+ pImpEditEngine->ImpInsertFeature( aSel, rFld );
+}
+
+void EditEngine::QuickFormatDoc( sal_Bool bFull )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( bFull )
+ pImpEditEngine->FormatFullDoc();
+ else
+ pImpEditEngine->FormatDoc();
+
+ // #111072# Don't pass active view, maybe selection is not updated yet...
+ pImpEditEngine->UpdateViews( NULL );
+}
+
+void EditEngine::QuickRemoveCharAttribs( sal_uInt16 nPara, sal_uInt16 nWhich )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->RemoveCharAttribs( nPara, nWhich );
+}
+
+void EditEngine::SetStyleSheet( sal_uInt16 nPara, SfxStyleSheet* pStyle )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetStyleSheet( nPara, pStyle );
+}
+
+SfxStyleSheet* EditEngine::GetStyleSheet( sal_uInt16 nPara ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetStyleSheet( nPara );
+}
+
+void EditEngine::SetStyleSheetPool( SfxStyleSheetPool* pSPool )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetStyleSheetPool( pSPool );
+}
+
+SfxStyleSheetPool* EditEngine::GetStyleSheetPool()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetStyleSheetPool();
+}
+
+void EditEngine::SetWordDelimiters( const XubString& rDelimiters )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->aWordDelimiters = rDelimiters;
+ if ( pImpEditEngine->aWordDelimiters.Search( CH_FEATURE ) == STRING_NOTFOUND )
+ pImpEditEngine->aWordDelimiters.Insert( CH_FEATURE );
+}
+
+XubString EditEngine::GetWordDelimiters() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->aWordDelimiters;
+}
+
+void EditEngine::SetGroupChars( const XubString& rChars )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ DBG_ASSERT( ( rChars.Len() % 2 ) == 0, "SetGroupChars: Ungerade Anzahl!" );
+ pImpEditEngine->aGroupChars = rChars;
+}
+
+XubString EditEngine::GetGroupChars() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->aGroupChars;
+}
+
+void EditEngine::EnablePasteSpecial( sal_Bool bEnable )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( bEnable )
+ pImpEditEngine->GetStatus().TurnOnFlags( EE_CNTRL_PASTESPECIAL );
+ else
+ pImpEditEngine->GetStatus().TurnOffFlags( EE_CNTRL_PASTESPECIAL );
+}
+
+sal_Bool EditEngine::IsPasteSpecialEnabled() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetStatus().AllowPasteSpecial();
+}
+
+void EditEngine::EnableIdleFormatter( sal_Bool bEnable )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( bEnable )
+ pImpEditEngine->GetStatus().TurnOnFlags( EE_CNTRL_DOIDLEFORMAT );
+ else
+ pImpEditEngine->GetStatus().TurnOffFlags( EE_CNTRL_DOIDLEFORMAT);
+}
+
+sal_Bool EditEngine::IsIdleFormatterEnabled() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetStatus().UseIdleFormatter();
+}
+
+void EditEngine::EraseVirtualDevice()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->EraseVirtualDevice();
+}
+
+void EditEngine::SetSpeller( Reference< XSpellChecker1 > &xSpeller )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetSpeller( xSpeller );
+}
+Reference< XSpellChecker1 > EditEngine::GetSpeller()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetSpeller();
+}
+Reference< XHyphenator > EditEngine::GetHyphenator() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetHyphenator();
+}
+
+void EditEngine::SetHyphenator( Reference< XHyphenator > & xHyph )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetHyphenator( xHyph );
+}
+
+void EditEngine::SetForbiddenCharsTable( vos::ORef<SvxForbiddenCharactersTable> xForbiddenChars )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetForbiddenCharsTable( xForbiddenChars );
+}
+
+vos::ORef<SvxForbiddenCharactersTable> EditEngine::GetForbiddenCharsTable() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetForbiddenCharsTable( FALSE );
+}
+
+
+void EditEngine::SetDefaultLanguage( LanguageType eLang )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetDefaultLanguage( eLang );
+}
+
+LanguageType EditEngine::GetDefaultLanguage() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetDefaultLanguage();
+}
+
+sal_Bool __EXPORT EditEngine::SpellNextDocument()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return sal_False;
+}
+
+EESpellState EditEngine::HasSpellErrors()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( !pImpEditEngine->GetSpeller().is() )
+ return EE_SPELL_NOSPELLER;
+
+ return pImpEditEngine->HasSpellErrors();
+}
+/*-- 13.10.2003 16:56:23---------------------------------------------------
+
+ -----------------------------------------------------------------------*/
+void EditEngine::StartSpelling(EditView& rEditView, sal_Bool bMultipleDoc)
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->StartSpelling(rEditView, bMultipleDoc);
+}
+/*-- 13.10.2003 16:56:23---------------------------------------------------
+
+ -----------------------------------------------------------------------*/
+void EditEngine::EndSpelling()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->EndSpelling();
+}
+
+/*-- 13.10.2003 16:43:27---------------------------------------------------
+
+ -----------------------------------------------------------------------*/
+bool EditEngine::SpellSentence(EditView& rView, ::svx::SpellPortions& rToFill, bool bIsGrammarChecking )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->SpellSentence( rView, rToFill, bIsGrammarChecking );
+}
+/*-- 08.09.2008 11:38:32---------------------------------------------------
+
+ -----------------------------------------------------------------------*/
+void EditEngine::PutSpellingToSentenceStart( EditView& rEditView )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->PutSpellingToSentenceStart( rEditView );
+}
+/*-- 13.10.2003 16:43:27---------------------------------------------------
+
+ -----------------------------------------------------------------------*/
+void EditEngine::ApplyChangedSentence(EditView& rEditView, const ::svx::SpellPortions& rNewPortions, bool bIsGrammarChecking )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->ApplyChangedSentence( rEditView, rNewPortions, bIsGrammarChecking );
+}
+
+sal_Bool EditEngine::HasConvertibleTextPortion( LanguageType nLang )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->HasConvertibleTextPortion( nLang );
+}
+
+sal_Bool __EXPORT EditEngine::ConvertNextDocument()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return sal_False;
+}
+
+sal_Bool EditEngine::HasText( const SvxSearchItem& rSearchItem )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->HasText( rSearchItem );
+}
+
+void EditEngine::SetGlobalCharStretching( sal_uInt16 nX, sal_uInt16 nY )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetCharStretching( nX, nY );
+}
+
+void EditEngine::GetGlobalCharStretching( sal_uInt16& rX, sal_uInt16& rY )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->GetCharStretching( rX, rY );
+}
+
+void EditEngine::DoStretchChars( sal_uInt16 nX, sal_uInt16 nY )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->DoStretchChars( nX, nY );
+}
+
+void EditEngine::SetBigTextObjectStart( sal_uInt16 nStartAtPortionCount )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ pImpEditEngine->SetBigTextObjectStart( nStartAtPortionCount );
+}
+
+sal_uInt16 EditEngine::GetBigTextObjectStart() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return pImpEditEngine->GetBigTextObjectStart();
+}
+
+sal_Bool EditEngine::ShouldCreateBigTextObject() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ sal_uInt16 nTextPortions = 0;
+ sal_uInt16 nParas = pImpEditEngine->GetEditDoc().Count();
+ for ( sal_uInt16 nPara = 0; nPara < nParas; nPara++ )
+ {
+ ParaPortion* pParaPortion = pImpEditEngine->GetParaPortions()[nPara];
+ nTextPortions = nTextPortions + pParaPortion->GetTextPortions().Count();
+ }
+ return ( nTextPortions >= pImpEditEngine->GetBigTextObjectStart() ) ? sal_True : sal_False;
+}
+
+USHORT EditEngine::GetFieldCount( USHORT nPara ) const
+{
+ USHORT nFields = 0;
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ if ( pNode )
+ {
+ const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
+ for ( sal_uInt16 nAttr = 0; nAttr < rAttrs.Count(); nAttr++ )
+ {
+ EditCharAttrib* pAttr = rAttrs[nAttr];
+ if ( pAttr->Which() == EE_FEATURE_FIELD )
+ nFields++;
+ }
+ }
+
+ return nFields;
+}
+
+EFieldInfo EditEngine::GetFieldInfo( USHORT nPara, USHORT nField ) const
+{
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( nPara );
+ if ( pNode )
+ {
+ USHORT nCurrentField = 0;
+ const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
+ for ( sal_uInt16 nAttr = 0; nAttr < rAttrs.Count(); nAttr++ )
+ {
+ EditCharAttrib* pAttr = rAttrs[nAttr];
+ if ( pAttr->Which() == EE_FEATURE_FIELD )
+ {
+ if ( nCurrentField == nField )
+ {
+ EFieldInfo aInfo( *(const SvxFieldItem*)pAttr->GetItem(), nPara, pAttr->GetStart() );
+ aInfo.aCurrentText = ((EditCharAttribField*)pAttr)->GetFieldValue();
+ return aInfo;
+ }
+
+ nCurrentField++;
+ }
+ }
+ }
+ return EFieldInfo();
+}
+
+
+sal_Bool EditEngine::UpdateFields()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ sal_Bool bChanges = pImpEditEngine->UpdateFields();
+ if ( bChanges )
+ pImpEditEngine->FormatAndUpdate();
+ return bChanges;
+}
+
+void EditEngine::RemoveFields( sal_Bool bKeepFieldText, TypeId aType )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( bKeepFieldText )
+ pImpEditEngine->UpdateFields();
+
+ sal_uInt16 nParas = pImpEditEngine->GetEditDoc().Count();
+ for ( sal_uInt16 nPara = 0; nPara < nParas; nPara++ )
+ {
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().GetObject( nPara );
+ const CharAttribArray& rAttrs = pNode->GetCharAttribs().GetAttribs();
+ for ( sal_uInt16 nAttr = rAttrs.Count(); nAttr; )
+ {
+ const EditCharAttrib* pAttr = rAttrs[--nAttr];
+ if ( pAttr->Which() == EE_FEATURE_FIELD )
+ {
+ const SvxFieldData* pFldData = ((const SvxFieldItem*)pAttr->GetItem())->GetField();
+ if ( pFldData && ( !aType || ( pFldData->IsA( aType ) ) ) )
+ {
+ DBG_ASSERT( pAttr->GetItem()->ISA( SvxFieldItem ), "Kein FeldItem..." );
+ EditSelection aSel( EditPaM( pNode, pAttr->GetStart() ), EditPaM( pNode, pAttr->GetEnd() ) );
+ String aFieldText = ((EditCharAttribField*)pAttr)->GetFieldValue();
+ pImpEditEngine->ImpInsertText( aSel, aFieldText );
+ }
+ }
+ }
+ }
+}
+
+sal_Bool EditEngine::HasOnlineSpellErrors() const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ sal_uInt16 nNodes = pImpEditEngine->GetEditDoc().Count();
+ for ( sal_uInt16 n = 0; n < nNodes; n++ )
+ {
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().GetObject( n );
+ if ( pNode->GetWrongList() && pNode->GetWrongList()->Count() )
+ return sal_True;
+ }
+ return sal_False;
+}
+
+void EditEngine::CompleteOnlineSpelling()
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ if ( pImpEditEngine->GetStatus().DoOnlineSpelling() )
+ {
+ if( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatAndUpdate();
+
+ pImpEditEngine->StopOnlineSpellTimer();
+ pImpEditEngine->DoOnlineSpelling( 0, sal_True, sal_False );
+ }
+}
+
+USHORT EditEngine::FindParagraph( long nDocPosY )
+{
+ return pImpEditEngine->GetParaPortions().FindParagraph( nDocPosY );
+}
+
+EPosition EditEngine::FindDocPosition( const Point& rDocPos ) const
+{
+ EPosition aPos;
+ // From the point of the API, this is const....
+ EditPaM aPaM = ((EditEngine*)this)->pImpEditEngine->GetPaM( rDocPos, FALSE );
+ if ( aPaM.GetNode() )
+ {
+ aPos.nPara = pImpEditEngine->aEditDoc.GetPos( aPaM.GetNode() );
+ aPos.nIndex = aPaM.GetIndex();
+ }
+ return aPos;
+}
+
+Rectangle EditEngine::GetCharacterBounds( const EPosition& rPos ) const
+{
+ Rectangle aBounds;
+ ContentNode* pNode = pImpEditEngine->GetEditDoc().SaveGetObject( rPos.nPara );
+
+ // #109151# Check against index, not paragraph
+ if ( pNode && ( rPos.nIndex < pNode->Len() ) )
+ {
+ aBounds = pImpEditEngine->PaMtoEditCursor( EditPaM( pNode, rPos.nIndex ), GETCRSR_TXTONLY );
+ Rectangle aR2 = pImpEditEngine->PaMtoEditCursor( EditPaM( pNode, rPos.nIndex+1 ), GETCRSR_TXTONLY|GETCRSR_ENDOFLINE );
+ if ( aR2.Right() > aBounds.Right() )
+ aBounds.Right() = aR2.Right();
+ }
+ return aBounds;
+}
+
+ParagraphInfos EditEngine::GetParagraphInfos( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ // Funktioniert nur, wenn nicht bereits in der Formatierung...
+ if ( !pImpEditEngine->IsFormatted() )
+ pImpEditEngine->FormatDoc();
+
+ ParagraphInfos aInfos;
+ aInfos.bValid = pImpEditEngine->IsFormatted();
+ if ( pImpEditEngine->IsFormatted() )
+ {
+ ParaPortion* pParaPortion = pImpEditEngine->GetParaPortions()[nPara];
+ EditLine* pLine = (pParaPortion && pParaPortion->GetLines().Count()) ?
+ pParaPortion->GetLines().GetObject( 0 ) : NULL;
+ DBG_ASSERT( pParaPortion && pLine, "GetParagraphInfos - Paragraph out of range" );
+ if ( pParaPortion && pLine )
+ {
+ aInfos.nParaHeight = (USHORT)pParaPortion->GetHeight();
+ aInfos.nLines = pParaPortion->GetLines().Count();
+ aInfos.nFirstLineStartX = pLine->GetStartPosX();
+ aInfos.nFirstLineOffset = pParaPortion->GetFirstLineOffset();
+ aInfos.nFirstLineHeight = pLine->GetHeight();
+ aInfos.nFirstLineTextHeight = pLine->GetTxtHeight();
+ aInfos.nFirstLineMaxAscent = pLine->GetMaxAscent();
+ }
+ }
+ return aInfos;
+}
+
+::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >
+ EditEngine::CreateTransferable( const ESelection& rSelection ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ EditSelection aSel( pImpEditEngine->CreateSel( rSelection ) );
+ return pImpEditEngine->CreateTransferable( aSel );
+}
+
+// =====================================================================
+// ====================== Virtuelle Methoden =======================
+// =====================================================================
+void __EXPORT EditEngine::DrawingText( const Point&, const XubString&, USHORT, USHORT,
+ const sal_Int32*, const SvxFont&, sal_uInt16, sal_uInt16, BYTE,
+ const EEngineData::WrongSpellVector*, const SvxFieldData*, bool, bool, bool,
+ const ::com::sun::star::lang::Locale*, const Color&, const Color&)
+
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+void __EXPORT EditEngine::PaintingFirstLine( sal_uInt16, const Point&, long, const Point&, short, OutputDevice* )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+void __EXPORT EditEngine::ParagraphInserted( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( GetNotifyHdl().IsSet() )
+ {
+ EENotify aNotify( EE_NOTIFY_PARAGRAPHINSERTED );
+ aNotify.pEditEngine = this;
+ aNotify.nParagraph = nPara;
+ pImpEditEngine->CallNotify( aNotify );
+ }
+}
+
+void __EXPORT EditEngine::ParagraphDeleted( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( GetNotifyHdl().IsSet() )
+ {
+ EENotify aNotify( EE_NOTIFY_PARAGRAPHREMOVED );
+ aNotify.pEditEngine = this;
+ aNotify.nParagraph = nPara;
+ pImpEditEngine->CallNotify( aNotify );
+ }
+}
+void EditEngine::ParagraphConnected( USHORT /*nLeftParagraph*/, USHORT /*nRightParagraph*/ )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+sal_Bool __EXPORT EditEngine::FormattingParagraph( sal_uInt16 )
+{
+ // return sal_True, wenn die Attribute geaendert wurden...
+ DBG_CHKTHIS( EditEngine, 0 );
+ return sal_False;
+}
+
+void __EXPORT EditEngine::ParaAttribsChanged( sal_uInt16 /* nParagraph */ )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+void __EXPORT EditEngine::StyleSheetChanged( SfxStyleSheet* /* pStyle */ )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+void __EXPORT EditEngine::ParagraphHeightChanged( sal_uInt16 nPara )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+
+ if ( GetNotifyHdl().IsSet() )
+ {
+ EENotify aNotify( EE_NOTIFY_TEXTHEIGHTCHANGED );
+ aNotify.pEditEngine = this;
+ aNotify.nParagraph = nPara;
+ pImpEditEngine->CallNotify( aNotify );
+ }
+}
+
+XubString __EXPORT EditEngine::GetUndoComment( sal_uInt16 nId ) const
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ XubString aComment;
+ switch ( nId )
+ {
+ case EDITUNDO_REMOVECHARS:
+ case EDITUNDO_CONNECTPARAS:
+ case EDITUNDO_REMOVEFEATURE:
+ case EDITUNDO_DELCONTENT:
+ case EDITUNDO_DELETE:
+ case EDITUNDO_CUT:
+ aComment = XubString( EditResId( RID_EDITUNDO_DEL ) );
+ break;
+ case EDITUNDO_MOVEPARAGRAPHS:
+ case EDITUNDO_MOVEPARAS:
+ case EDITUNDO_DRAGANDDROP:
+ aComment = XubString( EditResId( RID_EDITUNDO_MOVE ) );
+ break;
+ case EDITUNDO_INSERTFEATURE:
+ case EDITUNDO_SPLITPARA:
+ case EDITUNDO_INSERTCHARS:
+ case EDITUNDO_PASTE:
+ case EDITUNDO_INSERT:
+ case EDITUNDO_READ:
+ aComment = XubString( EditResId( RID_EDITUNDO_INSERT ) );
+ break;
+ case EDITUNDO_SRCHANDREPL:
+ case EDITUNDO_REPLACEALL:
+ aComment = XubString( EditResId( RID_EDITUNDO_REPLACE ) );
+ break;
+ case EDITUNDO_ATTRIBS:
+ case EDITUNDO_PARAATTRIBS:
+ case EDITUNDO_STRETCH:
+ aComment = XubString( EditResId( RID_EDITUNDO_SETATTRIBS ) );
+ break;
+ case EDITUNDO_RESETATTRIBS:
+ aComment = XubString( EditResId( RID_EDITUNDO_RESETATTRIBS ) );
+ break;
+ case EDITUNDO_STYLESHEET:
+ aComment = XubString( EditResId( RID_EDITUNDO_SETSTYLE ) );
+ break;
+ case EDITUNDO_TRANSLITERATE:
+ aComment = XubString( EditResId( RID_EDITUNDO_TRANSLITERATE ) );
+ break;
+ case EDITUNDO_INDENTBLOCK:
+ case EDITUNDO_UNINDENTBLOCK:
+ aComment = XubString( EditResId( RID_EDITUNDO_INDENT ) );
+ break;
+ }
+ return aComment;
+}
+
+Rectangle EditEngine::GetBulletArea( sal_uInt16 )
+{
+ return Rectangle( Point(), Point() );
+}
+
+XubString __EXPORT EditEngine::CalcFieldValue( const SvxFieldItem&, sal_uInt16, sal_uInt16, Color*&, Color*& )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+ return ' ';
+}
+
+void __EXPORT EditEngine::FieldClicked( const SvxFieldItem&, sal_uInt16, sal_uInt16 )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+void __EXPORT EditEngine::FieldSelected( const SvxFieldItem&, sal_uInt16, sal_uInt16 )
+{
+ DBG_CHKTHIS( EditEngine, 0 );
+}
+
+ // =====================================================================
+// ====================== Statische Methoden =======================
+// =====================================================================
+SfxItemPool* EditEngine::CreatePool( sal_Bool bPersistentRefCounts )
+{
+ SfxItemPool* pPool = new EditEngineItemPool( bPersistentRefCounts );
+ return pPool;
+}
+
+SfxItemPool& EditEngine::GetGlobalItemPool()
+{
+ if ( !pGlobalPool )
+ pGlobalPool = CreatePool();
+ return *pGlobalPool;
+}
+
+sal_uInt32 EditEngine::RegisterClipboardFormatName()
+{
+ static sal_uInt32 nFormat = 0;
+ if ( !nFormat )
+ nFormat = SotExchange::RegisterFormatName( String( RTL_CONSTASCII_USTRINGPARAM( "EditEngineFormat" ) ) );
+ return nFormat;
+}
+
+sal_uInt16 EditEngine::GetAvailableSearchOptions()
+{
+ return SEARCH_OPTIONS_SEARCH | SEARCH_OPTIONS_REPLACE |
+ SEARCH_OPTIONS_REPLACE_ALL | SEARCH_OPTIONS_WHOLE_WORDS |
+ SEARCH_OPTIONS_BACKWARDS | SEARCH_OPTIONS_REG_EXP |
+ SEARCH_OPTIONS_EXACT | SEARCH_OPTIONS_SELECTION;
+}
+
+void EditEngine::SetFontInfoInItemSet( SfxItemSet& rSet, const Font& rFont )
+{
+ SvxFont aSvxFont( rFont );
+ SetFontInfoInItemSet( rSet, aSvxFont );
+
+}
+
+void EditEngine::SetFontInfoInItemSet( SfxItemSet& rSet, const SvxFont& rFont )
+{
+ rSet.Put( SvxLanguageItem( rFont.GetLanguage(), EE_CHAR_LANGUAGE ) );
+ rSet.Put( SvxFontItem( rFont.GetFamily(), rFont.GetName(), XubString(), rFont.GetPitch(), rFont.GetCharSet(), EE_CHAR_FONTINFO ) );
+ rSet.Put( SvxFontHeightItem( rFont.GetSize().Height(), 100, EE_CHAR_FONTHEIGHT ) );
+ rSet.Put( SvxCharScaleWidthItem( 100, EE_CHAR_FONTWIDTH ) );
+ rSet.Put( SvxShadowedItem( rFont.IsShadow(), EE_CHAR_SHADOW ) );
+ rSet.Put( SvxEscapementItem( rFont.GetEscapement(), rFont.GetPropr(), EE_CHAR_ESCAPEMENT ) );
+ rSet.Put( SvxWeightItem( rFont.GetWeight(), EE_CHAR_WEIGHT ) );
+ rSet.Put( SvxColorItem( rFont.GetColor(), EE_CHAR_COLOR ) );
+ rSet.Put( SvxUnderlineItem( rFont.GetUnderline(), EE_CHAR_UNDERLINE ) );
+ rSet.Put( SvxOverlineItem( rFont.GetOverline(), EE_CHAR_OVERLINE ) );
+ rSet.Put( SvxCrossedOutItem( rFont.GetStrikeout(), EE_CHAR_STRIKEOUT ) );
+ rSet.Put( SvxPostureItem( rFont.GetItalic(), EE_CHAR_ITALIC ) );
+ rSet.Put( SvxContourItem( rFont.IsOutline(), EE_CHAR_OUTLINE ) );
+ rSet.Put( SvxAutoKernItem( rFont.IsKerning(), EE_CHAR_PAIRKERNING ) );
+ rSet.Put( SvxKerningItem( rFont.GetFixKerning(), EE_CHAR_KERNING ) );
+ rSet.Put( SvxWordLineModeItem( rFont.IsWordLineMode(), EE_CHAR_WLM ) );
+ rSet.Put( SvxEmphasisMarkItem( rFont.GetEmphasisMark(), EE_CHAR_EMPHASISMARK ) );
+ rSet.Put( SvxCharReliefItem( rFont.GetRelief(), EE_CHAR_RELIEF ) );
+}
+
+Font EditEngine::CreateFontFromItemSet( const SfxItemSet& rItemSet, USHORT nScriptType )
+{
+ SvxFont aFont;
+ CreateFont( aFont, rItemSet, true, nScriptType );
+ return aFont;
+}
+
+// Maybe we can remove the next two methods, check after 6.x
+Font EditEngine::CreateFontFromItemSet( const SfxItemSet& rItemSet )
+{
+ return CreateSvxFontFromItemSet( rItemSet );
+}
+
+SvxFont EditEngine::CreateSvxFontFromItemSet( const SfxItemSet& rItemSet )
+{
+ SvxFont aFont;
+ CreateFont( aFont, rItemSet );
+ return aFont;
+}
+
+sal_Bool EditEngine::DoesKeyMoveCursor( const KeyEvent& rKeyEvent )
+{
+ sal_Bool bDoesMove = sal_False;
+
+ switch ( rKeyEvent.GetKeyCode().GetCode() )
+ {
+ case KEY_UP:
+ case KEY_DOWN:
+ case KEY_LEFT:
+ case KEY_RIGHT:
+ case KEY_HOME:
+ case KEY_END:
+ case KEY_PAGEUP:
+ case KEY_PAGEDOWN:
+ {
+ if ( !rKeyEvent.GetKeyCode().IsMod2() )
+ bDoesMove = sal_True;
+ }
+ break;
+ }
+ return bDoesMove;
+}
+
+sal_Bool EditEngine::DoesKeyChangeText( const KeyEvent& rKeyEvent )
+{
+ sal_Bool bDoesChange = sal_False;
+
+ KeyFuncType eFunc = rKeyEvent.GetKeyCode().GetFunction();
+ if ( eFunc != KEYFUNC_DONTKNOW )
+ {
+ switch ( eFunc )
+ {
+ case KEYFUNC_UNDO:
+ case KEYFUNC_REDO:
+ case KEYFUNC_CUT:
+ case KEYFUNC_PASTE: bDoesChange = sal_True;
+ break;
+ default: // wird dann evtl. unten bearbeitet.
+ eFunc = KEYFUNC_DONTKNOW;
+ }
+ }
+ if ( eFunc == KEYFUNC_DONTKNOW )
+ {
+ switch ( rKeyEvent.GetKeyCode().GetCode() )
+ {
+ case KEY_DELETE:
+ case KEY_BACKSPACE: bDoesChange = sal_True;
+ break;
+ case KEY_RETURN:
+ case KEY_TAB:
+ {
+ if ( !rKeyEvent.GetKeyCode().IsMod1() && !rKeyEvent.GetKeyCode().IsMod2() )
+ bDoesChange = sal_True;
+ }
+ break;
+ default:
+ {
+ bDoesChange = IsSimpleCharInput( rKeyEvent );
+ }
+ }
+ }
+ return bDoesChange;
+}
+
+sal_Bool EditEngine::IsSimpleCharInput( const KeyEvent& rKeyEvent )
+{
+ if( EditEngine::IsPrintable( rKeyEvent.GetCharCode() ) &&
+ ( KEY_MOD2 != (rKeyEvent.GetKeyCode().GetModifier() & ~KEY_SHIFT ) ) &&
+ ( KEY_MOD1 != (rKeyEvent.GetKeyCode().GetModifier() & ~KEY_SHIFT ) ) )
+ {
+ return sal_True;
+ }
+ return sal_False;
+}
+
+// Mal in den Outliner schieben...
+void EditEngine::ImportBulletItem( SvxNumBulletItem& /*rNumBullet*/, sal_uInt16 /*nLevel*/,
+ const SvxBulletItem* /*pOldBullet*/, const SvxLRSpaceItem* /*pOldLRSpace*/ )
+{
+/* TL_NFLR
+ if ( pOldBullet || pOldLRSpace )
+ {
+ // Numberformat dynamisch, weil Zuweisungsoperator nicht implementiert.
+
+ // Altes NumBulletItem nur uebernehmen, wenn kein altes BulletItem
+ const SvxNumberFormat* pFmt = ( !pOldBullet && ( rNumBullet.GetNumRule()->GetLevelCount() > nLevel ) ) ?
+ rNumBullet.GetNumRule()->Get( nLevel ) : NULL;
+ SvxNumberFormat* pNumberFormat = pFmt
+ ? new SvxNumberFormat( *pFmt )
+ : new SvxNumberFormat( SVX_NUM_NUMBER_NONE );
+ if ( pOldBullet )
+ {
+ // Style
+ SvxExtNumType eNumType;
+ switch( pOldBullet->GetStyle() )
+ {
+ case BS_BMP: eNumType = SVX_NUM_BITMAP; break;
+ case BS_BULLET: eNumType = SVX_NUM_CHAR_SPECIAL; break;
+ case BS_ROMAN_BIG: eNumType = SVX_NUM_ROMAN_UPPER; break;
+ case BS_ROMAN_SMALL: eNumType = SVX_NUM_ROMAN_LOWER; break;
+ case BS_ABC_BIG: eNumType = SVX_NUM_CHARS_UPPER_LETTER; break;
+ case BS_ABC_SMALL: eNumType = SVX_NUM_CHARS_LOWER_LETTER; break;
+ case BS_123: eNumType = SVX_NUM_ARABIC; break;
+ default: eNumType = SVX_NUM_NUMBER_NONE; break;
+ }
+ pNumberFormat->SetNumberingType(
+ sal::static_int_cast< sal_Int16 >( eNumType ) );
+
+ // Justification
+ SvxAdjust eAdjust;
+ switch( pOldBullet->GetJustification() & (BJ_HRIGHT|BJ_HCENTER|BJ_HLEFT) )
+ {
+ case BJ_HRIGHT: eAdjust = SVX_ADJUST_RIGHT; break;
+ case BJ_HCENTER: eAdjust = SVX_ADJUST_CENTER; break;
+ default: eAdjust = SVX_ADJUST_LEFT; break;
+ }
+ pNumberFormat->SetNumAdjust(eAdjust);
+
+ // Prefix/Suffix
+ pNumberFormat->SetPrefix( pOldBullet->GetPrevText() );
+ pNumberFormat->SetSuffix( pOldBullet->GetFollowText() );
+
+ //Font
+ if ( eNumType != SVX_NUM_BITMAP )
+ {
+ Font aTmpFont = pOldBullet->GetFont();
+ pNumberFormat->SetBulletFont( &aTmpFont );
+ }
+
+ // Color
+ pNumberFormat->SetBulletColor( pOldBullet->GetFont().GetColor() );
+
+ // Start
+ pNumberFormat->SetStart( pOldBullet->GetStart() );
+
+ // Scale
+ pNumberFormat->SetBulletRelSize( pOldBullet->GetScale() );
+
+ // Bullet/Bitmap
+ if( eNumType == SVX_NUM_CHAR_SPECIAL )
+ {
+ pNumberFormat->SetBulletChar( pOldBullet->GetSymbol() );
+ }
+ else if( eNumType == SVX_NUM_BITMAP )
+ {
+ SvxBrushItem aBItem( Graphic( pOldBullet->GetBitmap() ), GPOS_NONE, SID_ATTR_BRUSH );
+ pNumberFormat->SetGraphicBrush( &aBItem );
+ }
+ }
+
+ // Einzug und Erstzeileneinzug
+//TL_NFLR if ( pOldLRSpace )
+//TL_NFLR {
+//TL_NFLR short nLSpace = (short)pOldLRSpace->GetTxtLeft();
+//TL_NFLR pNumberFormat->SetLSpace( nLSpace );
+//TL_NFLR pNumberFormat->SetAbsLSpace( nLSpace );
+//TL_NFLR pNumberFormat->SetFirstLineOffset( pOldLRSpace->GetTxtFirstLineOfst() );
+//TL_NFLR }
+
+ rNumBullet.GetNumRule()->SetLevel( nLevel, *pNumberFormat );
+ delete pNumberFormat;
+ }
+*/
+}
+
+BOOL EditEngine::HasValidData( const ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& rTransferable )
+{
+ BOOL bValidData = FALSE;
+
+ if ( rTransferable.is() )
+ {
+ // Every application that copies rtf or any other text format also copies plain text into the clipboard....
+ datatransfer::DataFlavor aFlavor;
+ SotExchange::GetFormatDataFlavor( SOT_FORMAT_STRING, aFlavor );
+ bValidData = rTransferable->isDataFlavorSupported( aFlavor );
+ }
+
+ return bValidData;
+}
+
+/** sets a link that is called at the beginning of a drag operation at an edit view */
+void EditEngine::SetBeginDropHdl( const Link& rLink )
+{
+ pImpEditEngine->SetBeginDropHdl( rLink );
+}
+
+Link EditEngine::GetBeginDropHdl() const
+{
+ return pImpEditEngine->GetBeginDropHdl();
+}
+
+/** sets a link that is called at the end of a drag operation at an edit view */
+void EditEngine::SetEndDropHdl( const Link& rLink )
+{
+ pImpEditEngine->SetEndDropHdl( rLink );
+}
+
+Link EditEngine::GetEndDropHdl() const
+{
+ return pImpEditEngine->GetEndDropHdl();
+}
+
+void EditEngine::SetFirstWordCapitalization( BOOL bCapitalize )
+{
+ pImpEditEngine->SetFirstWordCapitalization( bCapitalize );
+}
+
+BOOL EditEngine::IsFirstWordCapitalization() const
+{
+ return pImpEditEngine->IsFirstWordCapitalization();
+}
+
+
+// ---------------------------------------------------
+
+
+EFieldInfo::EFieldInfo()
+{
+ pFieldItem = NULL;
+}
+
+
+EFieldInfo::EFieldInfo( const SvxFieldItem& rFieldItem, USHORT nPara, USHORT nPos ) : aPosition( nPara, nPos )
+{
+ pFieldItem = new SvxFieldItem( rFieldItem );
+}
+
+EFieldInfo::~EFieldInfo()
+{
+ delete pFieldItem;
+}
+
+EFieldInfo::EFieldInfo( const EFieldInfo& rFldInfo )
+{
+ *this = rFldInfo;
+}
+
+EFieldInfo& EFieldInfo::operator= ( const EFieldInfo& rFldInfo )
+{
+ if( this == &rFldInfo )
+ return *this;
+
+ pFieldItem = rFldInfo.pFieldItem ? new SvxFieldItem( *rFldInfo.pFieldItem ) : 0;
+ aCurrentText = rFldInfo.aCurrentText;
+ aPosition = rFldInfo.aPosition;
+
+ return *this;
+}