Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / ui / docvw / edtwin.cxx
blob: 3249b7035b431a34c1ae2ce4d2fad6719d26f4ee [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 <tools/list.hxx>
#include <swtypes.hxx>
#include <hintids.hxx>
#include <com/sun/star/accessibility/XAccessible.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/i18n/XBreakIterator.hpp>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <com/sun/star/i18n/InputSequenceCheckMode.hpp>
#include <com/sun/star/i18n/UnicodeScript.hpp>
#include <vcl/help.hxx>
#include <vcl/graph.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/cmdevt.h>
#include <sot/storage.hxx>
#include <svl/macitem.hxx>
#include <unotools/securityoptions.hxx>
#include <basic/sbxvar.hxx>
#include <svl/ctloptions.hxx>
#include <basic/sbx.hxx>
#include <svl/eitem.hxx>
#include <svl/stritem.hxx>
#include <sfx2/ipclient.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/request.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/dispatch.hxx>
#include <svl/ptitem.hxx>
#include <editeng/sizeitem.hxx>
#include <editeng/langitem.hxx>
#include <svx/htmlmode.hxx>
#include <svx/svdview.hxx>
#include <svx/svdhdl.hxx>
#include <svx/svdoutl.hxx>
#include <editeng/editeng.hxx>
#include <editeng/svxacorr.hxx>
#include <editeng/scripttypeitem.hxx>
#include <editeng/flditem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/protitem.hxx>
#include <unotools/charclass.hxx>
#include <editeng/acorrcfg.hxx>
#include <SwSmartTagMgr.hxx>
#include <edtwin.hxx>
#include <view.hxx>
#include <wrtsh.hxx>
#include <IDocumentSettingAccess.hxx>
#include <fldbas.hxx>
#include <swmodule.hxx>
#include <docsh.hxx>
#include <viewopt.hxx>
#include <drawbase.hxx>
#include <dselect.hxx>
#include <textsh.hxx>
#include <shdwcrsr.hxx>
#include <txatbase.hxx>
#include <fmtanchr.hxx>
#include <fmtornt.hxx>
#include <fmtfsize.hxx>
#include <fmtclds.hxx>
#include <frmfmt.hxx>
#include <modcfg.hxx>
#include <fmtcol.hxx>
#include <wview.hxx>
#include <listsh.hxx>
#include <gloslst.hxx>
#include <inputwin.hxx>
#include <gloshdl.hxx>
#include <swundo.hxx>
#include <drwtxtsh.hxx>
#include <fchrfmt.hxx>
#include <fmturl.hxx>
#include <romenu.hxx>
#include <initui.hxx>
#include <frmatr.hxx>
#include <extinput.hxx>
#include <acmplwrd.hxx>
#include <swcalwrp.hxx>
#include <swdtflvr.hxx>
#include <wdocsh.hxx>
#include <crsskip.hxx>
#include <breakit.hxx>
#include <checkit.hxx>
#include <helpid.h>
#include <cmdid.h>
#include <docvw.hrc>
#include <uitool.hxx>
#include <fmtfollowtextflow.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <charfmt.hxx>
#include <numrule.hxx>
#include <pagedesc.hxx>
#include <svtools/ruler.hxx>
#include "formatclipboard.hxx"
#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>
#include <IMark.hxx>
#include <doc.hxx>
#include <xmloff/odffields.hxx>
#include <PostItMgr.hxx>
using namespace sw::mark;
using namespace ::com::sun::star;
/*--------------------------------------------------------------------
Beschreibung: Globals
--------------------------------------------------------------------*/
static bool bInputLanguageSwitched = false;
extern sal_Bool bNoInterrupt; // in mainwn.cxx
//Normalerweise wird im MouseButtonUp eine Selektion aufgehoben wenn die
//Selektion nicht gerade aufgezogen wird. Leider wird im MouseButtonDown
//bei doppel-/dreifach-Klick Selektiert, diese Selektion wird in dem Handler
//komplett abgeschlossen und kann deshalb im Up nicht mehr unterschieden
//werden. Um dies Aufzuloese wird bHoldSelection im Down gesetzt und im
//Up ausgewertet.
static sal_Bool bHoldSelection = sal_False;
sal_Bool bFrmDrag = sal_False;
sal_Bool bValidCrsrPos = sal_False;
sal_Bool bModePushed = sal_False;
sal_Bool bDDTimerStarted = sal_False;
sal_Bool bFlushCharBuffer = sal_False;
sal_Bool SwEditWin::bReplaceQuote = sal_False;
sal_Bool bDDINetAttr = sal_False;
SdrHdlKind eSdrMoveHdl = HDL_USER;
QuickHelpData* SwEditWin::pQuickHlpData = 0;
long SwEditWin::nDDStartPosY = 0;
long SwEditWin::nDDStartPosX = 0;
Color SwEditWin::aTextBackColor(COL_YELLOW);
Color SwEditWin::aTextColor(COL_RED);
sal_Bool SwEditWin::bTransparentBackColor = sal_False; // Hintergrund nicht transparent
extern sal_Bool bExecuteDrag;
SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType );
DBG_NAME(edithdl)
class SwAnchorMarker
{
SdrHdl* pHdl;
Point aHdlPos;
Point aLastPos;
bool bTopRightHandle;
public:
SwAnchorMarker( SdrHdl* pH )
: pHdl( pH )
, aHdlPos( pH->GetPos() )
, aLastPos( pH->GetPos() )
, bTopRightHandle( pH->GetKind() == HDL_ANCHOR_TR )
{}
const Point& GetLastPos() const { return aLastPos; }
void SetLastPos( const Point& rNew ) { aLastPos = rNew; }
void SetPos( const Point& rNew ) { pHdl->SetPos( rNew ); }
const Point& GetPos() { return pHdl->GetPos(); }
const Point& GetHdlPos() { return aHdlPos; }
SdrHdl* GetHdl() const { return pHdl; }
void ChgHdl( SdrHdl* pNew )
{
pHdl = pNew;
if ( pHdl )
{
bTopRightHandle = (pHdl->GetKind() == HDL_ANCHOR_TR);
}
}
const Point GetPosForHitTest( const OutputDevice& rOut )
{
Point aHitTestPos( GetPos() );
aHitTestPos = rOut.LogicToPixel( aHitTestPos );
if ( bTopRightHandle )
{
aHitTestPos += Point( -1, 1 );
}
else
{
aHitTestPos += Point( 1, 1 );
}
aHitTestPos = rOut.PixelToLogic( aHitTestPos );
return aHitTestPos;
}
};
struct QuickHelpData
{
SvStringsISortDtor aArr;
sal_uInt16* pAttrs;
CommandExtTextInputData* pCETID;
sal_uLong nTipId;
sal_uInt16 nLen, nCurArrPos;
sal_Bool bClear : 1, bChkInsBlank : 1, bIsTip : 1, bIsAutoText : 1;
QuickHelpData() : pAttrs( 0 ), pCETID( 0 ) { ClearCntnt(); }
void Move( QuickHelpData& rCpy );
void ClearCntnt();
void Start( SwWrtShell& rSh, sal_uInt16 nWrdLen );
void Stop( SwWrtShell& rSh );
sal_Bool HasCntnt() const { return aArr.Count() && 0 != nLen; }
void Inc( sal_Bool bEndLess )
{
if( ++nCurArrPos >= aArr.Count() )
nCurArrPos = (bEndLess && !bIsAutoText )? 0 : nCurArrPos-1;
}
void Dec( sal_Bool bEndLess )
{
if( 0 == nCurArrPos-- )
nCurArrPos = (bEndLess && !bIsAutoText ) ? aArr.Count()-1 : 0;
}
void FillStrArr( SwWrtShell& rSh, const String& rWord );
};
/*--------------------------------------------------------------------
Beschreibung: Minimale Bewegung Zittern vermeiden
--------------------------------------------------------------------*/
#define HIT_PIX 2 /* Hit-Toleranz in Pixel */
#define MIN_MOVE 4
inline sal_Bool IsMinMove(const Point &rStartPos, const Point &rLPt)
{
return Abs(rStartPos.X() - rLPt.X()) > MIN_MOVE ||
Abs(rStartPos.Y() - rLPt.Y()) > MIN_MOVE;
}
/*--------------------------------------------------------------------
JP 30.07.98: fuer MouseButtonDown - feststellen, ob ein DrawObject
und KEIN SwgFrame getroffen wurde! Shift/Ctrl sollen
nur bei DrawObjecte zum Selektieren fuehren, bei SwgFlys
ggfs zum ausloesen von Hyperlinks (DownLoad/NewWindow!)
--------------------------------------------------------------------*/
inline sal_Bool IsDrawObjSelectable( const SwWrtShell& rSh, const Point& rPt )
{
sal_Bool bRet = sal_True;
SdrObject* pObj;
switch( rSh.GetObjCntType( rPt, pObj ))
{
case OBJCNT_NONE:
case OBJCNT_FLY:
case OBJCNT_GRF:
case OBJCNT_OLE:
bRet = sal_False;
break;
default:; //prevent warning
}
return bRet;
}
/*--------------------------------------------------------------------
Beschreibung: Pointer umschalten
--------------------------------------------------------------------*/
void SwEditWin::UpdatePointer(const Point &rLPt, sal_uInt16 nModifier )
{
SwWrtShell &rSh = rView.GetWrtShell();
if( pApplyTempl )
{
PointerStyle eStyle = POINTER_FILL;
if ( rSh.IsOverReadOnlyPos( rLPt ) )
{
if( pUserMarker )
{
delete pUserMarker;
pUserMarker = 0L;
}
eStyle = POINTER_NOTALLOWED;
}
else
{
SwRect aRect;
SwRect* pRect = &aRect;
const SwFrmFmt* pFmt = 0;
bool bFrameIsValidTarget = false;
if( pApplyTempl->pFormatClipboard )
bFrameIsValidTarget = pApplyTempl->pFormatClipboard->HasContentForThisType( nsSelectionType::SEL_FRM );
else if( !pApplyTempl->nColor )
bFrameIsValidTarget = ( pApplyTempl->eType == SFX_STYLE_FAMILY_FRAME );
if( bFrameIsValidTarget &&
0 !=(pFmt = rSh.GetFmtFromObj( rLPt, &pRect )) &&
PTR_CAST(SwFlyFrmFmt, pFmt))
{
//Highlight fuer Rahmen anwerfen
Rectangle aTmp( pRect->SVRect() );
if ( !pUserMarker )
{
pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp );
}
}
else if(pUserMarker)
{
delete pUserMarker;
pUserMarker = 0L;
}
rSh.SwCrsrShell::SetVisCrsr( rLPt );
}
SetPointer( eStyle );
return;
}
if( !rSh.VisArea().Width() )
return;
SET_CURR_SHELL(&rSh);
if ( IsChainMode() )
{
SwRect aRect;
int nChainable = rSh.Chainable( aRect, *rSh.GetFlyFrmFmt(), rLPt );
PointerStyle eStyle = nChainable
? POINTER_CHAIN_NOTALLOWED : POINTER_CHAIN;
if ( !nChainable )
{
Rectangle aTmp( aRect.SVRect() );
if ( !pUserMarker )
{
pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp );
}
}
else
{
delete pUserMarker;
pUserMarker = 0L;
}
rView.GetViewFrame()->ShowStatusText(
SW_RESSTR(STR_CHAIN_OK+nChainable));
SetPointer( eStyle );
return;
}
// Removed ExecHyperlink option.
//sal_Bool bExecHyperlinks = rSh.GetViewOptions()->IsExecHyperlinks() ^
// (nModifier == KEY_MOD2 ? sal_True : sal_False);
sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
if ( !bExecHyperlinks )
{
SvtSecurityOptions aSecOpts;
const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
if ( ( bSecureOption && nModifier == KEY_MOD1 ) ||
( !bSecureOption && nModifier != KEY_MOD1 ) )
bExecHyperlinks = sal_True;
}
const sal_Bool bExecSmarttags = nModifier == KEY_MOD1;
SdrView *pSdrView = rSh.GetDrawView();
sal_Bool bPrefSdrPointer = sal_False;
sal_Bool bHitHandle = sal_False;
sal_Bool bCntAtPos = sal_False;
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
rSh.IsCrsrReadonly();
aActHitType = SDRHIT_NONE;
PointerStyle eStyle = POINTER_TEXT;
if ( !pSdrView )
bCntAtPos = sal_True;
else if ( sal_True == (bHitHandle = pSdrView->PickHandle( rLPt ) != 0) )
{
aActHitType = SDRHIT_OBJECT;
bPrefSdrPointer = sal_True;
}
else
{
const sal_Bool bNotInSelObj = !rSh.IsInsideSelectedObj( rLPt );
if ( rView.GetDrawFuncPtr() && !bInsDraw && bNotInSelObj )
{
aActHitType = SDRHIT_OBJECT;
if (IsObjectSelect())
eStyle = POINTER_ARROW;
else
bPrefSdrPointer = sal_True;
}
else
{
SdrObject* pObj; SdrPageView* pPV;
pSdrView->SetHitTolerancePixel( HIT_PIX );
if ( bNotInSelObj && bExecHyperlinks &&
pSdrView->PickObj( rLPt, pSdrView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO ))
{
SdrObjMacroHitRec aTmp;
aTmp.aPos = rLPt;
aTmp.pPageView = pPV;
SetPointer( pObj->GetMacroPointer( aTmp ) );
return;
}
else
{
// dvo: IsObjSelectable() eventually calls SdrView::PickObj, so
// apparently this is used to determine whether this is a
// drawling layer object or not.
if ( rSh.IsObjSelectable( rLPt ) )
{
if (pSdrView->IsTextEdit())
{
aActHitType = SDRHIT_NONE;
bPrefSdrPointer = sal_True;
}
else
{
SdrViewEvent aVEvt;
SdrHitKind eHit = pSdrView->PickAnything(rLPt, aVEvt);
if (eHit == SDRHIT_URLFIELD && bExecHyperlinks)
{
aActHitType = SDRHIT_OBJECT;
bPrefSdrPointer = sal_True;
}
else
{
// if we're over a selected object, we show an
// ARROW by default. We only show a MOVE if 1) the
// object is selected, and 2) it may be moved
// (i.e., position is not protected).
bool bMovable =
(!bNotInSelObj) &&
(rSh.IsObjSelected() || rSh.IsFrmSelected()) &&
(!rSh.IsSelObjProtected(FLYPROTECT_POS));
eStyle = bMovable ? POINTER_MOVE : POINTER_ARROW;
aActHitType = SDRHIT_OBJECT;
}
}
}
else
{
if ( rSh.IsFrmSelected() && !bNotInSelObj )
{
// dvo: this branch appears to be dead and should be
// removed in a future version. Reason: The condition
// !bNotInSelObj means that this branch will only be
// executed in the cursor points inside a selected
// object. However, if this is the case, the previous
// if( rSh.IsObjSelectable(rLPt) ) must always be true:
// rLPt is inside a selected object, then obviously
// rLPt is over a selectable object.
if (rSh.IsSelObjProtected(FLYPROTECT_SIZE))
eStyle = POINTER_NOTALLOWED;
else
eStyle = POINTER_MOVE;
aActHitType = SDRHIT_OBJECT;
}
else
{
if ( rView.GetDrawFuncPtr() )
bPrefSdrPointer = sal_True;
else
bCntAtPos = sal_True;
}
}
}
}
}
if ( bPrefSdrPointer )
{
if (bIsDocReadOnly || (rSh.IsObjSelected() && rSh.IsSelObjProtected(FLYPROTECT_CONTENT)))
SetPointer( POINTER_NOTALLOWED );
else
{
if (rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->IsInsertForm() && !bHitHandle)
SetPointer( POINTER_DRAW_RECT );
else
SetPointer( pSdrView->GetPreferedPointer( rLPt, rSh.GetOut() ) );
}
}
else
{
if( !rSh.IsPageAtPos( rLPt ) || pAnchorMarker )
eStyle = POINTER_ARROW;
else
{
if( bCntAtPos )
{
SwContentAtPos aSwContentAtPos(
SwContentAtPos::SW_CLICKFIELD|
SwContentAtPos::SW_INETATTR|
SwContentAtPos::SW_FTN |
SwContentAtPos::SW_SMARTTAG );
if( rSh.GetContentAtPos( rLPt, aSwContentAtPos) )
{
const bool bClickToFollow = SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos ||
SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos;
if( !bClickToFollow ||
(SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos && bExecHyperlinks) ||
(SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos && bExecSmarttags) )
eStyle = POINTER_REFHAND;
}
}
}
// which kind of text pointer have we to show - horz / vert - ?
if( POINTER_TEXT == eStyle && rSh.IsInVerticalText( &rLPt ))
eStyle = POINTER_TEXT_VERTICAL;
SetPointer( eStyle );
}
}
/*--------------------------------------------------------------------
Beschreibung: Timer fuer Selektion vergroessern
--------------------------------------------------------------------*/
IMPL_LINK( SwEditWin, TimerHandler, Timer *, EMPTYARG )
{
DBG_PROFSTART(edithdl);
SwWrtShell &rSh = rView.GetWrtShell();
Point aModPt( aMovePos );
const SwRect aOldVis( rSh.VisArea() );
sal_Bool bDone = sal_False;
if ( !rSh.VisArea().IsInside( aModPt ) )
{
if ( bInsDraw )
{
const int nMaxScroll = 40;
rView.Scroll( Rectangle(aModPt,Size(1,1)), nMaxScroll, nMaxScroll);
bDone = sal_True;
}
else if ( bFrmDrag )
{
(rSh.*rSh.fnDrag)(&aModPt,sal_False);
bDone = sal_True;
}
if ( !bDone )
aModPt = rSh.GetCntntPos( aModPt,aModPt.Y() > rSh.VisArea().Bottom() );
}
if ( !bDone && !(bFrmDrag || bInsDraw) )
{
if ( pRowColumnSelectionStart )
{
Point aPos( aModPt );
rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag );
}
else
(rSh.*rSh.fnSetCrsr)( &aModPt, sal_False );
//fix(24138): Es kann sein, dass der "Sprung" ueber eine Tabelle so
//nicht geschafft wird. Deshalb wir hier eben per Up/Down ueber die
//Tabelle gesprungen.
const SwRect& rVisArea = rSh.VisArea();
if( aOldVis == rVisArea && !rSh.IsStartOfDoc() && !rSh.IsEndOfDoc() )
{
//JP 11.10.2001 Bug 72294 - take the center point of VisArea to
// decide in which direction the user want.
if( aModPt.Y() < ( rVisArea.Top() + rVisArea.Height() / 2 ) )
rSh.Up( sal_True, 1 );
else
rSh.Down( sal_True, 1 );
}
}
aMovePos += rSh.VisArea().Pos() - aOldVis.Pos();
JustifyAreaTimer();
DBG_PROFSTOP(edithdl);
return 0;
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwEditWin::JustifyAreaTimer()
{
const Rectangle &rVisArea = GetView().GetVisArea();
#ifdef UNX
const long coMinLen = 100;
#else
const long coMinLen = 50;
#endif
long nTimeout = 800,
nDiff = Max(
Max( aMovePos.Y() - rVisArea.Bottom(), rVisArea.Top() - aMovePos.Y() ),
Max( aMovePos.X() - rVisArea.Right(), rVisArea.Left() - aMovePos.X()));
aTimer.SetTimeout( Max( coMinLen, nTimeout - nDiff) );
}
void SwEditWin::LeaveArea(const Point &rPos)
{
aMovePos = rPos;
JustifyAreaTimer();
if( !aTimer.IsActive() )
aTimer.Start();
if( pShadCrsr )
delete pShadCrsr, pShadCrsr = 0;
}
inline void SwEditWin::EnterArea()
{
aTimer.Stop();
}
/*------------------------------------------------------------------------
Beschreibung: Modus fuer Rahmen einfuegen
------------------------------------------------------------------------*/
void SwEditWin::InsFrm(sal_uInt16 nCols)
{
StdDrawMode( OBJ_NONE, sal_False );
bInsFrm = sal_True;
nInsFrmColCount = nCols;
}
void SwEditWin::StdDrawMode( SdrObjKind eSdrObjectKind, sal_Bool bObjSelect )
{
SetSdrDrawMode( eSdrObjectKind );
if (bObjSelect)
rView.SetDrawFuncPtr(new DrawSelection( &rView.GetWrtShell(), this, &rView ));
else
rView.SetDrawFuncPtr(new SwDrawBase( &rView.GetWrtShell(), this, &rView ));
rView.SetSelDrawSlot();
SetSdrDrawMode( eSdrObjectKind );
if (bObjSelect)
rView.GetDrawFuncPtr()->Activate( SID_OBJECT_SELECT );
else
rView.GetDrawFuncPtr()->Activate( sal::static_int_cast< sal_uInt16 >(eSdrObjectKind) ); // don't know if this is useful at all; but it keeps functionality as it was...
bInsFrm = sal_False;
nInsFrmColCount = 1;
}
void SwEditWin::StopInsFrm()
{
if (rView.GetDrawFuncPtr())
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
}
rView.LeaveDrawCreate(); // Konstruktionsmode verlassen
bInsFrm = sal_False;
nInsFrmColCount = 1;
}
/*--------------------------------------------------------------------
--------------------------------------------------------------------*/
sal_Bool SwEditWin::IsInputSequenceCheckingRequired( const String &rText, const SwPaM& rCrsr ) const
{
const SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions();
if ( !rCTLOptions.IsCTLFontEnabled() ||
!rCTLOptions.IsCTLSequenceChecking() )
return sal_False;
const xub_StrLen nFirstPos = rCrsr.Start()->nContent.GetIndex();
if ( 0 == nFirstPos ) /* first char needs not to be checked */
return sal_False;
SwBreakIt *pBreakIter = SwBreakIt::Get();
uno::Reference < i18n::XBreakIterator > xBI = pBreakIter->GetBreakIter();
long nCTLScriptPos = -1;
if (xBI.is())
{
if (xBI->getScriptType( rText, 0 ) == i18n::ScriptType::COMPLEX)
nCTLScriptPos = 0;
else
nCTLScriptPos = xBI->nextScript( rText, 0, i18n::ScriptType::COMPLEX );
}
return (0 <= nCTLScriptPos && nCTLScriptPos <= rText.Len());
}
/*--------------------------------------------------------------------
Beschreibung: Der Character Buffer wird in das Dokument eingefuegt
--------------------------------------------------------------------*/
void SwEditWin::FlushInBuffer()
{
if ( aInBuffer.Len() )
{
SwWrtShell& rSh = rView.GetWrtShell();
// generate new sequence input checker if not already done
if ( !pCheckIt )
pCheckIt = new SwCheckIt;
uno::Reference < i18n::XExtendedInputSequenceChecker > xISC = pCheckIt->xCheck;
if ( xISC.is() && IsInputSequenceCheckingRequired( aInBuffer, *rSh.GetCrsr() ) )
{
//
// apply (Thai) input sequence checking/correction
//
rSh.Push(); // push current cursor to stack
// get text from the beginning (i.e left side) of current selection
// to the start of the paragraph
rSh.NormalizePam(); // make point be the first (left) one
if (!rSh.GetCrsr()->HasMark())
rSh.GetCrsr()->SetMark();
rSh.GetCrsr()->GetMark()->nContent = 0;
String aLeftText( rSh.GetCrsr()->GetTxt() );
SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions();
xub_StrLen nExpandSelection = 0;
if (aLeftText.Len() > 0)
{
sal_Unicode cChar = '\0';
xub_StrLen nTmpPos = aLeftText.Len();
sal_Int16 nCheckMode = rCTLOptions.IsCTLSequenceCheckingRestricted() ?
i18n::InputSequenceCheckMode::STRICT : i18n::InputSequenceCheckMode::BASIC;
rtl::OUString aOldText( aLeftText );
rtl::OUString aNewText( aOldText );
if (rCTLOptions.IsCTLSequenceCheckingTypeAndReplace())
{
for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k)
{
cChar = aInBuffer.GetChar(k);
const xub_StrLen nPrevPos = static_cast<xub_StrLen>(xISC->correctInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode ));
// valid sequence or sequence could be corrected:
if (nPrevPos != aNewText.getLength())
nTmpPos = nPrevPos + 1;
}
// find position of first character that has changed
sal_Int32 nOldLen = aOldText.getLength();
sal_Int32 nNewLen = aNewText.getLength();
const sal_Unicode *pOldTxt = aOldText.getStr();
const sal_Unicode *pNewTxt = aNewText.getStr();
sal_Int32 nChgPos = 0;
while ( nChgPos < nOldLen && nChgPos < nNewLen &&
pOldTxt[nChgPos] == pNewTxt[nChgPos] )
++nChgPos;
xub_StrLen nChgLen = static_cast< xub_StrLen >(nNewLen - nChgPos);
String aChgText( aNewText.copy( static_cast< xub_StrLen >(nChgPos), nChgLen ) );
if (aChgText.Len())
{
aInBuffer = aChgText;
nExpandSelection = aLeftText.Len() - static_cast< xub_StrLen >(nChgPos);
}
else
aInBuffer.Erase();
}
else
{
for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k)
{
cChar = aInBuffer.GetChar(k);
if (xISC->checkInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode ))
{
// character can be inserted:
aNewText += rtl::OUString( (sal_Unicode) cChar );
++nTmpPos;
}
}
aInBuffer = aNewText.copy( aOldText.getLength() ); // copy new text to be inserted to buffer
}
}
// at this point now we will insert the buffer text 'normally' some lines below...
rSh.Pop( sal_False ); // pop old cursor from stack
if (!aInBuffer.Len())
return;
// if text prior to the original selection needs to be changed
// as well, we now expand the selection accordingly.
SwPaM &rCrsr = *rSh.GetCrsr();
xub_StrLen nCrsrStartPos = rCrsr.Start()->nContent.GetIndex();
DBG_ASSERT( nCrsrStartPos >= nExpandSelection, "cannot expand selection as specified!!" );
if (nExpandSelection && nCrsrStartPos >= nExpandSelection)
{
if (!rCrsr.HasMark())
rCrsr.SetMark();
rCrsr.Start()->nContent -= nExpandSelection;
}
}
uno::Reference< frame::XDispatchRecorder > xRecorder =
rView.GetViewFrame()->GetBindings().GetRecorder();
if ( xRecorder.is() )
{
//Shell ermitteln
SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
// Request generieren und recorden
if (pSfxShell)
{
SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING );
aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, aInBuffer ) );
aReq.Done();
}
}
//#21019# apply CTL and CJK language to the text input
sal_Bool bLang = true;
if(eBufferLanguage != LANGUAGE_DONTKNOW)
{
sal_uInt16 nWhich = 0;
switch( GetI18NScriptTypeOfLanguage( eBufferLanguage ))
{
case i18n::ScriptType::ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break;
case i18n::ScriptType::COMPLEX: nWhich = RES_CHRATR_CTL_LANGUAGE; break;
case i18n::ScriptType::LATIN: nWhich = RES_CHRATR_LANGUAGE; break;
default: bLang = sal_False;
}
if(bLang)
{
SfxItemSet aLangSet(rView.GetPool(), nWhich, nWhich);
rSh.GetCurAttr(aLangSet);
if(SFX_ITEM_DEFAULT <= aLangSet.GetItemState(nWhich, sal_True))
{
LanguageType eLang = static_cast<const SvxLanguageItem&>(aLangSet.Get(nWhich)).GetLanguage();
if ( eLang == eBufferLanguage )
// current language attribute equal to language reported from system
bLang = sal_False;
else if ( !bInputLanguageSwitched && RES_CHRATR_LANGUAGE == nWhich /* && (eLang&LANGUAGE_MASK_PRIMARY) == LANGUAGE_ENGLISH */ )
{
// special case: switching between two "LATIN" languages
// In case the current keyboard setting might be suitable for both languages we can't safely assume that the user
// wants to use the language reported from the system, except if we knew that it was explicitly switched (thus the check for "bInputLangeSwitched").
// The language reported by the system could be just the system default language that the user is not even aware of,
// because no language selection tool is installed at all. In this case the OOo language should get preference as
// it might have been selected by the user explicitly.
// Usually this case happens if the OOo language is different to the system language but the system keyboard is still suitable
// for the OOo language (e.g. writing English texts with a German keyboard).
// For non-latin keyboards overwriting the attribute is still valid. We do this for kyrillic and greek ATM.
// In future versions of OOo this should be replaced by a configuration switch that allows to give the preference to
// the OOo setting or the system setting explicitly and/or a better handling of the script type.
sal_Int16 nScript = GetAppCharClass().getScript( aInBuffer, 0 );
i18n::UnicodeScript eType = (i18n::UnicodeScript) nScript;
bool bSystemIsNonLatin = false, bOOoLangIsNonLatin = false;
switch ( eType )
{
case i18n::UnicodeScript_kGreek:
case i18n::UnicodeScript_kCyrillic:
// in case other UnicodeScripts require special keyboards they can be added here
bSystemIsNonLatin = true;
break;
default:
break;
}
switch ( eLang )
{
case LANGUAGE_AZERI_CYRILLIC:
case LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA:
case LANGUAGE_BULGARIAN:
case LANGUAGE_GREEK:
case LANGUAGE_RUSSIAN:
case LANGUAGE_RUSSIAN_MOLDOVA:
case LANGUAGE_SERBIAN_CYRILLIC:
case LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA:
case LANGUAGE_UZBEK_CYRILLIC:
case LANGUAGE_UKRAINIAN:
case LANGUAGE_BELARUSIAN:
bOOoLangIsNonLatin = true;
break;
default:
break;
}
bLang = (bSystemIsNonLatin != bOOoLangIsNonLatin);
}
}
if(bLang)
{
SvxLanguageItem aLangItem( eBufferLanguage, nWhich );
rSh.SetAttrItem( aLangItem );
}
}
}
rSh.Insert( aInBuffer );
eBufferLanguage = LANGUAGE_DONTKNOW;
aInBuffer.Erase();
bFlushCharBuffer = sal_False;
}
}
#define MOVE_LEFT_SMALL 0
#define MOVE_UP_SMALL 1
#define MOVE_RIGHT_BIG 2
#define MOVE_DOWN_BIG 3
#define MOVE_LEFT_BIG 4
#define MOVE_UP_BIG 5
#define MOVE_RIGHT_SMALL 6
#define MOVE_DOWN_SMALL 7
// #121236# Support for shift key in writer
#define MOVE_LEFT_HUGE 8
#define MOVE_UP_HUGE 9
#define MOVE_RIGHT_HUGE 10
#define MOVE_DOWN_HUGE 11
void SwEditWin::ChangeFly( sal_uInt8 nDir, sal_Bool bWeb )
{
SwWrtShell &rSh = rView.GetWrtShell();
SwRect aTmp = rSh.GetFlyRect();
if( aTmp.HasArea() &&
!rSh.IsSelObjProtected( FLYPROTECT_POS ) )
{
SfxItemSet aSet(rSh.GetAttrPool(),
RES_FRM_SIZE, RES_FRM_SIZE,
RES_VERT_ORIENT, RES_ANCHOR,
RES_COL, RES_COL,
RES_PROTECT, RES_PROTECT,
RES_FOLLOW_TEXT_FLOW, RES_FOLLOW_TEXT_FLOW, 0);
rSh.GetFlyFrmAttr( aSet );
RndStdIds eAnchorId = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
Size aSnap;
bool bHuge(MOVE_LEFT_HUGE == nDir ||
MOVE_UP_HUGE == nDir ||
MOVE_RIGHT_HUGE == nDir ||
MOVE_DOWN_HUGE == nDir);
if(MOVE_LEFT_SMALL == nDir ||
MOVE_UP_SMALL == nDir ||
MOVE_RIGHT_SMALL == nDir ||
MOVE_DOWN_SMALL == nDir )
{
aSnap = PixelToLogic(Size(1,1));
}
else
{
aSnap = rSh.GetViewOptions()->GetSnapSize();
short nDiv = rSh.GetViewOptions()->GetDivisionX();
if ( nDiv > 0 )
aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv );
nDiv = rSh.GetViewOptions()->GetDivisionY();
if ( nDiv > 0 )
aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv );
}
if(bHuge)
{
// #121236# 567twips == 1cm, but just take three times the normal snap
aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
}
SwRect aBoundRect;
Point aRefPoint;
{
SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) );
const bool bFollowTextFlow =
static_cast<const SwFmtFollowTextFlow&>(aSet.Get(RES_FOLLOW_TEXT_FLOW)).GetValue();
const SwPosition* pToCharCntntPos = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetCntntAnchor();
rSh.CalcBoundRect( aBoundRect, eAnchorId,
text::RelOrientation::FRAME, aVert.GetRelationOrient(),
pToCharCntntPos, bFollowTextFlow,
false, &aRefPoint );
}
long nLeft = Min( aTmp.Left() - aBoundRect.Left(), aSnap.Width() );
long nRight = Min( aBoundRect.Right() - aTmp.Right(), aSnap.Width() );
long nUp = Min( aTmp.Top() - aBoundRect.Top(), aSnap.Height() );
long nDown = Min( aBoundRect.Bottom() - aTmp.Bottom(), aSnap.Height() );
switch ( nDir )
{
case MOVE_LEFT_BIG:
case MOVE_LEFT_HUGE:
case MOVE_LEFT_SMALL: aTmp.Left( aTmp.Left() - nLeft );
break;
case MOVE_UP_BIG:
case MOVE_UP_HUGE:
case MOVE_UP_SMALL: aTmp.Top( aTmp.Top() - nUp );
break;
case MOVE_RIGHT_SMALL:
if( aTmp.Width() < aSnap.Width() + MINFLY )
break;
nRight = aSnap.Width(); // kein break
case MOVE_RIGHT_HUGE:
case MOVE_RIGHT_BIG: aTmp.Left( aTmp.Left() + nRight );
break;
case MOVE_DOWN_SMALL:
if( aTmp.Height() < aSnap.Height() + MINFLY )
break;
nDown = aSnap.Height(); // kein break
case MOVE_DOWN_HUGE:
case MOVE_DOWN_BIG: aTmp.Top( aTmp.Top() + nDown );
break;
default: ASSERT( sal_True, "ChangeFly: Unknown direction." );
}
sal_Bool bSet = sal_False;
if ((FLY_AS_CHAR == eAnchorId) && ( nDir % 2 ))
{
long aDiff = aTmp.Top() - aRefPoint.Y();
if( aDiff > 0 )
aDiff = 0;
else if ( aDiff < -aTmp.Height() )
aDiff = -aTmp.Height();
SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) );
sal_Int16 eNew;
if( bWeb )
{
eNew = aVert.GetVertOrient();
sal_Bool bDown = 0 != ( nDir & 0x02 );
switch( eNew )
{
case text::VertOrientation::CHAR_TOP:
if( bDown ) eNew = text::VertOrientation::CENTER;
break;
case text::VertOrientation::CENTER:
eNew = bDown ? text::VertOrientation::TOP : text::VertOrientation::CHAR_TOP;
break;
case text::VertOrientation::TOP:
if( !bDown ) eNew = text::VertOrientation::CENTER;
break;
case text::VertOrientation::LINE_TOP:
if( bDown ) eNew = text::VertOrientation::LINE_CENTER;
break;
case text::VertOrientation::LINE_CENTER:
eNew = bDown ? text::VertOrientation::LINE_BOTTOM : text::VertOrientation::LINE_TOP;
break;
case text::VertOrientation::LINE_BOTTOM:
if( !bDown ) eNew = text::VertOrientation::LINE_CENTER;
break;
default:; //prevent warning
}
}
else
{
aVert.SetPos( aDiff );
eNew = text::VertOrientation::NONE;
}
aVert.SetVertOrient( eNew );
aSet.Put( aVert );
bSet = sal_True;
}
if (bWeb && (FLY_AT_PARA == eAnchorId)
&& ( nDir==MOVE_LEFT_SMALL || nDir==MOVE_RIGHT_BIG ))
{
SwFmtHoriOrient aHori( (SwFmtHoriOrient&)aSet.Get(RES_HORI_ORIENT) );
sal_Int16 eNew;
eNew = aHori.GetHoriOrient();
switch( eNew )
{
case text::HoriOrientation::RIGHT:
if( nDir==MOVE_LEFT_SMALL )
eNew = text::HoriOrientation::LEFT;
break;
case text::HoriOrientation::LEFT:
if( nDir==MOVE_RIGHT_BIG )
eNew = text::HoriOrientation::RIGHT;
break;
default:; //prevent warning
}
if( eNew != aHori.GetHoriOrient() )
{
aHori.SetHoriOrient( eNew );
aSet.Put( aHori );
bSet = sal_True;
}
}
rSh.StartAllAction();
if( bSet )
rSh.SetFlyFrmAttr( aSet );
sal_Bool bSetPos = (FLY_AS_CHAR != eAnchorId);
if(bSetPos && bWeb)
{
if (FLY_AT_PAGE != eAnchorId)
{
bSetPos = sal_False;
}
else
{
bSetPos = (::GetHtmlMode(rView.GetDocShell()) & HTMLMODE_SOME_ABS_POS) ?
sal_True : sal_False;
}
}
if( bSetPos )
rSh.SetFlyPos( aTmp.Pos() );
rSh.EndAllAction();
}
}
/* -----------------------------23.05.2002 11:35------------------------------
---------------------------------------------------------------------------*/
void SwEditWin::ChangeDrawing( sal_uInt8 nDir )
{
SwWrtShell &rSh = rView.GetWrtShell();
rSh.StartUndo();
long nX = 0;
long nY = 0;
const sal_Bool bOnePixel(
MOVE_LEFT_SMALL == nDir ||
MOVE_UP_SMALL == nDir ||
MOVE_RIGHT_SMALL == nDir ||
MOVE_DOWN_SMALL == nDir);
const sal_Bool bHuge(
MOVE_LEFT_HUGE == nDir ||
MOVE_UP_HUGE == nDir ||
MOVE_RIGHT_HUGE == nDir ||
MOVE_DOWN_HUGE == nDir);
sal_uInt16 nAnchorDir = SW_MOVE_UP;
switch(nDir)
{
case MOVE_LEFT_SMALL:
case MOVE_LEFT_HUGE:
case MOVE_LEFT_BIG:
nX = -1;
nAnchorDir = SW_MOVE_LEFT;
break;
case MOVE_UP_SMALL:
case MOVE_UP_HUGE:
case MOVE_UP_BIG:
nY = -1;
break;
case MOVE_RIGHT_SMALL:
case MOVE_RIGHT_HUGE:
case MOVE_RIGHT_BIG:
nX = +1;
nAnchorDir = SW_MOVE_RIGHT;
break;
case MOVE_DOWN_SMALL:
case MOVE_DOWN_HUGE:
case MOVE_DOWN_BIG:
nY = +1;
nAnchorDir = SW_MOVE_DOWN;
break;
}
if(0 != nX || 0 != nY)
{
sal_uInt8 nProtect = rSh.IsSelObjProtected( FLYPROTECT_POS|FLYPROTECT_SIZE );
Size aSnap( rSh.GetViewOptions()->GetSnapSize() );
short nDiv = rSh.GetViewOptions()->GetDivisionX();
if ( nDiv > 0 )
aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv );
nDiv = rSh.GetViewOptions()->GetDivisionY();
if ( nDiv > 0 )
aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv );
if(bOnePixel)
{
aSnap = PixelToLogic(Size(1,1));
}
else if(bHuge)
{
// #121236# 567twips == 1cm, but just take three times the normal snap
aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
}
nX *= aSnap.Width();
nY *= aSnap.Height();
SdrView *pSdrView = rSh.GetDrawView();
const SdrHdlList& rHdlList = pSdrView->GetHdlList();
SdrHdl* pHdl = rHdlList.GetFocusHdl();
rSh.StartAllAction();
if(0L == pHdl)
{
// now move the selected draw objects
// if the object's position is not protected
if(0 == (nProtect&FLYPROTECT_POS))
{
sal_Bool bDummy1, bDummy2;
const bool bVertAnchor = rSh.IsFrmVertical( sal_True, bDummy1, bDummy2 );
const bool bHoriMove = !bVertAnchor == !( nDir % 2 );
const bool bMoveAllowed =
!bHoriMove || (rSh.GetAnchorId() != FLY_AS_CHAR);
if ( bMoveAllowed )
{
pSdrView->MoveAllMarked(Size(nX, nY));
rSh.SetModified();
}
}
}
else
{
// move handle with index nHandleIndex
if(pHdl && (nX || nY))
{
if( HDL_ANCHOR == pHdl->GetKind() ||
HDL_ANCHOR_TR == pHdl->GetKind() )
{
// anchor move cannot be allowed when position is protected
if(0 == (nProtect&FLYPROTECT_POS))
rSh.MoveAnchor( nAnchorDir );
}
//now resize if size is protected
else if(0 == (nProtect&FLYPROTECT_SIZE))
{
// now move the Handle (nX, nY)
Point aStartPoint(pHdl->GetPos());
Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
const SdrDragStat& rDragStat = pSdrView->GetDragStat();
// start dragging
pSdrView->BegDragObj(aStartPoint, 0, pHdl, 0);
if(pSdrView->IsDragObj())
{
sal_Bool bWasNoSnap = static_cast< sal_Bool >(rDragStat.IsNoSnap());
sal_Bool bWasSnapEnabled = pSdrView->IsSnapEnabled();
// switch snapping off
if(!bWasNoSnap)
((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
if(bWasSnapEnabled)
pSdrView->SetSnapEnabled(sal_False);
pSdrView->MovAction(aEndPoint);
pSdrView->EndDragObj();
rSh.SetModified();
// restore snap
if(!bWasNoSnap)
((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
if(bWasSnapEnabled)
pSdrView->SetSnapEnabled(bWasSnapEnabled);
}
}
}
}
rSh.EndAllAction();
}
rSh.EndUndo();
}
/*--------------------------------------------------------------------
Beschreibung: KeyEvents
--------------------------------------------------------------------*/
void SwEditWin::KeyInput(const KeyEvent &rKEvt)
{
if( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE &&
pApplyTempl && pApplyTempl->pFormatClipboard )
{
pApplyTempl->pFormatClipboard->Erase();
SetApplyTemplate(SwApplyTemplate());
rView.GetViewFrame()->GetBindings().Invalidate(SID_FORMATPAINTBRUSH);
}
SfxObjectShell *pObjSh = (SfxObjectShell*)rView.GetViewFrame()->GetObjectShell();
if ( bLockInput || (pObjSh && pObjSh->GetProgress()) )
// Wenn die Rechenleiste aktiv ist oder
// auf dem Document ein Progress laeuft wird keine
// Bestellungen angenommen.
return;
if( pShadCrsr )
delete pShadCrsr, pShadCrsr = 0;
aKeyInputFlushTimer.Stop();
SwWrtShell &rSh = rView.GetWrtShell();
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
rSh.IsCrsrReadonly();
//if the language changes the buffer must be flushed
LanguageType eNewLanguage = GetInputLanguage();
if(!bIsDocReadOnly && eBufferLanguage != eNewLanguage && aInBuffer.Len())
{
FlushInBuffer();
}
eBufferLanguage = eNewLanguage;
QuickHelpData aTmpQHD;
if( pQuickHlpData->bClear )
{
aTmpQHD.Move( *pQuickHlpData );
pQuickHlpData->Stop( rSh );
}
// OS:auch die DrawView braucht noch ein readonly-Flag
if ( !bIsDocReadOnly && rSh.GetDrawView() && rSh.GetDrawView()->KeyInput( rKEvt, this ) )
{
rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll( sal_False );
rSh.SetModified();
return; // Event von der SdrView ausgewertet
}
if ( rView.GetDrawFuncPtr() && bInsFrm )
{
StopInsFrm();
rSh.Edit();
}
sal_Bool bFlushBuffer = sal_False;
sal_Bool bNormalChar = sal_False;
sal_Bool bChkInsBlank = pQuickHlpData->bChkInsBlank;
pQuickHlpData->bChkInsBlank = sal_False;
KeyEvent aKeyEvent( rKEvt );
// look for vertical mappings
if( !bIsDocReadOnly && !rSh.IsSelFrmMode() && !rSh.IsObjSelected() )
{
//JP 21.2.2002: must changed from switch to if, because the Linux
// compiler has problem with the code. Has to remove if the new general
// handler exist.
sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();
if( KEY_UP == nKey || KEY_DOWN == nKey ||
KEY_LEFT == nKey || KEY_RIGHT == nKey )
{
// In general, we want to map the direction keys if we are inside
// some vertical formatted text.
// 1. Exception: For a table cursor in a horizontal table, the
// directions should never be mapped.
// 2. Exception: For a table cursor in a vertical table, the
// directions should always be mapped.
const bool bVertText = rSh.IsInVerticalText();
const bool bTblCrsr = rSh.GetTableCrsr();
const bool bVertTable = rSh.IsTableVertical();
if( ( bVertText && ( !bTblCrsr || bVertTable ) ) ||
( bTblCrsr && bVertTable ) )
{
// Attempt to integrate cursor travelling for mongolian layout does not work.
// Thus, back to previous mapping of cursor keys to direction keys.
if( KEY_UP == nKey ) nKey = KEY_LEFT;
else if( KEY_DOWN == nKey ) nKey = KEY_RIGHT;
else if( KEY_LEFT == nKey ) nKey = KEY_DOWN;
else if( KEY_RIGHT == nKey ) nKey = KEY_UP;
}
if ( rSh.IsInRightToLeftText() )
{
if( KEY_LEFT == nKey ) nKey = KEY_RIGHT;
else if( KEY_RIGHT == nKey ) nKey = KEY_LEFT;
}
aKeyEvent = KeyEvent( rKEvt.GetCharCode(),
KeyCode( nKey, rKEvt.GetKeyCode().GetModifier() ),
rKEvt.GetRepeat() );
}
}
const KeyCode& rKeyCode = aKeyEvent.GetKeyCode();
sal_Unicode aCh = aKeyEvent.GetCharCode();
// enable switching to notes ankor with Ctrl - Alt - Page Up/Down
// pressing this inside a note will switch to next/previous note
if ((rKeyCode.IsMod1() && rKeyCode.IsMod2()) && ((rKeyCode.GetCode() == KEY_PAGEUP) || (rKeyCode.GetCode() == KEY_PAGEDOWN)))
{
const bool bNext = rKeyCode.GetCode()==KEY_PAGEDOWN ? true : false;
const SwFieldType* pFldType = rSh.GetFldType( 0, RES_POSTITFLD );
rSh.MoveFldType( pFldType, bNext );
return;
}
const SwFrmFmt* pFlyFmt = rSh.GetFlyFrmFmt();
if( pFlyFmt )
{
sal_uInt16 nEvent;
if( 32 <= aCh &&
0 == (( KEY_MOD1 | KEY_MOD2 ) & rKeyCode.GetModifier() ))
nEvent = SW_EVENT_FRM_KEYINPUT_ALPHA;
else
nEvent = SW_EVENT_FRM_KEYINPUT_NOALPHA;
const SvxMacro* pMacro = pFlyFmt->GetMacro().GetMacroTable().Get( nEvent );
if( pMacro )
{
String sRet;
SbxArrayRef xArgs = new SbxArray;
SbxVariableRef xVar = new SbxVariable;
xVar->PutString( pFlyFmt->GetName() );
xArgs->Put( &xVar, 1 );
xVar = new SbxVariable;
if( SW_EVENT_FRM_KEYINPUT_ALPHA == nEvent )
xVar->PutChar( aCh );
else
xVar->PutUShort( rKeyCode.GetModifier() | rKeyCode.GetCode() );
xArgs->Put( &xVar, 2 );
rSh.ExecMacro( *pMacro, &sRet, &xArgs );
if( sRet.Len() && 0 != sRet.ToInt32() )
return ;
}
}
int nLclSelectionType;
//A is converted to 1
if( rKeyCode.GetFullCode() == (KEY_A | KEY_MOD1 |KEY_SHIFT)
&& rSh.HasDrawView() &&
(0 != (nLclSelectionType = rSh.GetSelectionType()) &&
((nLclSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_GRF)) ||
((nLclSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1))))
{
SdrHdlList& rHdlList = (SdrHdlList&)rSh.GetDrawView()->GetHdlList();
SdrHdl* pAnchor = rHdlList.GetHdl(HDL_ANCHOR);
if ( ! pAnchor )
pAnchor = rHdlList.GetHdl(HDL_ANCHOR_TR);
if(pAnchor)
rHdlList.SetFocusHdl(pAnchor);
return;
}
SvxAutoCorrCfg* pACfg = 0;
SvxAutoCorrect* pACorr = 0;
uno::Reference< frame::XDispatchRecorder > xRecorder =
rView.GetViewFrame()->GetBindings().GetRecorder();
if ( !xRecorder.is() )
{
pACfg = SvxAutoCorrCfg::Get();
pACorr = pACfg->GetAutoCorrect();
}
SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
TblChgWidthHeightType eTblChgMode = nsTblChgWidthHeightType::WH_COL_LEFT; // initialization just for warning-free code
sal_uInt16 nTblChgSize = 0;
sal_Bool bStopKeyInputTimer = sal_True;
String sFmlEntry;
enum SW_KeyState { KS_Start,
KS_CheckKey, KS_InsChar, KS_InsTab,
KS_NoNum, KS_NumOff, KS_NumOrNoNum, KS_NumDown, KS_NumUp,
// -> #i23725#
KS_NumIndentInc, KS_NumIndentDec,
// <- #i23725#
KS_OutlineLvOff,
KS_NextCell, KS_PrevCell, KS_OutlineUp, KS_OutlineDown,
KS_GlossaryExpand, KS_NextPrevGlossary,
KS_AutoFmtByInput,
KS_NextObject, KS_PrevObject,
KS_KeyToView,
KS_LaunchOLEObject, KS_GoIntoFly, KS_GoIntoDrawing,
KS_EnterDrawHandleMode,
KS_CheckDocReadOnlyKeys,
KS_CheckAutoCorrect, KS_EditFormula,
KS_ColLeftBig, KS_ColRightBig,
KS_ColLeftSmall, KS_ColRightSmall,
KS_ColTopBig, KS_ColBottomBig,
KS_ColTopSmall, KS_ColBottomSmall,
KS_CellLeftBig, KS_CellRightBig,
KS_CellLeftSmall, KS_CellRightSmall,
KS_CellTopBig, KS_CellBottomBig,
KS_CellTopSmall, KS_CellBottomSmall,
KS_InsDel_ColLeftBig, KS_InsDel_ColRightBig,
KS_InsDel_ColLeftSmall, KS_InsDel_ColRightSmall,
KS_InsDel_ColTopBig, KS_InsDel_ColBottomBig,
KS_InsDel_ColTopSmall, KS_InsDel_ColBottomSmall,
KS_InsDel_CellLeftBig, KS_InsDel_CellRightBig,
KS_InsDel_CellLeftSmall, KS_InsDel_CellRightSmall,
KS_InsDel_CellTopBig, KS_InsDel_CellBottomBig,
KS_InsDel_CellTopSmall, KS_InsDel_CellBottomSmall,
KS_TblColCellInsDel,
KS_Fly_Change, KS_Draw_Change,
KS_SpecialInsert,
KS_EnterCharCell,
KS_GotoNextFieldMark,
KS_GotoPrevFieldMark,
KS_Ende };
SW_KeyState eKeyState = bIsDocReadOnly ? KS_CheckDocReadOnlyKeys : KS_CheckKey;
SW_KeyState eNextKeyState = KS_Ende;
sal_uInt8 nDir = 0;
if (nKS_NUMDOWN_Count > 0)
nKS_NUMDOWN_Count--;
if (nKS_NUMINDENTINC_Count > 0)
nKS_NUMINDENTINC_Count--;
while( KS_Ende != eKeyState )
{
SW_KeyState eFlyState = KS_KeyToView;
switch( eKeyState )
{
case KS_CheckKey:
eKeyState = KS_KeyToView; // default weiter zur View
#ifdef DBG_UTIL
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// JP 19.01.99: zum Umschalten des Cursor Verhaltens in ReadOnly
// Bereichen
if( 0x7210 == rKeyCode.GetFullCode() )
rSh.SetReadOnlyAvailable( !rSh.IsReadOnlyAvailable() );
else
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#endif
if( !rKeyCode.IsMod2() && '=' == aCh &&
!rSh.IsTableMode() && rSh.GetTableFmt() &&
rSh.IsSttPara() /*&& rSh.IsEndPara()*/ &&
!rSh.HasReadonlySel() )
{
// in der Tabelle am Anfang der Zelle ein '=' ->
// EditZeile aufrufen (F2-Funktionalitaet)
rSh.Push();
if( !rSh.MoveSection( fnSectionCurr, fnSectionStart) &&
!rSh.IsTableBoxTextFormat() )
{
// steht also am Anfang der Box
eKeyState = KS_EditFormula;
if( rSh.HasMark() )
rSh.SwapPam();
else
rSh.SttSelect();
rSh.MoveSection( fnSectionCurr, fnSectionEnd );
rSh.Pop( sal_True );
rSh.EndSelect();
sFmlEntry = '=';
}
else
rSh.Pop( sal_False );
}
else
{
if( pACorr && aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
!rSh.HasReadonlySel() && !aTmpQHD.bIsAutoText &&
pACorr->GetSwFlags().nAutoCmpltExpandKey ==
(rKeyCode.GetModifier() | rKeyCode.GetCode()) )
{
eKeyState = KS_GlossaryExpand;
break;
}
switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
{
case KEY_RIGHT | KEY_MOD2:
eKeyState = KS_ColRightBig;
eFlyState = KS_Fly_Change;
nDir = MOVE_RIGHT_SMALL;
goto KEYINPUT_CHECKTABLE;
case KEY_LEFT | KEY_MOD2:
eKeyState = KS_ColRightSmall;
eFlyState = KS_Fly_Change;
nDir = MOVE_LEFT_SMALL;
goto KEYINPUT_CHECKTABLE;
case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT:
eKeyState = KS_ColLeftSmall;
goto KEYINPUT_CHECKTABLE;
case KEY_LEFT | KEY_MOD2 | KEY_SHIFT:
eKeyState = KS_ColLeftBig;
goto KEYINPUT_CHECKTABLE;
case KEY_RIGHT | KEY_MOD2 | KEY_MOD1:
eKeyState = KS_CellRightBig;
goto KEYINPUT_CHECKTABLE;
case KEY_LEFT | KEY_MOD2 | KEY_MOD1:
eKeyState = KS_CellRightSmall;
goto KEYINPUT_CHECKTABLE;
case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
eKeyState = KS_CellLeftSmall;
goto KEYINPUT_CHECKTABLE;
case KEY_LEFT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
eKeyState = KS_CellLeftBig;
goto KEYINPUT_CHECKTABLE;
case KEY_UP | KEY_MOD2:
eKeyState = KS_ColBottomSmall;
eFlyState = KS_Fly_Change;
nDir = MOVE_UP_SMALL;
goto KEYINPUT_CHECKTABLE;
case KEY_DOWN | KEY_MOD2:
eKeyState = KS_ColBottomBig;
eFlyState = KS_Fly_Change;
nDir = MOVE_DOWN_SMALL;
goto KEYINPUT_CHECKTABLE;
case KEY_UP | KEY_MOD2 | KEY_MOD1:
eKeyState = KS_CellBottomSmall;
goto KEYINPUT_CHECKTABLE;
case KEY_DOWN | KEY_MOD2 | KEY_MOD1:
eKeyState = KS_CellBottomBig;
goto KEYINPUT_CHECKTABLE;
case KEY_UP | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
eKeyState = KS_CellTopBig;
goto KEYINPUT_CHECKTABLE;
case KEY_DOWN | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
eKeyState = KS_CellTopSmall;
goto KEYINPUT_CHECKTABLE;
KEYINPUT_CHECKTABLE:
if( rSh.IsTableMode() || !rSh.GetTableFmt() )
{
if(KS_KeyToView != eFlyState)
{
if(!pFlyFmt && KS_KeyToView != eFlyState &&
(rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
rSh.GetDrawView()->AreObjectsMarked())
eKeyState = KS_Draw_Change;
}
if( pFlyFmt )
eKeyState = eFlyState;
else if( KS_Draw_Change != eKeyState)
eKeyState = KS_EnterCharCell;
}
break;
// huge object move
case KEY_RIGHT | KEY_SHIFT:
case KEY_LEFT | KEY_SHIFT:
case KEY_UP | KEY_SHIFT:
case KEY_DOWN | KEY_SHIFT:
{
const int nSelectionType = rSh.GetSelectionType();
if ( ( pFlyFmt
&& ( nSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF) ) )
|| ( ( nSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM) )
&& rSh.GetDrawView()->AreObjectsMarked() ) )
{
eKeyState = pFlyFmt ? KS_Fly_Change : KS_Draw_Change;
switch ( rKeyCode.GetCode() )
{
case KEY_RIGHT: nDir = MOVE_RIGHT_HUGE; break;
case KEY_LEFT: nDir = MOVE_LEFT_HUGE; break;
case KEY_UP: nDir = MOVE_UP_HUGE; break;
case KEY_DOWN: nDir = MOVE_DOWN_HUGE; break;
}
}
break;
}
//-------
// Insert/Delete
case KEY_LEFT:
case KEY_LEFT | KEY_MOD1:
{
sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
if(!bMod1)
{
eFlyState = KS_Fly_Change;
nDir = MOVE_LEFT_BIG;
}
eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
( bMod1
? nsTblChgWidthHeightType::WH_CELL_LEFT
: nsTblChgWidthHeightType::WH_COL_LEFT );
nTblChgSize = pModOpt->GetTblVInsert();
}
goto KEYINPUT_CHECKTABLE_INSDEL;
case KEY_RIGHT | KEY_MOD1:
{
eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_CELL_RIGHT;
nTblChgSize = pModOpt->GetTblVInsert();
}
goto KEYINPUT_CHECKTABLE_INSDEL;
case KEY_UP:
case KEY_UP | KEY_MOD1:
{
sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
if(!bMod1)
{
eFlyState = KS_Fly_Change;
nDir = MOVE_UP_BIG;
}
eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
( bMod1
? nsTblChgWidthHeightType::WH_CELL_TOP
: nsTblChgWidthHeightType::WH_ROW_TOP );
nTblChgSize = pModOpt->GetTblHInsert();
}
goto KEYINPUT_CHECKTABLE_INSDEL;
case KEY_DOWN:
case KEY_DOWN | KEY_MOD1:
{
sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
if(!bMod1)
{
eFlyState = KS_Fly_Change;
nDir = MOVE_DOWN_BIG;
}
eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
( bMod1
? nsTblChgWidthHeightType::WH_CELL_BOTTOM
: nsTblChgWidthHeightType::WH_ROW_BOTTOM );
nTblChgSize = pModOpt->GetTblHInsert();
}
goto KEYINPUT_CHECKTABLE_INSDEL;
KEYINPUT_CHECKTABLE_INSDEL:
if( rSh.IsTableMode() || !rSh.GetTableFmt() ||
!bTblInsDelMode ||
sal_False /* Tabelle geschuetzt */
)
{
const int nSelectionType = rSh.GetSelectionType();
eKeyState = KS_KeyToView;
if(KS_KeyToView != eFlyState)
{
if((nSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
rSh.GetDrawView()->AreObjectsMarked())
eKeyState = KS_Draw_Change;
else if(nSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF))
eKeyState = KS_Fly_Change;
}
}
else
{
if( !bTblIsInsMode )
eTblChgMode = eTblChgMode | nsTblChgWidthHeightType::WH_FLAG_BIGGER;
eKeyState = KS_TblColCellInsDel;
}
break;
case KEY_DELETE:
if (rSh.IsInFrontOfLabel() &&
rSh.NumOrNoNum(sal_False))
eKeyState = KS_NumOrNoNum;
break;
case KEY_DELETE | KEY_MOD2:
if( !rSh.IsTableMode() && rSh.GetTableFmt() )
{
eKeyState = KS_Ende;
bTblInsDelMode = sal_True;
bTblIsInsMode = sal_False;
bTblIsColMode = sal_True;
aKeyInputTimer.Start();
bStopKeyInputTimer = sal_False;
}
break;
case KEY_INSERT | KEY_MOD2:
if( !rSh.IsTableMode() && rSh.GetTableFmt() )
{
eKeyState = KS_Ende;
bTblInsDelMode = sal_True;
bTblIsInsMode = sal_True;
bTblIsColMode = sal_True;
aKeyInputTimer.Start();
bStopKeyInputTimer = sal_False;
}
break;
case KEY_RETURN: // Return
if ( !rSh.HasReadonlySel()
&& !rSh.CrsrInsideInputFld() )
{
const int nSelectionType = rSh.GetSelectionType();
if(nSelectionType & nsSelectionType::SEL_OLE)
eKeyState = KS_LaunchOLEObject;
else if(nSelectionType & nsSelectionType::SEL_FRM)
eKeyState = KS_GoIntoFly;
else if((nSelectionType & nsSelectionType::SEL_DRW) &&
0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) &&
rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)
eKeyState = KS_GoIntoDrawing;
else if( aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
aTmpQHD.bIsAutoText )
eKeyState = KS_GlossaryExpand;
//RETURN und leerer Absatz in Numerierung -> Num. beenden
else if( !aInBuffer.Len() &&
rSh.GetCurNumRule() &&
!rSh.GetCurNumRule()->IsOutlineRule() &&
!rSh.HasSelection() &&
rSh.IsSttPara() && rSh.IsEndPara() )
eKeyState = KS_NumOff, eNextKeyState = KS_OutlineLvOff;
//RETURN fuer neuen Absatz mit AutoFormatierung
else if( pACfg && pACfg->IsAutoFmtByInput() &&
!(nSelectionType & (nsSelectionType::SEL_GRF |
nsSelectionType::SEL_OLE | nsSelectionType::SEL_FRM |
nsSelectionType::SEL_TBL_CELLS | nsSelectionType::SEL_DRW |
nsSelectionType::SEL_DRW_TXT)) )
eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_AutoFmtByInput;
else
eNextKeyState = eKeyState, eKeyState = KS_CheckAutoCorrect;
}
break;
case KEY_RETURN | KEY_MOD2: // ALT-Return
if ( !rSh.HasReadonlySel()
&& !rSh.IsSttPara()
&& rSh.GetCurNumRule()
&& !rSh.CrsrInsideInputFld() )
{
eKeyState = KS_NoNum;
}
else if( rSh.CanSpecialInsert() )
eKeyState = KS_SpecialInsert;
break;
case KEY_BACKSPACE:
case KEY_BACKSPACE | KEY_SHIFT:
if ( !rSh.HasReadonlySel()
&& !rSh.CrsrInsideInputFld() )
{
sal_Bool bDone = sal_False;
// Remove the paragraph indent, if the cursor is at the
// beginning of a paragraph, there is no selection
// and no numbering rule found at the current paragraph
// Also try to remove indent, if current paragraph
// has numbering rule, but isn't counted and only
// key <backspace> is hit.
const bool bOnlyBackspaceKey( KEY_BACKSPACE == rKeyCode.GetFullCode() );
if ( rSh.IsSttPara()
&& !rSh.HasSelection()
&& ( rSh.GetCurNumRule() == NULL
|| ( rSh.IsNoNum() && bOnlyBackspaceKey ) ) )
{
bDone = rSh.TryRemoveIndent();
}
if (bDone)
eKeyState = KS_Ende;
else
{
if ( rSh.IsSttPara() && !rSh.IsNoNum() )
{
if (nKS_NUMDOWN_Count > 0
&& rSh.GetNumLevel() > 0)
{
eKeyState = KS_NumUp;
nKS_NUMDOWN_Count = 2;
bDone = sal_True;
}
else if (nKS_NUMINDENTINC_Count > 0)
{
eKeyState = KS_NumIndentDec;
nKS_NUMINDENTINC_Count = 2;
bDone = sal_True;
}
}
// If the cursor is in an empty paragraph, which has
// a numbering, but not the outline numbering, and
// there is no selection, the numbering has to be
// deleted on key <Backspace>.
// Otherwise method <SwEditShell::NumOrNoNum(..)>
// should only change the <IsCounted()> state of
// the current paragraph depending of the key.
// On <backspace> it is set to <false>,
// on <shift-backspace> it is set to <true>.
// Thus, assure that method <SwEditShell::NumOrNum(..)>
// is only called for the intended purpose.
if ( !bDone && rSh.IsSttPara() )
{
bool bCallNumOrNoNum( false );
if ( bOnlyBackspaceKey && !rSh.IsNoNum() )
{
bCallNumOrNoNum = true;
}
else if ( !bOnlyBackspaceKey && rSh.IsNoNum() )
{
bCallNumOrNoNum = true;
}
else if ( bOnlyBackspaceKey
&& rSh.IsSttPara()
&& rSh.IsEndPara()
&& !rSh.HasSelection() )
{
const SwNumRule* pCurrNumRule( rSh.GetCurNumRule() );
if ( pCurrNumRule != NULL
&& pCurrNumRule != rSh.GetOutlineNumRule() )
{
bCallNumOrNoNum = true;
}
}
if ( bCallNumOrNoNum
&& rSh.NumOrNoNum( !bOnlyBackspaceKey, sal_True ) )
{
eKeyState = KS_NumOrNoNum;
}
}
}
}
break;
case KEY_RIGHT:
{
eFlyState = KS_Fly_Change;
nDir = MOVE_RIGHT_BIG;
eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_COL_RIGHT;
nTblChgSize = pModOpt->GetTblVInsert();
goto KEYINPUT_CHECKTABLE_INSDEL;
}
case KEY_TAB:
{
#ifdef SW_CRSR_TIMER
sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
#endif
if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark() || rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
{
eKeyState=KS_GotoNextFieldMark;
}
else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
{
GetView().GetViewFrame()->GetDispatcher()->Execute( FN_GOTO_NEXT_INPUTFLD );
eKeyState = KS_Ende;
}
else if( rSh.GetCurNumRule()
&& rSh.IsSttOfPara()
&& !rSh.HasReadonlySel() )
{
if ( rSh.IsFirstOfNumRule() &&
numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
eKeyState = KS_NumIndentInc;
else
eKeyState = KS_NumDown;
}
else if ( rSh.GetTableFmt() )
{
if( rSh.HasSelection() || rSh.HasReadonlySel() )
eKeyState = KS_NextCell;
else
eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_NextCell;
}
else if ( rSh.GetSelectionType() &
(nsSelectionType::SEL_GRF |
nsSelectionType::SEL_FRM |
nsSelectionType::SEL_OLE |
nsSelectionType::SEL_DRW |
nsSelectionType::SEL_DRW_FORM))
eKeyState = KS_NextObject;
else
{
eKeyState = KS_InsTab;
if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
{
SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
if( pColl &&
//0 <= pColl->GetOutlineLevel() && #i24560#
//MAXLEVEL - 1 > pColl->GetOutlineLevel() )//#outline level,zhaojianwei
pColl->IsAssignedToListLevelOfOutlineStyle()
&& MAXLEVEL-1 > pColl->GetAssignedOutlineStyleLevel() )//<-end,zhaojianwei
eKeyState = KS_OutlineDown;
}
}
#ifdef SW_CRSR_TIMER
rSh.ChgCrsrTimerFlag( bOld );
#endif
}
break;
case KEY_TAB | KEY_SHIFT:
{
#ifdef SW_CRSR_TIMER
sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
#endif
if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark()|| rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
{
eKeyState=KS_GotoPrevFieldMark;
}
else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
{
GetView().GetViewFrame()->GetDispatcher()->Execute( FN_GOTO_PREV_INPUTFLD );
eKeyState = KS_Ende;
}
else if( rSh.GetCurNumRule()
&& rSh.IsSttOfPara()
&& !rSh.HasReadonlySel() )
{
if ( rSh.IsFirstOfNumRule() &&
numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
eKeyState = KS_NumIndentDec;
else
eKeyState = KS_NumUp;
}
else if ( rSh.GetTableFmt() )
{
if( rSh.HasSelection() || rSh.HasReadonlySel() )
eKeyState = KS_PrevCell;
else
eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_PrevCell;
}
else if ( rSh.GetSelectionType() &
(nsSelectionType::SEL_GRF |
nsSelectionType::SEL_FRM |
nsSelectionType::SEL_OLE |
nsSelectionType::SEL_DRW |
nsSelectionType::SEL_DRW_FORM))
eKeyState = KS_PrevObject;
else
{
eKeyState = KS_Ende;
if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
{
SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
//if( pColl && 0 < pColl->GetOutlineLevel() && //#outline level,zhaojianwei
// MAXLEVEL - 1 >= pColl->GetOutlineLevel() )
if( pColl &&
pColl->IsAssignedToListLevelOfOutlineStyle() &&
0 < pColl->GetAssignedOutlineStyleLevel())
eKeyState = KS_OutlineUp;
}
}
#ifdef SW_CRSR_TIMER
rSh.ChgCrsrTimerFlag( bOld );
#endif
}
break;
case KEY_TAB | KEY_MOD1:
case KEY_TAB | KEY_MOD2:
if( !rSh.HasReadonlySel() )
{
if( aTmpQHD.HasCntnt() && !rSh.HasSelection() )
{
// zum naechsten Tip
aTmpQHD.Inc( pACorr && pACorr->GetSwFlags().
bAutoCmpltEndless );
eKeyState = KS_NextPrevGlossary;
}
else if( rSh.GetTableFmt() )
eKeyState = KS_InsTab;
else if((rSh.GetSelectionType() &
(nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM|
nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) &&
rSh.GetDrawView()->AreObjectsMarked())
eKeyState = KS_EnterDrawHandleMode;
else
{
eKeyState = KS_InsTab;
}
}
break;
case KEY_TAB | KEY_MOD1 | KEY_SHIFT:
if( aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
!rSh.HasReadonlySel() )
{
// zum vorherigen Tip
aTmpQHD.Dec( pACorr && pACorr->GetSwFlags().
bAutoCmpltEndless );
eKeyState = KS_NextPrevGlossary;
}
else if((rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM|
nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) &&
rSh.GetDrawView()->AreObjectsMarked())
eKeyState = KS_EnterDrawHandleMode;
break;
case KEY_F2 :
if( !rSh.HasReadonlySel() )
{
const int nSelectionType = rSh.GetSelectionType();
if(nSelectionType & nsSelectionType::SEL_FRM)
eKeyState = KS_GoIntoFly;
else if((nSelectionType & nsSelectionType::SEL_DRW))
eKeyState = KS_GoIntoDrawing;
}
break;
}
}
break;
case KS_CheckDocReadOnlyKeys:
{
eKeyState = KS_KeyToView;
switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
{
case KEY_TAB:
case KEY_TAB | KEY_SHIFT:
bNormalChar = sal_False;
eKeyState = KS_Ende;
if ( rSh.GetSelectionType() &
(nsSelectionType::SEL_GRF |
nsSelectionType::SEL_FRM |
nsSelectionType::SEL_OLE |
nsSelectionType::SEL_DRW |
nsSelectionType::SEL_DRW_FORM))
{
eKeyState = rKeyCode.GetModifier() & KEY_SHIFT ?
KS_PrevObject : KS_NextObject;
}
else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
{
GetView().GetViewFrame()->GetDispatcher()->Execute(
KEY_SHIFT != rKeyCode.GetModifier() ? FN_GOTO_NEXT_INPUTFLD : FN_GOTO_PREV_INPUTFLD );
}
else
{
rSh.SelectNextPrevHyperlink( KEY_SHIFT != rKeyCode.GetModifier() );
}
break;
case KEY_RETURN:
{
const int nSelectionType = rSh.GetSelectionType();
if(nSelectionType & nsSelectionType::SEL_FRM)
eKeyState = KS_GoIntoFly;
else
{
SfxItemSet aSet(rSh.GetAttrPool(), RES_TXTATR_INETFMT, RES_TXTATR_INETFMT);
rSh.GetCurAttr(aSet);
if(SFX_ITEM_SET == aSet.GetItemState(RES_TXTATR_INETFMT, sal_False))
{
const SfxPoolItem& rItem = aSet.Get(RES_TXTATR_INETFMT, sal_True);
bNormalChar = sal_False;
eKeyState = KS_Ende;
rSh.ClickToINetAttr((const SwFmtINetFmt&)rItem, URLLOAD_NOFILTER);
}
}
}
break;
}
}
break;
case KS_EnterCharCell:
{
eKeyState = KS_KeyToView;
switch ( rKeyCode.GetModifier() | rKeyCode.GetCode() )
{
case KEY_RIGHT | KEY_MOD2:
rSh.Right( CRSR_SKIP_CHARS, sal_False, 1, sal_False );
eKeyState = KS_Ende;
FlushInBuffer();
break;
case KEY_LEFT | KEY_MOD2:
rSh.Left( CRSR_SKIP_CHARS, sal_False, 1, sal_False );
eKeyState = KS_Ende;
FlushInBuffer();
break;
}
}
break;
case KS_KeyToView:
{
eKeyState = KS_Ende;
bNormalChar =
!rKeyCode.IsMod2() &&
rKeyCode.GetModifier() != (KEY_MOD1) &&
rKeyCode.GetModifier() != (KEY_MOD1|KEY_SHIFT) &&
SW_ISPRINTABLE( aCh );
if (bNormalChar && rSh.IsInFrontOfLabel())
{
rSh.NumOrNoNum(sal_False);
}
if( aInBuffer.Len() && ( !bNormalChar || bIsDocReadOnly ))
FlushInBuffer();
if( rView.KeyInput( aKeyEvent ) )
bFlushBuffer = sal_True, bNormalChar = sal_False;
else
{
// OS 22.09.95: Da der Sfx Acceleratoren nur aufruft, wenn sie beim letzten
// Statusupdate enabled wurden, muss copy ggf. von uns
// 'gewaltsam' gerufen werden.
if( rKeyCode.GetFunction() == KEYFUNC_COPY )
GetView().GetViewFrame()->GetBindings().Execute(SID_COPY);
if( !bIsDocReadOnly && bNormalChar )
{
const int nSelectionType = rSh.GetSelectionType();
if((nSelectionType & nsSelectionType::SEL_DRW) &&
0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) &&
rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)
{
SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
if(pObj)
{
EnterDrawTextMode(pObj->GetLogicRect().Center());
if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
((SwDrawTextShell*)rView.GetCurShell())->Init();
rSh.GetDrawView()->KeyInput( rKEvt, this );
}
}
else if(nSelectionType & nsSelectionType::SEL_FRM)
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
rSh.MoveSection( fnSectionCurr, fnSectionEnd );
}
eKeyState = KS_InsChar;
}
else
{
bNormalChar = sal_False;
Window::KeyInput( aKeyEvent );
}
}
}
break;
case KS_LaunchOLEObject:
rSh.LaunchOLEObj();
eKeyState = KS_Ende;
break;
case KS_GoIntoFly :
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
rSh.MoveSection( fnSectionCurr, fnSectionEnd );
eKeyState = KS_Ende;
break;
case KS_GoIntoDrawing :
{
SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
if(pObj)
{
EnterDrawTextMode(pObj->GetLogicRect().Center());
if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
((SwDrawTextShell*)rView.GetCurShell())->Init();
}
eKeyState = KS_Ende;
}
break;
case KS_EnterDrawHandleMode:
{
const SdrHdlList& rHdlList = rSh.GetDrawView()->GetHdlList();
sal_Bool bForward(!aKeyEvent.GetKeyCode().IsShift());
((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
eKeyState = KS_Ende;
}
break;
case KS_InsTab:
if( rView.ISA( SwWebView )) //Kein Tabulator fuer Web!
{
Window::KeyInput( aKeyEvent );
eKeyState = KS_Ende;
break;
}
aCh = '\t';
// kein break!
case KS_InsChar:
if (rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
{
::sw::mark::ICheckboxFieldmark* pFieldmark =
dynamic_cast< ::sw::mark::ICheckboxFieldmark* >
(rSh.GetCurrentFieldmark());
OSL_ENSURE(pFieldmark,
"Where is my FieldMark??");
if(pFieldmark)
{
pFieldmark->SetChecked(!pFieldmark->IsChecked());
OSL_ENSURE(pFieldmark->IsExpanded(),
"where is the otherpos?");
if (pFieldmark->IsExpanded())
{
rSh.CalcLayout();
}
}
eKeyState = KS_Ende;
}
else if ( !rSh.HasReadonlySel()
|| rSh.CrsrInsideInputFld() )
{
const sal_Bool bIsNormalChar =
GetAppCharClass().isLetterNumeric( String( aCh ), 0 );
if( bChkInsBlank && bIsNormalChar &&
(aInBuffer.Len() || !rSh.IsSttPara() || !rSh.IsEndPara() ))
{
// vor dem Zeichen noch ein Blank einfuegen. Dieses
// kommt zwischen den Expandierten Text und dem neuen
// "nicht Worttrenner".
aInBuffer.Expand( aInBuffer.Len() + 1, ' ' );
}
const sal_Bool bIsAutoCorrectChar = SvxAutoCorrect::IsAutoCorrectChar( aCh );
const sal_Bool bRunNext = pACorr != NULL && pACorr->HasRunNext();
if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) &&
pACfg->IsAutoFmtByInput() &&
(( pACorr->IsAutoCorrFlag( ChgWeightUnderl ) &&
( '*' == aCh || '_' == aCh ) ) ||
( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))||
( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh))))
{
FlushInBuffer();
rSh.AutoCorrect( *pACorr, aCh );
if( '\"' != aCh && '\'' != aCh ) // nur bei "*_" rufen!
rSh.UpdateAttr();
}
else if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) &&
pACfg->IsAutoFmtByInput() &&
pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd |
ChgOrdinalNumber | AddNonBrkSpace |
ChgToEnEmDash | SetINetAttr |
Autocorrect ) &&
'\"' != aCh && '\'' != aCh && '*' != aCh && '_' != aCh
)
{
FlushInBuffer();
rSh.AutoCorrect( *pACorr, aCh );
}
else
{
aInBuffer.Expand( aInBuffer.Len() + aKeyEvent.GetRepeat() + 1,aCh );
bFlushCharBuffer = Application::AnyInput( INPUT_KEYBOARD );
bFlushBuffer = !bFlushCharBuffer;
if( bFlushCharBuffer )
aKeyInputFlushTimer.Start();
}
eKeyState = KS_Ende;
}
else
{
InfoBox( this, SW_RES( MSG_READONLY_CONTENT )).Execute();
eKeyState = KS_Ende;
}
break;
case KS_CheckAutoCorrect:
{
if( pACorr && pACfg->IsAutoFmtByInput() &&
pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd |
ChgOrdinalNumber |
ChgToEnEmDash | SetINetAttr |
Autocorrect ) &&
!rSh.HasReadonlySel() )
{
FlushInBuffer();
rSh.AutoCorrect( *pACorr, static_cast< sal_Unicode >('\0') );
}
eKeyState = eNextKeyState;
}
break;
default:
{
sal_uInt16 nSlotId = 0;
FlushInBuffer();
switch( eKeyState )
{
case KS_SpecialInsert:
rSh.DoSpecialInsert();
break;
case KS_NoNum:
rSh.NoNum();
break;
case KS_NumOff:
// Shellwechsel - also vorher aufzeichnen
rSh.DelNumRules();
eKeyState = eNextKeyState;
break;
case KS_OutlineLvOff: // delete autofmt outlinelevel later
break;
case KS_NumDown:
rSh.NumUpDown( sal_True );
nKS_NUMDOWN_Count = 2; // #i23725#
break;
case KS_NumUp:
rSh.NumUpDown( sal_False );
break;
case KS_NumIndentInc:
rSh.ChangeIndentOfAllListLevels(360);
nKS_NUMINDENTINC_Count = 2;
break;
case KS_GotoNextFieldMark:
{
::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkAfter();
if(pFieldmark) rSh.GotoFieldmark(pFieldmark);
}
break;
case KS_GotoPrevFieldMark:
{
::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkBefore();
if(pFieldmark) rSh.GotoFieldmark(pFieldmark);
}
break;
case KS_NumIndentDec:
rSh.ChangeIndentOfAllListLevels(-360);
// <--
break;
case KS_OutlineDown:
rSh.OutlineUpDown( 1 );
break;
case KS_OutlineUp:
rSh.OutlineUpDown( -1 );
break;
case KS_NextCell:
//In Tabelle immer 'flushen'
rSh.GoNextCell();
nSlotId = FN_GOTO_NEXT_CELL;
break;
case KS_PrevCell:
rSh.GoPrevCell();
nSlotId = FN_GOTO_PREV_CELL;
break;
case KS_AutoFmtByInput:
rSh.SplitNode( sal_True );
break;
case KS_NextObject:
case KS_PrevObject:
if(rSh.GotoObj( KS_NextObject == eKeyState, GOTOOBJ_GOTO_ANY))
{
if( rSh.IsFrmSelected() &&
rView.GetDrawFuncPtr() )
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
}
rSh.HideCrsr();
rSh.EnterSelFrmMode();
}
break;
case KS_GlossaryExpand:
{
// ersetze das Wort oder Kuerzel durch den den Textbaustein
rSh.StartUndo( UNDO_START );
String sFnd( *aTmpQHD.aArr[ aTmpQHD.nCurArrPos ] );
if( aTmpQHD.bIsAutoText )
{
SwGlossaryList* pList = ::GetGlossaryList();
String sShrtNm;
String sGroup;
if(pList->GetShortName( sFnd, sShrtNm, sGroup))
{
rSh.SttSelect();
rSh.ExtendSelection( sal_False, aTmpQHD.nLen );
SwGlossaryHdl* pGlosHdl = GetView().GetGlosHdl();
pGlosHdl->SetCurGroup(sGroup, sal_True);
pGlosHdl->InsertGlossary( sShrtNm);
pQuickHlpData->bChkInsBlank = sal_True;
}
}
else
{
rSh.Insert( sFnd.Erase( 0, aTmpQHD.nLen ));
pQuickHlpData->bChkInsBlank = !pACorr ||
pACorr->GetSwFlags().bAutoCmpltAppendBlanc;
}
rSh.EndUndo( UNDO_END );
}
break;
case KS_NextPrevGlossary:
pQuickHlpData->Move( aTmpQHD );
pQuickHlpData->Start( rSh, USHRT_MAX );
break;
case KS_EditFormula:
{
const sal_uInt16 nId = SwInputChild::GetChildWindowId();
SfxViewFrame* pVFrame = GetView().GetViewFrame();
pVFrame->ToggleChildWindow( nId );
SwInputChild* pChildWin = (SwInputChild*)pVFrame->
GetChildWindow( nId );
if( pChildWin )
pChildWin->SetFormula( sFmlEntry );
}
break;
case KS_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
case KS_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
case KS_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHMove() ); break;
case KS_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHMove() ); break;
case KS_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
case KS_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVMove() ); break;
case KS_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
case KS_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
case KS_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHMove() ); break;
case KS_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHMove() ); break;
case KS_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
case KS_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
case KS_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVMove() ); break;
case KS_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVMove() ); break;
//---------------
case KS_InsDel_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_ColTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_ColTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHInsert() ); break;
case KS_InsDel_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVInsert() ); break;
case KS_InsDel_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVInsert() ); break;
//---------------
case KS_TblColCellInsDel:
rSh.SetColRowWidthHeight( eTblChgMode, nTblChgSize );
break;
case KS_Fly_Change:
{
SdrView *pSdrView = rSh.GetDrawView();
const SdrHdlList& rHdlList = pSdrView->GetHdlList();
if(rHdlList.GetFocusHdl())
ChangeDrawing( nDir );
else
ChangeFly( nDir, rView.ISA( SwWebView ) );
}
break;
case KS_Draw_Change :
ChangeDrawing( nDir );
break;
default:; //prevent warning
}
if( nSlotId && rView.GetViewFrame()->GetBindings().GetRecorder().is() )
{
SfxRequest aReq(rView.GetViewFrame(), nSlotId );
aReq.Done();
}
eKeyState = KS_Ende;
}
}
}
if( bStopKeyInputTimer )
{
aKeyInputTimer.Stop();
bTblInsDelMode = sal_False;
}
// falls die gepufferten Zeichen eingefuegt werden sollen
if( bFlushBuffer && aInBuffer.Len() )
{
//OS 16.02.96 11.04: bFlushCharBuffer wurde hier nicht zurueckgesetzt
// warum nicht?
sal_Bool bSave = bFlushCharBuffer;
FlushInBuffer();
bFlushCharBuffer = bSave;
// evt. Tip-Hilfe anzeigen
String sWord;
if( bNormalChar && pACfg && pACorr &&
( pACfg->IsAutoTextTip() ||
pACorr->GetSwFlags().bAutoCompleteWords ) &&
rSh.GetPrevAutoCorrWord( *pACorr, sWord ) )
{
ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr);
}
}
}
/*--------------------------------------------------------------------
Beschreibung: MouseEvents
--------------------------------------------------------------------*/
void SwEditWin::RstMBDownFlags()
{
//Nicht auf allen Systemen kommt vor dem modalen
//Dialog noch ein MouseButton Up (wie unter WINDOWS).
//Daher hier die Stati zuruecksetzen und die Maus
//fuer den Dialog freigeben.
bMBPressed = bNoInterrupt = sal_False;
EnterArea();
ReleaseMouse();
}
void SwEditWin::MouseButtonDown(const MouseEvent& _rMEvt)
{
SwWrtShell &rSh = rView.GetWrtShell();
// We have to check if a context menu is shown and we have an UI
// active inplace client. In that case we have to ignore the mouse
// button down event. Otherwise we would crash (context menu has been
// opened by inplace client and we would deactivate the inplace client,
// the contex menu is closed by VCL asynchronously which in the end
// would work on deleted objects or the context menu has no parent anymore)
// See #126086# and #128122#
SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient();
sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
if ( bIsOleActive && PopupMenu::IsInExecute() )
return;
MouseEvent rMEvt(_rMEvt);
if (rView.GetPostItMgr()->IsHit(rMEvt.GetPosPixel()))
return;
rView.GetPostItMgr()->SetActiveSidebarWin(0);
GrabFocus();
//ignore key modifiers for format paintbrush
{
sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard
&& pApplyTempl->pFormatClipboard->HasContent();
if( bExecFormatPaintbrush )
rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(),
_rMEvt.GetMode(), _rMEvt.GetButtons() );
}
bWasShdwCrsr = 0 != pShadCrsr;
if( bWasShdwCrsr )
delete pShadCrsr, pShadCrsr = 0;
const Point aDocPos( PixelToLogic( rMEvt.GetPosPixel() ) );
if ( IsChainMode() )
{
SetChainMode( sal_False );
SwRect aDummy;
SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)rSh.GetFlyFrmFmt();
if ( !rSh.Chainable( aDummy, *pFmt, aDocPos ) )
rSh.Chain( *pFmt, aDocPos );
UpdatePointer( aDocPos, rMEvt.GetModifier() );
return;
}
//Nach GrabFocus sollte eine Shell gepusht sein. Das muss eigentlich
//klappen aber in der Praxis ...
lcl_SelectShellForDrop( rView );
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly();
sal_Bool bCallBase = sal_True;
if( pQuickHlpData->bClear )
pQuickHlpData->Stop( rSh );
pQuickHlpData->bChkInsBlank = sal_False;
if( rSh.FinishOLEObj() )
return; //InPlace beenden und der Klick zaehlt nicht mehr
SET_CURR_SHELL( &rSh );
SdrView *pSdrView = rSh.GetDrawView();
if ( pSdrView )
{
if (pSdrView->MouseButtonDown( rMEvt, this ) )
{
rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
return; // Event von der SdrView ausgewertet
}
}
bIsInMove = sal_False;
aStartPos = rMEvt.GetPosPixel();
aRszMvHdlPt.X() = 0, aRszMvHdlPt.Y() = 0;
sal_uInt8 nMouseTabCol = 0;
const sal_Bool bTmp = !rSh.IsDrawCreate() && !pApplyTempl && !rSh.IsInSelect() &&
rMEvt.GetClicks() == 1 && MOUSE_LEFT == rMEvt.GetButtons();
if ( bTmp &&
0 != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPos ) ) &&
!rSh.IsObjSelectable( aDocPos ) )
{
// Enhanced table selection
if ( SW_TABSEL_HORI <= nMouseTabCol && SW_TABCOLSEL_VERT >= nMouseTabCol )
{
rSh.EnterStdMode();
rSh.SelectTableRowCol( aDocPos );
if( SW_TABSEL_HORI != nMouseTabCol && SW_TABSEL_HORI_RTL != nMouseTabCol)
{
pRowColumnSelectionStart = new Point( aDocPos );
bIsRowDrag = SW_TABROWSEL_HORI == nMouseTabCol||
SW_TABROWSEL_HORI_RTL == nMouseTabCol ||
SW_TABCOLSEL_VERT == nMouseTabCol;
bMBPressed = sal_True;
CaptureMouse();
}
return;
}
if ( !rSh.IsTableMode() )
{
//Zuppeln von Tabellenspalten aus dem Dokument heraus.
if(SW_TABCOL_VERT == nMouseTabCol || SW_TABCOL_HORI == nMouseTabCol)
rView.SetTabColFromDoc( sal_True );
else
rView.SetTabRowFromDoc( sal_True );
rView.SetTabColFromDocPos( aDocPos );
rView.InvalidateRulerPos();
SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
rBind.Update();
if ( RulerColumnDrag( rMEvt,
(SW_TABCOL_VERT == nMouseTabCol || SW_TABROW_HORI == nMouseTabCol)) )
{
rView.SetTabColFromDoc( sal_False );
rView.SetTabRowFromDoc( sal_False );
rView.InvalidateRulerPos();
rBind.Update();
bCallBase = sal_False;
}
else
{
return;
}
}
}
else if (bTmp &&
rSh.IsNumLabel(aDocPos))
{
SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPos );
rView.SetNumRuleNodeFromDoc( pNodeAtPos );
rView.InvalidateRulerPos();
SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
rBind.Update();
if ( RulerMarginDrag( rMEvt,
rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPos ) ) )
{
rView.SetNumRuleNodeFromDoc( NULL );
rView.InvalidateRulerPos();
rBind.Update();
bCallBase = sal_False;
}
else
{
// Make sure the pointer is set to 0, otherwise it may point to
// nowhere after deleting the corresponding text node.
rView.SetNumRuleNodeFromDoc( NULL );
return;
}
}
if ( rSh.IsInSelect() )
rSh.EndSelect();
//Abfrage auf LEFT, da sonst auch bei einem Click mit der rechten Taste
//beispielsweise die Selektion aufgehoben wird.
if ( MOUSE_LEFT == rMEvt.GetButtons() )
{
sal_Bool bOnlyText = sal_False;
bMBPressed = bNoInterrupt = sal_True;
nKS_NUMDOWN_Count = 0; // #i23725#
CaptureMouse();
//ggf. Cursorpositionen zuruecksetzen
rSh.ResetCursorStack();
switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
{
case MOUSE_LEFT:
case MOUSE_LEFT + KEY_SHIFT:
case MOUSE_LEFT + KEY_MOD2:
if( rSh.IsObjSelected() )
{
SdrHdl* pHdl;
if( !bIsDocReadOnly &&
!pAnchorMarker &&
0 != ( pHdl = pSdrView->PickHandle(aDocPos) ) &&
( pHdl->GetKind() == HDL_ANCHOR ||
pHdl->GetKind() == HDL_ANCHOR_TR ) )
{
// Set selected during drag
pHdl->SetSelected(true);
pAnchorMarker = new SwAnchorMarker( pHdl );
UpdatePointer( aDocPos, rMEvt.GetModifier() );
return;
}
}
if ( EnterDrawMode( rMEvt, aDocPos ) )
{
bNoInterrupt = sal_False;
return;
}
else if ( rView.GetDrawFuncPtr() && bInsFrm )
{
StopInsFrm();
rSh.Edit();
}
// Ohne SHIFT, da sonst Toggle bei Selektion nicht funktioniert
if (rMEvt.GetClicks() == 1)
{
if ( rSh.IsSelFrmMode())
{
SdrHdl* pHdl = rSh.GetDrawView()->PickHandle(aDocPos);
sal_Bool bHitHandle = pHdl && pHdl->GetKind() != HDL_ANCHOR &&
pHdl->GetKind() != HDL_ANCHOR_TR;
if ((rSh.IsInsideSelectedObj(aDocPos) || bHitHandle) &&
!(rMEvt.GetModifier() == KEY_SHIFT && !bHitHandle))
{
rSh.EnterSelFrmMode( &aDocPos );
if ( !pApplyTempl )
{
//nur, wenn keine Position zum Sizen getroffen ist.
if (!bHitHandle)
{
StartDDTimer();
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
}
bFrmDrag = sal_True;
}
bNoInterrupt = sal_False;
return;
}
}
}
}
sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
if ( !bExecHyperlinks )
{
SvtSecurityOptions aSecOpts;
const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) ||
( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) )
bExecHyperlinks = sal_True;
}
// Enhanced selection
sal_uInt8 nNumberOfClicks = static_cast< sal_uInt8 >(rMEvt.GetClicks() % 4);
if ( 0 == nNumberOfClicks && 0 < rMEvt.GetClicks() )
nNumberOfClicks = 4;
sal_Bool bExecDrawTextLink = sal_False;
switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
{
case MOUSE_LEFT:
case MOUSE_LEFT + KEY_MOD1:
case MOUSE_LEFT + KEY_MOD2:
switch ( nNumberOfClicks )
{
case 1:
{
UpdatePointer( aDocPos, rMEvt.GetModifier() );
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
// URL in DrawText-Objekt getroffen?
if (bExecHyperlinks && pSdrView)
{
SdrViewEvent aVEvt;
pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
if (aVEvt.eEvent == SDREVENT_EXECUTEURL)
bExecDrawTextLink = sal_True;
}
//Rahmen nur zu selektieren versuchen, wenn
//der Pointer bereits entsprechend geschaltet wurde
if ( aActHitType != SDRHIT_NONE && !rSh.IsSelFrmMode() &&
!GetView().GetViewFrame()->GetDispatcher()->IsLocked() &&
!bExecDrawTextLink)
{
// Test if there is a draw object at that position and if it should be selected.
sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
if(bShould)
{
rView.NoRotate();
rSh.HideCrsr();
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
sal_Bool bSelObj = rSh.SelectObj( aDocPos,
rMEvt.IsMod1() ? SW_ENTER_GROUP : 0);
if( bUnLockView )
rSh.LockView( sal_False );
if( bSelObj )
{
// falls im Macro der Rahmen deselektiert
// wurde, muss nur noch der Cursor
// wieder angezeigt werden.
if( FRMTYPE_NONE == rSh.GetSelFrmType() )
rSh.ShowCrsr();
else
{
if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr())
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
}
rSh.EnterSelFrmMode( &aDocPos );
bFrmDrag = sal_True;
UpdatePointer( aDocPos, rMEvt.GetModifier() );
}
return;
}
else
bOnlyText = static_cast< sal_Bool >(rSh.IsObjSelectable( aDocPos ));
if (!rView.GetDrawFuncPtr())
rSh.ShowCrsr();
}
else
bOnlyText = KEY_MOD1 != rMEvt.GetModifier();
}
else if ( rSh.IsSelFrmMode() &&
(aActHitType == SDRHIT_NONE ||
!rSh.IsInsideSelectedObj( aDocPos )))
{
rView.NoRotate();
SdrHdl *pHdl;
if( !bIsDocReadOnly && !pAnchorMarker && 0 !=
( pHdl = pSdrView->PickHandle(aDocPos) ) &&
( pHdl->GetKind() == HDL_ANCHOR ||
pHdl->GetKind() == HDL_ANCHOR_TR ) )
{
pAnchorMarker = new SwAnchorMarker( pHdl );
UpdatePointer( aDocPos, rMEvt.GetModifier() );
return;
}
else
{
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
sal_uInt8 nFlag = rMEvt.IsShift() ? SW_ADD_SELECT :0;
if( rMEvt.IsMod1() )
nFlag = nFlag | SW_ENTER_GROUP;
if ( rSh.IsSelFrmMode() )
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
}
sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag );
if( bUnLockView )
rSh.LockView( sal_False );
if( !bSelObj )
{
// Cursor hier umsetzen, damit er nicht zuerst
// im Rahmen gezeichnet wird; ShowCrsr() geschieht
// in LeaveSelFrmMode()
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify( &rSh );
bCallBase = sal_False;
}
else
{
rSh.HideCrsr();
rSh.EnterSelFrmMode( &aDocPos );
rSh.SelFlyGrabCrsr();
rSh.MakeSelVisible();
bFrmDrag = sal_True;
if( rSh.IsFrmSelected() &&
rView.GetDrawFuncPtr() )
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
}
UpdatePointer( aDocPos, rMEvt.GetModifier() );
return;
}
}
}
break;
}
case 2:
{
bFrmDrag = sal_False;
if ( !bIsDocReadOnly && rSh.IsInsideSelectedObj(aDocPos) &&
0 == rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) )
/* SJ: 01.03.2005: this is no good, on the one hand GetSelectionType is used as flag field (take a look into the GetSelectionType method)
on the other hand the return value is used in a switch without proper masking (very nice), this must lead to trouble
*/
switch ( rSh.GetSelectionType() &~ ( nsSelectionType::SEL_FONTWORK | nsSelectionType::SEL_EXTRUDED_CUSTOMSHAPE ) )
{
case nsSelectionType::SEL_GRF:
RstMBDownFlags();
GetView().GetViewFrame()->GetBindings().Execute(
FN_FORMAT_GRAFIC_DLG, 0, 0,
SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT);
return;
// Doppelklick auf OLE-Objekt --> OLE-InPlace
case nsSelectionType::SEL_OLE:
if (!rSh.IsSelObjProtected(FLYPROTECT_CONTENT))
{
RstMBDownFlags();
rSh.LaunchOLEObj();
}
return;
case nsSelectionType::SEL_FRM:
RstMBDownFlags();
GetView().GetViewFrame()->GetBindings().Execute(
FN_FORMAT_FRAME_DLG, 0, 0, SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT);
return;
case nsSelectionType::SEL_DRW:
RstMBDownFlags();
EnterDrawTextMode(aDocPos);
if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
((SwDrawTextShell*)rView.GetCurShell())->Init();
return;
}
//falls die Cursorposition korrigiert wurde oder
// ein Fly im ReadOnlyModus selektiert ist,
//keine Wortselektion.
if ( !bValidCrsrPos ||
(rSh.IsFrmSelected() && rSh.IsFrmSelected() ))
return;
SwField *pFld;
sal_Bool bFtn = sal_False;
if( !bIsDocReadOnly &&
( 0 != ( pFld = rSh.GetCurFld() ) ||
0 != ( bFtn = rSh.GetCurFtn() )) )
{
RstMBDownFlags();
if( bFtn )
GetView().GetViewFrame()->GetBindings().Execute( FN_EDIT_FOOTNOTE );
else
{
sal_uInt16 nTypeId = pFld->GetTypeId();
SfxViewFrame* pVFrame = GetView().GetViewFrame();
switch( nTypeId )
{
case TYP_POSTITFLD:
case TYP_SCRIPTFLD:
{
//falls es ein Readonly-Bereich ist, dann muss der Status
//enabled werden
sal_uInt16 nSlot = TYP_POSTITFLD == nTypeId ? FN_POSTIT : FN_JAVAEDIT;
SfxBoolItem aItem(nSlot, sal_True);
pVFrame->GetBindings().SetState(aItem);
pVFrame->GetBindings().Execute(nSlot);
break;
}
case TYP_AUTHORITY :
pVFrame->GetBindings().Execute(FN_EDIT_AUTH_ENTRY_DLG);
break;
default:
pVFrame->GetBindings().Execute(FN_EDIT_FIELD);
}
}
return;
}
//im Extended Mode hat Doppel- und
//Dreifachklick keine Auswirkungen.
if ( rSh.IsExtMode() || rSh.IsBlockMode() )
return;
//Wort selektieren, gfs. Additional Mode
if ( KEY_MOD1 == rMEvt.GetModifier() && !rSh.IsAddMode() )
{
rSh.EnterAddMode();
rSh.SelWrd( &aDocPos );
rSh.LeaveAddMode();
}
else
rSh.SelWrd( &aDocPos );
bHoldSelection = sal_True;
return;
}
case 3:
case 4:
{
bFrmDrag = sal_False;
//im Extended Mode hat Doppel- und
//Dreifachklick keine Auswirkungen.
if ( rSh.IsExtMode() )
return;
//falls die Cursorposition korrigiert wurde oder
// ein Fly im ReadOnlyModus selektiert ist,
//keine Wortselektion.
if ( !bValidCrsrPos || rSh.IsFrmSelected() )
return;
//Zeile selektieren, gfs. Additional Mode
const bool bMod = KEY_MOD1 == rMEvt.GetModifier() &&
!rSh.IsAddMode();
if ( bMod )
rSh.EnterAddMode();
// Enhanced selection
if ( 3 == nNumberOfClicks )
rSh.SelSentence( &aDocPos );
else
rSh.SelPara( &aDocPos );
if ( bMod )
rSh.LeaveAddMode();
bHoldSelection = sal_True;
return;
}
default:
return;
}
/* no break */
case MOUSE_LEFT + KEY_SHIFT:
case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
{
sal_Bool bLockView = bWasShdwCrsr;
switch ( rMEvt.GetModifier() )
{
case KEY_MOD1 + KEY_SHIFT:
{
if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
{
rView.NoRotate();
rSh.HideCrsr();
if ( rSh.IsSelFrmMode() )
rSh.SelectObj(aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP);
else
{ if ( rSh.SelectObj( aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP ) )
{
rSh.EnterSelFrmMode( &aDocPos );
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
bFrmDrag = sal_True;
return;
}
}
}
else if( rSh.IsSelFrmMode() &&
rSh.GetDrawView()->PickHandle( aDocPos ))
{
bFrmDrag = sal_True;
bNoInterrupt = sal_False;
return;
}
}
break;
case KEY_MOD1:
if ( !bExecDrawTextLink )
{
if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
{
rView.NoRotate();
rSh.HideCrsr();
if ( rSh.IsSelFrmMode() )
rSh.SelectObj(aDocPos, SW_ENTER_GROUP);
else
{ if ( rSh.SelectObj( aDocPos, SW_ENTER_GROUP ) )
{
rSh.EnterSelFrmMode( &aDocPos );
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
bFrmDrag = sal_True;
return;
}
}
}
else if( rSh.IsSelFrmMode() &&
rSh.GetDrawView()->PickHandle( aDocPos ))
{
bFrmDrag = sal_True;
bNoInterrupt = sal_False;
return;
}
else
{
if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
{
rSh.PushMode();
bModePushed = sal_True;
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
rSh.EnterAddMode();
if( bUnLockView )
rSh.LockView( sal_False );
}
bCallBase = sal_False;
}
}
break;
case KEY_MOD2:
{
if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
{
rSh.PushMode();
bModePushed = sal_True;
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
rSh.EnterBlockMode();
if( bUnLockView )
rSh.LockView( sal_False );
}
bCallBase = sal_False;
}
break;
case KEY_SHIFT:
{
if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
{
rView.NoRotate();
rSh.HideCrsr();
if ( rSh.IsSelFrmMode() )
{
rSh.SelectObj(aDocPos, SW_ADD_SELECT);
const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
if (rMarkList.GetMark(0) == NULL)
{
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
bFrmDrag = sal_False;
}
}
else
{ if ( rSh.SelectObj( aDocPos ) )
{
rSh.EnterSelFrmMode( &aDocPos );
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
bFrmDrag = sal_True;
return;
}
}
}
else
{
if ( rSh.IsSelFrmMode() &&
rSh.IsInsideSelectedObj( aDocPos ) )
{
rSh.EnterSelFrmMode( &aDocPos );
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
bFrmDrag = sal_True;
return;
}
if ( rSh.IsSelFrmMode() )
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
bFrmDrag = sal_False;
}
if ( !rSh.IsExtMode() )
{
// keine Selection anfangen, wenn in ein URL-
// Feld oder eine -Grafik geklickt wird
sal_Bool bSttSelect = rSh.HasSelection() ||
Pointer(POINTER_REFHAND) != GetPointer();
if( !bSttSelect )
{
bSttSelect = sal_True;
if( bExecHyperlinks )
{
SwContentAtPos aCntntAtPos(
SwContentAtPos::SW_FTN |
SwContentAtPos::SW_INETATTR );
if( rSh.GetContentAtPos( aDocPos, aCntntAtPos ) )
{
if( !rSh.IsViewLocked() &&
!rSh.IsReadOnlyAvailable() &&
aCntntAtPos.IsInProtectSect() )
bLockView = sal_True;
bSttSelect = sal_False;
}
else if( rSh.IsURLGrfAtPos( aDocPos ))
bSttSelect = sal_False;
}
}
if( bSttSelect )
rSh.SttSelect();
}
}
bCallBase = sal_False;
break;
}
default:
if( !rSh.IsViewLocked() )
{
SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD |
SwContentAtPos::SW_INETATTR );
if( rSh.GetContentAtPos( aDocPos, aCntntAtPos, sal_False ) &&
!rSh.IsReadOnlyAvailable() &&
aCntntAtPos.IsInProtectSect() )
bLockView = sal_True;
}
}
if ( rSh.IsGCAttr() )
{
rSh.GCAttr();
rSh.ClearGCAttr();
}
sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False;
if( !bOverSelect )
bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos );
if ( !bOverSelect )
{
const sal_Bool bTmpNoInterrupt = bNoInterrupt;
bNoInterrupt = sal_False;
if( !rSh.IsViewLocked() && bLockView )
rSh.LockView( sal_True );
else
bLockView = sal_False;
int nTmpSetCrsr = 0;
{ // nur temp. Move-Kontext aufspannen, da sonst die
// Abfrage auf die Inhaltsform nicht funktioniert!!!
MV_KONTEXT( &rSh );
nTmpSetCrsr = (rSh.*rSh.fnSetCrsr)(&aDocPos,bOnlyText);
bValidCrsrPos = !(CRSR_POSCHG & nTmpSetCrsr);
bCallBase = sal_False;
}
//#i42732# - notify the edit window that from now on we do not use the input language
if ( !(CRSR_POSOLD & nTmpSetCrsr) )
SetUseInputLanguage( sal_False );
if( bLockView )
rSh.LockView( sal_False );
bNoInterrupt = bTmpNoInterrupt;
}
if ( !bOverURLGrf && !bOnlyText )
{
const int nSelType = rSh.GetSelectionType();
// Check in general, if an object is selectable at given position.
// Thus, also text fly frames in background become selectable via Ctrl-Click.
if ( ( nSelType & nsSelectionType::SEL_OLE )
|| ( nSelType & nsSelectionType::SEL_GRF )
|| rSh.IsObjSelectable( aDocPos ) )
{
MV_KONTEXT( &rSh );
if( !rSh.IsFrmSelected() )
rSh.GotoNextFly();
rSh.EnterSelFrmMode();
bCallBase = sal_False;
}
}
break;
}
}
}
if (bCallBase)
Window::MouseButtonDown(rMEvt);
}
/*--------------------------------------------------------------------
Beschreibung: MouseMove
--------------------------------------------------------------------*/
void SwEditWin::MouseMove(const MouseEvent& _rMEvt)
{
MouseEvent rMEvt(_rMEvt);
//ignore key modifiers for format paintbrush
{
sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard
&& pApplyTempl->pFormatClipboard->HasContent();
if( bExecFormatPaintbrush )
rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(),
_rMEvt.GetMode(), _rMEvt.GetButtons() );
}
// solange eine Action laeuft sollte das MouseMove abgeklemmt sein
// Ansonsten gibt es den Bug 40102
SwWrtShell &rSh = rView.GetWrtShell();
if( rSh.ActionPend() )
return ;
if( pShadCrsr && 0 != (rMEvt.GetModifier() + rMEvt.GetButtons() ) )
delete pShadCrsr, pShadCrsr = 0;
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly();
SET_CURR_SHELL( &rSh );
//aPixPt == Point in Pixel, rel. zu ChildWin
//aDocPt == Point in Twips, Dokumentkoordinaten
const Point aPixPt( rMEvt.GetPosPixel() );
const Point aDocPt( PixelToLogic( aPixPt ) );
if ( IsChainMode() )
{
UpdatePointer( aDocPt, rMEvt.GetModifier() );
if ( rMEvt.IsLeaveWindow() )
rView.GetViewFrame()->HideStatusText();
return;
}
SdrView *pSdrView = rSh.GetDrawView();
const SwCallMouseEvent aLastCallEvent( aSaveCallEvent );
aSaveCallEvent.Clear();
if ( !bIsDocReadOnly && pSdrView && pSdrView->MouseMove(rMEvt,this) )
{
SetPointer( POINTER_TEXT );
return; // Event von der SdrView ausgewertet
}
const Point aOldPt( rSh.VisArea().Pos() );
const sal_Bool bInsWin = rSh.VisArea().IsInside( aDocPt );
if( pShadCrsr && !bInsWin )
delete pShadCrsr, pShadCrsr = 0;
if( bInsWin && pRowColumnSelectionStart )
{
EnterArea();
Point aPos( aDocPt );
if( rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag ))
return;
}
// Position ist noetig fuer OS/2, da dort nach einem MB-Down
// offensichtlich sofort ein MB-Move gerufen wird.
if( bDDTimerStarted )
{
Point aDD( SwEditWin::nDDStartPosX, SwEditWin::nDDStartPosY );
aDD = LogicToPixel( aDD );
Rectangle aRect( aDD.X()-3, aDD.Y()-3, aDD.X()+3, aDD.Y()+3 );
if ( !aRect.IsInside( aPixPt ) ) // MA 23. May. 95: Tatterschutz.
StopDDTimer( &rSh, aDocPt );
}
if(rView.GetDrawFuncPtr())
{
if( bInsDraw )
{
rView.GetDrawFuncPtr()->MouseMove( rMEvt );
if ( !bInsWin )
{
Point aTmp( aDocPt );
aTmp += rSh.VisArea().Pos() - aOldPt;
LeaveArea( aTmp );
}
else
EnterArea();
return;
}
else if(!rSh.IsFrmSelected() && !rSh.IsObjSelected())
{
SfxBindings &rBnd = rSh.GetView().GetViewFrame()->GetBindings();
Point aRelPos = rSh.GetRelativePagePosition(aDocPt);
if(aRelPos.X() >= 0)
{
FieldUnit eMetric = ::GetDfltMetric(0 != PTR_CAST(SwWebView, &GetView()));
SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, static_cast< sal_uInt16 >(eMetric)));
const SfxPointItem aTmp1( SID_ATTR_POSITION, aRelPos );
rBnd.SetState( aTmp1 );
}
else
{
rBnd.Invalidate(SID_ATTR_POSITION);
}
rBnd.Invalidate(SID_ATTR_SIZE);
const SfxStringItem aCell( SID_TABLE_CELL, aEmptyStr );
rBnd.SetState( aCell );
}
}
sal_uInt8 nMouseTabCol;
if( !bIsDocReadOnly && bInsWin && !pApplyTempl && !rSh.IsInSelect() )
{
if ( SW_TABCOL_NONE != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPt ) ) &&
!rSh.IsObjSelectable( aDocPt ) )
{
sal_uInt16 nPointer = USHRT_MAX;
bool bChkTblSel = false;
switch ( nMouseTabCol )
{
case SW_TABCOL_VERT :
case SW_TABROW_HORI :
nPointer = POINTER_VSIZEBAR;
bChkTblSel = true;
break;
case SW_TABROW_VERT :
case SW_TABCOL_HORI :
nPointer = POINTER_HSIZEBAR;
bChkTblSel = true;
break;
// Enhanced table selection
case SW_TABSEL_HORI :
nPointer = POINTER_TAB_SELECT_SE;
break;
case SW_TABSEL_HORI_RTL :
case SW_TABSEL_VERT :
nPointer = POINTER_TAB_SELECT_SW;
break;
case SW_TABCOLSEL_HORI :
case SW_TABROWSEL_VERT :
nPointer = POINTER_TAB_SELECT_S;
break;
case SW_TABROWSEL_HORI :
nPointer = POINTER_TAB_SELECT_E;
break;
case SW_TABROWSEL_HORI_RTL :
case SW_TABCOLSEL_VERT :
nPointer = POINTER_TAB_SELECT_W;
break;
}
if ( USHRT_MAX != nPointer &&
// Enhanced table selection is explicitely allowed in table mode
( !bChkTblSel || !rSh.IsTableMode() ) )
{
SetPointer( nPointer );
}
return;
}
else if (rSh.IsNumLabel(aDocPt, RULER_MOUSE_MARGINWIDTH))
{
SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPt );
const sal_uInt16 nPointer =
rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPt )
? POINTER_VSIZEBAR
: POINTER_HSIZEBAR;
SetPointer( nPointer );
return;
}
}
sal_Bool bDelShadCrsr = sal_True;
switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
{
case MOUSE_LEFT:
if( pAnchorMarker )
{
// Now we need to refresh the SdrHdl pointer of pAnchorMarker.
// This looks a little bit tricky, but it solves the following
// problem: the pAnchorMarker contains a pointer to an SdrHdl,
// if the FindAnchorPos-call cause a scrolling of the visible
// area, it's possible that the SdrHdl will be destroyed and a
// new one will initialized at the original position(GetHdlPos).
// So the pAnchorMarker has to find the right SdrHdl, if it's
// the old one, it will find it with position aOld, if this one
// is destroyed, it will find a new one at position GetHdlPos().
const Point aOld = pAnchorMarker->GetPosForHitTest( *(rSh.GetOut()) );
Point aNew = rSh.FindAnchorPos( aDocPt );
SdrHdl* pHdl;
if( (0!=( pHdl = pSdrView->PickHandle( aOld ) )||
0 !=(pHdl = pSdrView->PickHandle( pAnchorMarker->GetHdlPos()) ) ) &&
( pHdl->GetKind() == HDL_ANCHOR ||
pHdl->GetKind() == HDL_ANCHOR_TR ) )
{
pAnchorMarker->ChgHdl( pHdl );
if( aNew.X() || aNew.Y() )
{
pAnchorMarker->SetPos( aNew );
pAnchorMarker->SetLastPos( aDocPt );
}
}
else
{
delete pAnchorMarker;
pAnchorMarker = NULL;
}
}
if ( bInsDraw )
{
if ( !bMBPressed )
break;
if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) )
{
if ( !bInsWin )
LeaveArea( aDocPt );
else
EnterArea();
if ( rView.GetDrawFuncPtr() )
{
pSdrView->SetOrtho(sal_False);
rView.GetDrawFuncPtr()->MouseMove( rMEvt );
}
bIsInMove = sal_True;
}
return;
}
case MOUSE_LEFT + KEY_SHIFT:
case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
if ( !bMBPressed )
break;
case MOUSE_LEFT + KEY_MOD1:
if ( bFrmDrag && rSh.IsSelFrmMode() )
{
if( !bMBPressed )
break;
if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) )
{
// Event-Verarbeitung fuers Resizen
if( pSdrView->AreObjectsMarked() )
{
const SwFrmFmt* pFlyFmt;
const SvxMacro* pMacro;
const Point aSttPt( PixelToLogic( aStartPos ) );
// geht es los?
if( HDL_USER == eSdrMoveHdl )
{
SdrHdl* pHdl = pSdrView->PickHandle( aSttPt );
eSdrMoveHdl = pHdl ? pHdl->GetKind() : HDL_MOVE;
}
sal_uInt16 nEvent = HDL_MOVE == eSdrMoveHdl
? SW_EVENT_FRM_MOVE
: SW_EVENT_FRM_RESIZE;
if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) &&
0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable().
Get( nEvent )) &&
aRszMvHdlPt != aDocPt )
{
aRszMvHdlPt = aDocPt;
sal_uInt16 nPos = 0;
String sRet;
SbxArrayRef xArgs = new SbxArray;
SbxVariableRef xVar = new SbxVariable;
xVar->PutString( pFlyFmt->GetName() );
xArgs->Put( &xVar, ++nPos );
if( SW_EVENT_FRM_RESIZE == nEvent )
{
xVar = new SbxVariable;
xVar->PutUShort( static_cast< sal_uInt16 >(eSdrMoveHdl) );
xArgs->Put( &xVar, ++nPos );
}
xVar = new SbxVariable;
xVar->PutLong( aDocPt.X() - aSttPt.X() );
xArgs->Put( &xVar, ++nPos );
xVar = new SbxVariable;
xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
xArgs->Put( &xVar, ++nPos );
ReleaseMouse();
rSh.ExecMacro( *pMacro, &sRet, &xArgs );
CaptureMouse();
if( sRet.Len() && 0 != sRet.ToInt32() )
return ;
}
}
// Event-Verarbeitung fuers Resizen
if( bIsDocReadOnly )
break;
if ( rMEvt.IsShift() )
{
pSdrView->SetOrtho(sal_True);
pSdrView->SetAngleSnapEnabled(sal_True);
}
else
{
pSdrView->SetOrtho(sal_False);
pSdrView->SetAngleSnapEnabled(sal_False);
}
(rSh.*rSh.fnDrag)( &aDocPt, rMEvt.IsShift() );
bIsInMove = sal_True;
}
else if( bIsDocReadOnly )
break;
if ( !bInsWin )
{
Point aTmp( aDocPt );
aTmp += rSh.VisArea().Pos() - aOldPt;
LeaveArea( aTmp );
}
else if(bIsInMove)
EnterArea();
return;
}
if ( !rSh.IsSelFrmMode() && !bDDINetAttr &&
(IsMinMove( aStartPos,aPixPt ) || bIsInMove) &&
(rSh.IsInSelect() || !rSh.ChgCurrPam( aDocPt )) )
{
if ( pSdrView )
{
if ( rMEvt.IsShift() )
pSdrView->SetOrtho(sal_True);
else
pSdrView->SetOrtho(sal_False);
}
if ( !bInsWin )
{
Point aTmp( aDocPt );
aTmp += rSh.VisArea().Pos() - aOldPt;
LeaveArea( aTmp );
}
else
{
//JP 24.09.98: Fix fuer die Bugs 55592 / 55931
//JP 23.04.99: Fix fuer den Bugs 65289
//JP 06.07.99: Fix fuer den Bugs 67360
if( !rMEvt.IsSynthetic() &&
!(( MOUSE_LEFT + KEY_MOD1 ==
rMEvt.GetModifier() + rMEvt.GetButtons() ) &&
rSh.Is_FnDragEQBeginDrag() && !rSh.IsAddMode() ))
{
(rSh.*rSh.fnDrag)( &aDocPt,sal_False );
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False));
EnterArea();
}
}
}
bDDINetAttr = sal_False;
break;
case 0:
{
if ( pApplyTempl )
{
UpdatePointer(aDocPt, 0); // evtl. muss hier ein Rahmen markiert werden
break;
}
//#i6193#, change ui if mouse is over SwPostItField
// TODO: do the same thing for redlines SW_REDLINE
SwRect aFldRect;
SwContentAtPos aCntntAtPos( SwContentAtPos::SW_FIELD);
if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_False, &aFldRect ) )
{
const SwField* pFld = aCntntAtPos.aFnd.pFld;
if (pFld->Which()== RES_POSTITFLD)
{
rView.GetPostItMgr()->SetShadowState(reinterpret_cast<const SwPostItField*>(pFld),false);
}
else
rView.GetPostItMgr()->SetShadowState(0,false);
}
else
rView.GetPostItMgr()->SetShadowState(0,false);
// no break;
}
case KEY_SHIFT:
case KEY_MOD2:
case KEY_MOD1:
if ( !bInsDraw )
{
sal_Bool bTstShdwCrsr = sal_True;
UpdatePointer( aDocPt, rMEvt.GetModifier() );
const SwFrmFmt* pFmt = 0;
const SwFmtINetFmt* pINet = 0;
SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR );
if( rSh.GetContentAtPos( aDocPt, aCntntAtPos ) )
pINet = (SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr;
const void* pTmp = pINet;
if( pINet ||
0 != ( pTmp = pFmt = rSh.GetFmtFromAnyObj( aDocPt )))
{
bTstShdwCrsr = sal_False;
if( pTmp == pINet )
aSaveCallEvent.Set( pINet );
else
{
IMapObject* pIMapObj = pFmt->GetIMapObject( aDocPt );
if( pIMapObj )
aSaveCallEvent.Set( pFmt, pIMapObj );
else
aSaveCallEvent.Set( EVENT_OBJECT_URLITEM, pFmt );
}
// sollte wir ueber einem InternetFeld mit einem
// gebundenen Macro stehen?
if( aSaveCallEvent != aLastCallEvent )
{
if( aLastCallEvent.HasEvent() )
rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT,
aLastCallEvent, sal_True );
// 0 besagt, das das Object gar keine Tabelle hat
if( !rSh.CallEvent( SFX_EVENT_MOUSEOVER_OBJECT,
aSaveCallEvent ))
aSaveCallEvent.Clear();
}
}
else if( aLastCallEvent.HasEvent() )
{
// Cursor stand auf einem Object
rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT,
aLastCallEvent, sal_True );
}
if( bTstShdwCrsr && bInsWin && !bIsDocReadOnly &&
!bInsFrm &&
!rSh.GetViewOptions()->getBrowseMode() &&
rSh.GetViewOptions()->IsShadowCursor() &&
!(rMEvt.GetModifier() + rMEvt.GetButtons()) &&
!rSh.HasSelection() && !GetConnectMetaFile() )
{
SwRect aRect;
sal_Int16 eOrient;
SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode();
if( rSh.GetShadowCrsrPos( aDocPt, eMode, aRect, eOrient ))
{
if( !pShadCrsr )
pShadCrsr = new SwShadowCursor( *this,
SwViewOption::GetDirectCursorColor() );
if( text::HoriOrientation::RIGHT != eOrient && text::HoriOrientation::CENTER != eOrient )
eOrient = text::HoriOrientation::LEFT;
pShadCrsr->SetPos( aRect.Pos(), aRect.Height(), static_cast< sal_uInt16 >(eOrient) );
bDelShadCrsr = sal_False;
}
}
}
break;
case MOUSE_LEFT + KEY_MOD2:
if( rSh.IsBlockMode() && !rMEvt.IsSynthetic() )
{
(rSh.*rSh.fnDrag)( &aDocPt,sal_False );
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False));
EnterArea();
}
break;
}
if( bDelShadCrsr && pShadCrsr )
delete pShadCrsr, pShadCrsr = 0;
bWasShdwCrsr = sal_False;
}
/*--------------------------------------------------------------------
Beschreibung: Button Up
--------------------------------------------------------------------*/
void SwEditWin::MouseButtonUp(const MouseEvent& rMEvt)
{
sal_Bool bCallBase = sal_True;
sal_Bool bCallShadowCrsr = bWasShdwCrsr;
bWasShdwCrsr = sal_False;
if( pShadCrsr )
delete pShadCrsr, pShadCrsr = 0;
if( pRowColumnSelectionStart )
DELETEZ( pRowColumnSelectionStart );
SdrHdlKind eOldSdrMoveHdl = eSdrMoveHdl;
eSdrMoveHdl = HDL_USER; // fuer die MoveEvents - wieder zuruecksetzen
// sicherheitshalber zuruecksetzen Bug 27900
rView.SetTabColFromDoc( sal_False );
rView.SetNumRuleNodeFromDoc(NULL);
SwWrtShell &rSh = rView.GetWrtShell();
SET_CURR_SHELL( &rSh );
SdrView *pSdrView = rSh.GetDrawView();
if ( pSdrView )
{
pSdrView->SetOrtho(sal_False);
if ( pSdrView->MouseButtonUp( rMEvt,this ) )
{
rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
return; // Event von der SdrView ausgewertet
}
}
//MouseButtonUp nur bearbeiten, wenn auch das Down an dieses Fenster ging.
if ( !bMBPressed )
{
return;
}
Point aDocPt( PixelToLogic( rMEvt.GetPosPixel() ) );
if ( bDDTimerStarted )
{
StopDDTimer( &rSh, aDocPt );
bMBPressed = sal_False;
if ( rSh.IsSelFrmMode() )
{
(rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
bFrmDrag = sal_False;
}
bNoInterrupt = sal_False;
ReleaseMouse();
return;
}
if( pAnchorMarker )
{
if(pAnchorMarker->GetHdl())
{
// delete selected after drag
pAnchorMarker->GetHdl()->SetSelected(false);
}
Point aPnt( pAnchorMarker->GetLastPos() );
DELETEZ( pAnchorMarker );
if( aPnt.X() || aPnt.Y() )
rSh.FindAnchorPos( aPnt, sal_True );
}
if ( bInsDraw && rView.GetDrawFuncPtr() )
{
if ( rView.GetDrawFuncPtr()->MouseButtonUp( rMEvt ) )
{
if (rView.GetDrawFuncPtr()) // Koennte im MouseButtonUp zerstoert worden sein
{
rView.GetDrawFuncPtr()->Deactivate();
if (!rView.IsDrawMode())
{
rView.SetDrawFuncPtr(NULL);
SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
rBind.Invalidate( SID_ATTR_SIZE );
rBind.Invalidate( SID_TABLE_CELL );
}
}
if ( rSh.IsObjSelected() )
{
rSh.EnterSelFrmMode();
if (!rView.GetDrawFuncPtr())
StdDrawMode( OBJ_NONE, sal_True );
}
else if ( rSh.IsFrmSelected() )
{
rSh.EnterSelFrmMode();
StopInsFrm();
}
else
{
const Point aDocPos( PixelToLogic( aStartPos ) );
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
rSh.Edit();
}
rView.AttrChangedNotify( &rSh );
}
else if (rMEvt.GetButtons() == MOUSE_RIGHT && rSh.IsDrawCreate())
rView.GetDrawFuncPtr()->BreakCreate(); // Zeichnen abbrechen
bNoInterrupt = sal_False;
ReleaseMouse();
return;
}
sal_Bool bPopMode = sal_False;
switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
{
case MOUSE_LEFT:
if ( bInsDraw && rSh.IsDrawCreate() )
{
if ( rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->MouseButtonUp(rMEvt) == sal_True )
{
rView.GetDrawFuncPtr()->Deactivate();
rView.AttrChangedNotify( &rSh );
if ( rSh.IsObjSelected() )
rSh.EnterSelFrmMode();
if ( rView.GetDrawFuncPtr() && bInsFrm )
StopInsFrm();
}
bCallBase = sal_False;
break;
}
case MOUSE_LEFT + KEY_MOD1:
case MOUSE_LEFT + KEY_MOD2:
case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
if ( bFrmDrag && rSh.IsSelFrmMode() )
{
if ( rMEvt.IsMod1() ) //Kopieren und nicht moven.
{
//Drag abbrechen, statt dessen internes Copy verwenden
Rectangle aRect;
rSh.GetDrawView()->TakeActionRect( aRect );
if (!aRect.IsEmpty())
{
rSh.BreakDrag();
Point aEndPt, aSttPt;
if ( rSh.GetSelFrmType() & FRMTYPE_FLY_ATCNT )
{
aEndPt = aRect.TopLeft();
aSttPt = rSh.GetDrawView()->GetAllMarkedRect().TopLeft();
}
else
{
aEndPt = aRect.Center();
aSttPt = rSh.GetDrawView()->GetAllMarkedRect().Center();
}
if ( aSttPt != aEndPt )
{
rSh.StartUndo( UNDO_UI_DRAG_AND_COPY );
rSh.Copy(&rSh, aSttPt, aEndPt, sal_False);
rSh.EndUndo( UNDO_UI_DRAG_AND_COPY );
}
}
else
(rSh.*rSh.fnEndDrag)( &aDocPt,sal_False );
}
else
{
{
const SwFrmFmt* pFlyFmt;
const SvxMacro* pMacro;
sal_uInt16 nEvent = HDL_MOVE == eOldSdrMoveHdl
? SW_EVENT_FRM_MOVE
: SW_EVENT_FRM_RESIZE;
if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) &&
0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable().
Get( nEvent )) )
{
const Point aSttPt( PixelToLogic( aStartPos ) );
aRszMvHdlPt = aDocPt;
sal_uInt16 nPos = 0;
SbxArrayRef xArgs = new SbxArray;
SbxVariableRef xVar = new SbxVariable;
xVar->PutString( pFlyFmt->GetName() );
xArgs->Put( &xVar, ++nPos );
if( SW_EVENT_FRM_RESIZE == nEvent )
{
xVar = new SbxVariable;
xVar->PutUShort( static_cast< sal_uInt16 >(eOldSdrMoveHdl) );
xArgs->Put( &xVar, ++nPos );
}
xVar = new SbxVariable;
xVar->PutLong( aDocPt.X() - aSttPt.X() );
xArgs->Put( &xVar, ++nPos );
xVar = new SbxVariable;
xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
xArgs->Put( &xVar, ++nPos );
xVar = new SbxVariable;
xVar->PutUShort( 1 );
xArgs->Put( &xVar, ++nPos );
ReleaseMouse();
rSh.ExecMacro( *pMacro, 0, &xArgs );
CaptureMouse();
}
}
(rSh.*rSh.fnEndDrag)( &aDocPt,sal_False );
}
bFrmDrag = sal_False;
bCallBase = sal_False;
break;
}
bPopMode = sal_True;
// no break
case MOUSE_LEFT + KEY_SHIFT:
if (rSh.IsSelFrmMode())
{
(rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
bFrmDrag = sal_False;
bCallBase = sal_False;
break;
}
if( bHoldSelection )
{
//JP 27.04.99: Bug 65389 - das EndDrag sollte auf jedenfall
// gerufen werden.
bHoldSelection = sal_False;
(rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
}
else
{
if ( !rSh.IsInSelect() && rSh.ChgCurrPam( aDocPt ) )
{
const sal_Bool bTmpNoInterrupt = bNoInterrupt;
bNoInterrupt = sal_False;
{ // nur temp. Move-Kontext aufspannen, da sonst die
// Abfrage auf die Inhaltsform nicht funktioniert!!!
MV_KONTEXT( &rSh );
const Point aDocPos( PixelToLogic( aStartPos ) );
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
}
bNoInterrupt = bTmpNoInterrupt;
}
else
{
sal_Bool bInSel = rSh.IsInSelect();
(rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
// Internetfield? --> Link-Callen (DocLaden!!)
//JP 18.10.96: Bug 32437 -
// if( !rSh.HasSelection() )
if( !bInSel )
{
sal_uInt16 nFilter = URLLOAD_NOFILTER;
if( KEY_MOD1 == rMEvt.GetModifier() )
nFilter |= URLLOAD_NEWVIEW;
sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
if ( !bExecHyperlinks )
{
SvtSecurityOptions aSecOpts;
const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) ||
( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) )
bExecHyperlinks = sal_True;
}
const sal_Bool bExecSmarttags = rMEvt.GetModifier() == KEY_MOD1;
if(pApplyTempl)
bExecHyperlinks = sal_False;
SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD |
SwContentAtPos::SW_INETATTR |
SwContentAtPos::SW_SMARTTAG | SwContentAtPos::SW_FORMCTRL);
if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) )
{
sal_Bool bViewLocked = rSh.IsViewLocked();
if( !bViewLocked && !rSh.IsReadOnlyAvailable() &&
aCntntAtPos.IsInProtectSect() )
rSh.LockView( sal_True );
ReleaseMouse();
if( SwContentAtPos::SW_FIELD == aCntntAtPos.eCntntAtPos )
{
if ( aCntntAtPos.pFndTxtAttr != NULL
&& aCntntAtPos.pFndTxtAttr->Which() == RES_TXTATR_INPUTFIELD )
{
// select content of Input Field, but exclude CH_TXT_ATR_INPUTFIELDSTART
// and CH_TXT_ATR_INPUTFIELDEND
rSh.SttSelect();
rSh.SelectTxt( *(aCntntAtPos.pFndTxtAttr->GetStart()) + 1,
*(aCntntAtPos.pFndTxtAttr->End()) - 1 );
}
else
{
rSh.ClickToField( *aCntntAtPos.aFnd.pFld );
}
}
else if ( SwContentAtPos::SW_SMARTTAG == aCntntAtPos.eCntntAtPos )
{
// execute smarttag menu
if ( bExecSmarttags && SwSmartTagMgr::Get().IsSmartTagsEnabled() )
rView.ExecSmartTagPopup( aDocPt );
}
else if ( SwContentAtPos::SW_FORMCTRL == aCntntAtPos.eCntntAtPos )
{
ASSERT( aCntntAtPos.aFnd.pFldmark != NULL, "where is my field ptr???");
if ( aCntntAtPos.aFnd.pFldmark != NULL)
{
IFieldmark *fieldBM = const_cast< IFieldmark* > ( aCntntAtPos.aFnd.pFldmark );
if (fieldBM->GetFieldname( ).equalsAscii( ODF_FORMCHECKBOX ) )
{
ICheckboxFieldmark* pCheckboxFm = dynamic_cast<ICheckboxFieldmark*>(fieldBM);
pCheckboxFm->SetChecked(!pCheckboxFm->IsChecked());
pCheckboxFm->Invalidate();
rSh.InvalidateWindows( rView.GetVisArea() );
} else if (fieldBM->GetFieldname().equalsAscii( ODF_FORMDROPDOWN) ) {
rView.ExecFieldPopup( aDocPt, fieldBM );
fieldBM->Invalidate();
rSh.InvalidateWindows( rView.GetVisArea() );
} else {
// unknown type..
}
}
}
else // if ( SwContentAtPos::SW_INETATTR == aCntntAtPos.eCntntAtPos )
{
if ( bExecHyperlinks )
rSh.ClickToINetAttr( *(SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr, nFilter );
}
rSh.LockView( bViewLocked );
bCallShadowCrsr = sal_False;
}
else
{
aCntntAtPos = SwContentAtPos( SwContentAtPos::SW_FTN );
if( !rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) && bExecHyperlinks )
{
SdrViewEvent aVEvt;
if (pSdrView)
pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
if (pSdrView && aVEvt.eEvent == SDREVENT_EXECUTEURL)
{
// URL-Feld getroffen
const SvxURLField *pField = aVEvt.pURLField;
if (pField)
{
String sURL(pField->GetURL());
String sTarget(pField->GetTargetFrame());
::LoadURL( sURL, &rSh, nFilter, &sTarget);
}
bCallShadowCrsr = sal_False;
}
else
{
// Grafik getroffen
ReleaseMouse();
if( rSh.ClickToINetGrf( aDocPt, nFilter ))
bCallShadowCrsr = sal_False;
}
}
}
if( bCallShadowCrsr &&
rSh.GetViewOptions()->IsShadowCursor() &&
MOUSE_LEFT == (rMEvt.GetModifier() + rMEvt.GetButtons()) &&
!rSh.HasSelection() &&
!GetConnectMetaFile() &&
rSh.VisArea().IsInside( aDocPt ))
{
SwUndoId nLastUndoId(UNDO_EMPTY);
if (rSh.GetLastUndoInfo(0, & nLastUndoId))
{
if (UNDO_INS_FROM_SHADOWCRSR == nLastUndoId)
{
rSh.Undo();
}
}
SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode();
rSh.SetShadowCrsrPos( aDocPt, eMode );
}
}
}
bCallBase = sal_False;
}
// gfs. im Down gepushten Mode wieder zuruecksetzen
if ( bPopMode && bModePushed )
{
rSh.PopMode();
bModePushed = sal_False;
bCallBase = sal_False;
}
break;
default:
ReleaseMouse();
return;
}
if( pApplyTempl )
{
int eSelection = rSh.GetSelectionType();
SwFormatClipboard* pFormatClipboard = pApplyTempl->pFormatClipboard;
if( pFormatClipboard )//apply format paintbrush
{
//get some parameters
SwWrtShell& rWrtShell = rView.GetWrtShell();
SfxStyleSheetBasePool* pPool=0;
bool bNoCharacterFormats = false;
bool bNoParagraphFormats = false;
{
SwDocShell* pDocSh = rView.GetDocShell();
if(pDocSh)
pPool = pDocSh->GetStyleSheetPool();
if( (rMEvt.GetModifier()&KEY_MOD1) && (rMEvt.GetModifier()&KEY_SHIFT) )
bNoCharacterFormats = true;
else if( rMEvt.GetModifier() & KEY_MOD1 )
bNoParagraphFormats = true;
}
//execute paste
pFormatClipboard->Paste( rWrtShell, pPool, bNoCharacterFormats, bNoParagraphFormats );
//if the clipboard is empty after paste remove the ApplyTemplate
if(!pFormatClipboard->HasContent())
SetApplyTemplate(SwApplyTemplate());
}
else if( pApplyTempl->nColor )
{
sal_uInt16 nId = 0;
switch( pApplyTempl->nColor )
{
case SID_ATTR_CHAR_COLOR_EXT:
nId = RES_CHRATR_COLOR;
break;
case SID_ATTR_CHAR_COLOR_BACKGROUND_EXT:
nId = RES_CHRATR_BACKGROUND;
break;
}
if( nId && (nsSelectionType::SEL_TXT|nsSelectionType::SEL_TBL) & eSelection)
{
if( rSh.IsSelection() && !rSh.HasReadonlySel() )
{
if(nId == RES_CHRATR_BACKGROUND)
{
Color aColor( COL_TRANSPARENT );
if( !SwEditWin::bTransparentBackColor )
aColor = SwEditWin::aTextBackColor;
rSh.SetAttrItem( SvxBrushItem( aColor, nId ) );
}
else
rSh.SetAttrItem( SvxColorItem(SwEditWin::aTextColor, nId) );
rSh.UnSetVisCrsr();
rSh.EnterStdMode();
rSh.SetVisCrsr(aDocPt);
pApplyTempl->bUndo = sal_True;
bCallBase = sal_False;
aTemplateTimer.Stop();
}
else if(rMEvt.GetClicks() == 1)
{
// keine Selektion -> also Giesskanne abschalten
aTemplateTimer.Start();
}
}
}
else
{
String aStyleName;
switch ( pApplyTempl->eType )
{
case SFX_STYLE_FAMILY_PARA:
if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL )
& eSelection ) && !rSh.HasReadonlySel() )
{
rSh.SetTxtFmtColl( pApplyTempl->aColl.pTxtColl );
pApplyTempl->bUndo = sal_True;
bCallBase = sal_False;
if ( pApplyTempl->aColl.pTxtColl )
aStyleName = pApplyTempl->aColl.pTxtColl->GetName();
}
break;
case SFX_STYLE_FAMILY_CHAR:
if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL )
& eSelection ) && !rSh.HasReadonlySel() )
{
rSh.SetAttrItem( SwFmtCharFmt(pApplyTempl->aColl.pCharFmt) );
rSh.UnSetVisCrsr();
rSh.EnterStdMode();
rSh.SetVisCrsr(aDocPt);
pApplyTempl->bUndo = sal_True;
bCallBase = sal_False;
if ( pApplyTempl->aColl.pCharFmt )
aStyleName = pApplyTempl->aColl.pCharFmt->GetName();
}
break;
case SFX_STYLE_FAMILY_FRAME :
{
const SwFrmFmt* pFmt = rSh.GetFmtFromObj( aDocPt );
if(PTR_CAST(SwFlyFrmFmt, pFmt))
{
rSh.SetFrmFmt( pApplyTempl->aColl.pFrmFmt, sal_False, &aDocPt );
pApplyTempl->bUndo = sal_True;
bCallBase = sal_False;
if( pApplyTempl->aColl.pFrmFmt )
aStyleName = pApplyTempl->aColl.pFrmFmt->GetName();
}
break;
}
case SFX_STYLE_FAMILY_PAGE:
// Kein Undo bei Seitenvorlagen
rSh.ChgCurPageDesc( *pApplyTempl->aColl.pPageDesc );
if ( pApplyTempl->aColl.pPageDesc )
aStyleName = pApplyTempl->aColl.pPageDesc->GetName();
bCallBase = sal_False;
break;
case SFX_STYLE_FAMILY_PSEUDO:
if( !rSh.HasReadonlySel() )
{
rSh.SetCurNumRule( *pApplyTempl->aColl.pNumRule,
false,
pApplyTempl->aColl.pNumRule->GetDefaultListId() );
bCallBase = sal_False;
pApplyTempl->bUndo = sal_True;
if( pApplyTempl->aColl.pNumRule )
aStyleName = pApplyTempl->aColl.pNumRule->GetName();
}
break;
}
uno::Reference< frame::XDispatchRecorder > xRecorder =
rView.GetViewFrame()->GetBindings().GetRecorder();
if ( aStyleName.Len() && xRecorder.is() )
{
SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
if ( pSfxShell )
{
SfxRequest aReq( rView.GetViewFrame(), SID_STYLE_APPLY );
aReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aStyleName ) );
aReq.AppendItem( SfxUInt16Item( SID_STYLE_FAMILY, (sal_uInt16) pApplyTempl->eType ) );
aReq.Done();
}
}
}
}
ReleaseMouse();
// Hier kommen nur verarbeitete MouseEvents an; nur bei diesen duerfen
// die Modi zurueckgesetzt werden.
bMBPressed = sal_False;
//sicherheitshalber aufrufen, da jetzt das Selektieren bestimmt zu Ende ist.
//Andernfalls koennte der Timeout des Timers Kummer machen.
EnterArea();
bNoInterrupt = sal_False;
if (bCallBase)
Window::MouseButtonUp(rMEvt);
}
/*--------------------------------------------------------------------
Beschreibung: Vorlage anwenden
--------------------------------------------------------------------*/
void SwEditWin::SetApplyTemplate(const SwApplyTemplate &rTempl)
{
static sal_Bool bIdle = sal_False;
DELETEZ(pApplyTempl);
SwWrtShell &rSh = rView.GetWrtShell();
if(rTempl.pFormatClipboard)
{
pApplyTempl = new SwApplyTemplate( rTempl );
SetPointer( POINTER_FILL );//@todo #i20119# maybe better a new brush pointer here in future
rSh.NoEdit( sal_False );
bIdle = rSh.GetViewOptions()->IsIdle();
((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
}
else if(rTempl.nColor)
{
pApplyTempl = new SwApplyTemplate( rTempl );
SetPointer( POINTER_FILL );
rSh.NoEdit( sal_False );
bIdle = rSh.GetViewOptions()->IsIdle();
((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
}
else if( rTempl.eType )
{
pApplyTempl = new SwApplyTemplate( rTempl );
SetPointer( POINTER_FILL );
rSh.NoEdit( sal_False );
bIdle = rSh.GetViewOptions()->IsIdle();
((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
}
else
{
SetPointer( POINTER_TEXT );
rSh.UnSetVisCrsr();
((SwViewOption *)rSh.GetViewOptions())->SetIdle( bIdle );
if ( !rSh.IsSelFrmMode() )
rSh.Edit();
}
static sal_uInt16 __READONLY_DATA aInva[] =
{
SID_STYLE_WATERCAN,
SID_ATTR_CHAR_COLOR_EXT,
SID_ATTR_CHAR_COLOR_BACKGROUND_EXT,
0
};
rView.GetViewFrame()->GetBindings().Invalidate(aInva);
}
/*--------------------------------------------------------------------
Beschreibung: ctor
--------------------------------------------------------------------*/
SwEditWin::SwEditWin(Window *pParent, SwView &rMyView):
Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)),
DropTargetHelper( this ),
DragSourceHelper( this ),
eBufferLanguage(LANGUAGE_DONTKNOW),
pApplyTempl(0),
pAnchorMarker( 0 ),
pUserMarker( 0 ),
pUserMarkerObj( 0 ),
pShadCrsr( 0 ),
pRowColumnSelectionStart( 0 ),
rView( rMyView ),
aActHitType(SDRHIT_NONE),
m_nDropFormat( 0 ),
m_nDropAction( 0 ),
m_nDropDestination( 0 ),
nInsFrmColCount( 1 ),
eDrawMode(OBJ_NONE),
bLockInput(sal_False),
bObjectSelect( sal_False ),
nKS_NUMDOWN_Count(0),
nKS_NUMINDENTINC_Count(0)
{
SetHelpId(HID_EDIT_WIN);
EnableChildTransparentMode();
SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS );
bLinkRemoved = bMBPressed = bInsDraw = bInsFrm =
bIsInDrag = bOldIdle = bOldIdleSet = bChainMode = bWasShdwCrsr = sal_False;
//#i42732# initially use the input language
bUseInputLanguage = sal_True;
SetMapMode(MapMode(MAP_TWIP));
SetPointer( POINTER_TEXT );
aTimer.SetTimeoutHdl(LINK(this, SwEditWin, TimerHandler));
bTblInsDelMode = sal_False;
aKeyInputTimer.SetTimeout( 3000 );
aKeyInputTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputTimerHandler));
aKeyInputFlushTimer.SetTimeout( 200 );
aKeyInputFlushTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputFlushHandler));
// TemplatePointer fuer Farben soll nach Einfachclick
// ohne Selektion zurueckgesetzt werden
aTemplateTimer.SetTimeout(400);
aTemplateTimer.SetTimeoutHdl(LINK(this, SwEditWin, TemplateTimerHdl));
//JP 16.12.98: temporaere Loesung!!! Sollte bei jeder Cursorbewegung
// den Font von der akt. einfuege Position setzen!
if( !rMyView.GetDocShell()->IsReadOnly() )
{
Font aFont;
SetInputContext( InputContext( aFont, INPUTCONTEXT_TEXT |
INPUTCONTEXT_EXTTEXTINPUT ) );
}
}
SwEditWin::~SwEditWin()
{
aKeyInputTimer.Stop();
delete pShadCrsr;
delete pRowColumnSelectionStart;
if( pQuickHlpData->bClear && rView.GetWrtShellPtr() )
pQuickHlpData->Stop( rView.GetWrtShell() );
bExecuteDrag = sal_False;
delete pApplyTempl;
rView.SetDrawFuncPtr(NULL);
if(pUserMarker)
{
delete pUserMarker;
}
delete pAnchorMarker;
}
/******************************************************************************
* Beschreibung: DrawTextEditMode einschalten
******************************************************************************/
void SwEditWin::EnterDrawTextMode( const Point& aDocPos )
{
if ( rView.EnterDrawTextMode(aDocPos) == sal_True )
{
if (rView.GetDrawFuncPtr())
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
}
rView.NoRotate();
rView.AttrChangedNotify( &rView.GetWrtShell() );
}
}
/******************************************************************************
* Beschreibung: DrawMode einschalten
******************************************************************************/
sal_Bool SwEditWin::EnterDrawMode(const MouseEvent& rMEvt, const Point& aDocPos)
{
SwWrtShell &rSh = rView.GetWrtShell();
SdrView *pSdrView = rSh.GetDrawView();
if ( rView.GetDrawFuncPtr() )
{
if (rSh.IsDrawCreate())
return sal_True;
sal_Bool bRet = rView.GetDrawFuncPtr()->MouseButtonDown( rMEvt );
rView.AttrChangedNotify( &rSh );
return bRet;
}
if ( pSdrView && pSdrView->IsTextEdit() )
{
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
rSh.EndTextEdit(); // Danebengeklickt, Ende mit Edit
rSh.SelectObj( aDocPos );
if ( !rSh.IsObjSelected() && !rSh.IsFrmSelected() )
rSh.LeaveSelFrmMode();
else
{
SwEditWin::nDDStartPosY = aDocPos.Y();
SwEditWin::nDDStartPosX = aDocPos.X();
bFrmDrag = sal_True;
}
if( bUnLockView )
rSh.LockView( sal_False );
rView.AttrChangedNotify( &rSh );
return sal_True;
}
return sal_False;
}
/******************************************************************************
* Beschreibung:
******************************************************************************/
sal_Bool SwEditWin::IsDrawSelMode()
{
return IsObjectSelect();
}
/******************************************************************************
* Beschreibung:
******************************************************************************/
void SwEditWin::GetFocus()
{
if ( rView.GetPostItMgr()->HasActiveSidebarWin() )
{
rView.GetPostItMgr()->GrabFocusOnActiveSidebarWin();
}
else
{
rView.GotFocus();
Window::GetFocus();
rView.GetWrtShell().InvalidateAccessibleFocus();
}
}
/******************************************************************************
* Beschreibung:
******************************************************************************/
void SwEditWin::LoseFocus()
{
rView.GetWrtShell().InvalidateAccessibleFocus();
Window::LoseFocus();
if( pQuickHlpData->bClear )
pQuickHlpData->Stop( rView.GetWrtShell() );
rView.LostFocus();
}
/******************************************************************************
* Beschreibung:
******************************************************************************/
void SwEditWin::Command( const CommandEvent& rCEvt )
{
SwWrtShell &rSh = rView.GetWrtShell();
if ( !rView.GetViewFrame() )
{
//Wenn der ViewFrame in Kuerze stirbt kein Popup mehr!
Window::Command(rCEvt);
return;
}
// The command event is send to the window after a possible context
// menu from an inplace client has been closed. Now we have the chance
// to deactivate the inplace client without any problem regarding parent
// windows and code on the stack.
// For more information, see #126086# and #128122#
SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient();
sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
if ( bIsOleActive && ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ))
{
rSh.FinishOLEObj();
return;
}
sal_Bool bCallBase = sal_True;
switch ( rCEvt.GetCommand() )
{
case COMMAND_CONTEXTMENU:
{
const sal_uInt16 nId = SwInputChild::GetChildWindowId();
SwInputChild* pChildWin = (SwInputChild*)GetView().GetViewFrame()->
GetChildWindow( nId );
if (rView.GetPostItMgr()->IsHit(rCEvt.GetMousePosPixel()))
return;
if((!pChildWin || pChildWin->GetView() != &rView) &&
!rSh.IsDrawCreate() && !IsDrawAction())
{
SET_CURR_SHELL( &rSh );
if (!pApplyTempl)
{
if (bNoInterrupt == sal_True)
{
ReleaseMouse();
bNoInterrupt = sal_False;
bMBPressed = sal_False;
}
Point aDocPos( PixelToLogic( rCEvt.GetMousePosPixel() ) );
if ( !rCEvt.IsMouseEvent() )
aDocPos = rSh.GetCharRect().Center();
else
{
SelectMenuPosition(rSh, rCEvt.GetMousePosPixel());
rView.StopShellTimer();
}
const Point aPixPos = LogicToPixel( aDocPos );
if ( rView.GetDocShell()->IsReadOnly() )
{
SwReadOnlyPopup* pROPopup = new SwReadOnlyPopup( aDocPos, rView );
ui::ContextMenuExecuteEvent aEvent;
aEvent.SourceWindow = VCLUnoHelper::GetInterface( this );
aEvent.ExecutePosition.X = aPixPos.X();
aEvent.ExecutePosition.Y = aPixPos.Y();
Menu* pMenu = 0;
::rtl::OUString sMenuName =
::rtl::OUString::createFromAscii( "private:resource/ReadonlyContextMenu");
if( GetView().TryContextMenuInterception( *pROPopup, sMenuName, pMenu, aEvent ) )
{
if ( pMenu )
{
sal_uInt16 nExecId = ((PopupMenu*)pMenu)->Execute(this, aPixPos);
if( !::ExecuteMenuCommand( *static_cast<PopupMenu*>(pMenu), *rView.GetViewFrame(), nExecId ))
pROPopup->Execute(this, nExecId);
}
else
pROPopup->Execute(this, aPixPos);
}
delete pROPopup;
}
else if ( !rView.ExecSpellPopup( aDocPos ) )
GetView().GetViewFrame()->GetDispatcher()->ExecutePopup( 0, this, &aPixPos);
}
else if (pApplyTempl->bUndo)
rSh.Do(SwWrtShell::UNDO);
bCallBase = sal_False;
}
}
break;
case COMMAND_WHEEL:
case COMMAND_STARTAUTOSCROLL:
case COMMAND_AUTOSCROLL:
if( pShadCrsr )
delete pShadCrsr, pShadCrsr = 0;
bCallBase = !rView.HandleWheelCommands( rCEvt );
break;
case COMMAND_VOICE:
{
//ggf. an Outliner weiterleiten
if ( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
{
bCallBase = sal_False;
rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
break;
}
const CommandVoiceData *pCData = rCEvt.GetVoiceData();
if ( VOICECOMMANDTYPE_CONTROL == pCData->GetType() )
break;
sal_uInt16 nSlotId = 0;
SfxPoolItem *pItem = 0;
switch ( pCData->GetCommand() )
{
case DICTATIONCOMMAND_NEWPARAGRAPH: nSlotId = FN_INSERT_BREAK; break;
case DICTATIONCOMMAND_NEWLINE: nSlotId = FN_INSERT_LINEBREAK; break;
case DICTATIONCOMMAND_LEFT: nSlotId = FN_PREV_WORD; break;
case DICTATIONCOMMAND_RIGHT: nSlotId = FN_NEXT_WORD; break;
case DICTATIONCOMMAND_UP: nSlotId = FN_LINE_UP; break;
case DICTATIONCOMMAND_DOWN: nSlotId = FN_LINE_DOWN; break;
case DICTATIONCOMMAND_UNDO: nSlotId = SID_UNDO; break;
case DICTATIONCOMMAND_REPEAT: nSlotId = SID_REPEAT; break;
case DICTATIONCOMMAND_DEL: nSlotId = FN_DELETE_BACK_WORD; break;
case DICTATIONCOMMAND_BOLD_ON: nSlotId = SID_ATTR_CHAR_WEIGHT;
pItem = new SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT );
break;
case DICTATIONCOMMAND_BOLD_OFF: nSlotId = SID_ATTR_CHAR_WEIGHT;
pItem = new SvxWeightItem( WEIGHT_NORMAL, RES_CHRATR_WEIGHT );
break;
case DICTATIONCOMMAND_UNDERLINE_ON: nSlotId = SID_ATTR_CHAR_UNDERLINE;
pItem = new SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_WEIGHT );
break;
case DICTATIONCOMMAND_UNDERLINE_OFF:nSlotId = SID_ATTR_CHAR_UNDERLINE;
pItem = new SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE );
break;
case DICTATIONCOMMAND_ITALIC_ON: nSlotId = SID_ATTR_CHAR_POSTURE;
pItem = new SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE );
break;
case DICTATIONCOMMAND_ITALIC_OFF: nSlotId = SID_ATTR_CHAR_POSTURE;
pItem = new SvxPostureItem( ITALIC_NONE, RES_CHRATR_POSTURE );
break;
case DICTATIONCOMMAND_NUMBERING_ON:
if ( !rSh.GetCurNumRule() )
nSlotId = FN_NUM_NUMBERING_ON;
break;
case DICTATIONCOMMAND_NUMBERING_OFF:
if ( rSh.GetCurNumRule() )
nSlotId = FN_NUM_NUMBERING_ON;
break;
case DICTATIONCOMMAND_TAB:
{
rSh.Insert( '\t' );
}
break;
case DICTATIONCOMMAND_UNKNOWN:
{
rView.GetWrtShell().Insert( pCData->GetText() );
}
break;
#ifdef DBG_UTIL
default:
ASSERT( !this, "unknown speech command." );
#endif
}
if ( nSlotId )
{
bCallBase = sal_False;
if ( pItem )
{
const SfxPoolItem* aArgs[2];
aArgs[0] = pItem;
aArgs[1] = 0;
GetView().GetViewFrame()->GetBindings().Execute(
nSlotId, aArgs, 0, SFX_CALLMODE_STANDARD );
delete pItem;
}
else
GetView().GetViewFrame()->GetBindings().Execute( nSlotId );
}
}
break;
case COMMAND_STARTEXTTEXTINPUT:
{
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
rSh.IsCrsrReadonly();
if(!bIsDocReadOnly)
{
if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
{
bCallBase = sal_False;
rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
}
else
{
if( rSh.HasSelection() )
rSh.DelRight();
bCallBase = sal_False;
LanguageType eInputLanguage = GetInputLanguage();
rSh.CreateExtTextInput(eInputLanguage);
}
}
break;
}
case COMMAND_ENDEXTTEXTINPUT:
{
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
rSh.IsCrsrReadonly();
if(!bIsDocReadOnly)
{
if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
{
bCallBase = sal_False;
rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
}
else
{
bCallBase = sal_False;
String sRecord = rSh.DeleteExtTextInput();
uno::Reference< frame::XDispatchRecorder > xRecorder =
rView.GetViewFrame()->GetBindings().GetRecorder();
if ( sRecord.Len() )
{
// #102812# convert quotes in IME text
// works on the last input character, this is escpecially in Korean text often done
// quotes that are inside of the string are not replaced!
const sal_Unicode aCh = sRecord.GetChar(sRecord.Len() - 1);
SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get();
SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect();
if(pACorr &&
(( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))||
( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh))))
{
rSh.DelLeft();
rSh.AutoCorrect( *pACorr, aCh );
}
if ( xRecorder.is() )
{
//Shell ermitteln
SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
// Request generieren und recorden
if (pSfxShell)
{
SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING );
aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, sRecord ) );
aReq.Done();
}
}
}
}
}
}
break;
case COMMAND_EXTTEXTINPUT:
{
sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
rSh.IsCrsrReadonly();
if(!bIsDocReadOnly)
{
QuickHelpData aTmpQHD;
if( pQuickHlpData->bClear )
{
aTmpQHD.Move( *pQuickHlpData );
pQuickHlpData->Stop( rSh );
}
String sWord;
if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
{
bCallBase = sal_False;
rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
}
else
{
const CommandExtTextInputData* pData = rCEvt.GetExtTextInputData();
if( pData )
{
sWord = pData->GetText();
bCallBase = sal_False;
rSh.SetExtTextInputData( *pData );
}
}
uno::Reference< frame::XDispatchRecorder > xRecorder =
rView.GetViewFrame()->GetBindings().GetRecorder();
if(!xRecorder.is())
{
SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get();
SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect();
if( pACfg && pACorr &&
( pACfg->IsAutoTextTip() ||
pACorr->GetSwFlags().bAutoCompleteWords ) &&
rSh.GetPrevAutoCorrWord( *pACorr, sWord ) )
{
ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr, sal_True);
}
}
}
}
break;
case COMMAND_CURSORPOS:
// will be handled by the base class
break;
case COMMAND_PASTESELECTION:
if( !rView.GetDocShell()->IsReadOnly() )
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSelection( this ));
if( !aDataHelper.GetXTransferable().is() )
break;
sal_uLong nDropFormat;
sal_uInt16 nEventAction, nDropAction, nDropDestination;
nDropDestination = GetDropDestination( rCEvt.GetMousePosPixel() );
if( !nDropDestination )
break;
nDropAction = SotExchange::GetExchangeAction(
aDataHelper.GetDataFlavorExVector(),
nDropDestination, EXCHG_IN_ACTION_COPY,
EXCHG_IN_ACTION_COPY, nDropFormat,
nEventAction );
if( EXCHG_INOUT_ACTION_NONE != nDropAction )
{
const Point aDocPt( PixelToLogic( rCEvt.GetMousePosPixel() ) );
SwTransferable::PasteData( aDataHelper, rSh, nDropAction,
nDropFormat, nDropDestination, sal_False,
sal_False, &aDocPt, EXCHG_IN_ACTION_COPY,
sal_True );
}
}
break;
case COMMAND_MODKEYCHANGE :
{
const CommandModKeyData* pCommandData = (const CommandModKeyData*)rCEvt.GetData();
if(pCommandData->IsMod1() && !pCommandData->IsMod2())
{
sal_uInt16 nSlot = 0;
if(pCommandData->IsLeftShift() && !pCommandData->IsRightShift())
nSlot = SID_ATTR_PARA_LEFT_TO_RIGHT;
else if(!pCommandData->IsLeftShift() && pCommandData->IsRightShift())
nSlot = SID_ATTR_PARA_RIGHT_TO_LEFT;
if(nSlot && SW_MOD()->GetCTLOptions().IsCTLFontEnabled())
GetView().GetViewFrame()->GetDispatcher()->Execute(nSlot);
}
}
break;
case COMMAND_HANGUL_HANJA_CONVERSION :
GetView().GetViewFrame()->GetDispatcher()->Execute(SID_HANGUL_HANJA_CONVERSION);
break;
case COMMAND_INPUTLANGUAGECHANGE :
//#i42732# update state of fontname if input language changes
bInputLanguageSwitched = true;
SetUseInputLanguage( sal_True );
break;
case COMMAND_SELECTIONCHANGE:
{
const CommandSelectionChangeData *pData = rCEvt.GetSelectionChangeData();
rSh.SttCrsrMove();
rSh.GoStartSentence();
rSh.GetCrsr()->GetPoint()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetStart());
rSh.SetMark();
rSh.GetCrsr()->GetMark()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetEnd() - pData->GetStart());
rSh.EndCrsrMove( sal_True );
}
break;
case COMMAND_PREPARERECONVERSION:
if( rSh.HasSelection() )
{
SwPaM *pCrsr = (SwPaM*)rSh.GetCrsr();
if( rSh.IsMultiSelection() )
{
if( pCrsr && !pCrsr->HasMark() &&
pCrsr->GetPoint() == pCrsr->GetMark() )
{
rSh.GoPrevCrsr();
pCrsr = (SwPaM*)rSh.GetCrsr();
}
// Cancel all selections other than the last selected one.
while( rSh.GetCrsr()->GetNext() != rSh.GetCrsr() )
delete rSh.GetCrsr()->GetNext();
}
if( pCrsr )
{
sal_uLong nPosNodeIdx = pCrsr->GetPoint()->nNode.GetIndex();
xub_StrLen nPosIdx = pCrsr->GetPoint()->nContent.GetIndex();
sal_uLong nMarkNodeIdx = pCrsr->GetMark()->nNode.GetIndex();
xub_StrLen nMarkIdx = pCrsr->GetMark()->nContent.GetIndex();
if( !rSh.GetCrsr()->HasMark() )
rSh.GetCrsr()->SetMark();
rSh.SttCrsrMove();
if( nPosNodeIdx < nMarkNodeIdx )
{
rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx;
rSh.GetCrsr()->GetPoint()->nContent = nPosIdx;
rSh.GetCrsr()->GetMark()->nNode = nPosNodeIdx;
rSh.GetCrsr()->GetMark()->nContent =
rSh.GetCrsr()->GetCntntNode( sal_True )->Len();
}
else if( nPosNodeIdx == nMarkNodeIdx )
{
rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx;
rSh.GetCrsr()->GetPoint()->nContent = nPosIdx;
rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx;
rSh.GetCrsr()->GetMark()->nContent = nMarkIdx;
}
else
{
rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx;
rSh.GetCrsr()->GetMark()->nContent = nMarkIdx;
rSh.GetCrsr()->GetPoint()->nNode = nMarkNodeIdx;
rSh.GetCrsr()->GetPoint()->nContent =
rSh.GetCrsr()->GetCntntNode( sal_False )->Len();
}
rSh.EndCrsrMove( sal_True );
}
}
break;
#ifdef DBG_UTIL
default:
ASSERT( !this, "unknown command." );
#endif
}
if (bCallBase)
Window::Command(rCEvt);
}
/* -----------------25.08.2003 10:12-----------------
#i18686#: select the object/cursor at the mouse
position of the context menu request
--------------------------------------------------*/
sal_Bool SwEditWin::SelectMenuPosition(SwWrtShell& rSh, const Point& rMousePos )
{
sal_Bool bRet = sal_False;
const Point aDocPos( PixelToLogic( rMousePos ) );
const bool bIsInsideSelectedObj( rSh.IsInsideSelectedObj( aDocPos ) );
//create a synthetic mouse event out of the coordinates
MouseEvent aMEvt(rMousePos);
SdrView *pSdrView = rSh.GetDrawView();
if ( pSdrView )
{
// no close of insert_draw and reset of draw mode,
// if context menu position is inside a selected object.
if ( !bIsInsideSelectedObj && rView.GetDrawFuncPtr() )
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
rBind.Invalidate( SID_ATTR_SIZE );
rBind.Invalidate( SID_TABLE_CELL );
}
// if draw text is active and there's a text selection
// at the mouse position then do nothing
if(rSh.GetSelectionType() & nsSelectionType::SEL_DRW_TXT)
{
OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();
ESelection aSelection = pOLV->GetSelection();
if(!aSelection.IsZero())
{
SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner();
sal_Bool bVertical = pOutliner->IsVertical();
const EditEngine& rEditEng = pOutliner->GetEditEngine();
Point aEEPos(aDocPos);
const Rectangle& rOutputArea = pOLV->GetOutputArea();
// regard vertical mode
if(bVertical)
{
aEEPos -= rOutputArea.TopRight();
//invert the horizontal direction and exchange X and Y
long nTemp = -aEEPos.X();
aEEPos.X() = aEEPos.Y();
aEEPos.Y() = nTemp;
}
else
aEEPos -= rOutputArea.TopLeft();
EPosition aDocPosition = rEditEng.FindDocPosition(aEEPos);
ESelection aCompare(aDocPosition.nPara, aDocPosition.nIndex);
// make it a forward selection - otherwise the IsLess/IsGreater do not work :-(
aSelection.Adjust();
if(!aCompare.IsLess(aSelection) && !aCompare.IsGreater(aSelection))
{
return sal_False;
}
}
}
if (pSdrView->MouseButtonDown( aMEvt, this ) )
{
pSdrView->MouseButtonUp( aMEvt, this );
rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
return sal_True;
}
}
rSh.ResetCursorStack();
if ( EnterDrawMode( aMEvt, aDocPos ) )
{
return sal_True;
}
if ( rView.GetDrawFuncPtr() && bInsFrm )
{
StopInsFrm();
rSh.Edit();
}
UpdatePointer( aDocPos, 0 );
if( !rSh.IsSelFrmMode() &&
!GetView().GetViewFrame()->GetDispatcher()->IsLocked() )
{
// #107513#
// Test if there is a draw object at that position and if it should be selected.
sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
if(bShould)
{
rView.NoRotate();
rSh.HideCrsr();
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
sal_Bool bSelObj = rSh.SelectObj( aDocPos, 0);
if( bUnLockView )
rSh.LockView( sal_False );
if( bSelObj )
{
bRet = sal_True;
// falls im Macro der Rahmen deselektiert
// wurde, muss nur noch der Cursor
// wieder angezeigt werden.
if( FRMTYPE_NONE == rSh.GetSelFrmType() )
rSh.ShowCrsr();
else
{
if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr())
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
}
rSh.EnterSelFrmMode( &aDocPos );
bFrmDrag = sal_True;
UpdatePointer( aDocPos, 0 );
return bRet;
}
}
if (!rView.GetDrawFuncPtr())
rSh.ShowCrsr();
}
}
else if ( rSh.IsSelFrmMode() &&
(aActHitType == SDRHIT_NONE ||
!bIsInsideSelectedObj))
{
rView.NoRotate();
sal_Bool bUnLockView = !rSh.IsViewLocked();
rSh.LockView( sal_True );
sal_uInt8 nFlag = 0;
if ( rSh.IsSelFrmMode() )
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
rView.AttrChangedNotify(&rSh);
bRet = sal_True;
}
sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag );
if( bUnLockView )
rSh.LockView( sal_False );
if( !bSelObj )
{
// Cursor hier umsetzen, damit er nicht zuerst
// im Rahmen gezeichnet wird; ShowCrsr() geschieht
// in LeaveSelFrmMode()
bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
rSh.LeaveSelFrmMode();
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
bRet = sal_True;
}
else
{
rSh.HideCrsr();
rSh.EnterSelFrmMode( &aDocPos );
rSh.SelFlyGrabCrsr();
rSh.MakeSelVisible();
bFrmDrag = sal_True;
if( rSh.IsFrmSelected() &&
rView.GetDrawFuncPtr() )
{
rView.GetDrawFuncPtr()->Deactivate();
rView.SetDrawFuncPtr(NULL);
rView.LeaveDrawCreate();
rView.AttrChangedNotify( &rSh );
}
UpdatePointer( aDocPos, 0 );
bRet = sal_True;
}
}
else if ( rSh.IsSelFrmMode() && bIsInsideSelectedObj )
{
// ## object at the mouse cursor is already selected - do nothing
return sal_False;
}
if ( rSh.IsGCAttr() )
{
rSh.GCAttr();
rSh.ClearGCAttr();
}
sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False;
if( !bOverSelect )
bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos );
if ( !bOverSelect )
{
{ // nur temp. Move-Kontext aufspannen, da sonst die
// Abfrage auf die Inhaltsform nicht funktioniert!!!
MV_KONTEXT( &rSh );
(rSh.*rSh.fnSetCrsr)(&aDocPos, sal_False);
bRet = sal_True;
}
}
if( !bOverURLGrf )
{
const int nSelType = rSh.GetSelectionType();
if( nSelType == nsSelectionType::SEL_OLE ||
nSelType == nsSelectionType::SEL_GRF )
{
MV_KONTEXT( &rSh );
if( !rSh.IsFrmSelected() )
rSh.GotoNextFly();
rSh.EnterSelFrmMode();
bRet = sal_True;
}
}
return bRet;
}
SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType )
{
//Shell ermitteln
SfxShell* pShell;
SfxDispatcher* pDispatcher = rView.GetViewFrame()->GetDispatcher();
for(sal_uInt16 i = 0; sal_True; ++i )
{
pShell = pDispatcher->GetShell( i );
if( !pShell || pShell->IsA( nType ) )
break;
}
return pShell;
}
void SwEditWin::ClearTip()
{
}
IMPL_LINK( SwEditWin, KeyInputFlushHandler, Timer *, EMPTYARG )
{
FlushInBuffer();
return 0;
}
IMPL_LINK( SwEditWin, KeyInputTimerHandler, Timer *, EMPTYARG )
{
bTblInsDelMode = sal_False;
return 0;
}
void SwEditWin::_InitStaticData()
{
pQuickHlpData = new QuickHelpData();
}
void SwEditWin::_FinitStaticData()
{
delete pQuickHlpData;
}
/* -----------------23.01.2003 12:15-----------------
* #i3370# remove quick help to prevent saving
* of autocorrection suggestions
* --------------------------------------------------*/
void SwEditWin::StopQuickHelp()
{
if( HasFocus() && pQuickHlpData && pQuickHlpData->bClear )
pQuickHlpData->Stop( rView.GetWrtShell() );
}
/*-----------------23.02.97 18:39-------------------
--------------------------------------------------*/
IMPL_LINK(SwEditWin, TemplateTimerHdl, Timer*, EMPTYARG)
{
SetApplyTemplate(SwApplyTemplate());
return 0;
}
void SwEditWin::SetChainMode( sal_Bool bOn )
{
if ( !bChainMode )
StopInsFrm();
if ( pUserMarker )
{
delete pUserMarker;
pUserMarker = 0L;
}
bChainMode = bOn;
if ( !bChainMode )
rView.GetViewFrame()->HideStatusText();
static sal_uInt16 __READONLY_DATA aInva[] =
{
FN_FRAME_CHAIN, FN_FRAME_UNCHAIN, 0
};
rView.GetViewFrame()->GetBindings().Invalidate(aInva);
}
uno::Reference< ::com::sun::star::accessibility::XAccessible > SwEditWin::CreateAccessible()
{
vos::OGuard aGuard(Application::GetSolarMutex()); // this should have
// happend already!!!
SwWrtShell *pSh = rView.GetWrtShellPtr();
ASSERT( pSh, "no writer shell, no accessible object" );
uno::Reference<
::com::sun::star::accessibility::XAccessible > xAcc;
if( pSh )
xAcc = pSh->CreateAccessible();
return xAcc;
}
//-------------------------------------------------------------
void QuickHelpData::Move( QuickHelpData& rCpy )
{
// Pointer verschieben
aArr.Insert( &rCpy.aArr );
rCpy.aArr.Remove( (sal_uInt16)0, rCpy.aArr.Count() );
// nTipId = rCpy.nTipId;
bClear = rCpy.bClear;
nLen = rCpy.nLen;
nCurArrPos = rCpy.nCurArrPos;
bChkInsBlank = rCpy.bChkInsBlank;
bIsTip = rCpy.bIsTip;
bIsAutoText = rCpy.bIsAutoText;
if( pCETID ) delete pCETID;
pCETID = rCpy.pCETID;
rCpy.pCETID = 0;
if( pAttrs )
delete[] pAttrs;
pAttrs = rCpy.pAttrs;
rCpy.pAttrs = 0;
}
void QuickHelpData::ClearCntnt()
{
nLen = nCurArrPos = 0;
bClear = bChkInsBlank = sal_False;
nTipId = 0;
aArr.DeleteAndDestroy( 0 , aArr.Count() );
bIsTip = sal_True;
bIsAutoText = sal_True;
delete pCETID, pCETID = 0;
delete[] pAttrs, pAttrs = 0;
}
void QuickHelpData::Start( SwWrtShell& rSh, sal_uInt16 nWrdLen )
{
if( pCETID ) delete pCETID, pCETID = 0;
if( pAttrs ) delete[] pAttrs, pAttrs = 0;
if( USHRT_MAX != nWrdLen )
{
nLen = nWrdLen;
nCurArrPos = 0;
}
bClear = sal_True;
Window& rWin = rSh.GetView().GetEditWin();
if( bIsTip )
{
Point aPt( rWin.OutputToScreenPixel( rWin.LogicToPixel(
rSh.GetCharRect().Pos() )));
aPt.Y() -= 3;
nTipId = Help::ShowTip( &rWin, Rectangle( aPt, Size( 1, 1 )),
*aArr[ nCurArrPos ],
QUICKHELP_LEFT | QUICKHELP_BOTTOM );
}
else
{
String sStr( *aArr[ nCurArrPos ] );
sStr.Erase( 0, nLen );
sal_uInt16 nL = sStr.Len();
pAttrs = new sal_uInt16[ nL ];
for( sal_uInt16 n = nL; n; )
*(pAttrs + --n ) = EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE |
EXTTEXTINPUT_ATTR_HIGHLIGHT;
pCETID = new CommandExtTextInputData( sStr, pAttrs, nL,
0, 0, 0, sal_False );
rSh.CreateExtTextInput(rWin.GetInputLanguage());
rSh.SetExtTextInputData( *pCETID );
}
}
void QuickHelpData::Stop( SwWrtShell& rSh )
{
if( !bIsTip )
rSh.DeleteExtTextInput( 0, sal_False );
else if( nTipId )
Help::HideTip( nTipId );
ClearCntnt();
}
void QuickHelpData::FillStrArr( SwWrtShell& rSh, const String& rWord )
{
// #i22961# get the letter-case context
const CharClass& rCharClass = GetAppCharClass();
const String aLWord = rCharClass.toLower( rWord, 0, rWord.Len() );
const bool bIsUpper = (rWord == rCharClass.toUpper( rWord, 0, rWord.Len() ) );
const bool bIsLower = (rWord == aLWord);
// add all matching month/day names from the calendar
salhelper::SingletonRef<SwCalendarWrapper>* pCalendar = s_getCalendarWrapper();
(*pCalendar)->LoadDefaultCalendar( rSh.GetCurLang() );
{
uno::Sequence< i18n::CalendarItem > aNames(
(*pCalendar)->getMonths() );
for( int n = 0; n < 2; ++n )
{
for( long nPos = 0, nEnd = aNames.getLength(); nPos < nEnd; ++nPos )
{
const String& rS = aNames[ nPos ].FullName;
if( rS.Len() <= rWord.Len() + 1 )
continue;
const String aLName = rCharClass.toLower( rS, 0, rWord.Len() );
if( aLName != aLWord )
continue;
// #i22961# provide case-sensitive autocompletion suggestions
String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) );
if( !aArr.Insert( pNew ) )
delete pNew;
}
if( !n ) // get data for the second loop
aNames = (*pCalendar)->getDays();
}
}
// and then add all words from the AutoCompleteWord-List
const SwAutoCompleteWord& rACLst = rSh.GetAutoCompleteWords();
sal_uInt16 nStt, nEnd;
if( rACLst.GetRange( rWord, nStt, nEnd ) )
{
for(; nStt < nEnd; ++nStt )
{
const String& rS = rACLst[ nStt ];
if( rS.Len() <= rWord.Len() )
continue;
// #i22961# provide case-sensitive autocompletion suggestions
String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) );
if( !aArr.Insert( pNew ) )
delete pNew;
}
}
}
void SwEditWin::ShowAutoTextCorrectQuickHelp(
const String& rWord, SvxAutoCorrCfg* pACfg, SvxAutoCorrect* pACorr,
sal_Bool bFromIME )
{
SwWrtShell& rSh = rView.GetWrtShell();
pQuickHlpData->ClearCntnt();
if( pACfg->IsAutoTextTip() )
{
SwGlossaryList* pList = ::GetGlossaryList();
pList->HasLongName( rWord, &pQuickHlpData->aArr );
}
if( pQuickHlpData->aArr.Count() )
{
pQuickHlpData->bIsTip = sal_True;
pQuickHlpData->bIsAutoText = sal_True;
}
else if( pACorr->GetSwFlags().bAutoCompleteWords )
{
pQuickHlpData->bIsAutoText = sal_False;
pQuickHlpData->bIsTip = bFromIME ||
!pACorr ||
pACorr->GetSwFlags().bAutoCmpltShowAsTip;
pQuickHlpData->FillStrArr( rSh, rWord );
}
if( pQuickHlpData->aArr.Count() )
pQuickHlpData->Start( rSh, rWord.Len() );
}
/* -----------------29.03.2006 11:01-----------------
*
* --------------------------------------------------*/
void SwEditWin::SetUseInputLanguage( sal_Bool bNew )
{
if ( bNew || bUseInputLanguage )
{
SfxBindings& rBind = GetView().GetViewFrame()->GetBindings();
rBind.Invalidate( SID_ATTR_CHAR_FONT );
rBind.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
}
bUseInputLanguage = bNew;
}
/*-- 13.11.2008 10:18:17---------------------------------------------------
-----------------------------------------------------------------------*/
XubString SwEditWin::GetSurroundingText() const
{
String sReturn;
SwWrtShell& rSh = rView.GetWrtShell();
if( rSh.HasSelection() && !rSh.IsMultiSelection() && rSh.IsSelOnePara() )
rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
else if( !rSh.HasSelection() )
{
SwPosition *pPos = rSh.GetCrsr()->GetPoint();
xub_StrLen nPos = pPos->nContent.GetIndex();
// get the sentence around the cursor
rSh.HideCrsr();
rSh.GoStartSentence();
rSh.SetMark();
rSh.GoEndSentence();
rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
pPos->nContent = nPos;
rSh.ClearMark();
rSh.HideCrsr();
}
return sReturn;
}
/*-- 13.11.2008 10:18:17---------------------------------------------------
-----------------------------------------------------------------------*/
Selection SwEditWin::GetSurroundingTextSelection() const
{
SwWrtShell& rSh = rView.GetWrtShell();
if( rSh.HasSelection() )
{
String sReturn;
rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
return Selection( 0, sReturn.Len() );
}
else
{
// Return the position of the visible cursor in the sentence
// around the visible cursor.
SwPosition *pPos = rSh.GetCrsr()->GetPoint();
xub_StrLen nPos = pPos->nContent.GetIndex();
rSh.HideCrsr();
rSh.GoStartSentence();
xub_StrLen nStartPos = rSh.GetCrsr()->GetPoint()->nContent.GetIndex();
pPos->nContent = nPos;
rSh.ClearMark();
rSh.ShowCrsr();
return Selection( nPos - nStartPos, nPos - nStartPos );
}
}
// MT: Removed Windows::SwitchView() introduced with IA2 CWS.
// There are other notifications for this when the active view has chnaged, so please update the code to use that event mechanism
void SwEditWin::SwitchView()
{
#ifdef ACCESSIBLE_LAYOUT
if (!Application::IsAccessibilityEnabled())
{
return ;
}
rView.GetWrtShell().InvalidateAccessibleFocus();
#endif
}