/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sw.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "formatclipboard.hxx" #include #include #include #include #include #include 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(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(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(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.GetNumRuleAtCurrCrsrPos() && !rSh.GetNumRuleAtCurrCrsrPos()->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.GetNumRuleAtCurrCrsrPos() && !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 is hit. const bool bOnlyBackspaceKey( KEY_BACKSPACE == rKeyCode.GetFullCode() ); if ( rSh.IsSttPara() && !rSh.HasSelection() && ( rSh.GetNumRuleAtCurrCrsrPos() == 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 . // Otherwise method // should only change the state of // the current paragraph depending of the key. // On it is set to , // on it is set to . // Thus, assure that method // 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.GetNumRuleAtCurrCrsrPos() ); 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.GetNumRuleAtCurrCrsrPos() && rSh.IsSttOfPara() && !rSh.HasReadonlySel() ) { if ( !rSh.IsMultiSelection() && rSh.IsFirstOfNumRuleAtCrsrPos() && 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.GetNumRuleAtCurrCrsrPos() && rSh.IsSttOfPara() && !rSh.HasReadonlySel() ) { if ( !rSh.IsMultiSelection() && rSh.IsFirstOfNumRuleAtCrsrPos() && 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(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(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(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.GetNumRuleAtCurrCrsrPos() ) nSlotId = FN_NUM_NUMBERING_ON; break; case DICTATIONCOMMAND_NUMBERING_OFF: if ( rSh.GetNumRuleAtCurrCrsrPos() ) 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: { 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 { const SwExtTextInput* pExtInp = rSh.GetDoc()->GetExtTextInput(); if ( pExtInp ) { // The carret placed at the end of the preedit. if ( POS_COLLIDE_START == ComparePosition( *pExtInp->End(), *pExtInp->End(), *rSh.GetCrsr()->End(), *rSh.GetCrsr()->End() ) ) { SwRect aInputRect; if ( rSh.GetCharRectAt( aInputRect, *pExtInp->Start() ) ) { Rectangle aRect( aInputRect.SVRect() ); SetCursorRect( &aRect, 1 ); bCallBase = sal_False; } } if ( bCallBase ) SetCursorRect(); } } } } 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(pData->GetStart()); rSh.SetMark(); rSh.GetCrsr()->GetMark()->nContent += sal::static_int_cast(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 // happened 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* 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 }