1efeef26fSAndrew Rist /************************************************************** 2efeef26fSAndrew Rist * 3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file 5efeef26fSAndrew Rist * distributed with this work for additional information 6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file 7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the 8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance 9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at 10efeef26fSAndrew Rist * 11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12efeef26fSAndrew Rist * 13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing, 14efeef26fSAndrew Rist * software distributed under the License is distributed on an 15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the 17efeef26fSAndrew Rist * specific language governing permissions and limitations 18efeef26fSAndrew Rist * under the License. 19efeef26fSAndrew Rist * 20efeef26fSAndrew Rist *************************************************************/ 21efeef26fSAndrew Rist 22efeef26fSAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 25cdf0e10cSrcweir #include "precompiled_sw.hxx" 26cdf0e10cSrcweir 27cdf0e10cSrcweir 28cdf0e10cSrcweir #include <tools/list.hxx> 29cdf0e10cSrcweir #include <swtypes.hxx> 30cdf0e10cSrcweir #include <hintids.hxx> 31cdf0e10cSrcweir #include <com/sun/star/accessibility/XAccessible.hpp> 32cdf0e10cSrcweir #include <comphelper/processfactory.hxx> 33cdf0e10cSrcweir #include <com/sun/star/i18n/XBreakIterator.hpp> 34cdf0e10cSrcweir #include <com/sun/star/i18n/ScriptType.hpp> 35cdf0e10cSrcweir #include <com/sun/star/i18n/InputSequenceCheckMode.hpp> 36cdf0e10cSrcweir 37cdf0e10cSrcweir #include <com/sun/star/i18n/UnicodeScript.hpp> 38cdf0e10cSrcweir 39cdf0e10cSrcweir #include <vcl/help.hxx> 40cdf0e10cSrcweir #include <vcl/graph.hxx> 41cdf0e10cSrcweir #include <vcl/msgbox.hxx> 42cdf0e10cSrcweir #include <vcl/cmdevt.h> 43cdf0e10cSrcweir #include <sot/storage.hxx> 44cdf0e10cSrcweir #include <svl/macitem.hxx> 45cdf0e10cSrcweir #include <unotools/securityoptions.hxx> 46cdf0e10cSrcweir #include <basic/sbxvar.hxx> 47cdf0e10cSrcweir #include <svl/ctloptions.hxx> 48cdf0e10cSrcweir #include <basic/sbx.hxx> 49cdf0e10cSrcweir #include <svl/eitem.hxx> 50cdf0e10cSrcweir #include <svl/stritem.hxx> 51cdf0e10cSrcweir #include <sfx2/ipclient.hxx> 52cdf0e10cSrcweir #include <sfx2/viewfrm.hxx> 53cdf0e10cSrcweir #include <sfx2/request.hxx> 54cdf0e10cSrcweir #include <sfx2/bindings.hxx> 55cdf0e10cSrcweir #include <sfx2/dispatch.hxx> 56cdf0e10cSrcweir #include <svl/ptitem.hxx> 57cdf0e10cSrcweir #include <editeng/sizeitem.hxx> 58cdf0e10cSrcweir #include <editeng/langitem.hxx> 59cdf0e10cSrcweir #include <svx/htmlmode.hxx> 60cdf0e10cSrcweir #include <svx/svdview.hxx> 61cdf0e10cSrcweir #include <svx/svdhdl.hxx> 62cdf0e10cSrcweir #include <svx/svdoutl.hxx> 63cdf0e10cSrcweir #include <editeng/editeng.hxx> 64cdf0e10cSrcweir #include <editeng/svxacorr.hxx> 65cdf0e10cSrcweir #include <editeng/scripttypeitem.hxx> 66cdf0e10cSrcweir #include <editeng/flditem.hxx> 67cdf0e10cSrcweir #include <editeng/colritem.hxx> 68cdf0e10cSrcweir #include <editeng/brshitem.hxx> 69cdf0e10cSrcweir #include <editeng/wghtitem.hxx> 70cdf0e10cSrcweir #include <editeng/udlnitem.hxx> 71cdf0e10cSrcweir #include <editeng/postitem.hxx> 72cdf0e10cSrcweir #include <editeng/protitem.hxx> 73cdf0e10cSrcweir #include <unotools/charclass.hxx> 74cdf0e10cSrcweir 75cdf0e10cSrcweir #include <editeng/acorrcfg.hxx> 76cdf0e10cSrcweir #include <SwSmartTagMgr.hxx> 77cdf0e10cSrcweir #include <edtwin.hxx> 78cdf0e10cSrcweir #include <view.hxx> 79cdf0e10cSrcweir #include <wrtsh.hxx> 80cdf0e10cSrcweir #include <IDocumentSettingAccess.hxx> 81cdf0e10cSrcweir #include <fldbas.hxx> 82cdf0e10cSrcweir #include <swmodule.hxx> 83cdf0e10cSrcweir #include <docsh.hxx> 84cdf0e10cSrcweir #include <viewopt.hxx> 85cdf0e10cSrcweir #include <drawbase.hxx> 86cdf0e10cSrcweir #include <dselect.hxx> 87cdf0e10cSrcweir #include <textsh.hxx> 88cdf0e10cSrcweir #include <shdwcrsr.hxx> 89cdf0e10cSrcweir #include <fmtanchr.hxx> 90cdf0e10cSrcweir #include <fmtornt.hxx> 91cdf0e10cSrcweir #include <fmtfsize.hxx> 92cdf0e10cSrcweir #include <fmtclds.hxx> 93cdf0e10cSrcweir #include <frmfmt.hxx> 94cdf0e10cSrcweir #include <modcfg.hxx> 95cdf0e10cSrcweir #include <fmtcol.hxx> 96cdf0e10cSrcweir #include <wview.hxx> 97cdf0e10cSrcweir #include <listsh.hxx> 98cdf0e10cSrcweir #include <gloslst.hxx> 99cdf0e10cSrcweir #include <inputwin.hxx> 100cdf0e10cSrcweir #include <gloshdl.hxx> 101cdf0e10cSrcweir #include <swundo.hxx> 102cdf0e10cSrcweir #include <drwtxtsh.hxx> 103cdf0e10cSrcweir #include <fchrfmt.hxx> 104cdf0e10cSrcweir #include <fmturl.hxx> 105cdf0e10cSrcweir #include <romenu.hxx> 106cdf0e10cSrcweir #include <initui.hxx> 107cdf0e10cSrcweir #include <frmatr.hxx> 108cdf0e10cSrcweir #include <extinput.hxx> 109cdf0e10cSrcweir #include <acmplwrd.hxx> 110cdf0e10cSrcweir #include <swcalwrp.hxx> 111cdf0e10cSrcweir #include <swdtflvr.hxx> 112cdf0e10cSrcweir #include <wdocsh.hxx> 113cdf0e10cSrcweir #include <crsskip.hxx> 114cdf0e10cSrcweir #include <breakit.hxx> 115cdf0e10cSrcweir #include <checkit.hxx> 116cdf0e10cSrcweir 117cdf0e10cSrcweir #include <helpid.h> 118cdf0e10cSrcweir #include <cmdid.h> 119cdf0e10cSrcweir #ifndef _DOCVW_HRC 120cdf0e10cSrcweir #include <docvw.hrc> 121cdf0e10cSrcweir #endif 122cdf0e10cSrcweir #include <uitool.hxx> 123cdf0e10cSrcweir // OD 18.09.2003 #i18732# 124cdf0e10cSrcweir #include <fmtfollowtextflow.hxx> 125cdf0e10cSrcweir #include <toolkit/helper/vclunohelper.hxx> 126cdf0e10cSrcweir #include <charfmt.hxx> 127cdf0e10cSrcweir #include <numrule.hxx> 128cdf0e10cSrcweir #include <pagedesc.hxx> 129cdf0e10cSrcweir #include <svtools/ruler.hxx> // #i23726# 130cdf0e10cSrcweir #include "formatclipboard.hxx" 131cdf0e10cSrcweir #include <vos/mutex.hxx> 132cdf0e10cSrcweir #include <vcl/svapp.hxx> 133cdf0e10cSrcweir 134cdf0e10cSrcweir #include <IMark.hxx> 135cdf0e10cSrcweir #include <doc.hxx> 136cdf0e10cSrcweir #include <xmloff/odffields.hxx> 137cdf0e10cSrcweir 138cdf0e10cSrcweir #include <PostItMgr.hxx> 139cdf0e10cSrcweir 140cdf0e10cSrcweir //JP 11.10.2001: enable test code for bug fix 91313 141cdf0e10cSrcweir #if defined(DBG_UTIL) && (OSL_DEBUG_LEVEL > 1) 142cdf0e10cSrcweir //#define TEST_FOR_BUG91313 143cdf0e10cSrcweir #endif 144cdf0e10cSrcweir 145cdf0e10cSrcweir using namespace sw::mark; 146cdf0e10cSrcweir using namespace ::com::sun::star; 147cdf0e10cSrcweir 148cdf0e10cSrcweir /*-------------------------------------------------------------------- 149cdf0e10cSrcweir Beschreibung: Globals 150cdf0e10cSrcweir --------------------------------------------------------------------*/ 151cdf0e10cSrcweir 152cdf0e10cSrcweir static bool bInputLanguageSwitched = false; 153cdf0e10cSrcweir extern sal_Bool bNoInterrupt; // in mainwn.cxx 154cdf0e10cSrcweir 155cdf0e10cSrcweir //Normalerweise wird im MouseButtonUp eine Selektion aufgehoben wenn die 156cdf0e10cSrcweir //Selektion nicht gerade aufgezogen wird. Leider wird im MouseButtonDown 157cdf0e10cSrcweir //bei doppel-/dreifach-Klick Selektiert, diese Selektion wird in dem Handler 158cdf0e10cSrcweir //komplett abgeschlossen und kann deshalb im Up nicht mehr unterschieden 159cdf0e10cSrcweir //werden. Um dies Aufzuloese wird bHoldSelection im Down gesetzt und im 160cdf0e10cSrcweir //Up ausgewertet. 161cdf0e10cSrcweir static sal_Bool bHoldSelection = sal_False; 162cdf0e10cSrcweir 163cdf0e10cSrcweir sal_Bool bFrmDrag = sal_False; 164cdf0e10cSrcweir sal_Bool bValidCrsrPos = sal_False; 165cdf0e10cSrcweir sal_Bool bModePushed = sal_False; 166cdf0e10cSrcweir sal_Bool bDDTimerStarted = sal_False; 167cdf0e10cSrcweir sal_Bool bFlushCharBuffer = sal_False; 168cdf0e10cSrcweir sal_Bool SwEditWin::bReplaceQuote = sal_False; 169cdf0e10cSrcweir sal_Bool bDDINetAttr = sal_False; 170cdf0e10cSrcweir SdrHdlKind eSdrMoveHdl = HDL_USER; 171cdf0e10cSrcweir 172cdf0e10cSrcweir QuickHelpData* SwEditWin::pQuickHlpData = 0; 173cdf0e10cSrcweir 174cdf0e10cSrcweir long SwEditWin::nDDStartPosY = 0; 175cdf0e10cSrcweir long SwEditWin::nDDStartPosX = 0; 176cdf0e10cSrcweir Color SwEditWin::aTextBackColor(COL_YELLOW); 177cdf0e10cSrcweir Color SwEditWin::aTextColor(COL_RED); 178cdf0e10cSrcweir sal_Bool SwEditWin::bTransparentBackColor = sal_False; // Hintergrund nicht transparent 179cdf0e10cSrcweir 180cdf0e10cSrcweir 181cdf0e10cSrcweir extern sal_Bool bExecuteDrag; 182cdf0e10cSrcweir 183cdf0e10cSrcweir SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType ); 184cdf0e10cSrcweir 185cdf0e10cSrcweir DBG_NAME(edithdl) 186cdf0e10cSrcweir 187cdf0e10cSrcweir class SwAnchorMarker 188cdf0e10cSrcweir { 189cdf0e10cSrcweir SdrHdl* pHdl; 190cdf0e10cSrcweir Point aHdlPos; 191cdf0e10cSrcweir Point aLastPos; 192cdf0e10cSrcweir // --> OD 2010-09-16 #i114522# 193cdf0e10cSrcweir bool bTopRightHandle; 194cdf0e10cSrcweir // <-- 195cdf0e10cSrcweir public: 196cdf0e10cSrcweir SwAnchorMarker( SdrHdl* pH ) 197cdf0e10cSrcweir : pHdl( pH ) 198cdf0e10cSrcweir , aHdlPos( pH->GetPos() ) 199cdf0e10cSrcweir , aLastPos( pH->GetPos() ) 200cdf0e10cSrcweir // --> OD 2010-09-16 #i114522# 201cdf0e10cSrcweir , bTopRightHandle( pH->GetKind() == HDL_ANCHOR_TR ) 202cdf0e10cSrcweir // <-- 203cdf0e10cSrcweir {} 204cdf0e10cSrcweir const Point& GetLastPos() const { return aLastPos; } 205cdf0e10cSrcweir void SetLastPos( const Point& rNew ) { aLastPos = rNew; } 206cdf0e10cSrcweir void SetPos( const Point& rNew ) { pHdl->SetPos( rNew ); } 207cdf0e10cSrcweir const Point& GetPos() { return pHdl->GetPos(); } 208cdf0e10cSrcweir const Point& GetHdlPos() { return aHdlPos; } 2094772d9afSArmin Le Grand SdrHdl* GetHdl() const { return pHdl; } 210cdf0e10cSrcweir void ChgHdl( SdrHdl* pNew ) 211cdf0e10cSrcweir { 212cdf0e10cSrcweir pHdl = pNew; 213cdf0e10cSrcweir // --> OD 2010-09-16 #i114522# 214cdf0e10cSrcweir if ( pHdl ) 215cdf0e10cSrcweir { 216cdf0e10cSrcweir bTopRightHandle = (pHdl->GetKind() == HDL_ANCHOR_TR); 217cdf0e10cSrcweir } 218cdf0e10cSrcweir // <-- 219cdf0e10cSrcweir } 220cdf0e10cSrcweir // --> OD 2010-09-16 #i114522# 221cdf0e10cSrcweir const Point GetPosForHitTest( const OutputDevice& rOut ) 222cdf0e10cSrcweir { 223cdf0e10cSrcweir Point aHitTestPos( GetPos() ); 224cdf0e10cSrcweir aHitTestPos = rOut.LogicToPixel( aHitTestPos ); 225cdf0e10cSrcweir if ( bTopRightHandle ) 226cdf0e10cSrcweir { 227cdf0e10cSrcweir aHitTestPos += Point( -1, 1 ); 228cdf0e10cSrcweir } 229cdf0e10cSrcweir else 230cdf0e10cSrcweir { 231cdf0e10cSrcweir aHitTestPos += Point( 1, 1 ); 232cdf0e10cSrcweir } 233cdf0e10cSrcweir aHitTestPos = rOut.PixelToLogic( aHitTestPos ); 234cdf0e10cSrcweir 235cdf0e10cSrcweir return aHitTestPos; 236cdf0e10cSrcweir } 237cdf0e10cSrcweir // <-- 238cdf0e10cSrcweir }; 239cdf0e10cSrcweir 240cdf0e10cSrcweir struct QuickHelpData 241cdf0e10cSrcweir { 242cdf0e10cSrcweir SvStringsISortDtor aArr; 243cdf0e10cSrcweir sal_uInt16* pAttrs; 244cdf0e10cSrcweir CommandExtTextInputData* pCETID; 245cdf0e10cSrcweir sal_uLong nTipId; 246cdf0e10cSrcweir sal_uInt16 nLen, nCurArrPos; 247cdf0e10cSrcweir sal_Bool bClear : 1, bChkInsBlank : 1, bIsTip : 1, bIsAutoText : 1; 248cdf0e10cSrcweir 249cdf0e10cSrcweir QuickHelpData() : pAttrs( 0 ), pCETID( 0 ) { ClearCntnt(); } 250cdf0e10cSrcweir 251cdf0e10cSrcweir void Move( QuickHelpData& rCpy ); 252cdf0e10cSrcweir void ClearCntnt(); 253cdf0e10cSrcweir void Start( SwWrtShell& rSh, sal_uInt16 nWrdLen ); 254cdf0e10cSrcweir void Stop( SwWrtShell& rSh ); 255cdf0e10cSrcweir 256cdf0e10cSrcweir sal_Bool HasCntnt() const { return aArr.Count() && 0 != nLen; } 257cdf0e10cSrcweir 258cdf0e10cSrcweir void Inc( sal_Bool bEndLess ) 259cdf0e10cSrcweir { 260cdf0e10cSrcweir if( ++nCurArrPos >= aArr.Count() ) 261cdf0e10cSrcweir nCurArrPos = (bEndLess && !bIsAutoText )? 0 : nCurArrPos-1; 262cdf0e10cSrcweir } 263cdf0e10cSrcweir void Dec( sal_Bool bEndLess ) 264cdf0e10cSrcweir { 265cdf0e10cSrcweir if( 0 == nCurArrPos-- ) 266cdf0e10cSrcweir nCurArrPos = (bEndLess && !bIsAutoText ) ? aArr.Count()-1 : 0; 267cdf0e10cSrcweir } 268cdf0e10cSrcweir void FillStrArr( SwWrtShell& rSh, const String& rWord ); 269cdf0e10cSrcweir }; 270cdf0e10cSrcweir 271cdf0e10cSrcweir 272cdf0e10cSrcweir /*-------------------------------------------------------------------- 273cdf0e10cSrcweir Beschreibung: Minimale Bewegung Zittern vermeiden 274cdf0e10cSrcweir --------------------------------------------------------------------*/ 275cdf0e10cSrcweir 276cdf0e10cSrcweir #define HIT_PIX 2 /* Hit-Toleranz in Pixel */ 277cdf0e10cSrcweir #define MIN_MOVE 4 278cdf0e10cSrcweir 279cdf0e10cSrcweir inline sal_Bool IsMinMove(const Point &rStartPos, const Point &rLPt) 280cdf0e10cSrcweir { 281cdf0e10cSrcweir return Abs(rStartPos.X() - rLPt.X()) > MIN_MOVE || 282cdf0e10cSrcweir Abs(rStartPos.Y() - rLPt.Y()) > MIN_MOVE; 283cdf0e10cSrcweir } 284cdf0e10cSrcweir 285cdf0e10cSrcweir /*-------------------------------------------------------------------- 286cdf0e10cSrcweir JP 30.07.98: fuer MouseButtonDown - feststellen, ob ein DrawObject 287cdf0e10cSrcweir und KEIN SwgFrame getroffen wurde! Shift/Ctrl sollen 288cdf0e10cSrcweir nur bei DrawObjecte zum Selektieren fuehren, bei SwgFlys 289cdf0e10cSrcweir ggfs zum ausloesen von Hyperlinks (DownLoad/NewWindow!) 290cdf0e10cSrcweir --------------------------------------------------------------------*/ 291cdf0e10cSrcweir inline sal_Bool IsDrawObjSelectable( const SwWrtShell& rSh, const Point& rPt ) 292cdf0e10cSrcweir { 293cdf0e10cSrcweir sal_Bool bRet = sal_True; 294cdf0e10cSrcweir SdrObject* pObj; 295cdf0e10cSrcweir switch( rSh.GetObjCntType( rPt, pObj )) 296cdf0e10cSrcweir { 297cdf0e10cSrcweir case OBJCNT_NONE: 298cdf0e10cSrcweir case OBJCNT_FLY: 299cdf0e10cSrcweir case OBJCNT_GRF: 300cdf0e10cSrcweir case OBJCNT_OLE: 301cdf0e10cSrcweir bRet = sal_False; 302cdf0e10cSrcweir break; 303cdf0e10cSrcweir default:; //prevent warning 304cdf0e10cSrcweir } 305cdf0e10cSrcweir return bRet; 306cdf0e10cSrcweir } 307cdf0e10cSrcweir 308cdf0e10cSrcweir /*-------------------------------------------------------------------- 309cdf0e10cSrcweir Beschreibung: Pointer umschalten 310cdf0e10cSrcweir --------------------------------------------------------------------*/ 311cdf0e10cSrcweir 312cdf0e10cSrcweir 313cdf0e10cSrcweir void SwEditWin::UpdatePointer(const Point &rLPt, sal_uInt16 nModifier ) 314cdf0e10cSrcweir { 315cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 316cdf0e10cSrcweir if( pApplyTempl ) 317cdf0e10cSrcweir { 318cdf0e10cSrcweir PointerStyle eStyle = POINTER_FILL; 319cdf0e10cSrcweir if( rSh.IsOverReadOnlyPos( rLPt )) 320cdf0e10cSrcweir { 321cdf0e10cSrcweir if( pUserMarker ) 322cdf0e10cSrcweir { 323cdf0e10cSrcweir delete pUserMarker; 324cdf0e10cSrcweir pUserMarker = 0L; 325cdf0e10cSrcweir } 326cdf0e10cSrcweir // rSh.SwCrsrShell::UnSetVisCrsr( rLPt ); 327cdf0e10cSrcweir eStyle = POINTER_NOTALLOWED; 328cdf0e10cSrcweir } 329cdf0e10cSrcweir else 330cdf0e10cSrcweir { 331cdf0e10cSrcweir SwRect aRect; 332cdf0e10cSrcweir SwRect* pRect = &aRect; 333cdf0e10cSrcweir const SwFrmFmt* pFmt = 0; 334cdf0e10cSrcweir 335cdf0e10cSrcweir bool bFrameIsValidTarget = false; 336cdf0e10cSrcweir if( pApplyTempl->pFormatClipboard ) 337cdf0e10cSrcweir bFrameIsValidTarget = pApplyTempl->pFormatClipboard->HasContentForThisType( nsSelectionType::SEL_FRM ); 338cdf0e10cSrcweir else if( !pApplyTempl->nColor ) 339cdf0e10cSrcweir bFrameIsValidTarget = ( pApplyTempl->eType == SFX_STYLE_FAMILY_FRAME ); 340cdf0e10cSrcweir 341cdf0e10cSrcweir if( bFrameIsValidTarget && 342cdf0e10cSrcweir 0 !=(pFmt = rSh.GetFmtFromObj( rLPt, &pRect )) && 343cdf0e10cSrcweir PTR_CAST(SwFlyFrmFmt, pFmt)) 344cdf0e10cSrcweir { 345cdf0e10cSrcweir //Highlight fuer Rahmen anwerfen 346cdf0e10cSrcweir Rectangle aTmp( pRect->SVRect() ); 347cdf0e10cSrcweir 348cdf0e10cSrcweir if ( !pUserMarker ) 349cdf0e10cSrcweir { 350cdf0e10cSrcweir pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp ); 351cdf0e10cSrcweir } 352cdf0e10cSrcweir } 353cdf0e10cSrcweir else if(pUserMarker) 354cdf0e10cSrcweir { 355cdf0e10cSrcweir delete pUserMarker; 356cdf0e10cSrcweir pUserMarker = 0L; 357cdf0e10cSrcweir } 358cdf0e10cSrcweir 359cdf0e10cSrcweir rSh.SwCrsrShell::SetVisCrsr( rLPt ); 360cdf0e10cSrcweir } 361cdf0e10cSrcweir SetPointer( eStyle ); 362cdf0e10cSrcweir return; 363cdf0e10cSrcweir } 364cdf0e10cSrcweir 365cdf0e10cSrcweir if( !rSh.VisArea().Width() ) 366cdf0e10cSrcweir return; 367cdf0e10cSrcweir 368cdf0e10cSrcweir SET_CURR_SHELL(&rSh); 369cdf0e10cSrcweir 370cdf0e10cSrcweir if ( IsChainMode() ) 371cdf0e10cSrcweir { 372cdf0e10cSrcweir SwRect aRect; 373cdf0e10cSrcweir int nChainable = rSh.Chainable( aRect, *rSh.GetFlyFrmFmt(), rLPt ); 374cdf0e10cSrcweir PointerStyle eStyle = nChainable 375cdf0e10cSrcweir ? POINTER_CHAIN_NOTALLOWED : POINTER_CHAIN; 376cdf0e10cSrcweir if ( !nChainable ) 377cdf0e10cSrcweir { 378cdf0e10cSrcweir Rectangle aTmp( aRect.SVRect() ); 379cdf0e10cSrcweir 380cdf0e10cSrcweir if ( !pUserMarker ) 381cdf0e10cSrcweir { 382cdf0e10cSrcweir pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp ); 383cdf0e10cSrcweir } 384cdf0e10cSrcweir } 385cdf0e10cSrcweir else 386cdf0e10cSrcweir { 387cdf0e10cSrcweir delete pUserMarker; 388cdf0e10cSrcweir pUserMarker = 0L; 389cdf0e10cSrcweir } 390cdf0e10cSrcweir 391cdf0e10cSrcweir rView.GetViewFrame()->ShowStatusText( 392cdf0e10cSrcweir SW_RESSTR(STR_CHAIN_OK+nChainable)); 393cdf0e10cSrcweir SetPointer( eStyle ); 394cdf0e10cSrcweir return; 395cdf0e10cSrcweir } 396cdf0e10cSrcweir 397cdf0e10cSrcweir // Removed ExecHyperlink option. 398cdf0e10cSrcweir //sal_Bool bExecHyperlinks = rSh.GetViewOptions()->IsExecHyperlinks() ^ 399cdf0e10cSrcweir // (nModifier == KEY_MOD2 ? sal_True : sal_False); 400cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly(); 401cdf0e10cSrcweir if ( !bExecHyperlinks ) 402cdf0e10cSrcweir { 403cdf0e10cSrcweir SvtSecurityOptions aSecOpts; 404cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK ); 405cdf0e10cSrcweir if ( ( bSecureOption && nModifier == KEY_MOD1 ) || 406cdf0e10cSrcweir ( !bSecureOption && nModifier != KEY_MOD1 ) ) 407cdf0e10cSrcweir bExecHyperlinks = sal_True; 408cdf0e10cSrcweir } 409cdf0e10cSrcweir 410cdf0e10cSrcweir const sal_Bool bExecSmarttags = nModifier == KEY_MOD1; 411cdf0e10cSrcweir 412cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 413cdf0e10cSrcweir sal_Bool bPrefSdrPointer = sal_False; 414cdf0e10cSrcweir sal_Bool bHitHandle = sal_False; 415cdf0e10cSrcweir sal_Bool bCntAtPos = sal_False; 416cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() && 417cdf0e10cSrcweir rSh.IsCrsrReadonly(); 418cdf0e10cSrcweir aActHitType = SDRHIT_NONE; 419cdf0e10cSrcweir PointerStyle eStyle = POINTER_TEXT; 420cdf0e10cSrcweir if ( !pSdrView ) 421cdf0e10cSrcweir bCntAtPos = sal_True; 422cdf0e10cSrcweir else if ( sal_True == (bHitHandle = pSdrView->PickHandle( rLPt ) != 0) ) 423cdf0e10cSrcweir { 424cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT; 425cdf0e10cSrcweir bPrefSdrPointer = sal_True; 426cdf0e10cSrcweir } 427cdf0e10cSrcweir else 428cdf0e10cSrcweir { 429cdf0e10cSrcweir const sal_Bool bNotInSelObj = !rSh.IsInsideSelectedObj( rLPt ); 430cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && !bInsDraw && bNotInSelObj ) 431cdf0e10cSrcweir { 432cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT; 433cdf0e10cSrcweir if (IsObjectSelect()) 434cdf0e10cSrcweir eStyle = POINTER_ARROW; 435cdf0e10cSrcweir else 436cdf0e10cSrcweir bPrefSdrPointer = sal_True; 437cdf0e10cSrcweir } 438cdf0e10cSrcweir else 439cdf0e10cSrcweir { 440cdf0e10cSrcweir SdrObject* pObj; SdrPageView* pPV; 441cdf0e10cSrcweir pSdrView->SetHitTolerancePixel( HIT_PIX ); 442cdf0e10cSrcweir if ( bNotInSelObj && bExecHyperlinks && 443cdf0e10cSrcweir pSdrView->PickObj( rLPt, pSdrView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO )) 444cdf0e10cSrcweir { 445cdf0e10cSrcweir SdrObjMacroHitRec aTmp; 446cdf0e10cSrcweir aTmp.aPos = rLPt; 447cdf0e10cSrcweir aTmp.pPageView = pPV; 448cdf0e10cSrcweir SetPointer( pObj->GetMacroPointer( aTmp ) ); 449cdf0e10cSrcweir return; 450cdf0e10cSrcweir } 451cdf0e10cSrcweir else 452cdf0e10cSrcweir { 453cdf0e10cSrcweir // dvo: IsObjSelectable() eventually calls SdrView::PickObj, so 454cdf0e10cSrcweir // apparently this is used to determine whether this is a 455cdf0e10cSrcweir // drawling layer object or not. 456cdf0e10cSrcweir if ( rSh.IsObjSelectable( rLPt ) ) 457cdf0e10cSrcweir { 458cdf0e10cSrcweir if (pSdrView->IsTextEdit()) 459cdf0e10cSrcweir { 460cdf0e10cSrcweir aActHitType = SDRHIT_NONE; 461cdf0e10cSrcweir bPrefSdrPointer = sal_True; 462cdf0e10cSrcweir } 463cdf0e10cSrcweir else 464cdf0e10cSrcweir { 465cdf0e10cSrcweir SdrViewEvent aVEvt; 466cdf0e10cSrcweir SdrHitKind eHit = pSdrView->PickAnything(rLPt, aVEvt); 467cdf0e10cSrcweir 468cdf0e10cSrcweir if (eHit == SDRHIT_URLFIELD && bExecHyperlinks) 469cdf0e10cSrcweir { 470cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT; 471cdf0e10cSrcweir bPrefSdrPointer = sal_True; 472cdf0e10cSrcweir } 473cdf0e10cSrcweir else 474cdf0e10cSrcweir { 475cdf0e10cSrcweir // if we're over a selected object, we show an 476cdf0e10cSrcweir // ARROW by default. We only show a MOVE if 1) the 477cdf0e10cSrcweir // object is selected, and 2) it may be moved 478cdf0e10cSrcweir // (i.e., position is not protected). 479cdf0e10cSrcweir bool bMovable = 480cdf0e10cSrcweir (!bNotInSelObj) && 481cdf0e10cSrcweir (rSh.IsObjSelected() || rSh.IsFrmSelected()) && 482cdf0e10cSrcweir (!rSh.IsSelObjProtected(FLYPROTECT_POS)); 483cdf0e10cSrcweir 484cdf0e10cSrcweir eStyle = bMovable ? POINTER_MOVE : POINTER_ARROW; 485cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT; 486cdf0e10cSrcweir } 487cdf0e10cSrcweir } 488cdf0e10cSrcweir } 489cdf0e10cSrcweir else 490cdf0e10cSrcweir { 491cdf0e10cSrcweir if ( rSh.IsFrmSelected() && !bNotInSelObj ) 492cdf0e10cSrcweir { 493cdf0e10cSrcweir // dvo: this branch appears to be dead and should be 494cdf0e10cSrcweir // removed in a future version. Reason: The condition 495cdf0e10cSrcweir // !bNotInSelObj means that this branch will only be 496cdf0e10cSrcweir // executed in the cursor points inside a selected 497cdf0e10cSrcweir // object. However, if this is the case, the previous 498cdf0e10cSrcweir // if( rSh.IsObjSelectable(rLPt) ) must always be true: 499cdf0e10cSrcweir // rLPt is inside a selected object, then obviously 500cdf0e10cSrcweir // rLPt is over a selectable object. 501cdf0e10cSrcweir if (rSh.IsSelObjProtected(FLYPROTECT_SIZE)) 502cdf0e10cSrcweir eStyle = POINTER_NOTALLOWED; 503cdf0e10cSrcweir else 504cdf0e10cSrcweir eStyle = POINTER_MOVE; 505cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT; 506cdf0e10cSrcweir } 507cdf0e10cSrcweir else 508cdf0e10cSrcweir { 509cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() ) 510cdf0e10cSrcweir bPrefSdrPointer = sal_True; 511cdf0e10cSrcweir else 512cdf0e10cSrcweir bCntAtPos = sal_True; 513cdf0e10cSrcweir } 514cdf0e10cSrcweir } 515cdf0e10cSrcweir } 516cdf0e10cSrcweir } 517cdf0e10cSrcweir } 518cdf0e10cSrcweir if ( bPrefSdrPointer ) 519cdf0e10cSrcweir { 520cdf0e10cSrcweir if (bIsDocReadOnly || (rSh.IsObjSelected() && rSh.IsSelObjProtected(FLYPROTECT_CONTENT))) 521cdf0e10cSrcweir SetPointer( POINTER_NOTALLOWED ); 522cdf0e10cSrcweir else 523cdf0e10cSrcweir { 524cdf0e10cSrcweir if (rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->IsInsertForm() && !bHitHandle) 525cdf0e10cSrcweir SetPointer( POINTER_DRAW_RECT ); 526cdf0e10cSrcweir else 527cdf0e10cSrcweir SetPointer( pSdrView->GetPreferedPointer( rLPt, rSh.GetOut() ) ); 528cdf0e10cSrcweir } 529cdf0e10cSrcweir } 530cdf0e10cSrcweir else 531cdf0e10cSrcweir { 532cdf0e10cSrcweir if( !rSh.IsPageAtPos( rLPt ) || pAnchorMarker ) 533cdf0e10cSrcweir eStyle = POINTER_ARROW; 534cdf0e10cSrcweir else 535cdf0e10cSrcweir { 536cdf0e10cSrcweir if( bCntAtPos ) 537cdf0e10cSrcweir { 538cdf0e10cSrcweir SwContentAtPos aSwContentAtPos( 539cdf0e10cSrcweir SwContentAtPos::SW_CLICKFIELD| 540cdf0e10cSrcweir SwContentAtPos::SW_INETATTR| 541cdf0e10cSrcweir SwContentAtPos::SW_FTN | 542cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG ); 543cdf0e10cSrcweir if( rSh.GetContentAtPos( rLPt, aSwContentAtPos) ) 544cdf0e10cSrcweir { 545cdf0e10cSrcweir const bool bClickToFollow = SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos || 546cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos; 547cdf0e10cSrcweir 548cdf0e10cSrcweir if( !bClickToFollow || 549cdf0e10cSrcweir (SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos && bExecHyperlinks) || 550cdf0e10cSrcweir (SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos && bExecSmarttags) ) 551cdf0e10cSrcweir eStyle = POINTER_REFHAND; 552cdf0e10cSrcweir } 553cdf0e10cSrcweir } 554cdf0e10cSrcweir } 555cdf0e10cSrcweir 556cdf0e10cSrcweir // which kind of text pointer have we to show - horz / vert - ? 557cdf0e10cSrcweir if( POINTER_TEXT == eStyle && rSh.IsInVerticalText( &rLPt )) 558cdf0e10cSrcweir eStyle = POINTER_TEXT_VERTICAL; 559cdf0e10cSrcweir 560cdf0e10cSrcweir SetPointer( eStyle ); 561cdf0e10cSrcweir } 562cdf0e10cSrcweir } 563cdf0e10cSrcweir 564cdf0e10cSrcweir /*-------------------------------------------------------------------- 565cdf0e10cSrcweir Beschreibung: Timer fuer Selektion vergroessern 566cdf0e10cSrcweir --------------------------------------------------------------------*/ 567cdf0e10cSrcweir 568cdf0e10cSrcweir 569cdf0e10cSrcweir IMPL_LINK( SwEditWin, TimerHandler, Timer *, EMPTYARG ) 570cdf0e10cSrcweir { 571cdf0e10cSrcweir DBG_PROFSTART(edithdl); 572cdf0e10cSrcweir 573cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 574cdf0e10cSrcweir Point aModPt( aMovePos ); 575cdf0e10cSrcweir const SwRect aOldVis( rSh.VisArea() ); 576cdf0e10cSrcweir sal_Bool bDone = sal_False; 577cdf0e10cSrcweir 578cdf0e10cSrcweir if ( !rSh.VisArea().IsInside( aModPt ) ) 579cdf0e10cSrcweir { 580cdf0e10cSrcweir if ( bInsDraw ) 581cdf0e10cSrcweir { 582cdf0e10cSrcweir const int nMaxScroll = 40; 583cdf0e10cSrcweir rView.Scroll( Rectangle(aModPt,Size(1,1)), nMaxScroll, nMaxScroll); 584cdf0e10cSrcweir bDone = sal_True; 585cdf0e10cSrcweir } 586cdf0e10cSrcweir else if ( bFrmDrag ) 587cdf0e10cSrcweir { 588cdf0e10cSrcweir (rSh.*rSh.fnDrag)(&aModPt,sal_False); 589cdf0e10cSrcweir bDone = sal_True; 590cdf0e10cSrcweir } 591cdf0e10cSrcweir if ( !bDone ) 592cdf0e10cSrcweir aModPt = rSh.GetCntntPos( aModPt,aModPt.Y() > rSh.VisArea().Bottom() ); 593cdf0e10cSrcweir } 594cdf0e10cSrcweir if ( !bDone && !(bFrmDrag || bInsDraw) ) 595cdf0e10cSrcweir { 596cdf0e10cSrcweir if ( pRowColumnSelectionStart ) 597cdf0e10cSrcweir { 598cdf0e10cSrcweir Point aPos( aModPt ); 599cdf0e10cSrcweir rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag ); 600cdf0e10cSrcweir } 601cdf0e10cSrcweir else 602cdf0e10cSrcweir (rSh.*rSh.fnSetCrsr)( &aModPt, sal_False ); 603cdf0e10cSrcweir 604cdf0e10cSrcweir //fix(24138): Es kann sein, dass der "Sprung" ueber eine Tabelle so 605cdf0e10cSrcweir //nicht geschafft wird. Deshalb wir hier eben per Up/Down ueber die 606cdf0e10cSrcweir //Tabelle gesprungen. 607cdf0e10cSrcweir const SwRect& rVisArea = rSh.VisArea(); 608cdf0e10cSrcweir if( aOldVis == rVisArea && !rSh.IsStartOfDoc() && !rSh.IsEndOfDoc() ) 609cdf0e10cSrcweir { 610cdf0e10cSrcweir //JP 11.10.2001 Bug 72294 - take the center point of VisArea to 611cdf0e10cSrcweir // decide in which direction the user want. 612cdf0e10cSrcweir if( aModPt.Y() < ( rVisArea.Top() + rVisArea.Height() / 2 ) ) 613cdf0e10cSrcweir rSh.Up( sal_True, 1 ); 614cdf0e10cSrcweir else 615cdf0e10cSrcweir rSh.Down( sal_True, 1 ); 616cdf0e10cSrcweir } 617cdf0e10cSrcweir } 618cdf0e10cSrcweir 619cdf0e10cSrcweir aMovePos += rSh.VisArea().Pos() - aOldVis.Pos(); 620cdf0e10cSrcweir JustifyAreaTimer(); 621cdf0e10cSrcweir DBG_PROFSTOP(edithdl); 622cdf0e10cSrcweir return 0; 623cdf0e10cSrcweir } 624cdf0e10cSrcweir 625cdf0e10cSrcweir /*-------------------------------------------------------------------- 626cdf0e10cSrcweir Beschreibung: 627cdf0e10cSrcweir --------------------------------------------------------------------*/ 628cdf0e10cSrcweir 629cdf0e10cSrcweir 630cdf0e10cSrcweir void SwEditWin::JustifyAreaTimer() 631cdf0e10cSrcweir { 632cdf0e10cSrcweir const Rectangle &rVisArea = GetView().GetVisArea(); 633cdf0e10cSrcweir #ifdef UNX 634cdf0e10cSrcweir const long coMinLen = 100; 635cdf0e10cSrcweir #else 636cdf0e10cSrcweir const long coMinLen = 50; 637cdf0e10cSrcweir #endif 638cdf0e10cSrcweir long nTimeout = 800, 639cdf0e10cSrcweir nDiff = Max( 640cdf0e10cSrcweir Max( aMovePos.Y() - rVisArea.Bottom(), rVisArea.Top() - aMovePos.Y() ), 641cdf0e10cSrcweir Max( aMovePos.X() - rVisArea.Right(), rVisArea.Left() - aMovePos.X())); 642cdf0e10cSrcweir #ifdef TEST_FOR_BUG91313 643cdf0e10cSrcweir aTimer.SetTimeout( Max( coMinLen, nTimeout - nDiff) ); 644cdf0e10cSrcweir #else 645cdf0e10cSrcweir aTimer.SetTimeout( Max( coMinLen, nTimeout - nDiff*2L) ); 646cdf0e10cSrcweir #endif 647cdf0e10cSrcweir } 648cdf0e10cSrcweir 649cdf0e10cSrcweir void SwEditWin::LeaveArea(const Point &rPos) 650cdf0e10cSrcweir { 651cdf0e10cSrcweir aMovePos = rPos; 652cdf0e10cSrcweir JustifyAreaTimer(); 653cdf0e10cSrcweir if( !aTimer.IsActive() ) 654cdf0e10cSrcweir aTimer.Start(); 655cdf0e10cSrcweir if( pShadCrsr ) 656cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 657cdf0e10cSrcweir } 658cdf0e10cSrcweir 659cdf0e10cSrcweir inline void SwEditWin::EnterArea() 660cdf0e10cSrcweir { 661cdf0e10cSrcweir aTimer.Stop(); 662cdf0e10cSrcweir } 663cdf0e10cSrcweir 664cdf0e10cSrcweir /*------------------------------------------------------------------------ 665cdf0e10cSrcweir Beschreibung: Modus fuer Rahmen einfuegen 666cdf0e10cSrcweir ------------------------------------------------------------------------*/ 667cdf0e10cSrcweir 668cdf0e10cSrcweir 669cdf0e10cSrcweir void SwEditWin::InsFrm(sal_uInt16 nCols) 670cdf0e10cSrcweir { 671cdf0e10cSrcweir StdDrawMode( OBJ_NONE, sal_False ); 672cdf0e10cSrcweir bInsFrm = sal_True; 673cdf0e10cSrcweir nInsFrmColCount = nCols; 674cdf0e10cSrcweir } 675cdf0e10cSrcweir 676cdf0e10cSrcweir 677cdf0e10cSrcweir 678cdf0e10cSrcweir void SwEditWin::StdDrawMode( SdrObjKind eSdrObjectKind, sal_Bool bObjSelect ) 679cdf0e10cSrcweir { 680cdf0e10cSrcweir SetSdrDrawMode( eSdrObjectKind ); 681cdf0e10cSrcweir 682cdf0e10cSrcweir /* if (GetDrawFuncPtr()) 683cdf0e10cSrcweir GetDrawFuncPtr()->Deactivate();*/ 684cdf0e10cSrcweir 685cdf0e10cSrcweir if (bObjSelect) 686cdf0e10cSrcweir rView.SetDrawFuncPtr(new DrawSelection( &rView.GetWrtShell(), this, &rView )); 687cdf0e10cSrcweir else 688cdf0e10cSrcweir rView.SetDrawFuncPtr(new SwDrawBase( &rView.GetWrtShell(), this, &rView )); 689cdf0e10cSrcweir 690cdf0e10cSrcweir rView.SetSelDrawSlot(); 691cdf0e10cSrcweir SetSdrDrawMode( eSdrObjectKind ); 692cdf0e10cSrcweir if (bObjSelect) 693cdf0e10cSrcweir rView.GetDrawFuncPtr()->Activate( SID_OBJECT_SELECT ); 694cdf0e10cSrcweir else 695cdf0e10cSrcweir 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... 696cdf0e10cSrcweir bInsFrm = sal_False; 697cdf0e10cSrcweir nInsFrmColCount = 1; 698cdf0e10cSrcweir } 699cdf0e10cSrcweir 700cdf0e10cSrcweir 701cdf0e10cSrcweir 702cdf0e10cSrcweir void SwEditWin::StopInsFrm() 703cdf0e10cSrcweir { 704cdf0e10cSrcweir if (rView.GetDrawFuncPtr()) 705cdf0e10cSrcweir { 706cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 707cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 708cdf0e10cSrcweir } 709cdf0e10cSrcweir rView.LeaveDrawCreate(); // Konstruktionsmode verlassen 710cdf0e10cSrcweir bInsFrm = sal_False; 711cdf0e10cSrcweir nInsFrmColCount = 1; 712cdf0e10cSrcweir } 713cdf0e10cSrcweir 714cdf0e10cSrcweir /*-------------------------------------------------------------------- 715cdf0e10cSrcweir --------------------------------------------------------------------*/ 716cdf0e10cSrcweir 717cdf0e10cSrcweir 718cdf0e10cSrcweir sal_Bool SwEditWin::IsInputSequenceCheckingRequired( const String &rText, const SwPaM& rCrsr ) const 719cdf0e10cSrcweir { 720cdf0e10cSrcweir const SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions(); 721cdf0e10cSrcweir if ( !rCTLOptions.IsCTLFontEnabled() || 722cdf0e10cSrcweir !rCTLOptions.IsCTLSequenceChecking() ) 723cdf0e10cSrcweir return sal_False; 724cdf0e10cSrcweir 725cdf0e10cSrcweir const xub_StrLen nFirstPos = rCrsr.Start()->nContent.GetIndex(); 726cdf0e10cSrcweir if ( 0 == nFirstPos ) /* first char needs not to be checked */ 727cdf0e10cSrcweir return sal_False; 728cdf0e10cSrcweir 729cdf0e10cSrcweir SwBreakIt *pBreakIter = SwBreakIt::Get(); 730cdf0e10cSrcweir uno::Reference < i18n::XBreakIterator > xBI = pBreakIter->GetBreakIter(); 731cdf0e10cSrcweir long nCTLScriptPos = -1; 732cdf0e10cSrcweir 733cdf0e10cSrcweir if (xBI.is()) 734cdf0e10cSrcweir { 735cdf0e10cSrcweir if (xBI->getScriptType( rText, 0 ) == i18n::ScriptType::COMPLEX) 736cdf0e10cSrcweir nCTLScriptPos = 0; 737cdf0e10cSrcweir else 738cdf0e10cSrcweir nCTLScriptPos = xBI->nextScript( rText, 0, i18n::ScriptType::COMPLEX ); 739cdf0e10cSrcweir } 740cdf0e10cSrcweir 741cdf0e10cSrcweir return (0 <= nCTLScriptPos && nCTLScriptPos <= rText.Len()); 742cdf0e10cSrcweir } 743cdf0e10cSrcweir 744cdf0e10cSrcweir 745cdf0e10cSrcweir /*-------------------------------------------------------------------- 746cdf0e10cSrcweir Beschreibung: Der Character Buffer wird in das Dokument eingefuegt 747cdf0e10cSrcweir --------------------------------------------------------------------*/ 748cdf0e10cSrcweir 749cdf0e10cSrcweir 750cdf0e10cSrcweir void SwEditWin::FlushInBuffer() 751cdf0e10cSrcweir { 752cdf0e10cSrcweir if ( aInBuffer.Len() ) 753cdf0e10cSrcweir { 754cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell(); 755cdf0e10cSrcweir 756cdf0e10cSrcweir // generate new sequence input checker if not already done 757cdf0e10cSrcweir if ( !pCheckIt ) 758cdf0e10cSrcweir pCheckIt = new SwCheckIt; 759cdf0e10cSrcweir 760cdf0e10cSrcweir uno::Reference < i18n::XExtendedInputSequenceChecker > xISC = pCheckIt->xCheck; 761cdf0e10cSrcweir if ( xISC.is() && IsInputSequenceCheckingRequired( aInBuffer, *rSh.GetCrsr() ) ) 762cdf0e10cSrcweir { 763cdf0e10cSrcweir // 764cdf0e10cSrcweir // apply (Thai) input sequence checking/correction 765cdf0e10cSrcweir // 766cdf0e10cSrcweir 767cdf0e10cSrcweir rSh.Push(); // push current cursor to stack 768cdf0e10cSrcweir 769cdf0e10cSrcweir // get text from the beginning (i.e left side) of current selection 770cdf0e10cSrcweir // to the start of the paragraph 771cdf0e10cSrcweir rSh.NormalizePam(); // make point be the first (left) one 772cdf0e10cSrcweir if (!rSh.GetCrsr()->HasMark()) 773cdf0e10cSrcweir rSh.GetCrsr()->SetMark(); 774cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = 0; 775cdf0e10cSrcweir String aLeftText( rSh.GetCrsr()->GetTxt() ); 776cdf0e10cSrcweir 777cdf0e10cSrcweir SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions(); 778cdf0e10cSrcweir 779cdf0e10cSrcweir xub_StrLen nExpandSelection = 0; 780cdf0e10cSrcweir if (aLeftText.Len() > 0) 781cdf0e10cSrcweir { 782cdf0e10cSrcweir sal_Unicode cChar = '\0'; 783cdf0e10cSrcweir 784cdf0e10cSrcweir xub_StrLen nTmpPos = aLeftText.Len(); 785cdf0e10cSrcweir sal_Int16 nCheckMode = rCTLOptions.IsCTLSequenceCheckingRestricted() ? 786cdf0e10cSrcweir i18n::InputSequenceCheckMode::STRICT : i18n::InputSequenceCheckMode::BASIC; 787cdf0e10cSrcweir 788cdf0e10cSrcweir rtl::OUString aOldText( aLeftText ); 789cdf0e10cSrcweir rtl::OUString aNewText( aOldText ); 790cdf0e10cSrcweir if (rCTLOptions.IsCTLSequenceCheckingTypeAndReplace()) 791cdf0e10cSrcweir { 792cdf0e10cSrcweir for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k) 793cdf0e10cSrcweir { 794cdf0e10cSrcweir cChar = aInBuffer.GetChar(k); 795cdf0e10cSrcweir const xub_StrLen nPrevPos = static_cast<xub_StrLen>(xISC->correctInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode )); 796cdf0e10cSrcweir 797cdf0e10cSrcweir // valid sequence or sequence could be corrected: 798cdf0e10cSrcweir if (nPrevPos != aNewText.getLength()) 799cdf0e10cSrcweir nTmpPos = nPrevPos + 1; 800cdf0e10cSrcweir } 801cdf0e10cSrcweir 802cdf0e10cSrcweir // find position of first character that has changed 803cdf0e10cSrcweir sal_Int32 nOldLen = aOldText.getLength(); 804cdf0e10cSrcweir sal_Int32 nNewLen = aNewText.getLength(); 805cdf0e10cSrcweir const sal_Unicode *pOldTxt = aOldText.getStr(); 806cdf0e10cSrcweir const sal_Unicode *pNewTxt = aNewText.getStr(); 807cdf0e10cSrcweir sal_Int32 nChgPos = 0; 808cdf0e10cSrcweir while ( nChgPos < nOldLen && nChgPos < nNewLen && 809cdf0e10cSrcweir pOldTxt[nChgPos] == pNewTxt[nChgPos] ) 810cdf0e10cSrcweir ++nChgPos; 811cdf0e10cSrcweir 812cdf0e10cSrcweir xub_StrLen nChgLen = static_cast< xub_StrLen >(nNewLen - nChgPos); 813cdf0e10cSrcweir String aChgText( aNewText.copy( static_cast< xub_StrLen >(nChgPos), nChgLen ) ); 814cdf0e10cSrcweir 815cdf0e10cSrcweir if (aChgText.Len()) 816cdf0e10cSrcweir { 817cdf0e10cSrcweir aInBuffer = aChgText; 818cdf0e10cSrcweir nExpandSelection = aLeftText.Len() - static_cast< xub_StrLen >(nChgPos); 819cdf0e10cSrcweir } 820cdf0e10cSrcweir else 821cdf0e10cSrcweir aInBuffer.Erase(); 822cdf0e10cSrcweir } 823cdf0e10cSrcweir else 824cdf0e10cSrcweir { 825cdf0e10cSrcweir for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k) 826cdf0e10cSrcweir { 827cdf0e10cSrcweir cChar = aInBuffer.GetChar(k); 828cdf0e10cSrcweir if (xISC->checkInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode )) 829cdf0e10cSrcweir { 830cdf0e10cSrcweir // character can be inserted: 831cdf0e10cSrcweir aNewText += rtl::OUString( (sal_Unicode) cChar ); 832cdf0e10cSrcweir ++nTmpPos; 833cdf0e10cSrcweir } 834cdf0e10cSrcweir } 835cdf0e10cSrcweir aInBuffer = aNewText.copy( aOldText.getLength() ); // copy new text to be inserted to buffer 836cdf0e10cSrcweir } 837cdf0e10cSrcweir } 838cdf0e10cSrcweir 839cdf0e10cSrcweir // at this point now we will insert the buffer text 'normally' some lines below... 840cdf0e10cSrcweir 841cdf0e10cSrcweir rSh.Pop( sal_False ); // pop old cursor from stack 842cdf0e10cSrcweir 843cdf0e10cSrcweir if (!aInBuffer.Len()) 844cdf0e10cSrcweir return; 845cdf0e10cSrcweir 846cdf0e10cSrcweir // if text prior to the original selection needs to be changed 847cdf0e10cSrcweir // as well, we now expand the selection accordingly. 848cdf0e10cSrcweir SwPaM &rCrsr = *rSh.GetCrsr(); 849cdf0e10cSrcweir xub_StrLen nCrsrStartPos = rCrsr.Start()->nContent.GetIndex(); 850cdf0e10cSrcweir DBG_ASSERT( nCrsrStartPos >= nExpandSelection, "cannot expand selection as specified!!" ); 851cdf0e10cSrcweir if (nExpandSelection && nCrsrStartPos >= nExpandSelection) 852cdf0e10cSrcweir { 853cdf0e10cSrcweir if (!rCrsr.HasMark()) 854cdf0e10cSrcweir rCrsr.SetMark(); 855cdf0e10cSrcweir rCrsr.Start()->nContent -= nExpandSelection; 856cdf0e10cSrcweir } 857cdf0e10cSrcweir } 858cdf0e10cSrcweir 859cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder = 860cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder(); 861cdf0e10cSrcweir if ( xRecorder.is() ) 862cdf0e10cSrcweir { 863cdf0e10cSrcweir //Shell ermitteln 864cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) ); 865cdf0e10cSrcweir // Request generieren und recorden 866cdf0e10cSrcweir if (pSfxShell) 867cdf0e10cSrcweir { 868cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING ); 869cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, aInBuffer ) ); 870cdf0e10cSrcweir aReq.Done(); 871cdf0e10cSrcweir } 872cdf0e10cSrcweir } 873cdf0e10cSrcweir //#21019# apply CTL and CJK language to the text input 874cdf0e10cSrcweir sal_Bool bLang = true; 875cdf0e10cSrcweir if(eBufferLanguage != LANGUAGE_DONTKNOW) 876cdf0e10cSrcweir { 877cdf0e10cSrcweir sal_uInt16 nWhich = 0; 878cdf0e10cSrcweir switch( GetI18NScriptTypeOfLanguage( eBufferLanguage )) 879cdf0e10cSrcweir { 880cdf0e10cSrcweir case i18n::ScriptType::ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break; 881cdf0e10cSrcweir case i18n::ScriptType::COMPLEX: nWhich = RES_CHRATR_CTL_LANGUAGE; break; 882cdf0e10cSrcweir case i18n::ScriptType::LATIN: nWhich = RES_CHRATR_LANGUAGE; break; 883cdf0e10cSrcweir default: bLang = sal_False; 884cdf0e10cSrcweir } 885cdf0e10cSrcweir if(bLang) 886cdf0e10cSrcweir { 887cdf0e10cSrcweir SfxItemSet aLangSet(rView.GetPool(), nWhich, nWhich); 888cdf0e10cSrcweir rSh.GetCurAttr(aLangSet); 889cdf0e10cSrcweir if(SFX_ITEM_DEFAULT <= aLangSet.GetItemState(nWhich, sal_True)) 890cdf0e10cSrcweir { 891cdf0e10cSrcweir LanguageType eLang = static_cast<const SvxLanguageItem&>(aLangSet.Get(nWhich)).GetLanguage(); 892cdf0e10cSrcweir if ( eLang == eBufferLanguage ) 893cdf0e10cSrcweir // current language attribute equal to language reported from system 894cdf0e10cSrcweir bLang = sal_False; 895cdf0e10cSrcweir else if ( !bInputLanguageSwitched && RES_CHRATR_LANGUAGE == nWhich /* && (eLang&LANGUAGE_MASK_PRIMARY) == LANGUAGE_ENGLISH */ ) 896cdf0e10cSrcweir { 897cdf0e10cSrcweir // special case: switching between two "LATIN" languages 898cdf0e10cSrcweir // In case the current keyboard setting might be suitable for both languages we can't safely assume that the user 899cdf0e10cSrcweir // wants to use the language reported from the system, except if we knew that it was explicitly switched (thus the check for "bInputLangeSwitched"). 900cdf0e10cSrcweir // The language reported by the system could be just the system default language that the user is not even aware of, 901cdf0e10cSrcweir // because no language selection tool is installed at all. In this case the OOo language should get preference as 902cdf0e10cSrcweir // it might have been selected by the user explicitly. 903cdf0e10cSrcweir // Usually this case happens if the OOo language is different to the system language but the system keyboard is still suitable 904cdf0e10cSrcweir // for the OOo language (e.g. writing English texts with a German keyboard). 905cdf0e10cSrcweir // For non-latin keyboards overwriting the attribute is still valid. We do this for kyrillic and greek ATM. 906cdf0e10cSrcweir // In future versions of OOo this should be replaced by a configuration switch that allows to give the preference to 907cdf0e10cSrcweir // the OOo setting or the system setting explicitly and/or a better handling of the script type. 908cdf0e10cSrcweir sal_Int16 nScript = GetAppCharClass().getScript( aInBuffer, 0 ); 909cdf0e10cSrcweir i18n::UnicodeScript eType = (i18n::UnicodeScript) nScript; 910cdf0e10cSrcweir 911cdf0e10cSrcweir bool bSystemIsNonLatin = false, bOOoLangIsNonLatin = false; 912cdf0e10cSrcweir switch ( eType ) 913cdf0e10cSrcweir { 914cdf0e10cSrcweir case i18n::UnicodeScript_kGreek: 915cdf0e10cSrcweir case i18n::UnicodeScript_kCyrillic: 916cdf0e10cSrcweir // in case other UnicodeScripts require special keyboards they can be added here 917cdf0e10cSrcweir bSystemIsNonLatin = true; 918cdf0e10cSrcweir break; 919cdf0e10cSrcweir default: 920cdf0e10cSrcweir break; 921cdf0e10cSrcweir } 922cdf0e10cSrcweir 923cdf0e10cSrcweir switch ( eLang ) 924cdf0e10cSrcweir { 925cdf0e10cSrcweir case LANGUAGE_AZERI_CYRILLIC: 926cdf0e10cSrcweir case LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA: 927cdf0e10cSrcweir case LANGUAGE_BULGARIAN: 928cdf0e10cSrcweir case LANGUAGE_GREEK: 929cdf0e10cSrcweir case LANGUAGE_RUSSIAN: 930cdf0e10cSrcweir case LANGUAGE_RUSSIAN_MOLDOVA: 931cdf0e10cSrcweir case LANGUAGE_SERBIAN_CYRILLIC: 932cdf0e10cSrcweir case LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA: 933cdf0e10cSrcweir case LANGUAGE_UZBEK_CYRILLIC: 934cdf0e10cSrcweir case LANGUAGE_UKRAINIAN: 935cdf0e10cSrcweir case LANGUAGE_BELARUSIAN: 936cdf0e10cSrcweir bOOoLangIsNonLatin = true; 937cdf0e10cSrcweir break; 938cdf0e10cSrcweir default: 939cdf0e10cSrcweir break; 940cdf0e10cSrcweir } 941cdf0e10cSrcweir 942cdf0e10cSrcweir bLang = (bSystemIsNonLatin != bOOoLangIsNonLatin); 943cdf0e10cSrcweir } 944cdf0e10cSrcweir } 945cdf0e10cSrcweir if(bLang) 946cdf0e10cSrcweir { 947cdf0e10cSrcweir SvxLanguageItem aLangItem( eBufferLanguage, nWhich ); 948cdf0e10cSrcweir rSh.SetAttr( aLangItem ); 949cdf0e10cSrcweir } 950cdf0e10cSrcweir } 951cdf0e10cSrcweir } 952cdf0e10cSrcweir 953cdf0e10cSrcweir rSh.Insert( aInBuffer ); 954cdf0e10cSrcweir eBufferLanguage = LANGUAGE_DONTKNOW; 955cdf0e10cSrcweir aInBuffer.Erase(); 956cdf0e10cSrcweir bFlushCharBuffer = sal_False; 957cdf0e10cSrcweir } 958cdf0e10cSrcweir } 959cdf0e10cSrcweir 960cdf0e10cSrcweir #define MOVE_LEFT_SMALL 0 961cdf0e10cSrcweir #define MOVE_UP_SMALL 1 962cdf0e10cSrcweir #define MOVE_RIGHT_BIG 2 963cdf0e10cSrcweir #define MOVE_DOWN_BIG 3 964cdf0e10cSrcweir #define MOVE_LEFT_BIG 4 965cdf0e10cSrcweir #define MOVE_UP_BIG 5 966cdf0e10cSrcweir #define MOVE_RIGHT_SMALL 6 967cdf0e10cSrcweir #define MOVE_DOWN_SMALL 7 968cdf0e10cSrcweir 96993641701SArmin Le Grand // #121236# Support for shift key in writer 97093641701SArmin Le Grand #define MOVE_LEFT_HUGE 8 97193641701SArmin Le Grand #define MOVE_UP_HUGE 9 97293641701SArmin Le Grand #define MOVE_RIGHT_HUGE 10 97393641701SArmin Le Grand #define MOVE_DOWN_HUGE 11 97493641701SArmin Le Grand 975cdf0e10cSrcweir void SwEditWin::ChangeFly( sal_uInt8 nDir, sal_Bool bWeb ) 976cdf0e10cSrcweir { 977cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 978cdf0e10cSrcweir SwRect aTmp = rSh.GetFlyRect(); 979cdf0e10cSrcweir if( aTmp.HasArea() && 980*aa2af2f2SOliver-Rainer Wittmann !rSh.IsSelObjProtected( FLYPROTECT_POS ) ) 981cdf0e10cSrcweir { 982cdf0e10cSrcweir SfxItemSet aSet(rSh.GetAttrPool(), 983cdf0e10cSrcweir RES_FRM_SIZE, RES_FRM_SIZE, 984cdf0e10cSrcweir RES_VERT_ORIENT, RES_ANCHOR, 985cdf0e10cSrcweir RES_COL, RES_COL, 986cdf0e10cSrcweir RES_PROTECT, RES_PROTECT, 987cdf0e10cSrcweir RES_FOLLOW_TEXT_FLOW, RES_FOLLOW_TEXT_FLOW, 0); 988cdf0e10cSrcweir rSh.GetFlyFrmAttr( aSet ); 989cdf0e10cSrcweir RndStdIds eAnchorId = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId(); 990cdf0e10cSrcweir Size aSnap; 99193641701SArmin Le Grand bool bHuge(MOVE_LEFT_HUGE == nDir || 99293641701SArmin Le Grand MOVE_UP_HUGE == nDir || 99393641701SArmin Le Grand MOVE_RIGHT_HUGE == nDir || 99493641701SArmin Le Grand MOVE_DOWN_HUGE == nDir); 99593641701SArmin Le Grand 996cdf0e10cSrcweir if(MOVE_LEFT_SMALL == nDir || 997cdf0e10cSrcweir MOVE_UP_SMALL == nDir || 998cdf0e10cSrcweir MOVE_RIGHT_SMALL == nDir || 999cdf0e10cSrcweir MOVE_DOWN_SMALL == nDir ) 100093641701SArmin Le Grand { 1001cdf0e10cSrcweir aSnap = PixelToLogic(Size(1,1)); 100293641701SArmin Le Grand } 1003cdf0e10cSrcweir else 1004cdf0e10cSrcweir { 1005cdf0e10cSrcweir aSnap = rSh.GetViewOptions()->GetSnapSize(); 1006cdf0e10cSrcweir short nDiv = rSh.GetViewOptions()->GetDivisionX(); 1007cdf0e10cSrcweir if ( nDiv > 0 ) 1008cdf0e10cSrcweir aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv ); 1009cdf0e10cSrcweir nDiv = rSh.GetViewOptions()->GetDivisionY(); 1010cdf0e10cSrcweir if ( nDiv > 0 ) 1011cdf0e10cSrcweir aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv ); 1012cdf0e10cSrcweir } 1013cdf0e10cSrcweir 101493641701SArmin Le Grand if(bHuge) 101593641701SArmin Le Grand { 101693641701SArmin Le Grand // #121236# 567twips == 1cm, but just take three times the normal snap 101793641701SArmin Le Grand aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3); 101893641701SArmin Le Grand } 101993641701SArmin Le Grand 1020cdf0e10cSrcweir SwRect aBoundRect; 1021cdf0e10cSrcweir Point aRefPoint; 1022cdf0e10cSrcweir // OD 18.09.2003 #i18732# - adjustment for allowing vertical position 1023cdf0e10cSrcweir // aligned to page for fly frame anchored to paragraph or to character. 1024cdf0e10cSrcweir { 1025cdf0e10cSrcweir SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) ); 1026cdf0e10cSrcweir const bool bFollowTextFlow = 1027cdf0e10cSrcweir static_cast<const SwFmtFollowTextFlow&>(aSet.Get(RES_FOLLOW_TEXT_FLOW)).GetValue(); 1028cdf0e10cSrcweir // OD 12.11.2003 #i22341# - additional provide content position 1029cdf0e10cSrcweir const SwPosition* pToCharCntntPos = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetCntntAnchor(); 1030cdf0e10cSrcweir rSh.CalcBoundRect( aBoundRect, eAnchorId, 1031cdf0e10cSrcweir text::RelOrientation::FRAME, aVert.GetRelationOrient(), 1032cdf0e10cSrcweir pToCharCntntPos, bFollowTextFlow, 1033cdf0e10cSrcweir false, &aRefPoint ); 1034cdf0e10cSrcweir } 1035cdf0e10cSrcweir long nLeft = Min( aTmp.Left() - aBoundRect.Left(), aSnap.Width() ); 1036cdf0e10cSrcweir long nRight = Min( aBoundRect.Right() - aTmp.Right(), aSnap.Width() ); 1037cdf0e10cSrcweir long nUp = Min( aTmp.Top() - aBoundRect.Top(), aSnap.Height() ); 1038cdf0e10cSrcweir long nDown = Min( aBoundRect.Bottom() - aTmp.Bottom(), aSnap.Height() ); 1039cdf0e10cSrcweir 1040cdf0e10cSrcweir switch ( nDir ) 1041cdf0e10cSrcweir { 1042cdf0e10cSrcweir case MOVE_LEFT_BIG: 104393641701SArmin Le Grand case MOVE_LEFT_HUGE: 104493641701SArmin Le Grand case MOVE_LEFT_SMALL: aTmp.Left( aTmp.Left() - nLeft ); 104593641701SArmin Le Grand break; 104693641701SArmin Le Grand 1047cdf0e10cSrcweir case MOVE_UP_BIG: 104893641701SArmin Le Grand case MOVE_UP_HUGE: 104993641701SArmin Le Grand case MOVE_UP_SMALL: aTmp.Top( aTmp.Top() - nUp ); 105093641701SArmin Le Grand break; 105193641701SArmin Le Grand 105293641701SArmin Le Grand case MOVE_RIGHT_SMALL: 105393641701SArmin Le Grand if( aTmp.Width() < aSnap.Width() + MINFLY ) 105493641701SArmin Le Grand break; 105593641701SArmin Le Grand nRight = aSnap.Width(); // kein break 105693641701SArmin Le Grand case MOVE_RIGHT_HUGE: 105793641701SArmin Le Grand case MOVE_RIGHT_BIG: aTmp.Left( aTmp.Left() + nRight ); 105893641701SArmin Le Grand break; 105993641701SArmin Le Grand 106093641701SArmin Le Grand case MOVE_DOWN_SMALL: 106193641701SArmin Le Grand if( aTmp.Height() < aSnap.Height() + MINFLY ) 106293641701SArmin Le Grand break; 106393641701SArmin Le Grand nDown = aSnap.Height(); // kein break 106493641701SArmin Le Grand case MOVE_DOWN_HUGE: 106593641701SArmin Le Grand case MOVE_DOWN_BIG: aTmp.Top( aTmp.Top() + nDown ); 106693641701SArmin Le Grand break; 106793641701SArmin Le Grand 1068cdf0e10cSrcweir default: ASSERT( sal_True, "ChangeFly: Unknown direction." ); 1069cdf0e10cSrcweir } 1070cdf0e10cSrcweir sal_Bool bSet = sal_False; 1071cdf0e10cSrcweir if ((FLY_AS_CHAR == eAnchorId) && ( nDir % 2 )) 1072cdf0e10cSrcweir { 1073cdf0e10cSrcweir long aDiff = aTmp.Top() - aRefPoint.Y(); 1074cdf0e10cSrcweir if( aDiff > 0 ) 1075cdf0e10cSrcweir aDiff = 0; 1076cdf0e10cSrcweir else if ( aDiff < -aTmp.Height() ) 1077cdf0e10cSrcweir aDiff = -aTmp.Height(); 1078cdf0e10cSrcweir SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) ); 1079cdf0e10cSrcweir sal_Int16 eNew; 1080cdf0e10cSrcweir if( bWeb ) 1081cdf0e10cSrcweir { 1082cdf0e10cSrcweir eNew = aVert.GetVertOrient(); 1083cdf0e10cSrcweir sal_Bool bDown = 0 != ( nDir & 0x02 ); 1084cdf0e10cSrcweir switch( eNew ) 1085cdf0e10cSrcweir { 1086cdf0e10cSrcweir case text::VertOrientation::CHAR_TOP: 1087cdf0e10cSrcweir if( bDown ) eNew = text::VertOrientation::CENTER; 1088cdf0e10cSrcweir break; 1089cdf0e10cSrcweir case text::VertOrientation::CENTER: 1090cdf0e10cSrcweir eNew = bDown ? text::VertOrientation::TOP : text::VertOrientation::CHAR_TOP; 1091cdf0e10cSrcweir break; 1092cdf0e10cSrcweir case text::VertOrientation::TOP: 1093cdf0e10cSrcweir if( !bDown ) eNew = text::VertOrientation::CENTER; 1094cdf0e10cSrcweir break; 1095cdf0e10cSrcweir case text::VertOrientation::LINE_TOP: 1096cdf0e10cSrcweir if( bDown ) eNew = text::VertOrientation::LINE_CENTER; 1097cdf0e10cSrcweir break; 1098cdf0e10cSrcweir case text::VertOrientation::LINE_CENTER: 1099cdf0e10cSrcweir eNew = bDown ? text::VertOrientation::LINE_BOTTOM : text::VertOrientation::LINE_TOP; 1100cdf0e10cSrcweir break; 1101cdf0e10cSrcweir case text::VertOrientation::LINE_BOTTOM: 1102cdf0e10cSrcweir if( !bDown ) eNew = text::VertOrientation::LINE_CENTER; 1103cdf0e10cSrcweir break; 1104cdf0e10cSrcweir default:; //prevent warning 1105cdf0e10cSrcweir } 1106cdf0e10cSrcweir } 1107cdf0e10cSrcweir else 1108cdf0e10cSrcweir { 1109cdf0e10cSrcweir aVert.SetPos( aDiff ); 1110cdf0e10cSrcweir eNew = text::VertOrientation::NONE; 1111cdf0e10cSrcweir } 1112cdf0e10cSrcweir aVert.SetVertOrient( eNew ); 1113cdf0e10cSrcweir aSet.Put( aVert ); 1114cdf0e10cSrcweir bSet = sal_True; 1115cdf0e10cSrcweir } 1116cdf0e10cSrcweir if (bWeb && (FLY_AT_PARA == eAnchorId) 1117cdf0e10cSrcweir && ( nDir==MOVE_LEFT_SMALL || nDir==MOVE_RIGHT_BIG )) 1118cdf0e10cSrcweir { 1119cdf0e10cSrcweir SwFmtHoriOrient aHori( (SwFmtHoriOrient&)aSet.Get(RES_HORI_ORIENT) ); 1120cdf0e10cSrcweir sal_Int16 eNew; 1121cdf0e10cSrcweir eNew = aHori.GetHoriOrient(); 1122cdf0e10cSrcweir switch( eNew ) 1123cdf0e10cSrcweir { 1124cdf0e10cSrcweir case text::HoriOrientation::RIGHT: 1125cdf0e10cSrcweir if( nDir==MOVE_LEFT_SMALL ) 1126cdf0e10cSrcweir eNew = text::HoriOrientation::LEFT; 1127cdf0e10cSrcweir break; 1128cdf0e10cSrcweir case text::HoriOrientation::LEFT: 1129cdf0e10cSrcweir if( nDir==MOVE_RIGHT_BIG ) 1130cdf0e10cSrcweir eNew = text::HoriOrientation::RIGHT; 1131cdf0e10cSrcweir break; 1132cdf0e10cSrcweir default:; //prevent warning 1133cdf0e10cSrcweir } 1134cdf0e10cSrcweir if( eNew != aHori.GetHoriOrient() ) 1135cdf0e10cSrcweir { 1136cdf0e10cSrcweir aHori.SetHoriOrient( eNew ); 1137cdf0e10cSrcweir aSet.Put( aHori ); 1138cdf0e10cSrcweir bSet = sal_True; 1139cdf0e10cSrcweir } 1140cdf0e10cSrcweir } 1141cdf0e10cSrcweir rSh.StartAllAction(); 1142cdf0e10cSrcweir if( bSet ) 1143cdf0e10cSrcweir rSh.SetFlyFrmAttr( aSet ); 1144cdf0e10cSrcweir sal_Bool bSetPos = (FLY_AS_CHAR != eAnchorId); 1145cdf0e10cSrcweir if(bSetPos && bWeb) 1146cdf0e10cSrcweir { 1147cdf0e10cSrcweir if (FLY_AT_PAGE != eAnchorId) 1148cdf0e10cSrcweir { 1149cdf0e10cSrcweir bSetPos = sal_False; 1150cdf0e10cSrcweir } 1151cdf0e10cSrcweir else 1152cdf0e10cSrcweir { 1153cdf0e10cSrcweir bSetPos = (::GetHtmlMode(rView.GetDocShell()) & HTMLMODE_SOME_ABS_POS) ? 1154cdf0e10cSrcweir sal_True : sal_False; 1155cdf0e10cSrcweir } 1156cdf0e10cSrcweir } 1157cdf0e10cSrcweir if( bSetPos ) 1158cdf0e10cSrcweir rSh.SetFlyPos( aTmp.Pos() ); 1159cdf0e10cSrcweir rSh.EndAllAction(); 1160cdf0e10cSrcweir } 1161cdf0e10cSrcweir } 1162cdf0e10cSrcweir /* -----------------------------23.05.2002 11:35------------------------------ 1163cdf0e10cSrcweir 1164cdf0e10cSrcweir ---------------------------------------------------------------------------*/ 1165cdf0e10cSrcweir void SwEditWin::ChangeDrawing( sal_uInt8 nDir ) 1166cdf0e10cSrcweir { 1167cdf0e10cSrcweir // --> OD 2005-01-31 #i40845# - start undo action in order to get only one 1168cdf0e10cSrcweir // undo action for this change. 1169cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 1170cdf0e10cSrcweir rSh.StartUndo(); 1171cdf0e10cSrcweir // <-- 1172cdf0e10cSrcweir 1173cdf0e10cSrcweir long nX = 0; 1174cdf0e10cSrcweir long nY = 0; 117593641701SArmin Le Grand const sal_Bool bOnePixel( 117693641701SArmin Le Grand MOVE_LEFT_SMALL == nDir || 117793641701SArmin Le Grand MOVE_UP_SMALL == nDir || 117893641701SArmin Le Grand MOVE_RIGHT_SMALL == nDir || 117993641701SArmin Le Grand MOVE_DOWN_SMALL == nDir); 118093641701SArmin Le Grand const sal_Bool bHuge( 118193641701SArmin Le Grand MOVE_LEFT_HUGE == nDir || 118293641701SArmin Le Grand MOVE_UP_HUGE == nDir || 118393641701SArmin Le Grand MOVE_RIGHT_HUGE == nDir || 118493641701SArmin Le Grand MOVE_DOWN_HUGE == nDir); 1185cdf0e10cSrcweir sal_uInt16 nAnchorDir = SW_MOVE_UP; 1186cdf0e10cSrcweir switch(nDir) 1187cdf0e10cSrcweir { 1188cdf0e10cSrcweir case MOVE_LEFT_SMALL: 118993641701SArmin Le Grand case MOVE_LEFT_HUGE: 1190cdf0e10cSrcweir case MOVE_LEFT_BIG: 1191cdf0e10cSrcweir nX = -1; 1192cdf0e10cSrcweir nAnchorDir = SW_MOVE_LEFT; 1193cdf0e10cSrcweir break; 1194cdf0e10cSrcweir case MOVE_UP_SMALL: 119593641701SArmin Le Grand case MOVE_UP_HUGE: 1196cdf0e10cSrcweir case MOVE_UP_BIG: 1197cdf0e10cSrcweir nY = -1; 1198cdf0e10cSrcweir break; 1199cdf0e10cSrcweir case MOVE_RIGHT_SMALL: 120093641701SArmin Le Grand case MOVE_RIGHT_HUGE: 1201cdf0e10cSrcweir case MOVE_RIGHT_BIG: 1202cdf0e10cSrcweir nX = +1; 1203cdf0e10cSrcweir nAnchorDir = SW_MOVE_RIGHT; 1204cdf0e10cSrcweir break; 1205cdf0e10cSrcweir case MOVE_DOWN_SMALL: 120693641701SArmin Le Grand case MOVE_DOWN_HUGE: 1207cdf0e10cSrcweir case MOVE_DOWN_BIG: 1208cdf0e10cSrcweir nY = +1; 1209cdf0e10cSrcweir nAnchorDir = SW_MOVE_DOWN; 1210cdf0e10cSrcweir break; 1211cdf0e10cSrcweir } 1212cdf0e10cSrcweir 1213cdf0e10cSrcweir if(0 != nX || 0 != nY) 1214cdf0e10cSrcweir { 1215cdf0e10cSrcweir sal_uInt8 nProtect = rSh.IsSelObjProtected( FLYPROTECT_POS|FLYPROTECT_SIZE ); 1216cdf0e10cSrcweir Size aSnap( rSh.GetViewOptions()->GetSnapSize() ); 1217cdf0e10cSrcweir short nDiv = rSh.GetViewOptions()->GetDivisionX(); 1218cdf0e10cSrcweir if ( nDiv > 0 ) 1219cdf0e10cSrcweir aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv ); 1220cdf0e10cSrcweir nDiv = rSh.GetViewOptions()->GetDivisionY(); 1221cdf0e10cSrcweir if ( nDiv > 0 ) 1222cdf0e10cSrcweir aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv ); 1223cdf0e10cSrcweir 1224cdf0e10cSrcweir if(bOnePixel) 122593641701SArmin Le Grand { 1226cdf0e10cSrcweir aSnap = PixelToLogic(Size(1,1)); 122793641701SArmin Le Grand } 122893641701SArmin Le Grand else if(bHuge) 122993641701SArmin Le Grand { 123093641701SArmin Le Grand // #121236# 567twips == 1cm, but just take three times the normal snap 123193641701SArmin Le Grand aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3); 123293641701SArmin Le Grand } 1233cdf0e10cSrcweir 1234cdf0e10cSrcweir nX *= aSnap.Width(); 1235cdf0e10cSrcweir nY *= aSnap.Height(); 1236cdf0e10cSrcweir 1237cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 1238cdf0e10cSrcweir const SdrHdlList& rHdlList = pSdrView->GetHdlList(); 1239cdf0e10cSrcweir SdrHdl* pHdl = rHdlList.GetFocusHdl(); 1240cdf0e10cSrcweir rSh.StartAllAction(); 1241cdf0e10cSrcweir if(0L == pHdl) 1242cdf0e10cSrcweir { 1243cdf0e10cSrcweir // now move the selected draw objects 1244cdf0e10cSrcweir // if the object's position is not protected 1245cdf0e10cSrcweir if(0 == (nProtect&FLYPROTECT_POS)) 1246cdf0e10cSrcweir { 1247cdf0e10cSrcweir // --> FME 2005-04-26 #i47138# 1248cdf0e10cSrcweir // Check if object is anchored as character and move direction 1249cdf0e10cSrcweir sal_Bool bDummy1, bDummy2; 1250cdf0e10cSrcweir const bool bVertAnchor = rSh.IsFrmVertical( sal_True, bDummy1, bDummy2 ); 1251cdf0e10cSrcweir const bool bHoriMove = !bVertAnchor == !( nDir % 2 ); 1252cdf0e10cSrcweir const bool bMoveAllowed = 1253cdf0e10cSrcweir !bHoriMove || (rSh.GetAnchorId() != FLY_AS_CHAR); 1254cdf0e10cSrcweir if ( bMoveAllowed ) 1255cdf0e10cSrcweir { 1256cdf0e10cSrcweir // <-- 1257cdf0e10cSrcweir pSdrView->MoveAllMarked(Size(nX, nY)); 1258cdf0e10cSrcweir rSh.SetModified(); 1259cdf0e10cSrcweir } 1260cdf0e10cSrcweir } 1261cdf0e10cSrcweir } 1262cdf0e10cSrcweir else 1263cdf0e10cSrcweir { 1264cdf0e10cSrcweir // move handle with index nHandleIndex 1265cdf0e10cSrcweir if(pHdl && (nX || nY)) 1266cdf0e10cSrcweir { 1267cdf0e10cSrcweir if( HDL_ANCHOR == pHdl->GetKind() || 1268cdf0e10cSrcweir HDL_ANCHOR_TR == pHdl->GetKind() ) 1269cdf0e10cSrcweir { 1270cdf0e10cSrcweir // anchor move cannot be allowed when position is protected 1271cdf0e10cSrcweir if(0 == (nProtect&FLYPROTECT_POS)) 1272cdf0e10cSrcweir rSh.MoveAnchor( nAnchorDir ); 1273cdf0e10cSrcweir } 1274cdf0e10cSrcweir //now resize if size is protected 1275cdf0e10cSrcweir else if(0 == (nProtect&FLYPROTECT_SIZE)) 1276cdf0e10cSrcweir { 1277cdf0e10cSrcweir // now move the Handle (nX, nY) 1278cdf0e10cSrcweir Point aStartPoint(pHdl->GetPos()); 1279cdf0e10cSrcweir Point aEndPoint(pHdl->GetPos() + Point(nX, nY)); 1280cdf0e10cSrcweir const SdrDragStat& rDragStat = pSdrView->GetDragStat(); 1281cdf0e10cSrcweir 1282cdf0e10cSrcweir // start dragging 1283cdf0e10cSrcweir pSdrView->BegDragObj(aStartPoint, 0, pHdl, 0); 1284cdf0e10cSrcweir 1285cdf0e10cSrcweir if(pSdrView->IsDragObj()) 1286cdf0e10cSrcweir { 1287cdf0e10cSrcweir sal_Bool bWasNoSnap = static_cast< sal_Bool >(rDragStat.IsNoSnap()); 1288cdf0e10cSrcweir sal_Bool bWasSnapEnabled = pSdrView->IsSnapEnabled(); 1289cdf0e10cSrcweir 1290cdf0e10cSrcweir // switch snapping off 1291cdf0e10cSrcweir if(!bWasNoSnap) 1292cdf0e10cSrcweir ((SdrDragStat&)rDragStat).SetNoSnap(sal_True); 1293cdf0e10cSrcweir if(bWasSnapEnabled) 1294cdf0e10cSrcweir pSdrView->SetSnapEnabled(sal_False); 1295cdf0e10cSrcweir 1296cdf0e10cSrcweir pSdrView->MovAction(aEndPoint); 1297cdf0e10cSrcweir pSdrView->EndDragObj(); 1298cdf0e10cSrcweir rSh.SetModified(); 1299cdf0e10cSrcweir 1300cdf0e10cSrcweir // restore snap 1301cdf0e10cSrcweir if(!bWasNoSnap) 1302cdf0e10cSrcweir ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap); 1303cdf0e10cSrcweir if(bWasSnapEnabled) 1304cdf0e10cSrcweir pSdrView->SetSnapEnabled(bWasSnapEnabled); 1305cdf0e10cSrcweir } 1306cdf0e10cSrcweir } 1307cdf0e10cSrcweir } 1308cdf0e10cSrcweir } 1309cdf0e10cSrcweir rSh.EndAllAction(); 1310cdf0e10cSrcweir } 1311cdf0e10cSrcweir 1312cdf0e10cSrcweir // --> OD 2005-01-31 #i40845# - end undo action 1313cdf0e10cSrcweir rSh.EndUndo(); 1314cdf0e10cSrcweir // <-- 1315cdf0e10cSrcweir } 1316cdf0e10cSrcweir 1317cdf0e10cSrcweir /*-------------------------------------------------------------------- 1318cdf0e10cSrcweir Beschreibung: KeyEvents 1319cdf0e10cSrcweir --------------------------------------------------------------------*/ 1320cdf0e10cSrcweir 1321cdf0e10cSrcweir 1322cdf0e10cSrcweir 1323cdf0e10cSrcweir void SwEditWin::KeyInput(const KeyEvent &rKEvt) 1324cdf0e10cSrcweir { 1325cdf0e10cSrcweir if( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE && 1326cdf0e10cSrcweir pApplyTempl && pApplyTempl->pFormatClipboard ) 1327cdf0e10cSrcweir { 1328cdf0e10cSrcweir pApplyTempl->pFormatClipboard->Erase(); 1329cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate()); 1330cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(SID_FORMATPAINTBRUSH); 1331cdf0e10cSrcweir } 1332cdf0e10cSrcweir 1333cdf0e10cSrcweir SfxObjectShell *pObjSh = (SfxObjectShell*)rView.GetViewFrame()->GetObjectShell(); 1334cdf0e10cSrcweir if ( bLockInput || (pObjSh && pObjSh->GetProgress()) ) 1335cdf0e10cSrcweir // Wenn die Rechenleiste aktiv ist oder 1336cdf0e10cSrcweir // auf dem Document ein Progress laeuft wird keine 1337cdf0e10cSrcweir // Bestellungen angenommen. 1338cdf0e10cSrcweir return; 1339cdf0e10cSrcweir 1340cdf0e10cSrcweir if( pShadCrsr ) 1341cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 1342cdf0e10cSrcweir aKeyInputFlushTimer.Stop(); 1343cdf0e10cSrcweir 1344cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 1345cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() && 1346cdf0e10cSrcweir rSh.IsCrsrReadonly(); 1347cdf0e10cSrcweir 1348cdf0e10cSrcweir //if the language changes the buffer must be flushed 1349cdf0e10cSrcweir LanguageType eNewLanguage = GetInputLanguage(); 1350cdf0e10cSrcweir if(!bIsDocReadOnly && eBufferLanguage != eNewLanguage && aInBuffer.Len()) 1351cdf0e10cSrcweir { 1352cdf0e10cSrcweir FlushInBuffer(); 1353cdf0e10cSrcweir } 1354cdf0e10cSrcweir eBufferLanguage = eNewLanguage; 1355cdf0e10cSrcweir 1356cdf0e10cSrcweir QuickHelpData aTmpQHD; 1357cdf0e10cSrcweir if( pQuickHlpData->bClear ) 1358cdf0e10cSrcweir { 1359cdf0e10cSrcweir aTmpQHD.Move( *pQuickHlpData ); 1360cdf0e10cSrcweir pQuickHlpData->Stop( rSh ); 1361cdf0e10cSrcweir } 1362cdf0e10cSrcweir 1363cdf0e10cSrcweir // OS:auch die DrawView braucht noch ein readonly-Flag 1364cdf0e10cSrcweir if ( !bIsDocReadOnly && rSh.GetDrawView() && rSh.GetDrawView()->KeyInput( rKEvt, this ) ) 1365cdf0e10cSrcweir { 1366cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll( sal_False ); 1367cdf0e10cSrcweir rSh.SetModified(); 1368cdf0e10cSrcweir return; // Event von der SdrView ausgewertet 1369cdf0e10cSrcweir } 1370cdf0e10cSrcweir 1371cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm ) 1372cdf0e10cSrcweir { 1373cdf0e10cSrcweir StopInsFrm(); 1374cdf0e10cSrcweir rSh.Edit(); 1375cdf0e10cSrcweir } 1376cdf0e10cSrcweir 1377cdf0e10cSrcweir sal_Bool bFlushBuffer = sal_False; 1378cdf0e10cSrcweir sal_Bool bNormalChar = sal_False; 1379cdf0e10cSrcweir sal_Bool bChkInsBlank = pQuickHlpData->bChkInsBlank; 1380cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_False; 1381cdf0e10cSrcweir 1382cdf0e10cSrcweir KeyEvent aKeyEvent( rKEvt ); 1383cdf0e10cSrcweir // look for vertical mappings 1384cdf0e10cSrcweir if( !bIsDocReadOnly && !rSh.IsSelFrmMode() && !rSh.IsObjSelected() ) 1385cdf0e10cSrcweir { 1386cdf0e10cSrcweir //JP 21.2.2002: must changed from switch to if, because the Linux 1387cdf0e10cSrcweir // compiler has problem with the code. Has to remove if the new general 1388cdf0e10cSrcweir // handler exist. 1389cdf0e10cSrcweir sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode(); 1390cdf0e10cSrcweir 1391cdf0e10cSrcweir if( KEY_UP == nKey || KEY_DOWN == nKey || 1392cdf0e10cSrcweir KEY_LEFT == nKey || KEY_RIGHT == nKey ) 1393cdf0e10cSrcweir { 1394cdf0e10cSrcweir // In general, we want to map the direction keys if we are inside 1395cdf0e10cSrcweir // some vertical formatted text. 1396cdf0e10cSrcweir // 1. Exception: For a table cursor in a horizontal table, the 1397cdf0e10cSrcweir // directions should never be mapped. 1398cdf0e10cSrcweir // 2. Exception: For a table cursor in a vertical table, the 1399cdf0e10cSrcweir // directions should always be mapped. 1400cdf0e10cSrcweir const bool bVertText = rSh.IsInVerticalText(); 1401cdf0e10cSrcweir const bool bTblCrsr = rSh.GetTableCrsr(); 1402cdf0e10cSrcweir const bool bVertTable = rSh.IsTableVertical(); 1403cdf0e10cSrcweir if( ( bVertText && ( !bTblCrsr || bVertTable ) ) || 1404cdf0e10cSrcweir ( bTblCrsr && bVertTable ) ) 1405cdf0e10cSrcweir { 1406cdf0e10cSrcweir // Attempt to integrate cursor travelling for mongolian layout does not work. 1407cdf0e10cSrcweir // Thus, back to previous mapping of cursor keys to direction keys. 1408cdf0e10cSrcweir if( KEY_UP == nKey ) nKey = KEY_LEFT; 1409cdf0e10cSrcweir else if( KEY_DOWN == nKey ) nKey = KEY_RIGHT; 1410cdf0e10cSrcweir else if( KEY_LEFT == nKey ) nKey = KEY_DOWN; 1411cdf0e10cSrcweir else if( KEY_RIGHT == nKey ) nKey = KEY_UP; 1412cdf0e10cSrcweir } 1413cdf0e10cSrcweir 1414cdf0e10cSrcweir if ( rSh.IsInRightToLeftText() ) 1415cdf0e10cSrcweir { 1416cdf0e10cSrcweir if( KEY_LEFT == nKey ) nKey = KEY_RIGHT; 1417cdf0e10cSrcweir else if( KEY_RIGHT == nKey ) nKey = KEY_LEFT; 1418cdf0e10cSrcweir } 1419cdf0e10cSrcweir 1420cdf0e10cSrcweir aKeyEvent = KeyEvent( rKEvt.GetCharCode(), 1421cdf0e10cSrcweir KeyCode( nKey, rKEvt.GetKeyCode().GetModifier() ), 1422cdf0e10cSrcweir rKEvt.GetRepeat() ); 1423cdf0e10cSrcweir } 1424cdf0e10cSrcweir } 1425cdf0e10cSrcweir 1426cdf0e10cSrcweir const KeyCode& rKeyCode = aKeyEvent.GetKeyCode(); 1427cdf0e10cSrcweir sal_Unicode aCh = aKeyEvent.GetCharCode(); 1428cdf0e10cSrcweir 1429cdf0e10cSrcweir // enable switching to notes ankor with Ctrl - Alt - Page Up/Down 1430cdf0e10cSrcweir // pressing this inside a note will switch to next/previous note 1431cdf0e10cSrcweir if ((rKeyCode.IsMod1() && rKeyCode.IsMod2()) && ((rKeyCode.GetCode() == KEY_PAGEUP) || (rKeyCode.GetCode() == KEY_PAGEDOWN))) 1432cdf0e10cSrcweir { 1433cdf0e10cSrcweir bool bNext = rKeyCode.GetCode()==KEY_PAGEDOWN ? true : false; 1434cdf0e10cSrcweir SwFieldType* pFldType = rSh.GetFldType(0, RES_POSTITFLD); 1435cdf0e10cSrcweir rSh.MoveFldType( pFldType, bNext ); 1436cdf0e10cSrcweir return; 1437cdf0e10cSrcweir } 1438cdf0e10cSrcweir 1439cdf0e10cSrcweir const SwFrmFmt* pFlyFmt = rSh.GetFlyFrmFmt(); 1440cdf0e10cSrcweir if( pFlyFmt ) 1441cdf0e10cSrcweir { 1442cdf0e10cSrcweir sal_uInt16 nEvent; 1443cdf0e10cSrcweir 1444cdf0e10cSrcweir if( 32 <= aCh && 1445cdf0e10cSrcweir 0 == (( KEY_MOD1 | KEY_MOD2 ) & rKeyCode.GetModifier() )) 1446cdf0e10cSrcweir nEvent = SW_EVENT_FRM_KEYINPUT_ALPHA; 1447cdf0e10cSrcweir else 1448cdf0e10cSrcweir nEvent = SW_EVENT_FRM_KEYINPUT_NOALPHA; 1449cdf0e10cSrcweir 1450cdf0e10cSrcweir const SvxMacro* pMacro = pFlyFmt->GetMacro().GetMacroTable().Get( nEvent ); 1451cdf0e10cSrcweir if( pMacro ) 1452cdf0e10cSrcweir { 1453cdf0e10cSrcweir String sRet; 1454cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray; 1455cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable; 1456cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() ); 1457cdf0e10cSrcweir xArgs->Put( &xVar, 1 ); 1458cdf0e10cSrcweir 1459cdf0e10cSrcweir xVar = new SbxVariable; 1460cdf0e10cSrcweir if( SW_EVENT_FRM_KEYINPUT_ALPHA == nEvent ) 1461cdf0e10cSrcweir xVar->PutChar( aCh ); 1462cdf0e10cSrcweir else 1463cdf0e10cSrcweir xVar->PutUShort( rKeyCode.GetModifier() | rKeyCode.GetCode() ); 1464cdf0e10cSrcweir xArgs->Put( &xVar, 2 ); 1465cdf0e10cSrcweir 1466cdf0e10cSrcweir rSh.ExecMacro( *pMacro, &sRet, &xArgs ); 1467cdf0e10cSrcweir if( sRet.Len() && 0 != sRet.ToInt32() ) 1468cdf0e10cSrcweir return ; 1469cdf0e10cSrcweir } 1470cdf0e10cSrcweir } 1471cdf0e10cSrcweir int nLclSelectionType; 1472cdf0e10cSrcweir //A is converted to 1 1473cdf0e10cSrcweir if( rKeyCode.GetFullCode() == (KEY_A | KEY_MOD1 |KEY_SHIFT) 1474cdf0e10cSrcweir && rSh.HasDrawView() && 1475cdf0e10cSrcweir (0 != (nLclSelectionType = rSh.GetSelectionType()) && 1476cdf0e10cSrcweir ((nLclSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_GRF)) || 1477cdf0e10cSrcweir ((nLclSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) && 1478cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)))) 1479cdf0e10cSrcweir { 1480cdf0e10cSrcweir SdrHdlList& rHdlList = (SdrHdlList&)rSh.GetDrawView()->GetHdlList(); 1481cdf0e10cSrcweir SdrHdl* pAnchor = rHdlList.GetHdl(HDL_ANCHOR); 1482cdf0e10cSrcweir if ( ! pAnchor ) 1483cdf0e10cSrcweir pAnchor = rHdlList.GetHdl(HDL_ANCHOR_TR); 1484cdf0e10cSrcweir if(pAnchor) 1485cdf0e10cSrcweir rHdlList.SetFocusHdl(pAnchor); 1486cdf0e10cSrcweir return; 1487cdf0e10cSrcweir } 1488cdf0e10cSrcweir 1489cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = 0; 1490cdf0e10cSrcweir SvxAutoCorrect* pACorr = 0; 1491cdf0e10cSrcweir 1492cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder = 1493cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder(); 1494cdf0e10cSrcweir if ( !xRecorder.is() ) 1495cdf0e10cSrcweir { 1496cdf0e10cSrcweir pACfg = SvxAutoCorrCfg::Get(); 1497cdf0e10cSrcweir pACorr = pACfg->GetAutoCorrect(); 1498cdf0e10cSrcweir } 1499cdf0e10cSrcweir 1500cdf0e10cSrcweir SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig(); 1501cdf0e10cSrcweir 1502cdf0e10cSrcweir TblChgWidthHeightType eTblChgMode = nsTblChgWidthHeightType::WH_COL_LEFT; // initialization just for warning-free code 1503cdf0e10cSrcweir sal_uInt16 nTblChgSize = 0; 1504cdf0e10cSrcweir sal_Bool bStopKeyInputTimer = sal_True; 1505cdf0e10cSrcweir String sFmlEntry; 1506cdf0e10cSrcweir 1507cdf0e10cSrcweir enum SW_KeyState { KS_Start, 1508cdf0e10cSrcweir KS_CheckKey, KS_InsChar, KS_InsTab, 1509cdf0e10cSrcweir KS_NoNum, KS_NumOff, KS_NumOrNoNum, KS_NumDown, KS_NumUp, 1510cdf0e10cSrcweir // -> #i23725# 1511cdf0e10cSrcweir KS_NumIndentInc, KS_NumIndentDec, 1512cdf0e10cSrcweir // <- #i23725# 1513cdf0e10cSrcweir 1514cdf0e10cSrcweir KS_OutlineLvOff, 1515cdf0e10cSrcweir KS_NextCell, KS_PrevCell, KS_OutlineUp, KS_OutlineDown, 1516cdf0e10cSrcweir KS_GlossaryExpand, KS_NextPrevGlossary, 1517cdf0e10cSrcweir KS_AutoFmtByInput, 1518cdf0e10cSrcweir KS_NextObject, KS_PrevObject, 1519cdf0e10cSrcweir KS_KeyToView, 1520cdf0e10cSrcweir KS_LaunchOLEObject, KS_GoIntoFly, KS_GoIntoDrawing, 1521cdf0e10cSrcweir KS_EnterDrawHandleMode, 1522cdf0e10cSrcweir KS_CheckDocReadOnlyKeys, 1523cdf0e10cSrcweir KS_CheckAutoCorrect, KS_EditFormula, 1524cdf0e10cSrcweir KS_ColLeftBig, KS_ColRightBig, 1525cdf0e10cSrcweir KS_ColLeftSmall, KS_ColRightSmall, 1526cdf0e10cSrcweir KS_ColTopBig, KS_ColBottomBig, 1527cdf0e10cSrcweir KS_ColTopSmall, KS_ColBottomSmall, 1528cdf0e10cSrcweir KS_CellLeftBig, KS_CellRightBig, 1529cdf0e10cSrcweir KS_CellLeftSmall, KS_CellRightSmall, 1530cdf0e10cSrcweir KS_CellTopBig, KS_CellBottomBig, 1531cdf0e10cSrcweir KS_CellTopSmall, KS_CellBottomSmall, 1532cdf0e10cSrcweir 1533cdf0e10cSrcweir KS_InsDel_ColLeftBig, KS_InsDel_ColRightBig, 1534cdf0e10cSrcweir KS_InsDel_ColLeftSmall, KS_InsDel_ColRightSmall, 1535cdf0e10cSrcweir KS_InsDel_ColTopBig, KS_InsDel_ColBottomBig, 1536cdf0e10cSrcweir KS_InsDel_ColTopSmall, KS_InsDel_ColBottomSmall, 1537cdf0e10cSrcweir KS_InsDel_CellLeftBig, KS_InsDel_CellRightBig, 1538cdf0e10cSrcweir KS_InsDel_CellLeftSmall, KS_InsDel_CellRightSmall, 1539cdf0e10cSrcweir KS_InsDel_CellTopBig, KS_InsDel_CellBottomBig, 1540cdf0e10cSrcweir KS_InsDel_CellTopSmall, KS_InsDel_CellBottomSmall, 1541cdf0e10cSrcweir KS_TblColCellInsDel, 1542cdf0e10cSrcweir 1543cdf0e10cSrcweir KS_Fly_Change, KS_Draw_Change, 1544cdf0e10cSrcweir KS_SpecialInsert, 1545cdf0e10cSrcweir KS_EnterCharCell, 1546cdf0e10cSrcweir KS_GotoNextFieldMark, 1547cdf0e10cSrcweir KS_GotoPrevFieldMark, 1548cdf0e10cSrcweir KS_Ende }; 1549cdf0e10cSrcweir 1550cdf0e10cSrcweir 1551cdf0e10cSrcweir 1552cdf0e10cSrcweir SW_KeyState eKeyState = bIsDocReadOnly ? KS_CheckDocReadOnlyKeys 1553cdf0e10cSrcweir : KS_CheckKey, 1554cdf0e10cSrcweir eNextKeyState = KS_Ende; 1555cdf0e10cSrcweir sal_uInt8 nDir = 0; 1556cdf0e10cSrcweir 1557cdf0e10cSrcweir // -> #i23725# 1558cdf0e10cSrcweir if (nKS_NUMDOWN_Count > 0) 1559cdf0e10cSrcweir nKS_NUMDOWN_Count--; 1560cdf0e10cSrcweir 1561cdf0e10cSrcweir if (nKS_NUMINDENTINC_Count > 0) 1562cdf0e10cSrcweir nKS_NUMINDENTINC_Count--; 1563cdf0e10cSrcweir // <- #i23725# 1564cdf0e10cSrcweir 1565cdf0e10cSrcweir while( KS_Ende != eKeyState ) 1566cdf0e10cSrcweir { 1567cdf0e10cSrcweir SW_KeyState eFlyState = KS_KeyToView; 1568cdf0e10cSrcweir 1569cdf0e10cSrcweir switch( eKeyState ) 1570cdf0e10cSrcweir { 1571cdf0e10cSrcweir case KS_CheckKey: 1572cdf0e10cSrcweir eKeyState = KS_KeyToView; // default weiter zur View 1573cdf0e10cSrcweir 1574cdf0e10cSrcweir #ifdef DBG_UTIL 1575cdf0e10cSrcweir //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 1576cdf0e10cSrcweir // JP 19.01.99: zum Umschalten des Cursor Verhaltens in ReadOnly 1577cdf0e10cSrcweir // Bereichen 1578cdf0e10cSrcweir if( 0x7210 == rKeyCode.GetFullCode() ) 1579cdf0e10cSrcweir rSh.SetReadOnlyAvailable( !rSh.IsReadOnlyAvailable() ); 1580cdf0e10cSrcweir else 1581cdf0e10cSrcweir //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 1582cdf0e10cSrcweir #endif 1583cdf0e10cSrcweir 1584cdf0e10cSrcweir if( !rKeyCode.IsMod2() && '=' == aCh && 1585cdf0e10cSrcweir !rSh.IsTableMode() && rSh.GetTableFmt() && 1586cdf0e10cSrcweir rSh.IsSttPara() /*&& rSh.IsEndPara()*/ && 1587cdf0e10cSrcweir !rSh.HasReadonlySel() ) 1588cdf0e10cSrcweir { 1589cdf0e10cSrcweir // in der Tabelle am Anfang der Zelle ein '=' -> 1590cdf0e10cSrcweir // EditZeile aufrufen (F2-Funktionalitaet) 1591cdf0e10cSrcweir rSh.Push(); 1592cdf0e10cSrcweir if( !rSh.MoveSection( fnSectionCurr, fnSectionStart) && 1593cdf0e10cSrcweir !rSh.IsTableBoxTextFormat() ) 1594cdf0e10cSrcweir { 1595cdf0e10cSrcweir // steht also am Anfang der Box 1596cdf0e10cSrcweir eKeyState = KS_EditFormula; 1597cdf0e10cSrcweir if( rSh.HasMark() ) 1598cdf0e10cSrcweir rSh.SwapPam(); 1599cdf0e10cSrcweir else 1600cdf0e10cSrcweir rSh.SttSelect(); 1601cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd ); 1602cdf0e10cSrcweir rSh.Pop( sal_True ); 1603cdf0e10cSrcweir rSh.EndSelect(); 1604cdf0e10cSrcweir sFmlEntry = '='; 1605cdf0e10cSrcweir } 1606cdf0e10cSrcweir else 1607cdf0e10cSrcweir rSh.Pop( sal_False ); 1608cdf0e10cSrcweir } 1609cdf0e10cSrcweir else 1610cdf0e10cSrcweir { 1611cdf0e10cSrcweir if( pACorr && aTmpQHD.HasCntnt() && !rSh.HasSelection() && 1612cdf0e10cSrcweir !rSh.HasReadonlySel() && !aTmpQHD.bIsAutoText && 1613cdf0e10cSrcweir pACorr->GetSwFlags().nAutoCmpltExpandKey == 1614cdf0e10cSrcweir (rKeyCode.GetModifier() | rKeyCode.GetCode()) ) 1615cdf0e10cSrcweir { 1616cdf0e10cSrcweir eKeyState = KS_GlossaryExpand; 1617cdf0e10cSrcweir break; 1618cdf0e10cSrcweir } 1619cdf0e10cSrcweir 1620cdf0e10cSrcweir switch( rKeyCode.GetModifier() | rKeyCode.GetCode() ) 1621cdf0e10cSrcweir { 1622cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2: 1623cdf0e10cSrcweir eKeyState = KS_ColRightBig; 1624cdf0e10cSrcweir eFlyState = KS_Fly_Change; 16254846d9baSOliver-Rainer Wittmann nDir = MOVE_RIGHT_SMALL; 1626cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 1627cdf0e10cSrcweir 1628cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2: 1629cdf0e10cSrcweir eKeyState = KS_ColRightSmall; 1630cdf0e10cSrcweir eFlyState = KS_Fly_Change; 16314846d9baSOliver-Rainer Wittmann nDir = MOVE_LEFT_SMALL; 1632cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 163393641701SArmin Le Grand 1634cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT: 1635cdf0e10cSrcweir eKeyState = KS_ColLeftSmall; 1636cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 163793641701SArmin Le Grand 1638cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_SHIFT: 1639cdf0e10cSrcweir eKeyState = KS_ColLeftBig; 1640cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 1641cdf0e10cSrcweir 1642cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_MOD1: 1643cdf0e10cSrcweir eKeyState = KS_CellRightBig; 1644cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 164593641701SArmin Le Grand 1646cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_MOD1: 1647cdf0e10cSrcweir eKeyState = KS_CellRightSmall; 1648cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 164993641701SArmin Le Grand 1650cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1: 1651cdf0e10cSrcweir eKeyState = KS_CellLeftSmall; 1652cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 165393641701SArmin Le Grand 1654cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1: 1655cdf0e10cSrcweir eKeyState = KS_CellLeftBig; 1656cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 1657cdf0e10cSrcweir 1658cdf0e10cSrcweir case KEY_UP | KEY_MOD2: 1659cdf0e10cSrcweir eKeyState = KS_ColBottomSmall; 1660cdf0e10cSrcweir eFlyState = KS_Fly_Change; 16614846d9baSOliver-Rainer Wittmann nDir = MOVE_UP_SMALL; 1662cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 166393641701SArmin Le Grand 1664cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2: 1665cdf0e10cSrcweir eKeyState = KS_ColBottomBig; 1666cdf0e10cSrcweir eFlyState = KS_Fly_Change; 16674846d9baSOliver-Rainer Wittmann nDir = MOVE_DOWN_SMALL; 1668cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 166993641701SArmin Le Grand 1670cdf0e10cSrcweir // case KEY_UP | KEY_MOD2 | KEY_SHIFT: 1671cdf0e10cSrcweir // eKeyState = KS_ColTopBig; 1672cdf0e10cSrcweir // goto KEYINPUT_CHECKTABLE; 1673cdf0e10cSrcweir // case KEY_DOWN | KEY_MOD2 | KEY_SHIFT: 1674cdf0e10cSrcweir // eKeyState = KS_ColTopSmall; 1675cdf0e10cSrcweir // goto KEYINPUT_CHECKTABLE; 1676cdf0e10cSrcweir 1677cdf0e10cSrcweir case KEY_UP | KEY_MOD2 | KEY_MOD1: 1678cdf0e10cSrcweir eKeyState = KS_CellBottomSmall; 1679cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 168093641701SArmin Le Grand 1681cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2 | KEY_MOD1: 1682cdf0e10cSrcweir eKeyState = KS_CellBottomBig; 1683cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 168493641701SArmin Le Grand 1685cdf0e10cSrcweir case KEY_UP | KEY_MOD2 | KEY_SHIFT | KEY_MOD1: 1686cdf0e10cSrcweir eKeyState = KS_CellTopBig; 1687cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 168893641701SArmin Le Grand 1689cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2 | KEY_SHIFT | KEY_MOD1: 1690cdf0e10cSrcweir eKeyState = KS_CellTopSmall; 1691cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE; 1692cdf0e10cSrcweir 1693cdf0e10cSrcweir KEYINPUT_CHECKTABLE: 1694cdf0e10cSrcweir if( rSh.IsTableMode() || !rSh.GetTableFmt() ) 1695cdf0e10cSrcweir { 1696cdf0e10cSrcweir if(KS_KeyToView != eFlyState) 1697cdf0e10cSrcweir { 1698cdf0e10cSrcweir if(!pFlyFmt && KS_KeyToView != eFlyState && 1699cdf0e10cSrcweir (rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) && 1700cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked()) 1701cdf0e10cSrcweir eKeyState = KS_Draw_Change; 1702cdf0e10cSrcweir } 1703cdf0e10cSrcweir 1704cdf0e10cSrcweir if( pFlyFmt ) 1705cdf0e10cSrcweir eKeyState = eFlyState; 1706cdf0e10cSrcweir else if( KS_Draw_Change != eKeyState) 1707cdf0e10cSrcweir eKeyState = KS_EnterCharCell; 1708cdf0e10cSrcweir } 1709cdf0e10cSrcweir break; 1710cdf0e10cSrcweir 17114846d9baSOliver-Rainer Wittmann // huge object move 17124846d9baSOliver-Rainer Wittmann case KEY_RIGHT | KEY_SHIFT: 17134846d9baSOliver-Rainer Wittmann case KEY_LEFT | KEY_SHIFT: 17144846d9baSOliver-Rainer Wittmann case KEY_UP | KEY_SHIFT: 17154846d9baSOliver-Rainer Wittmann case KEY_DOWN | KEY_SHIFT: 17164846d9baSOliver-Rainer Wittmann { 17174846d9baSOliver-Rainer Wittmann if ( pFlyFmt 17184846d9baSOliver-Rainer Wittmann || ( (rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) 17194846d9baSOliver-Rainer Wittmann && rSh.GetDrawView()->AreObjectsMarked() ) ) 17204846d9baSOliver-Rainer Wittmann { 17214846d9baSOliver-Rainer Wittmann eKeyState = pFlyFmt ? KS_Fly_Change : KS_Draw_Change; 17224846d9baSOliver-Rainer Wittmann switch ( rKeyCode.GetCode() ) 17234846d9baSOliver-Rainer Wittmann { 17244846d9baSOliver-Rainer Wittmann case KEY_RIGHT: nDir = MOVE_RIGHT_HUGE; break; 17254846d9baSOliver-Rainer Wittmann case KEY_LEFT: nDir = MOVE_LEFT_HUGE; break; 17264846d9baSOliver-Rainer Wittmann case KEY_UP: nDir = MOVE_UP_HUGE; break; 17274846d9baSOliver-Rainer Wittmann case KEY_DOWN: nDir = MOVE_DOWN_HUGE; break; 17284846d9baSOliver-Rainer Wittmann } 17294846d9baSOliver-Rainer Wittmann } 17304846d9baSOliver-Rainer Wittmann break; 17314846d9baSOliver-Rainer Wittmann } 17324846d9baSOliver-Rainer Wittmann 1733cdf0e10cSrcweir //------- 1734cdf0e10cSrcweir // Insert/Delete 1735cdf0e10cSrcweir case KEY_LEFT: 1736cdf0e10cSrcweir case KEY_LEFT | KEY_MOD1: 1737cdf0e10cSrcweir { 1738cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1); 1739cdf0e10cSrcweir if(!bMod1) 1740cdf0e10cSrcweir { 1741cdf0e10cSrcweir eFlyState = KS_Fly_Change; 1742cdf0e10cSrcweir nDir = MOVE_LEFT_BIG; 1743cdf0e10cSrcweir } 1744cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | 1745cdf0e10cSrcweir ( bMod1 1746cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_LEFT 1747cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_COL_LEFT ); 1748cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert(); 1749cdf0e10cSrcweir } 1750cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL; 1751cdf0e10cSrcweir // case KEY_RIGHT: 1752cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD1: 1753cdf0e10cSrcweir { 1754cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_CELL_RIGHT; 1755cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert(); 1756cdf0e10cSrcweir } 1757cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL; 1758cdf0e10cSrcweir case KEY_UP: 1759cdf0e10cSrcweir case KEY_UP | KEY_MOD1: 1760cdf0e10cSrcweir { 1761cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1); 1762cdf0e10cSrcweir if(!bMod1) 1763cdf0e10cSrcweir { 1764cdf0e10cSrcweir eFlyState = KS_Fly_Change; 1765cdf0e10cSrcweir nDir = MOVE_UP_BIG; 1766cdf0e10cSrcweir } 1767cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | 1768cdf0e10cSrcweir ( bMod1 1769cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_TOP 1770cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_ROW_TOP ); 1771cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblHInsert(); 1772cdf0e10cSrcweir } 1773cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL; 1774cdf0e10cSrcweir case KEY_DOWN: 1775cdf0e10cSrcweir case KEY_DOWN | KEY_MOD1: 1776cdf0e10cSrcweir { 1777cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1); 1778cdf0e10cSrcweir if(!bMod1) 1779cdf0e10cSrcweir { 1780cdf0e10cSrcweir eFlyState = KS_Fly_Change; 1781cdf0e10cSrcweir nDir = MOVE_DOWN_BIG; 1782cdf0e10cSrcweir } 1783cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | 1784cdf0e10cSrcweir ( bMod1 1785cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_BOTTOM 1786cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_ROW_BOTTOM ); 1787cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblHInsert(); 1788cdf0e10cSrcweir } 1789cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL; 1790cdf0e10cSrcweir 1791cdf0e10cSrcweir KEYINPUT_CHECKTABLE_INSDEL: 1792cdf0e10cSrcweir if( rSh.IsTableMode() || !rSh.GetTableFmt() || 1793cdf0e10cSrcweir !bTblInsDelMode || 1794cdf0e10cSrcweir sal_False /* Tabelle geschuetzt */ 1795cdf0e10cSrcweir ) 1796cdf0e10cSrcweir { 1797cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType(); 1798cdf0e10cSrcweir 1799cdf0e10cSrcweir eKeyState = KS_KeyToView; 1800cdf0e10cSrcweir if(KS_KeyToView != eFlyState) 1801cdf0e10cSrcweir { 1802cdf0e10cSrcweir if((nSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) && 1803cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked()) 1804cdf0e10cSrcweir eKeyState = KS_Draw_Change; 1805cdf0e10cSrcweir else if(nSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) 1806cdf0e10cSrcweir eKeyState = KS_Fly_Change; 1807cdf0e10cSrcweir } 1808cdf0e10cSrcweir } 1809cdf0e10cSrcweir else 1810cdf0e10cSrcweir { 1811cdf0e10cSrcweir if( !bTblIsInsMode ) 1812cdf0e10cSrcweir eTblChgMode = eTblChgMode | nsTblChgWidthHeightType::WH_FLAG_BIGGER; 1813cdf0e10cSrcweir eKeyState = KS_TblColCellInsDel; 1814cdf0e10cSrcweir } 1815cdf0e10cSrcweir break; 1816cdf0e10cSrcweir 1817cdf0e10cSrcweir case KEY_DELETE: 1818cdf0e10cSrcweir if (rSh.IsInFrontOfLabel() && 1819cdf0e10cSrcweir rSh.NumOrNoNum(sal_False)) 1820cdf0e10cSrcweir eKeyState = KS_NumOrNoNum; 1821cdf0e10cSrcweir break; 1822cdf0e10cSrcweir 1823cdf0e10cSrcweir case KEY_DELETE | KEY_MOD2: 1824cdf0e10cSrcweir if( !rSh.IsTableMode() && rSh.GetTableFmt() ) 1825cdf0e10cSrcweir { 1826cdf0e10cSrcweir eKeyState = KS_Ende; 1827cdf0e10cSrcweir bTblInsDelMode = sal_True; 1828cdf0e10cSrcweir bTblIsInsMode = sal_False; 1829cdf0e10cSrcweir bTblIsColMode = sal_True; 1830cdf0e10cSrcweir aKeyInputTimer.Start(); 1831cdf0e10cSrcweir bStopKeyInputTimer = sal_False; 1832cdf0e10cSrcweir } 1833cdf0e10cSrcweir break; 1834cdf0e10cSrcweir case KEY_INSERT | KEY_MOD2: 1835cdf0e10cSrcweir if( !rSh.IsTableMode() && rSh.GetTableFmt() ) 1836cdf0e10cSrcweir { 1837cdf0e10cSrcweir eKeyState = KS_Ende; 1838cdf0e10cSrcweir bTblInsDelMode = sal_True; 1839cdf0e10cSrcweir bTblIsInsMode = sal_True; 1840cdf0e10cSrcweir bTblIsColMode = sal_True; 1841cdf0e10cSrcweir aKeyInputTimer.Start(); 1842cdf0e10cSrcweir bStopKeyInputTimer = sal_False; 1843cdf0e10cSrcweir } 1844cdf0e10cSrcweir break; 1845cdf0e10cSrcweir 1846cdf0e10cSrcweir case KEY_RETURN: // Return 1847cdf0e10cSrcweir if( !rSh.HasReadonlySel() ) 1848cdf0e10cSrcweir { 1849cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType(); 1850cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_OLE) 1851cdf0e10cSrcweir eKeyState = KS_LaunchOLEObject; 1852cdf0e10cSrcweir else if(nSelectionType & nsSelectionType::SEL_FRM) 1853cdf0e10cSrcweir eKeyState = KS_GoIntoFly; 1854cdf0e10cSrcweir else if((nSelectionType & nsSelectionType::SEL_DRW) && 1855cdf0e10cSrcweir 0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) && 1856cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1) 1857cdf0e10cSrcweir eKeyState = KS_GoIntoDrawing; 1858cdf0e10cSrcweir else if( aTmpQHD.HasCntnt() && !rSh.HasSelection() && 1859cdf0e10cSrcweir aTmpQHD.bIsAutoText ) 1860cdf0e10cSrcweir eKeyState = KS_GlossaryExpand; 1861cdf0e10cSrcweir 1862cdf0e10cSrcweir //RETURN und leerer Absatz in Numerierung -> Num. beenden 1863cdf0e10cSrcweir else if( !aInBuffer.Len() && 1864cdf0e10cSrcweir rSh.GetCurNumRule() && 1865cdf0e10cSrcweir !rSh.GetCurNumRule()->IsOutlineRule() && 1866cdf0e10cSrcweir !rSh.HasSelection() && 1867cdf0e10cSrcweir rSh.IsSttPara() && rSh.IsEndPara() ) 1868cdf0e10cSrcweir eKeyState = KS_NumOff, eNextKeyState = KS_OutlineLvOff; 1869cdf0e10cSrcweir 1870cdf0e10cSrcweir //RETURN fuer neuen Absatz mit AutoFormatierung 1871cdf0e10cSrcweir else if( pACfg && pACfg->IsAutoFmtByInput() && 1872cdf0e10cSrcweir !(nSelectionType & (nsSelectionType::SEL_GRF | 1873cdf0e10cSrcweir nsSelectionType::SEL_OLE | nsSelectionType::SEL_FRM | 1874cdf0e10cSrcweir nsSelectionType::SEL_TBL_CELLS | nsSelectionType::SEL_DRW | 1875cdf0e10cSrcweir nsSelectionType::SEL_DRW_TXT)) ) 1876cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_AutoFmtByInput; 1877cdf0e10cSrcweir else 1878cdf0e10cSrcweir eNextKeyState = eKeyState, eKeyState = KS_CheckAutoCorrect; 1879cdf0e10cSrcweir } 1880cdf0e10cSrcweir break; 1881cdf0e10cSrcweir 1882cdf0e10cSrcweir case KEY_RETURN | KEY_MOD2: // ALT-Return 1883cdf0e10cSrcweir if( !rSh.HasReadonlySel() && !rSh.IsSttPara() && rSh.GetCurNumRule() ) 1884cdf0e10cSrcweir eKeyState = KS_NoNum; 1885cdf0e10cSrcweir else if( rSh.CanSpecialInsert() ) 1886cdf0e10cSrcweir eKeyState = KS_SpecialInsert; 1887cdf0e10cSrcweir break; 1888cdf0e10cSrcweir 1889cdf0e10cSrcweir case KEY_BACKSPACE: 1890cdf0e10cSrcweir case KEY_BACKSPACE | KEY_SHIFT: 1891cdf0e10cSrcweir if( !rSh.HasReadonlySel() ) 1892cdf0e10cSrcweir { 1893cdf0e10cSrcweir // #i23725# 1894cdf0e10cSrcweir sal_Bool bDone = sal_False; 1895cdf0e10cSrcweir // --> OD 2006-01-31 - try to add comment for code snip: 1896cdf0e10cSrcweir // Remove the paragraph indent, if the cursor is at the 1897cdf0e10cSrcweir // beginning of a paragraph, there is no selection 1898cdf0e10cSrcweir // and no numbering rule found at the current paragraph 1899cdf0e10cSrcweir // --> OD 2006-01-31 #b6341339#, #i58776# 1900cdf0e10cSrcweir // Also try to remove indent, if current paragraph 1901cdf0e10cSrcweir // has numbering rule, but isn't counted and only 1902cdf0e10cSrcweir // key <backspace> is hit. 1903cdf0e10cSrcweir const bool bOnlyBackspaceKey( 1904cdf0e10cSrcweir KEY_BACKSPACE == rKeyCode.GetFullCode() ); 1905cdf0e10cSrcweir if ( rSh.IsSttPara() && 1906cdf0e10cSrcweir !rSh.HasSelection() && // i40834 1907cdf0e10cSrcweir ( NULL == rSh.GetCurNumRule() || 1908cdf0e10cSrcweir ( rSh.IsNoNum() && bOnlyBackspaceKey ) ) ) 1909cdf0e10cSrcweir { 1910cdf0e10cSrcweir bDone = rSh.TryRemoveIndent(); 1911cdf0e10cSrcweir } 1912cdf0e10cSrcweir // <-- 1913cdf0e10cSrcweir 1914cdf0e10cSrcweir // -> #i23725# 1915cdf0e10cSrcweir if (bDone) 1916cdf0e10cSrcweir eKeyState = KS_Ende; 1917cdf0e10cSrcweir else 1918cdf0e10cSrcweir { 1919cdf0e10cSrcweir if (rSh.IsSttPara() && 1920cdf0e10cSrcweir ! rSh.IsNoNum()) 1921cdf0e10cSrcweir { 1922cdf0e10cSrcweir if (nKS_NUMDOWN_Count > 0 && 1923cdf0e10cSrcweir 0 < rSh.GetNumLevel()) 1924cdf0e10cSrcweir { 1925cdf0e10cSrcweir eKeyState = KS_NumUp; 1926cdf0e10cSrcweir nKS_NUMDOWN_Count = 2; 1927cdf0e10cSrcweir bDone = sal_True; 1928cdf0e10cSrcweir } 1929cdf0e10cSrcweir else if (nKS_NUMINDENTINC_Count > 0) 1930cdf0e10cSrcweir { 1931cdf0e10cSrcweir eKeyState = KS_NumIndentDec; 1932cdf0e10cSrcweir nKS_NUMINDENTINC_Count = 2; 1933cdf0e10cSrcweir bDone = sal_True; 1934cdf0e10cSrcweir } 1935cdf0e10cSrcweir } 1936cdf0e10cSrcweir // <- #i23725# 1937cdf0e10cSrcweir // --> OD 2006-01-31 #b6341339#, #i58776# 1938cdf0e10cSrcweir // --> OD 2006-04-21 #i63540# 1939cdf0e10cSrcweir // revise fix for issues b6341339 and i58776: 1940cdf0e10cSrcweir // If the cursor is in an empty paragraph, which has 1941cdf0e10cSrcweir // a numbering, but not the oultine numbering, and 1942cdf0e10cSrcweir // there is no selection, the numbering has to be 1943cdf0e10cSrcweir // deleted on key <Backspace>. 1944cdf0e10cSrcweir // Otherwise method <SwEditShell::NumOrNoNum(..)> 1945cdf0e10cSrcweir // should only change the <IsCounted()> state of 1946cdf0e10cSrcweir // the current paragraph depending of the key. 1947cdf0e10cSrcweir // On <backspace> it is set to <false>, 1948cdf0e10cSrcweir // on <shift-backspace> it is set to <true>. 1949cdf0e10cSrcweir // Thus, assure that method <SwEditShell::NumOrNum(..)> 1950cdf0e10cSrcweir // is only called for the intended purpose. 1951cdf0e10cSrcweir bool bCallNumOrNoNum( false ); 1952cdf0e10cSrcweir { 1953cdf0e10cSrcweir if ( !bDone ) 1954cdf0e10cSrcweir { 1955cdf0e10cSrcweir if ( bOnlyBackspaceKey && !rSh.IsNoNum() ) 1956cdf0e10cSrcweir { 1957cdf0e10cSrcweir bCallNumOrNoNum = true; 1958cdf0e10cSrcweir } 1959cdf0e10cSrcweir else if ( !bOnlyBackspaceKey && rSh.IsNoNum() ) 1960cdf0e10cSrcweir { 1961cdf0e10cSrcweir bCallNumOrNoNum = true; 1962cdf0e10cSrcweir } 1963cdf0e10cSrcweir else if ( bOnlyBackspaceKey && 1964cdf0e10cSrcweir rSh.IsSttPara() && rSh.IsEndPara() && 1965cdf0e10cSrcweir !rSh.HasSelection() ) 1966cdf0e10cSrcweir { 1967cdf0e10cSrcweir const SwNumRule* pCurrNumRule( rSh.GetCurNumRule() ); 1968cdf0e10cSrcweir if ( pCurrNumRule && 1969cdf0e10cSrcweir pCurrNumRule != rSh.GetOutlineNumRule() ) 1970cdf0e10cSrcweir { 1971cdf0e10cSrcweir bCallNumOrNoNum = true; 1972cdf0e10cSrcweir } 1973cdf0e10cSrcweir } 1974cdf0e10cSrcweir } 1975cdf0e10cSrcweir } 1976cdf0e10cSrcweir if ( bCallNumOrNoNum && 1977cdf0e10cSrcweir rSh.NumOrNoNum( !bOnlyBackspaceKey, sal_True ) ) 1978cdf0e10cSrcweir { 1979cdf0e10cSrcweir eKeyState = KS_NumOrNoNum; 1980cdf0e10cSrcweir } 1981cdf0e10cSrcweir // <-- 1982cdf0e10cSrcweir } 1983cdf0e10cSrcweir } 1984cdf0e10cSrcweir break; 1985cdf0e10cSrcweir 1986cdf0e10cSrcweir case KEY_RIGHT: 1987cdf0e10cSrcweir { 1988cdf0e10cSrcweir eFlyState = KS_Fly_Change; 1989cdf0e10cSrcweir nDir = MOVE_RIGHT_BIG; 1990cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_COL_RIGHT; 1991cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert(); 1992cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL; 1993cdf0e10cSrcweir } 1994cdf0e10cSrcweir case KEY_TAB: 1995cdf0e10cSrcweir { 1996cdf0e10cSrcweir 1997cdf0e10cSrcweir #ifdef SW_CRSR_TIMER 1998cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False ); 1999cdf0e10cSrcweir #endif 2000cdf0e10cSrcweir if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark() || rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT) 2001cdf0e10cSrcweir { 2002cdf0e10cSrcweir eKeyState=KS_GotoNextFieldMark; 2003cdf0e10cSrcweir } 2004cdf0e10cSrcweir else 2005cdf0e10cSrcweir if( rSh.GetCurNumRule() && rSh.IsSttOfPara() && 2006cdf0e10cSrcweir !rSh.HasReadonlySel() ) 2007cdf0e10cSrcweir { 2008cdf0e10cSrcweir // --> OD 2007-10-02 #b660435# 2009cdf0e10cSrcweir // if (rSh.IsFirstOfNumRule()) // #i23725# 2010cdf0e10cSrcweir if ( rSh.IsFirstOfNumRule() && 2011cdf0e10cSrcweir numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() ) 2012cdf0e10cSrcweir // <-- 2013cdf0e10cSrcweir eKeyState = KS_NumIndentInc; 2014cdf0e10cSrcweir else 2015cdf0e10cSrcweir eKeyState = KS_NumDown; 2016cdf0e10cSrcweir } 2017cdf0e10cSrcweir else if ( rSh.GetTableFmt() ) 2018cdf0e10cSrcweir { 2019cdf0e10cSrcweir if( rSh.HasSelection() || rSh.HasReadonlySel() ) 2020cdf0e10cSrcweir eKeyState = KS_NextCell; 2021cdf0e10cSrcweir else 2022cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_NextCell; 2023cdf0e10cSrcweir } 2024cdf0e10cSrcweir else if ( rSh.GetSelectionType() & 2025cdf0e10cSrcweir (nsSelectionType::SEL_GRF | 2026cdf0e10cSrcweir nsSelectionType::SEL_FRM | 2027cdf0e10cSrcweir nsSelectionType::SEL_OLE | 2028cdf0e10cSrcweir nsSelectionType::SEL_DRW | 2029cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM)) 2030cdf0e10cSrcweir 2031cdf0e10cSrcweir eKeyState = KS_NextObject; 2032cdf0e10cSrcweir else 2033cdf0e10cSrcweir { 2034cdf0e10cSrcweir eKeyState = KS_InsTab; 2035cdf0e10cSrcweir if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() ) 2036cdf0e10cSrcweir { 2037cdf0e10cSrcweir SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl(); 2038cdf0e10cSrcweir if( pColl && 2039cdf0e10cSrcweir //0 <= pColl->GetOutlineLevel() && #i24560# 2040cdf0e10cSrcweir //MAXLEVEL - 1 > pColl->GetOutlineLevel() )//#outline level,zhaojianwei 2041cdf0e10cSrcweir pColl->IsAssignedToListLevelOfOutlineStyle() 2042cdf0e10cSrcweir && MAXLEVEL-1 > pColl->GetAssignedOutlineStyleLevel() )//<-end,zhaojianwei 2043cdf0e10cSrcweir eKeyState = KS_OutlineDown; 2044cdf0e10cSrcweir } 2045cdf0e10cSrcweir } 2046cdf0e10cSrcweir #ifdef SW_CRSR_TIMER 2047cdf0e10cSrcweir rSh.ChgCrsrTimerFlag( bOld ); 2048cdf0e10cSrcweir #endif 2049cdf0e10cSrcweir } 2050cdf0e10cSrcweir break; 2051cdf0e10cSrcweir case KEY_TAB | KEY_SHIFT: 2052cdf0e10cSrcweir { 2053cdf0e10cSrcweir #ifdef SW_CRSR_TIMER 2054cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False ); 2055cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False ); 2056cdf0e10cSrcweir #endif 2057cdf0e10cSrcweir if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark()|| rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT) { 2058cdf0e10cSrcweir eKeyState=KS_GotoPrevFieldMark; 2059cdf0e10cSrcweir } 2060cdf0e10cSrcweir else if( rSh.GetCurNumRule() && rSh.IsSttOfPara() && 2061cdf0e10cSrcweir !rSh.HasReadonlySel() ) 2062cdf0e10cSrcweir { 2063cdf0e10cSrcweir // --> OD 2007-10-02 #b660435# 2064cdf0e10cSrcweir // if (rSh.IsFirstOfNumRule()) // #i23725# 2065cdf0e10cSrcweir if ( rSh.IsFirstOfNumRule() && 2066cdf0e10cSrcweir numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() ) 2067cdf0e10cSrcweir // <-- 2068cdf0e10cSrcweir eKeyState = KS_NumIndentDec; 2069cdf0e10cSrcweir else 2070cdf0e10cSrcweir eKeyState = KS_NumUp; 2071cdf0e10cSrcweir } 2072cdf0e10cSrcweir else if ( rSh.GetTableFmt() ) 2073cdf0e10cSrcweir { 2074cdf0e10cSrcweir if( rSh.HasSelection() || rSh.HasReadonlySel() ) 2075cdf0e10cSrcweir eKeyState = KS_PrevCell; 2076cdf0e10cSrcweir else 2077cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_PrevCell; 2078cdf0e10cSrcweir } 2079cdf0e10cSrcweir else if ( rSh.GetSelectionType() & 2080cdf0e10cSrcweir (nsSelectionType::SEL_GRF | 2081cdf0e10cSrcweir nsSelectionType::SEL_FRM | 2082cdf0e10cSrcweir nsSelectionType::SEL_OLE | 2083cdf0e10cSrcweir nsSelectionType::SEL_DRW | 2084cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM)) 2085cdf0e10cSrcweir 2086cdf0e10cSrcweir eKeyState = KS_PrevObject; 2087cdf0e10cSrcweir else 2088cdf0e10cSrcweir { 2089cdf0e10cSrcweir eKeyState = KS_Ende; 2090cdf0e10cSrcweir if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() ) 2091cdf0e10cSrcweir { 2092cdf0e10cSrcweir SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl(); 2093cdf0e10cSrcweir //if( pColl && 0 < pColl->GetOutlineLevel() && //#outline level,zhaojianwei 2094cdf0e10cSrcweir // MAXLEVEL - 1 >= pColl->GetOutlineLevel() ) 2095cdf0e10cSrcweir if( pColl && 2096cdf0e10cSrcweir pColl->IsAssignedToListLevelOfOutlineStyle() && 2097cdf0e10cSrcweir 0 < pColl->GetAssignedOutlineStyleLevel()) 2098cdf0e10cSrcweir eKeyState = KS_OutlineUp; 2099cdf0e10cSrcweir } 2100cdf0e10cSrcweir } 2101cdf0e10cSrcweir #ifdef SW_CRSR_TIMER 2102cdf0e10cSrcweir rSh.ChgCrsrTimerFlag( bOld ); 2103cdf0e10cSrcweir #endif 2104cdf0e10cSrcweir } 2105cdf0e10cSrcweir break; 2106cdf0e10cSrcweir case KEY_TAB | KEY_MOD1: 2107cdf0e10cSrcweir case KEY_TAB | KEY_MOD2: 2108cdf0e10cSrcweir if( !rSh.HasReadonlySel() ) 2109cdf0e10cSrcweir { 2110cdf0e10cSrcweir if( aTmpQHD.HasCntnt() && !rSh.HasSelection() ) 2111cdf0e10cSrcweir { 2112cdf0e10cSrcweir // zum naechsten Tip 2113cdf0e10cSrcweir aTmpQHD.Inc( pACorr && pACorr->GetSwFlags(). 2114cdf0e10cSrcweir bAutoCmpltEndless ); 2115cdf0e10cSrcweir eKeyState = KS_NextPrevGlossary; 2116cdf0e10cSrcweir } 2117cdf0e10cSrcweir else if( rSh.GetTableFmt() ) 2118cdf0e10cSrcweir eKeyState = KS_InsTab; 2119cdf0e10cSrcweir else if((rSh.GetSelectionType() & 2120cdf0e10cSrcweir (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM| 2121cdf0e10cSrcweir nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) && 2122cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked()) 2123cdf0e10cSrcweir eKeyState = KS_EnterDrawHandleMode; 2124cdf0e10cSrcweir else 2125cdf0e10cSrcweir { 2126cdf0e10cSrcweir eKeyState = KS_InsTab; 2127cdf0e10cSrcweir } 2128cdf0e10cSrcweir } 2129cdf0e10cSrcweir break; 2130cdf0e10cSrcweir 2131cdf0e10cSrcweir case KEY_TAB | KEY_MOD1 | KEY_SHIFT: 2132cdf0e10cSrcweir if( aTmpQHD.HasCntnt() && !rSh.HasSelection() && 2133cdf0e10cSrcweir !rSh.HasReadonlySel() ) 2134cdf0e10cSrcweir { 2135cdf0e10cSrcweir // zum vorherigen Tip 2136cdf0e10cSrcweir aTmpQHD.Dec( pACorr && pACorr->GetSwFlags(). 2137cdf0e10cSrcweir bAutoCmpltEndless ); 2138cdf0e10cSrcweir eKeyState = KS_NextPrevGlossary; 2139cdf0e10cSrcweir } 2140cdf0e10cSrcweir else if((rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM| 2141cdf0e10cSrcweir nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) && 2142cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked()) 2143cdf0e10cSrcweir eKeyState = KS_EnterDrawHandleMode; 2144cdf0e10cSrcweir break; 2145cdf0e10cSrcweir case KEY_F2 : 2146cdf0e10cSrcweir if( !rSh.HasReadonlySel() ) 2147cdf0e10cSrcweir { 2148cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType(); 2149cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_FRM) 2150cdf0e10cSrcweir eKeyState = KS_GoIntoFly; 2151cdf0e10cSrcweir else if((nSelectionType & nsSelectionType::SEL_DRW)) 2152cdf0e10cSrcweir eKeyState = KS_GoIntoDrawing; 2153cdf0e10cSrcweir } 2154cdf0e10cSrcweir break; 2155cdf0e10cSrcweir } 2156cdf0e10cSrcweir } 2157cdf0e10cSrcweir break; 2158cdf0e10cSrcweir case KS_CheckDocReadOnlyKeys: 2159cdf0e10cSrcweir { 2160cdf0e10cSrcweir eKeyState = KS_KeyToView; 2161cdf0e10cSrcweir switch( rKeyCode.GetModifier() | rKeyCode.GetCode() ) 2162cdf0e10cSrcweir { 2163cdf0e10cSrcweir case KEY_TAB: 2164cdf0e10cSrcweir case KEY_TAB | KEY_SHIFT: 2165cdf0e10cSrcweir bNormalChar = sal_False; 2166cdf0e10cSrcweir eKeyState = KS_Ende; 2167cdf0e10cSrcweir if ( rSh.GetSelectionType() & 2168cdf0e10cSrcweir (nsSelectionType::SEL_GRF | 2169cdf0e10cSrcweir nsSelectionType::SEL_FRM | 2170cdf0e10cSrcweir nsSelectionType::SEL_OLE | 2171cdf0e10cSrcweir nsSelectionType::SEL_DRW | 2172cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM)) 2173cdf0e10cSrcweir 2174cdf0e10cSrcweir { 2175cdf0e10cSrcweir eKeyState = rKeyCode.GetModifier() & KEY_SHIFT ? 2176cdf0e10cSrcweir KS_PrevObject : KS_NextObject; 2177cdf0e10cSrcweir } 2178cdf0e10cSrcweir else 2179cdf0e10cSrcweir rSh.SelectNextPrevHyperlink( 2180cdf0e10cSrcweir KEY_SHIFT != rKeyCode.GetModifier() ); 2181cdf0e10cSrcweir break; 2182cdf0e10cSrcweir case KEY_RETURN: 2183cdf0e10cSrcweir { 2184cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType(); 2185cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_FRM) 2186cdf0e10cSrcweir eKeyState = KS_GoIntoFly; 2187cdf0e10cSrcweir else 2188cdf0e10cSrcweir { 2189cdf0e10cSrcweir SfxItemSet aSet(rSh.GetAttrPool(), RES_TXTATR_INETFMT, RES_TXTATR_INETFMT); 2190cdf0e10cSrcweir rSh.GetCurAttr(aSet); 2191cdf0e10cSrcweir if(SFX_ITEM_SET == aSet.GetItemState(RES_TXTATR_INETFMT, sal_False)) 2192cdf0e10cSrcweir { 2193cdf0e10cSrcweir const SfxPoolItem& rItem = aSet.Get(RES_TXTATR_INETFMT, sal_True); 2194cdf0e10cSrcweir bNormalChar = sal_False; 2195cdf0e10cSrcweir eKeyState = KS_Ende; 2196cdf0e10cSrcweir rSh.ClickToINetAttr((const SwFmtINetFmt&)rItem, URLLOAD_NOFILTER); 2197cdf0e10cSrcweir } 2198cdf0e10cSrcweir } 2199cdf0e10cSrcweir } 2200cdf0e10cSrcweir break; 2201cdf0e10cSrcweir } 2202cdf0e10cSrcweir } 2203cdf0e10cSrcweir break; 2204cdf0e10cSrcweir 2205cdf0e10cSrcweir case KS_EnterCharCell: 2206cdf0e10cSrcweir { 2207cdf0e10cSrcweir eKeyState = KS_KeyToView; 2208cdf0e10cSrcweir switch ( rKeyCode.GetModifier() | rKeyCode.GetCode() ) 2209cdf0e10cSrcweir { 2210cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2: 2211cdf0e10cSrcweir rSh.Right( CRSR_SKIP_CHARS, sal_False, 1, sal_False ); 2212cdf0e10cSrcweir eKeyState = KS_Ende; 2213cdf0e10cSrcweir FlushInBuffer(); 2214cdf0e10cSrcweir break; 2215cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2: 2216cdf0e10cSrcweir rSh.Left( CRSR_SKIP_CHARS, sal_False, 1, sal_False ); 2217cdf0e10cSrcweir eKeyState = KS_Ende; 2218cdf0e10cSrcweir FlushInBuffer(); 2219cdf0e10cSrcweir break; 2220cdf0e10cSrcweir } 2221cdf0e10cSrcweir } 2222cdf0e10cSrcweir break; 2223cdf0e10cSrcweir 2224cdf0e10cSrcweir case KS_KeyToView: 2225cdf0e10cSrcweir { 2226cdf0e10cSrcweir eKeyState = KS_Ende; 2227cdf0e10cSrcweir bNormalChar = 2228cdf0e10cSrcweir !rKeyCode.IsMod2() && 2229cdf0e10cSrcweir rKeyCode.GetModifier() != (KEY_MOD1) && 2230cdf0e10cSrcweir rKeyCode.GetModifier() != (KEY_MOD1|KEY_SHIFT) && 2231cdf0e10cSrcweir SW_ISPRINTABLE( aCh ); 2232cdf0e10cSrcweir 2233cdf0e10cSrcweir if (bNormalChar && rSh.IsInFrontOfLabel()) 2234cdf0e10cSrcweir { 2235cdf0e10cSrcweir rSh.NumOrNoNum(sal_False); 2236cdf0e10cSrcweir } 2237cdf0e10cSrcweir 2238cdf0e10cSrcweir if( aInBuffer.Len() && ( !bNormalChar || bIsDocReadOnly )) 2239cdf0e10cSrcweir FlushInBuffer(); 2240cdf0e10cSrcweir 2241cdf0e10cSrcweir if( rView.KeyInput( aKeyEvent ) ) 2242cdf0e10cSrcweir bFlushBuffer = sal_True, bNormalChar = sal_False; 2243cdf0e10cSrcweir else 2244cdf0e10cSrcweir { 2245cdf0e10cSrcweir // OS 22.09.95: Da der Sfx Acceleratoren nur aufruft, wenn sie beim letzten 2246cdf0e10cSrcweir // Statusupdate enabled wurden, muss copy ggf. von uns 2247cdf0e10cSrcweir // 'gewaltsam' gerufen werden. 2248cdf0e10cSrcweir if( rKeyCode.GetFunction() == KEYFUNC_COPY ) 2249cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute(SID_COPY); 2250cdf0e10cSrcweir 2251cdf0e10cSrcweir 2252cdf0e10cSrcweir if( !bIsDocReadOnly && bNormalChar ) 2253cdf0e10cSrcweir { 2254cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType(); 2255cdf0e10cSrcweir if((nSelectionType & nsSelectionType::SEL_DRW) && 2256cdf0e10cSrcweir 0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) && 2257cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1) 2258cdf0e10cSrcweir { 2259cdf0e10cSrcweir SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(); 2260cdf0e10cSrcweir if(pObj) 2261cdf0e10cSrcweir { 2262cdf0e10cSrcweir EnterDrawTextMode(pObj->GetLogicRect().Center()); 2263cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) ) 2264cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init(); 2265cdf0e10cSrcweir rSh.GetDrawView()->KeyInput( rKEvt, this ); 2266cdf0e10cSrcweir } 2267cdf0e10cSrcweir } 2268cdf0e10cSrcweir else if(nSelectionType & nsSelectionType::SEL_FRM) 2269cdf0e10cSrcweir { 2270cdf0e10cSrcweir rSh.UnSelectFrm(); 2271cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 2272cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 2273cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd ); 2274cdf0e10cSrcweir } 2275cdf0e10cSrcweir eKeyState = KS_InsChar; 2276cdf0e10cSrcweir } 2277cdf0e10cSrcweir else 2278cdf0e10cSrcweir { 2279cdf0e10cSrcweir bNormalChar = sal_False; 2280cdf0e10cSrcweir Window::KeyInput( aKeyEvent ); 2281cdf0e10cSrcweir } 2282cdf0e10cSrcweir } 2283cdf0e10cSrcweir } 2284cdf0e10cSrcweir break; 2285cdf0e10cSrcweir case KS_LaunchOLEObject: 2286cdf0e10cSrcweir rSh.LaunchOLEObj(); 2287cdf0e10cSrcweir eKeyState = KS_Ende; 2288cdf0e10cSrcweir break; 2289cdf0e10cSrcweir case KS_GoIntoFly : 2290cdf0e10cSrcweir rSh.UnSelectFrm(); 2291cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 2292cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 2293cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd ); 2294cdf0e10cSrcweir eKeyState = KS_Ende; 2295cdf0e10cSrcweir break; 2296cdf0e10cSrcweir case KS_GoIntoDrawing : 2297cdf0e10cSrcweir { 2298cdf0e10cSrcweir SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(); 2299cdf0e10cSrcweir if(pObj) 2300cdf0e10cSrcweir { 2301cdf0e10cSrcweir EnterDrawTextMode(pObj->GetLogicRect().Center()); 2302cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) ) 2303cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init(); 2304cdf0e10cSrcweir } 2305cdf0e10cSrcweir eKeyState = KS_Ende; 2306cdf0e10cSrcweir } 2307cdf0e10cSrcweir break; 2308cdf0e10cSrcweir case KS_EnterDrawHandleMode: 2309cdf0e10cSrcweir { 2310cdf0e10cSrcweir const SdrHdlList& rHdlList = rSh.GetDrawView()->GetHdlList(); 2311cdf0e10cSrcweir sal_Bool bForward(!aKeyEvent.GetKeyCode().IsShift()); 2312cdf0e10cSrcweir 2313cdf0e10cSrcweir ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward); 2314cdf0e10cSrcweir eKeyState = KS_Ende; 2315cdf0e10cSrcweir } 2316cdf0e10cSrcweir break; 2317cdf0e10cSrcweir case KS_InsTab: 2318cdf0e10cSrcweir if( rView.ISA( SwWebView )) //Kein Tabulator fuer Web! 2319cdf0e10cSrcweir { 2320cdf0e10cSrcweir // Bug 56196 - dann sollte der weiter gereicht werden. 2321cdf0e10cSrcweir Window::KeyInput( aKeyEvent ); 2322cdf0e10cSrcweir eKeyState = KS_Ende; 2323cdf0e10cSrcweir break; 2324cdf0e10cSrcweir } 2325cdf0e10cSrcweir aCh = '\t'; 2326cdf0e10cSrcweir // kein break! 2327cdf0e10cSrcweir case KS_InsChar: 2328cdf0e10cSrcweir if (rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT) 2329cdf0e10cSrcweir { 2330cdf0e10cSrcweir ::sw::mark::ICheckboxFieldmark* pFieldmark = 2331cdf0e10cSrcweir dynamic_cast< ::sw::mark::ICheckboxFieldmark* > 2332cdf0e10cSrcweir (rSh.GetCurrentFieldmark()); 2333cdf0e10cSrcweir OSL_ENSURE(pFieldmark, 2334cdf0e10cSrcweir "Where is my FieldMark??"); 2335cdf0e10cSrcweir if(pFieldmark) 2336cdf0e10cSrcweir { 2337cdf0e10cSrcweir pFieldmark->SetChecked(!pFieldmark->IsChecked()); 2338cdf0e10cSrcweir SwDocShell* pDocSh = rView.GetDocShell(); 2339cdf0e10cSrcweir SwDoc *pDoc=pDocSh->GetDoc(); 2340cdf0e10cSrcweir OSL_ENSURE(pFieldmark->IsExpanded(), 2341cdf0e10cSrcweir "where is the otherpos?"); 2342cdf0e10cSrcweir if (pFieldmark->IsExpanded()) 2343cdf0e10cSrcweir { 2344cdf0e10cSrcweir SwPaM aPaM(pFieldmark->GetMarkPos(), pFieldmark->GetOtherMarkPos()); 2345cdf0e10cSrcweir if(0) 2346cdf0e10cSrcweir { 2347cdf0e10cSrcweir rSh.StartAllAction(); //$flr TODO: understand why this not works 2348cdf0e10cSrcweir pDoc->SetModified(aPaM); 2349cdf0e10cSrcweir rSh.EndAllAction(); 2350cdf0e10cSrcweir } 2351cdf0e10cSrcweir else 2352cdf0e10cSrcweir { 2353cdf0e10cSrcweir rSh.CalcLayout(); // workaround 2354cdf0e10cSrcweir } 2355cdf0e10cSrcweir } 2356cdf0e10cSrcweir } 2357cdf0e10cSrcweir eKeyState = KS_Ende; 2358cdf0e10cSrcweir } 2359cdf0e10cSrcweir else if(!rSh.HasReadonlySel()) 2360cdf0e10cSrcweir { 2361cdf0e10cSrcweir sal_Bool bIsNormalChar = GetAppCharClass().isLetterNumeric( 2362cdf0e10cSrcweir String( aCh ), 0 ); 2363cdf0e10cSrcweir if( bChkInsBlank && bIsNormalChar && 2364cdf0e10cSrcweir (aInBuffer.Len() || !rSh.IsSttPara() || !rSh.IsEndPara() )) 2365cdf0e10cSrcweir { 2366cdf0e10cSrcweir // vor dem Zeichen noch ein Blank einfuegen. Dieses 2367cdf0e10cSrcweir // kommt zwischen den Expandierten Text und dem neuen 2368cdf0e10cSrcweir // "nicht Worttrenner". 2369cdf0e10cSrcweir aInBuffer.Expand( aInBuffer.Len() + 1, ' ' ); 2370cdf0e10cSrcweir } 2371cdf0e10cSrcweir 2372cdf0e10cSrcweir 2373cdf0e10cSrcweir sal_Bool bIsAutoCorrectChar = SvxAutoCorrect::IsAutoCorrectChar( aCh ); 2374cdf0e10cSrcweir sal_Bool bRunNext = pACorr && pACorr->HasRunNext(); 2375cdf0e10cSrcweir if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) && 2376cdf0e10cSrcweir pACfg->IsAutoFmtByInput() && 2377cdf0e10cSrcweir (( pACorr->IsAutoCorrFlag( ChgWeightUnderl ) && 2378cdf0e10cSrcweir ( '*' == aCh || '_' == aCh ) ) || 2379cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))|| 2380cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh)))) 2381cdf0e10cSrcweir { 2382cdf0e10cSrcweir FlushInBuffer(); 2383cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh ); 2384cdf0e10cSrcweir if( '\"' != aCh && '\'' != aCh ) // nur bei "*_" rufen! 2385cdf0e10cSrcweir rSh.UpdateAttr(); 2386cdf0e10cSrcweir } 2387cdf0e10cSrcweir else if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) && 2388cdf0e10cSrcweir pACfg->IsAutoFmtByInput() && 2389cdf0e10cSrcweir pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd | 2390cdf0e10cSrcweir ChgOrdinalNumber | AddNonBrkSpace | 2391cdf0e10cSrcweir ChgToEnEmDash | SetINetAttr | 2392cdf0e10cSrcweir Autocorrect ) && 2393cdf0e10cSrcweir '\"' != aCh && '\'' != aCh && '*' != aCh && '_' != aCh 2394cdf0e10cSrcweir ) 2395cdf0e10cSrcweir { 2396cdf0e10cSrcweir FlushInBuffer(); 2397cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh ); 2398cdf0e10cSrcweir } 2399cdf0e10cSrcweir else 2400cdf0e10cSrcweir { 2401cdf0e10cSrcweir aInBuffer.Expand( aInBuffer.Len() + aKeyEvent.GetRepeat() + 1,aCh ); 2402cdf0e10cSrcweir bFlushCharBuffer = Application::AnyInput( INPUT_KEYBOARD ); 2403cdf0e10cSrcweir bFlushBuffer = !bFlushCharBuffer; 2404cdf0e10cSrcweir if( bFlushCharBuffer ) 2405cdf0e10cSrcweir aKeyInputFlushTimer.Start(); 2406cdf0e10cSrcweir } 2407cdf0e10cSrcweir eKeyState = KS_Ende; 2408cdf0e10cSrcweir } 2409cdf0e10cSrcweir else 2410cdf0e10cSrcweir { 2411cdf0e10cSrcweir InfoBox( this, SW_RES( MSG_READONLY_CONTENT )).Execute(); 2412cdf0e10cSrcweir // ??? Window::KeyInput( aKeyEvent ); 2413cdf0e10cSrcweir eKeyState = KS_Ende; 2414cdf0e10cSrcweir } 2415cdf0e10cSrcweir break; 2416cdf0e10cSrcweir 2417cdf0e10cSrcweir case KS_CheckAutoCorrect: 2418cdf0e10cSrcweir { 2419cdf0e10cSrcweir if( pACorr && pACfg->IsAutoFmtByInput() && 2420cdf0e10cSrcweir pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd | 2421cdf0e10cSrcweir ChgOrdinalNumber | 2422cdf0e10cSrcweir ChgToEnEmDash | SetINetAttr | 2423cdf0e10cSrcweir Autocorrect ) && 2424cdf0e10cSrcweir !rSh.HasReadonlySel() ) 2425cdf0e10cSrcweir /* { 2426cdf0e10cSrcweir pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd | 2427cdf0e10cSrcweir ChgFractionSymbol | ChgOrdinalNumber | 2428cdf0e10cSrcweir ChgToEnEmDash | SetINetAttr | 2429cdf0e10cSrcweir Autocorrect ) && 2430cdf0e10cSrcweir !rSh.HasReadonlySel() ) */ 2431cdf0e10cSrcweir { 2432cdf0e10cSrcweir FlushInBuffer(); 2433cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, static_cast< sal_Unicode >('\0') ); 2434cdf0e10cSrcweir } 2435cdf0e10cSrcweir eKeyState = eNextKeyState; 2436cdf0e10cSrcweir } 2437cdf0e10cSrcweir break; 2438cdf0e10cSrcweir 2439cdf0e10cSrcweir default: 2440cdf0e10cSrcweir { 2441cdf0e10cSrcweir sal_uInt16 nSlotId = 0; 2442cdf0e10cSrcweir FlushInBuffer(); 2443cdf0e10cSrcweir //??? if( bFlushCharBuffer ) 2444cdf0e10cSrcweir //??? FlushInBuffer( &rSh ); 2445cdf0e10cSrcweir switch( eKeyState ) 2446cdf0e10cSrcweir { 2447cdf0e10cSrcweir case KS_SpecialInsert: 2448cdf0e10cSrcweir rSh.DoSpecialInsert(); 2449cdf0e10cSrcweir break; 2450cdf0e10cSrcweir 2451cdf0e10cSrcweir case KS_NoNum: 2452cdf0e10cSrcweir rSh.NoNum(); 2453cdf0e10cSrcweir break; 2454cdf0e10cSrcweir 2455cdf0e10cSrcweir case KS_NumOff: 2456cdf0e10cSrcweir // Shellwechsel - also vorher aufzeichnen 2457cdf0e10cSrcweir rSh.DelNumRules(); 2458cdf0e10cSrcweir eKeyState = eNextKeyState; 2459cdf0e10cSrcweir break; 2460cdf0e10cSrcweir case KS_OutlineLvOff: // delete autofmt outlinelevel later 2461cdf0e10cSrcweir break; 2462cdf0e10cSrcweir 2463cdf0e10cSrcweir case KS_NumDown: 2464cdf0e10cSrcweir rSh.NumUpDown( sal_True ); 2465cdf0e10cSrcweir nKS_NUMDOWN_Count = 2; // #i23725# 2466cdf0e10cSrcweir break; 2467cdf0e10cSrcweir case KS_NumUp: 2468cdf0e10cSrcweir rSh.NumUpDown( sal_False ); 2469cdf0e10cSrcweir break; 2470cdf0e10cSrcweir 2471cdf0e10cSrcweir // -> #i23726# 2472cdf0e10cSrcweir case KS_NumIndentInc: 2473cdf0e10cSrcweir // --> OD 2008-06-16 #i90078# 2474cdf0e10cSrcweir rSh.ChangeIndentOfAllListLevels(360); 2475cdf0e10cSrcweir // <-- 2476cdf0e10cSrcweir nKS_NUMINDENTINC_Count = 2; 2477cdf0e10cSrcweir break; 2478cdf0e10cSrcweir 2479cdf0e10cSrcweir case KS_GotoNextFieldMark: 2480cdf0e10cSrcweir { 2481cdf0e10cSrcweir ::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkAfter(); 2482cdf0e10cSrcweir if(pFieldmark) rSh.GotoFieldmark(pFieldmark); 2483cdf0e10cSrcweir } 2484cdf0e10cSrcweir break; 2485cdf0e10cSrcweir 2486cdf0e10cSrcweir case KS_GotoPrevFieldMark: 2487cdf0e10cSrcweir { 2488cdf0e10cSrcweir ::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkBefore(); 2489cdf0e10cSrcweir if(pFieldmark) rSh.GotoFieldmark(pFieldmark); 2490cdf0e10cSrcweir } 2491cdf0e10cSrcweir break; 2492cdf0e10cSrcweir 2493cdf0e10cSrcweir case KS_NumIndentDec: 2494cdf0e10cSrcweir // --> OD 2008-06-16 #i90078# 2495cdf0e10cSrcweir rSh.ChangeIndentOfAllListLevels(-360); 2496cdf0e10cSrcweir // <-- 2497cdf0e10cSrcweir break; 2498cdf0e10cSrcweir // <- #i23726# 2499cdf0e10cSrcweir 2500cdf0e10cSrcweir case KS_OutlineDown: 2501cdf0e10cSrcweir rSh.OutlineUpDown( 1 ); 2502cdf0e10cSrcweir break; 2503cdf0e10cSrcweir case KS_OutlineUp: 2504cdf0e10cSrcweir rSh.OutlineUpDown( -1 ); 2505cdf0e10cSrcweir break; 2506cdf0e10cSrcweir 2507cdf0e10cSrcweir case KS_NextCell: 2508cdf0e10cSrcweir //In Tabelle immer 'flushen' 2509cdf0e10cSrcweir rSh.GoNextCell(); 2510cdf0e10cSrcweir nSlotId = FN_GOTO_NEXT_CELL; 2511cdf0e10cSrcweir break; 2512cdf0e10cSrcweir case KS_PrevCell: 2513cdf0e10cSrcweir rSh.GoPrevCell(); 2514cdf0e10cSrcweir nSlotId = FN_GOTO_PREV_CELL; 2515cdf0e10cSrcweir break; 2516cdf0e10cSrcweir case KS_AutoFmtByInput: 2517cdf0e10cSrcweir rSh.SplitNode( sal_True ); 2518cdf0e10cSrcweir break; 2519cdf0e10cSrcweir 2520cdf0e10cSrcweir // case KS_NumOrNoNum: 2521cdf0e10cSrcweir // break; 2522cdf0e10cSrcweir case KS_NextObject: 2523cdf0e10cSrcweir case KS_PrevObject: 2524cdf0e10cSrcweir if(rSh.GotoObj( KS_NextObject == eKeyState, GOTOOBJ_GOTO_ANY)) 2525cdf0e10cSrcweir { 2526cdf0e10cSrcweir if( rSh.IsFrmSelected() && 2527cdf0e10cSrcweir rView.GetDrawFuncPtr() ) 2528cdf0e10cSrcweir { 2529cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 2530cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 2531cdf0e10cSrcweir rView.LeaveDrawCreate(); 2532cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 2533cdf0e10cSrcweir } 2534cdf0e10cSrcweir rSh.HideCrsr(); 2535cdf0e10cSrcweir rSh.EnterSelFrmMode(); 2536cdf0e10cSrcweir } 2537cdf0e10cSrcweir break; 2538cdf0e10cSrcweir case KS_GlossaryExpand: 2539cdf0e10cSrcweir { 2540cdf0e10cSrcweir // ersetze das Wort oder Kuerzel durch den den Textbaustein 2541cdf0e10cSrcweir rSh.StartUndo( UNDO_START ); 2542cdf0e10cSrcweir 2543cdf0e10cSrcweir String sFnd( *aTmpQHD.aArr[ aTmpQHD.nCurArrPos ] ); 2544cdf0e10cSrcweir if( aTmpQHD.bIsAutoText ) 2545cdf0e10cSrcweir { 2546cdf0e10cSrcweir SwGlossaryList* pList = ::GetGlossaryList(); 2547cdf0e10cSrcweir String sShrtNm; 2548cdf0e10cSrcweir String sGroup; 2549cdf0e10cSrcweir if(pList->GetShortName( sFnd, sShrtNm, sGroup)) 2550cdf0e10cSrcweir { 2551cdf0e10cSrcweir rSh.SttSelect(); 2552cdf0e10cSrcweir rSh.ExtendSelection( sal_False, aTmpQHD.nLen ); 2553cdf0e10cSrcweir SwGlossaryHdl* pGlosHdl = GetView().GetGlosHdl(); 2554cdf0e10cSrcweir pGlosHdl->SetCurGroup(sGroup, sal_True); 2555cdf0e10cSrcweir pGlosHdl->InsertGlossary( sShrtNm); 2556cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_True; 2557cdf0e10cSrcweir } 2558cdf0e10cSrcweir } 2559cdf0e10cSrcweir else 2560cdf0e10cSrcweir { 2561cdf0e10cSrcweir rSh.Insert( sFnd.Erase( 0, aTmpQHD.nLen )); 2562cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = !pACorr || 2563cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCmpltAppendBlanc; 2564cdf0e10cSrcweir } 2565cdf0e10cSrcweir rSh.EndUndo( UNDO_END ); 2566cdf0e10cSrcweir } 2567cdf0e10cSrcweir break; 2568cdf0e10cSrcweir 2569cdf0e10cSrcweir case KS_NextPrevGlossary: 2570cdf0e10cSrcweir pQuickHlpData->Move( aTmpQHD ); 2571cdf0e10cSrcweir pQuickHlpData->Start( rSh, USHRT_MAX ); 2572cdf0e10cSrcweir break; 2573cdf0e10cSrcweir 2574cdf0e10cSrcweir case KS_EditFormula: 2575cdf0e10cSrcweir { 2576cdf0e10cSrcweir const sal_uInt16 nId = SwInputChild::GetChildWindowId(); 2577cdf0e10cSrcweir 2578cdf0e10cSrcweir SfxViewFrame* pVFrame = GetView().GetViewFrame(); 2579cdf0e10cSrcweir pVFrame->ToggleChildWindow( nId ); 2580cdf0e10cSrcweir SwInputChild* pChildWin = (SwInputChild*)pVFrame-> 2581cdf0e10cSrcweir GetChildWindow( nId ); 2582cdf0e10cSrcweir if( pChildWin ) 2583cdf0e10cSrcweir pChildWin->SetFormula( sFmlEntry ); 2584cdf0e10cSrcweir } 2585cdf0e10cSrcweir break; 2586cdf0e10cSrcweir 2587cdf0e10cSrcweir case KS_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break; 2588cdf0e10cSrcweir case KS_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break; 2589cdf0e10cSrcweir case KS_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHMove() ); break; 2590cdf0e10cSrcweir case KS_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHMove() ); break; 2591cdf0e10cSrcweir // case KS_ColTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break; 2592cdf0e10cSrcweir case KS_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break; 2593cdf0e10cSrcweir // case KS_ColTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_TOP, pModOpt->GetTblVMove() ); break; 2594cdf0e10cSrcweir case KS_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVMove() ); break; 2595cdf0e10cSrcweir case KS_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break; 2596cdf0e10cSrcweir case KS_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break; 2597cdf0e10cSrcweir case KS_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHMove() ); break; 2598cdf0e10cSrcweir case KS_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHMove() ); break; 2599cdf0e10cSrcweir case KS_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break; 2600cdf0e10cSrcweir case KS_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break; 2601cdf0e10cSrcweir case KS_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVMove() ); break; 2602cdf0e10cSrcweir case KS_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVMove() ); break; 2603cdf0e10cSrcweir 2604cdf0e10cSrcweir //--------------- 2605cdf0e10cSrcweir case KS_InsDel_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break; 2606cdf0e10cSrcweir case KS_InsDel_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break; 2607cdf0e10cSrcweir case KS_InsDel_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHInsert() ); break; 2608cdf0e10cSrcweir case KS_InsDel_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHInsert() ); break; 2609cdf0e10cSrcweir case KS_InsDel_ColTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break; 2610cdf0e10cSrcweir case KS_InsDel_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break; 2611cdf0e10cSrcweir case KS_InsDel_ColTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP, pModOpt->GetTblVInsert() ); break; 2612cdf0e10cSrcweir case KS_InsDel_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVInsert() ); break; 2613cdf0e10cSrcweir case KS_InsDel_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break; 2614cdf0e10cSrcweir case KS_InsDel_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break; 2615cdf0e10cSrcweir case KS_InsDel_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHInsert() ); break; 2616cdf0e10cSrcweir case KS_InsDel_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHInsert() ); break; 2617cdf0e10cSrcweir case KS_InsDel_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break; 2618cdf0e10cSrcweir case KS_InsDel_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break; 2619cdf0e10cSrcweir case KS_InsDel_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVInsert() ); break; 2620cdf0e10cSrcweir case KS_InsDel_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVInsert() ); break; 2621cdf0e10cSrcweir //--------------- 2622cdf0e10cSrcweir case KS_TblColCellInsDel: 2623cdf0e10cSrcweir rSh.SetColRowWidthHeight( eTblChgMode, nTblChgSize ); 2624cdf0e10cSrcweir break; 2625cdf0e10cSrcweir case KS_Fly_Change: 2626cdf0e10cSrcweir { 2627cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 2628cdf0e10cSrcweir const SdrHdlList& rHdlList = pSdrView->GetHdlList(); 2629cdf0e10cSrcweir if(rHdlList.GetFocusHdl()) 2630cdf0e10cSrcweir ChangeDrawing( nDir ); 2631cdf0e10cSrcweir else 2632cdf0e10cSrcweir ChangeFly( nDir, rView.ISA( SwWebView ) ); 2633cdf0e10cSrcweir } 2634cdf0e10cSrcweir break; 2635cdf0e10cSrcweir case KS_Draw_Change : 2636cdf0e10cSrcweir ChangeDrawing( nDir ); 2637cdf0e10cSrcweir break; 2638cdf0e10cSrcweir default:; //prevent warning 2639cdf0e10cSrcweir } 2640cdf0e10cSrcweir if( nSlotId && rView.GetViewFrame()->GetBindings().GetRecorder().is() ) 2641cdf0e10cSrcweir { 2642cdf0e10cSrcweir SfxRequest aReq(rView.GetViewFrame(), nSlotId ); 2643cdf0e10cSrcweir aReq.Done(); 2644cdf0e10cSrcweir } 2645cdf0e10cSrcweir eKeyState = KS_Ende; 2646cdf0e10cSrcweir } 2647cdf0e10cSrcweir } 2648cdf0e10cSrcweir } 2649cdf0e10cSrcweir 2650cdf0e10cSrcweir if( bStopKeyInputTimer ) 2651cdf0e10cSrcweir { 2652cdf0e10cSrcweir aKeyInputTimer.Stop(); 2653cdf0e10cSrcweir bTblInsDelMode = sal_False; 2654cdf0e10cSrcweir } 2655cdf0e10cSrcweir 2656cdf0e10cSrcweir // falls die gepufferten Zeichen eingefuegt werden sollen 2657cdf0e10cSrcweir if( bFlushBuffer && aInBuffer.Len() ) 2658cdf0e10cSrcweir { 2659cdf0e10cSrcweir //OS 16.02.96 11.04: bFlushCharBuffer wurde hier nicht zurueckgesetzt 2660cdf0e10cSrcweir // warum nicht? 2661cdf0e10cSrcweir sal_Bool bSave = bFlushCharBuffer; 2662cdf0e10cSrcweir FlushInBuffer(); 2663cdf0e10cSrcweir bFlushCharBuffer = bSave; 2664cdf0e10cSrcweir 2665cdf0e10cSrcweir // evt. Tip-Hilfe anzeigen 2666cdf0e10cSrcweir String sWord; 2667cdf0e10cSrcweir if( bNormalChar && pACfg && pACorr && 2668cdf0e10cSrcweir ( pACfg->IsAutoTextTip() || 2669cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCompleteWords ) && 2670cdf0e10cSrcweir rSh.GetPrevAutoCorrWord( *pACorr, sWord ) ) 2671cdf0e10cSrcweir { 2672cdf0e10cSrcweir ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr); 2673cdf0e10cSrcweir } 2674cdf0e10cSrcweir } 2675cdf0e10cSrcweir } 2676cdf0e10cSrcweir 2677cdf0e10cSrcweir /*-------------------------------------------------------------------- 2678cdf0e10cSrcweir Beschreibung: MouseEvents 2679cdf0e10cSrcweir --------------------------------------------------------------------*/ 2680cdf0e10cSrcweir 2681cdf0e10cSrcweir 2682cdf0e10cSrcweir void SwEditWin::RstMBDownFlags() 2683cdf0e10cSrcweir { 2684cdf0e10cSrcweir //Nicht auf allen Systemen kommt vor dem modalen 2685cdf0e10cSrcweir //Dialog noch ein MouseButton Up (wie unter WINDOWS). 2686cdf0e10cSrcweir //Daher hier die Stati zuruecksetzen und die Maus 2687cdf0e10cSrcweir //fuer den Dialog freigeben. 2688cdf0e10cSrcweir bMBPressed = bNoInterrupt = sal_False; 2689cdf0e10cSrcweir EnterArea(); 2690cdf0e10cSrcweir ReleaseMouse(); 2691cdf0e10cSrcweir } 2692cdf0e10cSrcweir 2693cdf0e10cSrcweir 2694cdf0e10cSrcweir 2695cdf0e10cSrcweir void SwEditWin::MouseButtonDown(const MouseEvent& _rMEvt) 2696cdf0e10cSrcweir { 2697cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 2698cdf0e10cSrcweir 2699cdf0e10cSrcweir // We have to check if a context menu is shown and we have an UI 2700cdf0e10cSrcweir // active inplace client. In that case we have to ignore the mouse 2701cdf0e10cSrcweir // button down event. Otherwise we would crash (context menu has been 2702cdf0e10cSrcweir // opened by inplace client and we would deactivate the inplace client, 2703cdf0e10cSrcweir // the contex menu is closed by VCL asynchronously which in the end 2704cdf0e10cSrcweir // would work on deleted objects or the context menu has no parent anymore) 2705cdf0e10cSrcweir // See #126086# and #128122# 2706cdf0e10cSrcweir SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient(); 2707cdf0e10cSrcweir sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() ); 2708cdf0e10cSrcweir 2709cdf0e10cSrcweir if ( bIsOleActive && PopupMenu::IsInExecute() ) 2710cdf0e10cSrcweir return; 2711cdf0e10cSrcweir 2712cdf0e10cSrcweir MouseEvent rMEvt(_rMEvt); 2713cdf0e10cSrcweir 2714cdf0e10cSrcweir if (rView.GetPostItMgr()->IsHit(rMEvt.GetPosPixel())) 2715cdf0e10cSrcweir return; 2716cdf0e10cSrcweir 2717cdf0e10cSrcweir rView.GetPostItMgr()->SetActiveSidebarWin(0); 2718cdf0e10cSrcweir 2719cdf0e10cSrcweir GrabFocus(); 2720cdf0e10cSrcweir 2721cdf0e10cSrcweir //ignore key modifiers for format paintbrush 2722cdf0e10cSrcweir { 2723cdf0e10cSrcweir sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard 2724cdf0e10cSrcweir && pApplyTempl->pFormatClipboard->HasContent(); 2725cdf0e10cSrcweir if( bExecFormatPaintbrush ) 2726cdf0e10cSrcweir rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(), 2727cdf0e10cSrcweir _rMEvt.GetMode(), _rMEvt.GetButtons() ); 2728cdf0e10cSrcweir } 2729cdf0e10cSrcweir 2730cdf0e10cSrcweir bWasShdwCrsr = 0 != pShadCrsr; 2731cdf0e10cSrcweir if( bWasShdwCrsr ) 2732cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 2733cdf0e10cSrcweir 2734cdf0e10cSrcweir const Point aDocPos( PixelToLogic( rMEvt.GetPosPixel() ) ); 2735cdf0e10cSrcweir 2736cdf0e10cSrcweir if ( IsChainMode() ) 2737cdf0e10cSrcweir { 2738cdf0e10cSrcweir SetChainMode( sal_False ); 2739cdf0e10cSrcweir SwRect aDummy; 2740cdf0e10cSrcweir SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)rSh.GetFlyFrmFmt(); 2741cdf0e10cSrcweir if ( !rSh.Chainable( aDummy, *pFmt, aDocPos ) ) 2742cdf0e10cSrcweir rSh.Chain( *pFmt, aDocPos ); 2743cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 2744cdf0e10cSrcweir return; 2745cdf0e10cSrcweir } 2746cdf0e10cSrcweir 2747cdf0e10cSrcweir //Nach GrabFocus sollte eine Shell gepusht sein. Das muss eigentlich 2748cdf0e10cSrcweir //klappen aber in der Praxis ... 2749cdf0e10cSrcweir lcl_SelectShellForDrop( rView ); 2750cdf0e10cSrcweir 2751cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly(); 2752cdf0e10cSrcweir sal_Bool bCallBase = sal_True; 2753cdf0e10cSrcweir 2754cdf0e10cSrcweir if( pQuickHlpData->bClear ) 2755cdf0e10cSrcweir pQuickHlpData->Stop( rSh ); 2756cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_False; 2757cdf0e10cSrcweir 2758cdf0e10cSrcweir if( rSh.FinishOLEObj() ) 2759cdf0e10cSrcweir return; //InPlace beenden und der Klick zaehlt nicht mehr 2760cdf0e10cSrcweir 2761cdf0e10cSrcweir SET_CURR_SHELL( &rSh ); 2762cdf0e10cSrcweir 2763cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 2764cdf0e10cSrcweir if ( pSdrView ) 2765cdf0e10cSrcweir { 2766cdf0e10cSrcweir if (pSdrView->MouseButtonDown( rMEvt, this ) ) 2767cdf0e10cSrcweir { 2768cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False); 2769cdf0e10cSrcweir return; // Event von der SdrView ausgewertet 2770cdf0e10cSrcweir } 2771cdf0e10cSrcweir } 2772cdf0e10cSrcweir 2773cdf0e10cSrcweir 2774cdf0e10cSrcweir bIsInMove = sal_False; 2775cdf0e10cSrcweir aStartPos = rMEvt.GetPosPixel(); 2776cdf0e10cSrcweir aRszMvHdlPt.X() = 0, aRszMvHdlPt.Y() = 0; 2777cdf0e10cSrcweir 2778cdf0e10cSrcweir sal_uInt8 nMouseTabCol = 0; 2779cdf0e10cSrcweir const sal_Bool bTmp = !rSh.IsDrawCreate() && !pApplyTempl && !rSh.IsInSelect() && 2780cdf0e10cSrcweir rMEvt.GetClicks() == 1 && MOUSE_LEFT == rMEvt.GetButtons(); 2781cdf0e10cSrcweir if ( bTmp && 2782cdf0e10cSrcweir 0 != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPos ) ) && 2783cdf0e10cSrcweir !rSh.IsObjSelectable( aDocPos ) ) 2784cdf0e10cSrcweir { 2785cdf0e10cSrcweir // --> FME 2004-07-30 #i32329# Enhanced table selection 2786cdf0e10cSrcweir if ( SW_TABSEL_HORI <= nMouseTabCol && SW_TABCOLSEL_VERT >= nMouseTabCol ) 2787cdf0e10cSrcweir { 2788cdf0e10cSrcweir rSh.EnterStdMode(); 2789cdf0e10cSrcweir rSh.SelectTableRowCol( aDocPos ); 2790cdf0e10cSrcweir if( SW_TABSEL_HORI != nMouseTabCol && SW_TABSEL_HORI_RTL != nMouseTabCol) 2791cdf0e10cSrcweir { 2792cdf0e10cSrcweir pRowColumnSelectionStart = new Point( aDocPos ); 2793cdf0e10cSrcweir bIsRowDrag = SW_TABROWSEL_HORI == nMouseTabCol|| 2794cdf0e10cSrcweir SW_TABROWSEL_HORI_RTL == nMouseTabCol || 2795cdf0e10cSrcweir SW_TABCOLSEL_VERT == nMouseTabCol; 2796cdf0e10cSrcweir bMBPressed = sal_True; 2797cdf0e10cSrcweir CaptureMouse(); 2798cdf0e10cSrcweir } 2799cdf0e10cSrcweir return; 2800cdf0e10cSrcweir } 2801cdf0e10cSrcweir // <-- 2802cdf0e10cSrcweir 2803cdf0e10cSrcweir if ( !rSh.IsTableMode() ) 2804cdf0e10cSrcweir { 2805cdf0e10cSrcweir //Zuppeln von Tabellenspalten aus dem Dokument heraus. 2806cdf0e10cSrcweir if(SW_TABCOL_VERT == nMouseTabCol || SW_TABCOL_HORI == nMouseTabCol) 2807cdf0e10cSrcweir rView.SetTabColFromDoc( sal_True ); 2808cdf0e10cSrcweir else 2809cdf0e10cSrcweir rView.SetTabRowFromDoc( sal_True ); 2810cdf0e10cSrcweir 2811cdf0e10cSrcweir rView.SetTabColFromDocPos( aDocPos ); 2812cdf0e10cSrcweir rView.InvalidateRulerPos(); 2813cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings(); 2814cdf0e10cSrcweir rBind.Update(); 2815cdf0e10cSrcweir if ( RulerColumnDrag( rMEvt, 2816cdf0e10cSrcweir (SW_TABCOL_VERT == nMouseTabCol || SW_TABROW_HORI == nMouseTabCol)) ) 2817cdf0e10cSrcweir { 2818cdf0e10cSrcweir rView.SetTabColFromDoc( sal_False ); 2819cdf0e10cSrcweir rView.SetTabRowFromDoc( sal_False ); 2820cdf0e10cSrcweir rView.InvalidateRulerPos(); 2821cdf0e10cSrcweir rBind.Update(); 2822cdf0e10cSrcweir bCallBase = sal_False; 2823cdf0e10cSrcweir } 2824cdf0e10cSrcweir else 2825cdf0e10cSrcweir { 2826cdf0e10cSrcweir return; 2827cdf0e10cSrcweir } 2828cdf0e10cSrcweir } 2829cdf0e10cSrcweir } 2830cdf0e10cSrcweir // #i23726# 2831cdf0e10cSrcweir else if (bTmp && 2832cdf0e10cSrcweir rSh.IsNumLabel(aDocPos)) 2833cdf0e10cSrcweir { 2834cdf0e10cSrcweir SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPos ); 2835cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( pNodeAtPos ); 2836cdf0e10cSrcweir rView.InvalidateRulerPos(); 2837cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings(); 2838cdf0e10cSrcweir rBind.Update(); 2839cdf0e10cSrcweir 2840cdf0e10cSrcweir // --> OD 2005-02-21 #i42921# 2841cdf0e10cSrcweir if ( RulerMarginDrag( rMEvt, 2842cdf0e10cSrcweir rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPos ) ) ) 2843cdf0e10cSrcweir // <-- 2844cdf0e10cSrcweir { 2845cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( NULL ); 2846cdf0e10cSrcweir rView.InvalidateRulerPos(); 2847cdf0e10cSrcweir rBind.Update(); 2848cdf0e10cSrcweir bCallBase = sal_False; 2849cdf0e10cSrcweir } 2850cdf0e10cSrcweir else 2851cdf0e10cSrcweir { 2852cdf0e10cSrcweir // --> FME 2005-11-03 #125036# Make sure the pointer is set to 0, 2853cdf0e10cSrcweir // otherwise it may point to nowhere after deleting the corresponding 2854cdf0e10cSrcweir // text node. 2855cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( NULL ); 2856cdf0e10cSrcweir // <-- 2857cdf0e10cSrcweir return; 2858cdf0e10cSrcweir } 2859cdf0e10cSrcweir } 2860cdf0e10cSrcweir 2861cdf0e10cSrcweir //Man kann sich in einem Selektionszustand befinden, wenn zuletzt 2862cdf0e10cSrcweir //mit dem Keyboard selektiert wurde, aber noch kein CURSOR_KEY 2863cdf0e10cSrcweir //anschliessend bewegt worden ist. In diesem Fall muss die vorher- 2864cdf0e10cSrcweir //gehende Selektion zuerst beendet werden. 2865cdf0e10cSrcweir //MA 07. Oct. 95: Und zwar nicht nur bei Linker Maustaste sondern immer. 2866cdf0e10cSrcweir //siehe auch Bug: 19263 2867cdf0e10cSrcweir if ( rSh.IsInSelect() ) 2868cdf0e10cSrcweir rSh.EndSelect(); 2869cdf0e10cSrcweir 2870cdf0e10cSrcweir //Abfrage auf LEFT, da sonst auch bei einem Click mit der rechten Taste 2871cdf0e10cSrcweir //beispielsweise die Selektion aufgehoben wird. 2872cdf0e10cSrcweir if ( MOUSE_LEFT == rMEvt.GetButtons() ) 2873cdf0e10cSrcweir { 2874cdf0e10cSrcweir sal_Bool bOnlyText = sal_False; 2875cdf0e10cSrcweir bMBPressed = bNoInterrupt = sal_True; 2876cdf0e10cSrcweir nKS_NUMDOWN_Count = 0; // #i23725# 2877cdf0e10cSrcweir 2878cdf0e10cSrcweir CaptureMouse(); 2879cdf0e10cSrcweir 2880cdf0e10cSrcweir //ggf. Cursorpositionen zuruecksetzen 2881cdf0e10cSrcweir rSh.ResetCursorStack(); 2882cdf0e10cSrcweir 2883cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() ) 2884cdf0e10cSrcweir { 2885cdf0e10cSrcweir case MOUSE_LEFT: 2886cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT: 2887cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2: 2888cdf0e10cSrcweir if( rSh.IsObjSelected() ) 2889cdf0e10cSrcweir { 2890cdf0e10cSrcweir SdrHdl* pHdl; 2891cdf0e10cSrcweir if( !bIsDocReadOnly && 2892cdf0e10cSrcweir !pAnchorMarker && 2893cdf0e10cSrcweir 0 != ( pHdl = pSdrView->PickHandle(aDocPos) ) && 2894cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR || 2895cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) ) 2896cdf0e10cSrcweir { 28974772d9afSArmin Le Grand // #121463# Set selected during drag 28984772d9afSArmin Le Grand pHdl->SetSelected(true); 2899cdf0e10cSrcweir pAnchorMarker = new SwAnchorMarker( pHdl ); 2900cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 2901cdf0e10cSrcweir return; 2902cdf0e10cSrcweir } 2903cdf0e10cSrcweir } 2904cdf0e10cSrcweir if ( EnterDrawMode( rMEvt, aDocPos ) ) 2905cdf0e10cSrcweir { 2906cdf0e10cSrcweir bNoInterrupt = sal_False; 2907cdf0e10cSrcweir return; 2908cdf0e10cSrcweir } 2909cdf0e10cSrcweir else if ( rView.GetDrawFuncPtr() && bInsFrm ) 2910cdf0e10cSrcweir { 2911cdf0e10cSrcweir StopInsFrm(); 2912cdf0e10cSrcweir rSh.Edit(); 2913cdf0e10cSrcweir } 2914cdf0e10cSrcweir 2915cdf0e10cSrcweir // Ohne SHIFT, da sonst Toggle bei Selektion nicht funktioniert 2916cdf0e10cSrcweir if (rMEvt.GetClicks() == 1) 2917cdf0e10cSrcweir { 2918cdf0e10cSrcweir if ( rSh.IsSelFrmMode()) 2919cdf0e10cSrcweir { 2920cdf0e10cSrcweir SdrHdl* pHdl = rSh.GetDrawView()->PickHandle(aDocPos); 2921cdf0e10cSrcweir sal_Bool bHitHandle = pHdl && pHdl->GetKind() != HDL_ANCHOR && 2922cdf0e10cSrcweir pHdl->GetKind() != HDL_ANCHOR_TR; 2923cdf0e10cSrcweir 2924cdf0e10cSrcweir if ((rSh.IsInsideSelectedObj(aDocPos) || bHitHandle) && 2925cdf0e10cSrcweir !(rMEvt.GetModifier() == KEY_SHIFT && !bHitHandle)) 2926cdf0e10cSrcweir { 2927cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 2928cdf0e10cSrcweir if ( !pApplyTempl ) 2929cdf0e10cSrcweir { 2930cdf0e10cSrcweir //nur, wenn keine Position zum Sizen getroffen ist. 2931cdf0e10cSrcweir if (!bHitHandle) 2932cdf0e10cSrcweir { 2933cdf0e10cSrcweir StartDDTimer(); 2934cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 2935cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 2936cdf0e10cSrcweir } 2937cdf0e10cSrcweir bFrmDrag = sal_True; 2938cdf0e10cSrcweir } 2939cdf0e10cSrcweir bNoInterrupt = sal_False; 2940cdf0e10cSrcweir return; 2941cdf0e10cSrcweir } 2942cdf0e10cSrcweir } 2943cdf0e10cSrcweir } 2944cdf0e10cSrcweir } 2945cdf0e10cSrcweir 2946cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly(); 2947cdf0e10cSrcweir if ( !bExecHyperlinks ) 2948cdf0e10cSrcweir { 2949cdf0e10cSrcweir SvtSecurityOptions aSecOpts; 2950cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK ); 2951cdf0e10cSrcweir if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) || 2952cdf0e10cSrcweir ( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) ) 2953cdf0e10cSrcweir bExecHyperlinks = sal_True; 2954cdf0e10cSrcweir } 2955cdf0e10cSrcweir 2956cdf0e10cSrcweir // --> FME 2004-07-30 #i32329# Enhanced selection 2957cdf0e10cSrcweir sal_uInt8 nNumberOfClicks = static_cast< sal_uInt8 >(rMEvt.GetClicks() % 4); 2958cdf0e10cSrcweir if ( 0 == nNumberOfClicks && 0 < rMEvt.GetClicks() ) 2959cdf0e10cSrcweir nNumberOfClicks = 4; 2960cdf0e10cSrcweir // <-- 2961cdf0e10cSrcweir 2962cdf0e10cSrcweir sal_Bool bExecDrawTextLink = sal_False; 2963cdf0e10cSrcweir 2964cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() ) 2965cdf0e10cSrcweir { 2966cdf0e10cSrcweir case MOUSE_LEFT: 2967cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1: 2968cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2: 2969cdf0e10cSrcweir switch ( nNumberOfClicks ) 2970cdf0e10cSrcweir { 2971cdf0e10cSrcweir case 1: 2972cdf0e10cSrcweir { 2973cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 2974cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 2975cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 2976cdf0e10cSrcweir 2977cdf0e10cSrcweir // URL in DrawText-Objekt getroffen? 2978cdf0e10cSrcweir if (bExecHyperlinks && pSdrView) 2979cdf0e10cSrcweir { 2980cdf0e10cSrcweir SdrViewEvent aVEvt; 2981cdf0e10cSrcweir pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 2982cdf0e10cSrcweir 2983cdf0e10cSrcweir if (aVEvt.eEvent == SDREVENT_EXECUTEURL) 2984cdf0e10cSrcweir bExecDrawTextLink = sal_True; 2985cdf0e10cSrcweir } 2986cdf0e10cSrcweir 2987cdf0e10cSrcweir //Rahmen nur zu selektieren versuchen, wenn 2988cdf0e10cSrcweir //der Pointer bereits entsprechend geschaltet wurde 2989cdf0e10cSrcweir if ( aActHitType != SDRHIT_NONE && !rSh.IsSelFrmMode() && 2990cdf0e10cSrcweir !GetView().GetViewFrame()->GetDispatcher()->IsLocked() && 2991cdf0e10cSrcweir !bExecDrawTextLink) 2992cdf0e10cSrcweir { 2993cdf0e10cSrcweir // #107513# 2994cdf0e10cSrcweir // Test if there is a draw object at that position and if it should be selected. 2995cdf0e10cSrcweir sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos); 2996cdf0e10cSrcweir 2997cdf0e10cSrcweir if(bShould) 2998cdf0e10cSrcweir { 2999cdf0e10cSrcweir rView.NoRotate(); 3000cdf0e10cSrcweir rSh.HideCrsr(); 3001cdf0e10cSrcweir 3002cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 3003cdf0e10cSrcweir rSh.LockView( sal_True ); 3004cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, 3005cdf0e10cSrcweir rMEvt.IsMod1() ? SW_ENTER_GROUP : 0); 3006cdf0e10cSrcweir if( bUnLockView ) 3007cdf0e10cSrcweir rSh.LockView( sal_False ); 3008cdf0e10cSrcweir 3009cdf0e10cSrcweir if( bSelObj ) 3010cdf0e10cSrcweir { 3011cdf0e10cSrcweir // falls im Macro der Rahmen deselektiert 3012cdf0e10cSrcweir // wurde, muss nur noch der Cursor 3013cdf0e10cSrcweir // wieder angezeigt werden. 3014cdf0e10cSrcweir if( FRMTYPE_NONE == rSh.GetSelFrmType() ) 3015cdf0e10cSrcweir rSh.ShowCrsr(); 3016cdf0e10cSrcweir else 3017cdf0e10cSrcweir { 3018cdf0e10cSrcweir if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr()) 3019cdf0e10cSrcweir { 3020cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 3021cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 3022cdf0e10cSrcweir rView.LeaveDrawCreate(); 3023cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 3024cdf0e10cSrcweir } 3025cdf0e10cSrcweir 3026cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3027cdf0e10cSrcweir bFrmDrag = sal_True; 3028cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 3029cdf0e10cSrcweir } 3030cdf0e10cSrcweir return; 3031cdf0e10cSrcweir } 3032cdf0e10cSrcweir else 3033cdf0e10cSrcweir bOnlyText = static_cast< sal_Bool >(rSh.IsObjSelectable( aDocPos )); 3034cdf0e10cSrcweir 3035cdf0e10cSrcweir if (!rView.GetDrawFuncPtr()) 3036cdf0e10cSrcweir rSh.ShowCrsr(); 3037cdf0e10cSrcweir } 3038cdf0e10cSrcweir else 3039cdf0e10cSrcweir bOnlyText = KEY_MOD1 != rMEvt.GetModifier(); 3040cdf0e10cSrcweir } 3041cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() && 3042cdf0e10cSrcweir (aActHitType == SDRHIT_NONE || 3043cdf0e10cSrcweir !rSh.IsInsideSelectedObj( aDocPos ))) 3044cdf0e10cSrcweir { 3045cdf0e10cSrcweir rView.NoRotate(); 3046cdf0e10cSrcweir SdrHdl *pHdl; 3047cdf0e10cSrcweir if( !bIsDocReadOnly && !pAnchorMarker && 0 != 3048cdf0e10cSrcweir ( pHdl = pSdrView->PickHandle(aDocPos) ) && 3049cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR || 3050cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) ) 3051cdf0e10cSrcweir { 3052cdf0e10cSrcweir pAnchorMarker = new SwAnchorMarker( pHdl ); 3053cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 3054cdf0e10cSrcweir return; 3055cdf0e10cSrcweir } 3056cdf0e10cSrcweir else 3057cdf0e10cSrcweir { 3058cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 3059cdf0e10cSrcweir rSh.LockView( sal_True ); 3060cdf0e10cSrcweir sal_uInt8 nFlag = rMEvt.IsShift() ? SW_ADD_SELECT :0; 3061cdf0e10cSrcweir if( rMEvt.IsMod1() ) 3062cdf0e10cSrcweir nFlag = nFlag | SW_ENTER_GROUP; 3063cdf0e10cSrcweir 3064cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 3065cdf0e10cSrcweir { 3066cdf0e10cSrcweir rSh.UnSelectFrm(); 3067cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 3068cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 3069cdf0e10cSrcweir } 3070cdf0e10cSrcweir 3071cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag ); 3072cdf0e10cSrcweir if( bUnLockView ) 3073cdf0e10cSrcweir rSh.LockView( sal_False ); 3074cdf0e10cSrcweir 3075cdf0e10cSrcweir if( !bSelObj ) 3076cdf0e10cSrcweir { 3077cdf0e10cSrcweir // Cursor hier umsetzen, damit er nicht zuerst 3078cdf0e10cSrcweir // im Rahmen gezeichnet wird; ShowCrsr() geschieht 3079cdf0e10cSrcweir // in LeaveSelFrmMode() 3080cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False)); 3081cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 3082cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 3083cdf0e10cSrcweir bCallBase = sal_False; 3084cdf0e10cSrcweir } 3085cdf0e10cSrcweir else 3086cdf0e10cSrcweir { 3087cdf0e10cSrcweir rSh.HideCrsr(); 3088cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3089cdf0e10cSrcweir rSh.SelFlyGrabCrsr(); 3090cdf0e10cSrcweir rSh.MakeSelVisible(); 3091cdf0e10cSrcweir bFrmDrag = sal_True; 3092cdf0e10cSrcweir if( rSh.IsFrmSelected() && 3093cdf0e10cSrcweir rView.GetDrawFuncPtr() ) 3094cdf0e10cSrcweir { 3095cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 3096cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 3097cdf0e10cSrcweir rView.LeaveDrawCreate(); 3098cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 3099cdf0e10cSrcweir } 3100cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() ); 3101cdf0e10cSrcweir return; 3102cdf0e10cSrcweir } 3103cdf0e10cSrcweir } 3104cdf0e10cSrcweir } 3105cdf0e10cSrcweir 3106cdf0e10cSrcweir break; 3107cdf0e10cSrcweir } 3108cdf0e10cSrcweir case 2: 3109cdf0e10cSrcweir { 3110cdf0e10cSrcweir bFrmDrag = sal_False; 3111cdf0e10cSrcweir if ( !bIsDocReadOnly && rSh.IsInsideSelectedObj(aDocPos) && 3112cdf0e10cSrcweir 0 == rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) ) 3113cdf0e10cSrcweir 3114cdf0e10cSrcweir /* 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) 3115cdf0e10cSrcweir on the other hand the return value is used in a switch without proper masking (very nice), this must lead to trouble 3116cdf0e10cSrcweir */ 3117cdf0e10cSrcweir switch ( rSh.GetSelectionType() &~ ( nsSelectionType::SEL_FONTWORK | nsSelectionType::SEL_EXTRUDED_CUSTOMSHAPE ) ) 3118cdf0e10cSrcweir { 3119cdf0e10cSrcweir case nsSelectionType::SEL_GRF: 3120cdf0e10cSrcweir RstMBDownFlags(); 3121cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( 3122cdf0e10cSrcweir FN_FORMAT_GRAFIC_DLG, 0, 0, 3123cdf0e10cSrcweir SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT); 3124cdf0e10cSrcweir return; 3125cdf0e10cSrcweir 3126cdf0e10cSrcweir // Doppelklick auf OLE-Objekt --> OLE-InPlace 3127cdf0e10cSrcweir case nsSelectionType::SEL_OLE: 3128cdf0e10cSrcweir if (!rSh.IsSelObjProtected(FLYPROTECT_CONTENT)) 3129cdf0e10cSrcweir { 3130cdf0e10cSrcweir RstMBDownFlags(); 3131cdf0e10cSrcweir rSh.LaunchOLEObj(); 3132cdf0e10cSrcweir } 3133cdf0e10cSrcweir return; 3134cdf0e10cSrcweir 3135cdf0e10cSrcweir case nsSelectionType::SEL_FRM: 3136cdf0e10cSrcweir RstMBDownFlags(); 3137cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( 3138cdf0e10cSrcweir FN_FORMAT_FRAME_DLG, 0, 0, SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT); 3139cdf0e10cSrcweir return; 3140cdf0e10cSrcweir 3141cdf0e10cSrcweir case nsSelectionType::SEL_DRW: 3142cdf0e10cSrcweir RstMBDownFlags(); 3143cdf0e10cSrcweir EnterDrawTextMode(aDocPos); 3144cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) ) 3145cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init(); 3146cdf0e10cSrcweir return; 3147cdf0e10cSrcweir } 3148cdf0e10cSrcweir 3149cdf0e10cSrcweir //falls die Cursorposition korrigiert wurde oder 3150cdf0e10cSrcweir // ein Fly im ReadOnlyModus selektiert ist, 3151cdf0e10cSrcweir //keine Wortselektion. 3152cdf0e10cSrcweir if ( !bValidCrsrPos || 3153cdf0e10cSrcweir (rSh.IsFrmSelected() && rSh.IsFrmSelected() )) 3154cdf0e10cSrcweir return; 3155cdf0e10cSrcweir 3156cdf0e10cSrcweir SwField *pFld; 3157cdf0e10cSrcweir sal_Bool bFtn = sal_False; 3158cdf0e10cSrcweir 3159cdf0e10cSrcweir if( !bIsDocReadOnly && 3160cdf0e10cSrcweir ( 0 != ( pFld = rSh.GetCurFld() ) || 3161cdf0e10cSrcweir 0 != ( bFtn = rSh.GetCurFtn() )) ) 3162cdf0e10cSrcweir { 3163cdf0e10cSrcweir RstMBDownFlags(); 3164cdf0e10cSrcweir if( bFtn ) 3165cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( FN_EDIT_FOOTNOTE ); 3166cdf0e10cSrcweir else 3167cdf0e10cSrcweir { 3168cdf0e10cSrcweir sal_uInt16 nTypeId = pFld->GetTypeId(); 3169cdf0e10cSrcweir SfxViewFrame* pVFrame = GetView().GetViewFrame(); 3170cdf0e10cSrcweir switch( nTypeId ) 3171cdf0e10cSrcweir { 3172cdf0e10cSrcweir case TYP_POSTITFLD: 3173cdf0e10cSrcweir case TYP_SCRIPTFLD: 3174cdf0e10cSrcweir { 3175cdf0e10cSrcweir //falls es ein Readonly-Bereich ist, dann muss der Status 3176cdf0e10cSrcweir //enabled werden 3177cdf0e10cSrcweir sal_uInt16 nSlot = TYP_POSTITFLD == nTypeId ? FN_POSTIT : FN_JAVAEDIT; 3178cdf0e10cSrcweir SfxBoolItem aItem(nSlot, sal_True); 3179cdf0e10cSrcweir pVFrame->GetBindings().SetState(aItem); 3180cdf0e10cSrcweir pVFrame->GetBindings().Execute(nSlot); 3181cdf0e10cSrcweir break; 3182cdf0e10cSrcweir } 3183cdf0e10cSrcweir case TYP_AUTHORITY : 3184cdf0e10cSrcweir pVFrame->GetBindings().Execute(FN_EDIT_AUTH_ENTRY_DLG); 3185cdf0e10cSrcweir break; 3186cdf0e10cSrcweir default: 3187cdf0e10cSrcweir pVFrame->GetBindings().Execute(FN_EDIT_FIELD); 3188cdf0e10cSrcweir } 3189cdf0e10cSrcweir } 3190cdf0e10cSrcweir return; 3191cdf0e10cSrcweir } 3192cdf0e10cSrcweir //im Extended Mode hat Doppel- und 3193cdf0e10cSrcweir //Dreifachklick keine Auswirkungen. 3194cdf0e10cSrcweir if ( rSh.IsExtMode() || rSh.IsBlockMode() ) 3195cdf0e10cSrcweir return; 3196cdf0e10cSrcweir 3197cdf0e10cSrcweir //Wort selektieren, gfs. Additional Mode 3198cdf0e10cSrcweir if ( KEY_MOD1 == rMEvt.GetModifier() && !rSh.IsAddMode() ) 3199cdf0e10cSrcweir { 3200cdf0e10cSrcweir rSh.EnterAddMode(); 3201cdf0e10cSrcweir rSh.SelWrd( &aDocPos ); 3202cdf0e10cSrcweir rSh.LeaveAddMode(); 3203cdf0e10cSrcweir } 3204cdf0e10cSrcweir else 3205cdf0e10cSrcweir rSh.SelWrd( &aDocPos ); 3206cdf0e10cSrcweir bHoldSelection = sal_True; 3207cdf0e10cSrcweir return; 3208cdf0e10cSrcweir } 3209cdf0e10cSrcweir case 3: 3210cdf0e10cSrcweir case 4: 3211cdf0e10cSrcweir { 3212cdf0e10cSrcweir bFrmDrag = sal_False; 3213cdf0e10cSrcweir //im Extended Mode hat Doppel- und 3214cdf0e10cSrcweir //Dreifachklick keine Auswirkungen. 3215cdf0e10cSrcweir if ( rSh.IsExtMode() ) 3216cdf0e10cSrcweir return; 3217cdf0e10cSrcweir 3218cdf0e10cSrcweir //falls die Cursorposition korrigiert wurde oder 3219cdf0e10cSrcweir // ein Fly im ReadOnlyModus selektiert ist, 3220cdf0e10cSrcweir //keine Wortselektion. 3221cdf0e10cSrcweir if ( !bValidCrsrPos || rSh.IsFrmSelected() ) 3222cdf0e10cSrcweir return; 3223cdf0e10cSrcweir 3224cdf0e10cSrcweir //Zeile selektieren, gfs. Additional Mode 3225cdf0e10cSrcweir const bool bMod = KEY_MOD1 == rMEvt.GetModifier() && 3226cdf0e10cSrcweir !rSh.IsAddMode(); 3227cdf0e10cSrcweir 3228cdf0e10cSrcweir if ( bMod ) 3229cdf0e10cSrcweir rSh.EnterAddMode(); 3230cdf0e10cSrcweir 3231cdf0e10cSrcweir // --> FME 2004-07-30 #i32329# Enhanced selection 3232cdf0e10cSrcweir if ( 3 == nNumberOfClicks ) 3233cdf0e10cSrcweir rSh.SelSentence( &aDocPos ); 3234cdf0e10cSrcweir else 3235cdf0e10cSrcweir rSh.SelPara( &aDocPos ); 3236cdf0e10cSrcweir // <-- 3237cdf0e10cSrcweir 3238cdf0e10cSrcweir if ( bMod ) 3239cdf0e10cSrcweir rSh.LeaveAddMode(); 3240cdf0e10cSrcweir 3241cdf0e10cSrcweir bHoldSelection = sal_True; 3242cdf0e10cSrcweir return; 3243cdf0e10cSrcweir } 3244cdf0e10cSrcweir 3245cdf0e10cSrcweir default: 3246cdf0e10cSrcweir return; 3247cdf0e10cSrcweir } 3248cdf0e10cSrcweir /* no break */ 3249cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT: 3250cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1: 3251cdf0e10cSrcweir { 3252cdf0e10cSrcweir sal_Bool bLockView = bWasShdwCrsr; 3253cdf0e10cSrcweir 3254cdf0e10cSrcweir switch ( rMEvt.GetModifier() ) 3255cdf0e10cSrcweir { 3256cdf0e10cSrcweir case KEY_MOD1 + KEY_SHIFT: 3257cdf0e10cSrcweir { 3258cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) ) 3259cdf0e10cSrcweir { 3260cdf0e10cSrcweir rView.NoRotate(); 3261cdf0e10cSrcweir rSh.HideCrsr(); 3262cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 3263cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP); 3264cdf0e10cSrcweir else 3265cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP ) ) 3266cdf0e10cSrcweir { 3267cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3268cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 3269cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 3270cdf0e10cSrcweir bFrmDrag = sal_True; 3271cdf0e10cSrcweir return; 3272cdf0e10cSrcweir } 3273cdf0e10cSrcweir } 3274cdf0e10cSrcweir } 3275cdf0e10cSrcweir else if( rSh.IsSelFrmMode() && 3276cdf0e10cSrcweir rSh.GetDrawView()->PickHandle( aDocPos )) 3277cdf0e10cSrcweir { 3278cdf0e10cSrcweir bFrmDrag = sal_True; 3279cdf0e10cSrcweir bNoInterrupt = sal_False; 3280cdf0e10cSrcweir return; 3281cdf0e10cSrcweir } 3282cdf0e10cSrcweir } 3283cdf0e10cSrcweir break; 3284cdf0e10cSrcweir case KEY_MOD1: 3285cdf0e10cSrcweir if ( !bExecDrawTextLink ) 3286cdf0e10cSrcweir { 3287cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) ) 3288cdf0e10cSrcweir { 3289cdf0e10cSrcweir rView.NoRotate(); 3290cdf0e10cSrcweir rSh.HideCrsr(); 3291cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 3292cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ENTER_GROUP); 3293cdf0e10cSrcweir else 3294cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos, SW_ENTER_GROUP ) ) 3295cdf0e10cSrcweir { 3296cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3297cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 3298cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 3299cdf0e10cSrcweir bFrmDrag = sal_True; 3300cdf0e10cSrcweir return; 3301cdf0e10cSrcweir } 3302cdf0e10cSrcweir } 3303cdf0e10cSrcweir } 3304cdf0e10cSrcweir else if( rSh.IsSelFrmMode() && 3305cdf0e10cSrcweir rSh.GetDrawView()->PickHandle( aDocPos )) 3306cdf0e10cSrcweir { 3307cdf0e10cSrcweir bFrmDrag = sal_True; 3308cdf0e10cSrcweir bNoInterrupt = sal_False; 3309cdf0e10cSrcweir return; 3310cdf0e10cSrcweir } 3311cdf0e10cSrcweir else 3312cdf0e10cSrcweir { 3313cdf0e10cSrcweir if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() ) 3314cdf0e10cSrcweir { 3315cdf0e10cSrcweir rSh.PushMode(); 3316cdf0e10cSrcweir bModePushed = sal_True; 3317cdf0e10cSrcweir 3318cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 3319cdf0e10cSrcweir rSh.LockView( sal_True ); 3320cdf0e10cSrcweir rSh.EnterAddMode(); 3321cdf0e10cSrcweir if( bUnLockView ) 3322cdf0e10cSrcweir rSh.LockView( sal_False ); 3323cdf0e10cSrcweir } 3324cdf0e10cSrcweir bCallBase = sal_False; 3325cdf0e10cSrcweir } 3326cdf0e10cSrcweir } 3327cdf0e10cSrcweir break; 3328cdf0e10cSrcweir case KEY_MOD2: 3329cdf0e10cSrcweir { 3330cdf0e10cSrcweir if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() ) 3331cdf0e10cSrcweir { 3332cdf0e10cSrcweir rSh.PushMode(); 3333cdf0e10cSrcweir bModePushed = sal_True; 3334cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 3335cdf0e10cSrcweir rSh.LockView( sal_True ); 3336cdf0e10cSrcweir rSh.EnterBlockMode(); 3337cdf0e10cSrcweir if( bUnLockView ) 3338cdf0e10cSrcweir rSh.LockView( sal_False ); 3339cdf0e10cSrcweir } 3340cdf0e10cSrcweir bCallBase = sal_False; 3341cdf0e10cSrcweir } 3342cdf0e10cSrcweir break; 3343cdf0e10cSrcweir case KEY_SHIFT: 3344cdf0e10cSrcweir { 3345cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) ) 3346cdf0e10cSrcweir { 3347cdf0e10cSrcweir rView.NoRotate(); 3348cdf0e10cSrcweir rSh.HideCrsr(); 3349cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 3350cdf0e10cSrcweir { 3351cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ADD_SELECT); 3352cdf0e10cSrcweir 3353cdf0e10cSrcweir const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList(); 3354cdf0e10cSrcweir if (rMarkList.GetMark(0) == NULL) 3355cdf0e10cSrcweir { 3356cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 3357cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 3358cdf0e10cSrcweir bFrmDrag = sal_False; 3359cdf0e10cSrcweir } 3360cdf0e10cSrcweir } 3361cdf0e10cSrcweir else 3362cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos ) ) 3363cdf0e10cSrcweir { 3364cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3365cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 3366cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 3367cdf0e10cSrcweir bFrmDrag = sal_True; 3368cdf0e10cSrcweir return; 3369cdf0e10cSrcweir } 3370cdf0e10cSrcweir } 3371cdf0e10cSrcweir } 3372cdf0e10cSrcweir else 3373cdf0e10cSrcweir { 3374cdf0e10cSrcweir if ( rSh.IsSelFrmMode() && 3375cdf0e10cSrcweir rSh.IsInsideSelectedObj( aDocPos ) ) 3376cdf0e10cSrcweir { 3377cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 3378cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 3379cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 3380cdf0e10cSrcweir bFrmDrag = sal_True; 3381cdf0e10cSrcweir return; 3382cdf0e10cSrcweir } 3383cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 3384cdf0e10cSrcweir { 3385cdf0e10cSrcweir rSh.UnSelectFrm(); 3386cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 3387cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 3388cdf0e10cSrcweir bFrmDrag = sal_False; 3389cdf0e10cSrcweir } 3390cdf0e10cSrcweir if ( !rSh.IsExtMode() ) 3391cdf0e10cSrcweir { 3392cdf0e10cSrcweir // keine Selection anfangen, wenn in ein URL- 3393cdf0e10cSrcweir // Feld oder eine -Grafik geklickt wird 3394cdf0e10cSrcweir sal_Bool bSttSelect = rSh.HasSelection() || 3395cdf0e10cSrcweir Pointer(POINTER_REFHAND) != GetPointer(); 3396cdf0e10cSrcweir 3397cdf0e10cSrcweir if( !bSttSelect ) 3398cdf0e10cSrcweir { 3399cdf0e10cSrcweir bSttSelect = sal_True; 3400cdf0e10cSrcweir if( bExecHyperlinks ) 3401cdf0e10cSrcweir { 3402cdf0e10cSrcweir SwContentAtPos aCntntAtPos( 3403cdf0e10cSrcweir SwContentAtPos::SW_FTN | 3404cdf0e10cSrcweir SwContentAtPos::SW_INETATTR ); 3405cdf0e10cSrcweir 3406cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPos, aCntntAtPos ) ) 3407cdf0e10cSrcweir { 3408cdf0e10cSrcweir if( !rSh.IsViewLocked() && 3409cdf0e10cSrcweir !rSh.IsReadOnlyAvailable() && 3410cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() ) 3411cdf0e10cSrcweir bLockView = sal_True; 3412cdf0e10cSrcweir 3413cdf0e10cSrcweir bSttSelect = sal_False; 3414cdf0e10cSrcweir } 3415cdf0e10cSrcweir else if( rSh.IsURLGrfAtPos( aDocPos )) 3416cdf0e10cSrcweir bSttSelect = sal_False; 3417cdf0e10cSrcweir } 3418cdf0e10cSrcweir } 3419cdf0e10cSrcweir 3420cdf0e10cSrcweir if( bSttSelect ) 3421cdf0e10cSrcweir rSh.SttSelect(); 3422cdf0e10cSrcweir } 3423cdf0e10cSrcweir } 3424cdf0e10cSrcweir bCallBase = sal_False; 3425cdf0e10cSrcweir break; 3426cdf0e10cSrcweir } 3427cdf0e10cSrcweir default: 3428cdf0e10cSrcweir if( !rSh.IsViewLocked() ) 3429cdf0e10cSrcweir { 3430cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD | 3431cdf0e10cSrcweir SwContentAtPos::SW_INETATTR ); 3432cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPos, aCntntAtPos, sal_False ) && 3433cdf0e10cSrcweir !rSh.IsReadOnlyAvailable() && 3434cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() ) 3435cdf0e10cSrcweir bLockView = sal_True; 3436cdf0e10cSrcweir } 3437cdf0e10cSrcweir } 3438cdf0e10cSrcweir 3439cdf0e10cSrcweir if ( rSh.IsGCAttr() ) 3440cdf0e10cSrcweir { 3441cdf0e10cSrcweir rSh.GCAttr(); 3442cdf0e10cSrcweir rSh.ClearGCAttr(); 3443cdf0e10cSrcweir } 3444cdf0e10cSrcweir 3445cdf0e10cSrcweir sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False; 3446cdf0e10cSrcweir if( !bOverSelect ) 3447cdf0e10cSrcweir bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos ); 3448cdf0e10cSrcweir 3449cdf0e10cSrcweir if ( !bOverSelect ) 3450cdf0e10cSrcweir { 3451cdf0e10cSrcweir const sal_Bool bTmpNoInterrupt = bNoInterrupt; 3452cdf0e10cSrcweir bNoInterrupt = sal_False; 3453cdf0e10cSrcweir 3454cdf0e10cSrcweir if( !rSh.IsViewLocked() && bLockView ) 3455cdf0e10cSrcweir rSh.LockView( sal_True ); 3456cdf0e10cSrcweir else 3457cdf0e10cSrcweir bLockView = sal_False; 3458cdf0e10cSrcweir 3459cdf0e10cSrcweir int nTmpSetCrsr = 0; 3460cdf0e10cSrcweir 3461cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die 3462cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!! 3463cdf0e10cSrcweir MV_KONTEXT( &rSh ); 3464cdf0e10cSrcweir nTmpSetCrsr = (rSh.*rSh.fnSetCrsr)(&aDocPos,bOnlyText); 3465cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & nTmpSetCrsr); 3466cdf0e10cSrcweir bCallBase = sal_False; 3467cdf0e10cSrcweir } 3468cdf0e10cSrcweir 3469cdf0e10cSrcweir //#i42732# - notify the edit window that from now on we do not use the input language 3470cdf0e10cSrcweir if ( !(CRSR_POSOLD & nTmpSetCrsr) ) 3471cdf0e10cSrcweir SetUseInputLanguage( sal_False ); 3472cdf0e10cSrcweir 3473cdf0e10cSrcweir if( bLockView ) 3474cdf0e10cSrcweir rSh.LockView( sal_False ); 3475cdf0e10cSrcweir 3476cdf0e10cSrcweir bNoInterrupt = bTmpNoInterrupt; 3477cdf0e10cSrcweir } 3478cdf0e10cSrcweir if ( !bOverURLGrf && !bOnlyText ) 3479cdf0e10cSrcweir { 3480cdf0e10cSrcweir const int nSelType = rSh.GetSelectionType(); 3481cdf0e10cSrcweir // --> OD 2009-12-30 #i89920# 3482cdf0e10cSrcweir // Check in general, if an object is selectable at given position. 3483cdf0e10cSrcweir // Thus, also text fly frames in background become selectable via Ctrl-Click. 3484cdf0e10cSrcweir if ( nSelType & nsSelectionType::SEL_OLE || 3485cdf0e10cSrcweir nSelType & nsSelectionType::SEL_GRF || 3486cdf0e10cSrcweir rSh.IsObjSelectable( aDocPos ) ) 3487cdf0e10cSrcweir // <-- 3488cdf0e10cSrcweir { 3489cdf0e10cSrcweir MV_KONTEXT( &rSh ); 3490cdf0e10cSrcweir if( !rSh.IsFrmSelected() ) 3491cdf0e10cSrcweir rSh.GotoNextFly(); 3492cdf0e10cSrcweir rSh.EnterSelFrmMode(); 3493cdf0e10cSrcweir bCallBase = sal_False; 3494cdf0e10cSrcweir } 3495cdf0e10cSrcweir } 3496cdf0e10cSrcweir // nicht mehr hier zuruecksetzen, damit -- falls durch MouseMove 3497cdf0e10cSrcweir // bei gedrueckter Ctrl-Taste eine Mehrfachselektion erfolgen soll, 3498cdf0e10cSrcweir // im Drag nicht die vorherige Selektion aufgehoben wird. 3499cdf0e10cSrcweir // if(bModePushed) 3500cdf0e10cSrcweir // rSh.PopMode(sal_False); 3501cdf0e10cSrcweir break; 3502cdf0e10cSrcweir } 3503cdf0e10cSrcweir } 3504cdf0e10cSrcweir } 3505cdf0e10cSrcweir if (bCallBase) 3506cdf0e10cSrcweir Window::MouseButtonDown(rMEvt); 3507cdf0e10cSrcweir } 3508cdf0e10cSrcweir 3509cdf0e10cSrcweir /*-------------------------------------------------------------------- 3510cdf0e10cSrcweir Beschreibung: MouseMove 3511cdf0e10cSrcweir --------------------------------------------------------------------*/ 3512cdf0e10cSrcweir 3513cdf0e10cSrcweir 3514cdf0e10cSrcweir void SwEditWin::MouseMove(const MouseEvent& _rMEvt) 3515cdf0e10cSrcweir { 3516cdf0e10cSrcweir MouseEvent rMEvt(_rMEvt); 3517cdf0e10cSrcweir 3518cdf0e10cSrcweir //ignore key modifiers for format paintbrush 3519cdf0e10cSrcweir { 3520cdf0e10cSrcweir sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard 3521cdf0e10cSrcweir && pApplyTempl->pFormatClipboard->HasContent(); 3522cdf0e10cSrcweir if( bExecFormatPaintbrush ) 3523cdf0e10cSrcweir rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(), 3524cdf0e10cSrcweir _rMEvt.GetMode(), _rMEvt.GetButtons() ); 3525cdf0e10cSrcweir } 3526cdf0e10cSrcweir 3527cdf0e10cSrcweir // solange eine Action laeuft sollte das MouseMove abgeklemmt sein 3528cdf0e10cSrcweir // Ansonsten gibt es den Bug 40102 3529cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 3530cdf0e10cSrcweir if( rSh.ActionPend() ) 3531cdf0e10cSrcweir return ; 3532cdf0e10cSrcweir 3533cdf0e10cSrcweir if( pShadCrsr && 0 != (rMEvt.GetModifier() + rMEvt.GetButtons() ) ) 3534cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 3535cdf0e10cSrcweir 3536cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly(); 3537cdf0e10cSrcweir 3538cdf0e10cSrcweir SET_CURR_SHELL( &rSh ); 3539cdf0e10cSrcweir 3540cdf0e10cSrcweir //aPixPt == Point in Pixel, rel. zu ChildWin 3541cdf0e10cSrcweir //aDocPt == Point in Twips, Dokumentkoordinaten 3542cdf0e10cSrcweir const Point aPixPt( rMEvt.GetPosPixel() ); 3543cdf0e10cSrcweir const Point aDocPt( PixelToLogic( aPixPt ) ); 3544cdf0e10cSrcweir 3545cdf0e10cSrcweir if ( IsChainMode() ) 3546cdf0e10cSrcweir { 3547cdf0e10cSrcweir UpdatePointer( aDocPt, rMEvt.GetModifier() ); 3548cdf0e10cSrcweir if ( rMEvt.IsLeaveWindow() ) 3549cdf0e10cSrcweir rView.GetViewFrame()->HideStatusText(); 3550cdf0e10cSrcweir return; 3551cdf0e10cSrcweir } 3552cdf0e10cSrcweir 3553cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 3554cdf0e10cSrcweir 3555cdf0e10cSrcweir const SwCallMouseEvent aLastCallEvent( aSaveCallEvent ); 3556cdf0e10cSrcweir aSaveCallEvent.Clear(); 3557cdf0e10cSrcweir 3558cdf0e10cSrcweir if ( !bIsDocReadOnly && pSdrView && pSdrView->MouseMove(rMEvt,this) ) 3559cdf0e10cSrcweir { 3560cdf0e10cSrcweir SetPointer( POINTER_TEXT ); 3561cdf0e10cSrcweir return; // Event von der SdrView ausgewertet 3562cdf0e10cSrcweir } 3563cdf0e10cSrcweir 3564cdf0e10cSrcweir const Point aOldPt( rSh.VisArea().Pos() ); 3565cdf0e10cSrcweir #ifdef TEST_FOR_BUG91313 3566cdf0e10cSrcweir // n Pixel as FUZZY border 3567cdf0e10cSrcweir SwRect aVis( rSh.VisArea() ); 3568cdf0e10cSrcweir Size aFuzzySz( 2, 2 ); 3569cdf0e10cSrcweir aFuzzySz = PixelToLogic( aFuzzySz ); 3570cdf0e10cSrcweir 3571cdf0e10cSrcweir aVis.Top( aVis.Top() + aFuzzySz.Height() ); 3572cdf0e10cSrcweir aVis.Bottom( aVis.Bottom() - aFuzzySz.Height() ); 3573cdf0e10cSrcweir aVis.Left( aVis.Left() + aFuzzySz.Width() ); 3574cdf0e10cSrcweir aVis.Right( aVis.Right() - aFuzzySz.Width() ); 3575cdf0e10cSrcweir const sal_Bool bInsWin = aVis.IsInside( aDocPt ); 3576cdf0e10cSrcweir #else 3577cdf0e10cSrcweir const sal_Bool bInsWin = rSh.VisArea().IsInside( aDocPt ); 3578cdf0e10cSrcweir #endif 3579cdf0e10cSrcweir 3580cdf0e10cSrcweir if( pShadCrsr && !bInsWin ) 3581cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 3582cdf0e10cSrcweir 3583cdf0e10cSrcweir if( bInsWin && pRowColumnSelectionStart ) 3584cdf0e10cSrcweir { 3585cdf0e10cSrcweir EnterArea(); 3586cdf0e10cSrcweir Point aPos( aDocPt ); 3587cdf0e10cSrcweir if( rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag )) 3588cdf0e10cSrcweir return; 3589cdf0e10cSrcweir } 3590cdf0e10cSrcweir 3591cdf0e10cSrcweir // Position ist noetig fuer OS/2, da dort nach einem MB-Down 3592cdf0e10cSrcweir // offensichtlich sofort ein MB-Move gerufen wird. 3593cdf0e10cSrcweir if( bDDTimerStarted ) 3594cdf0e10cSrcweir { 3595cdf0e10cSrcweir Point aDD( SwEditWin::nDDStartPosX, SwEditWin::nDDStartPosY ); 3596cdf0e10cSrcweir aDD = LogicToPixel( aDD ); 3597cdf0e10cSrcweir Rectangle aRect( aDD.X()-3, aDD.Y()-3, aDD.X()+3, aDD.Y()+3 ); 3598cdf0e10cSrcweir if ( !aRect.IsInside( aPixPt ) ) // MA 23. May. 95: Tatterschutz. 3599cdf0e10cSrcweir StopDDTimer( &rSh, aDocPt ); 3600cdf0e10cSrcweir } 3601cdf0e10cSrcweir 3602cdf0e10cSrcweir if(rView.GetDrawFuncPtr()) 3603cdf0e10cSrcweir { 3604cdf0e10cSrcweir if( bInsDraw ) 3605cdf0e10cSrcweir { 3606cdf0e10cSrcweir rView.GetDrawFuncPtr()->MouseMove( rMEvt ); 3607cdf0e10cSrcweir if ( !bInsWin ) 3608cdf0e10cSrcweir { 3609cdf0e10cSrcweir Point aTmp( aDocPt ); 3610cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt; 3611cdf0e10cSrcweir LeaveArea( aTmp ); 3612cdf0e10cSrcweir } 3613cdf0e10cSrcweir else 3614cdf0e10cSrcweir EnterArea(); 3615cdf0e10cSrcweir return; 3616cdf0e10cSrcweir } 3617cdf0e10cSrcweir else if(!rSh.IsFrmSelected() && !rSh.IsObjSelected()) 3618cdf0e10cSrcweir { 3619cdf0e10cSrcweir SfxBindings &rBnd = rSh.GetView().GetViewFrame()->GetBindings(); 3620cdf0e10cSrcweir Point aRelPos = rSh.GetRelativePagePosition(aDocPt); 3621cdf0e10cSrcweir if(aRelPos.X() >= 0) 3622cdf0e10cSrcweir { 3623cdf0e10cSrcweir FieldUnit eMetric = ::GetDfltMetric(0 != PTR_CAST(SwWebView, &GetView())); 3624cdf0e10cSrcweir SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, static_cast< sal_uInt16 >(eMetric))); 3625cdf0e10cSrcweir const SfxPointItem aTmp1( SID_ATTR_POSITION, aRelPos ); 3626cdf0e10cSrcweir rBnd.SetState( aTmp1 ); 3627cdf0e10cSrcweir } 3628cdf0e10cSrcweir else 3629cdf0e10cSrcweir { 3630cdf0e10cSrcweir rBnd.Invalidate(SID_ATTR_POSITION); 3631cdf0e10cSrcweir } 3632cdf0e10cSrcweir rBnd.Invalidate(SID_ATTR_SIZE); 3633cdf0e10cSrcweir const SfxStringItem aCell( SID_TABLE_CELL, aEmptyStr ); 3634cdf0e10cSrcweir rBnd.SetState( aCell ); 3635cdf0e10cSrcweir } 3636cdf0e10cSrcweir } 3637cdf0e10cSrcweir 3638cdf0e10cSrcweir sal_uInt8 nMouseTabCol; 3639cdf0e10cSrcweir if( !bIsDocReadOnly && bInsWin && !pApplyTempl && !rSh.IsInSelect() ) 3640cdf0e10cSrcweir { 3641cdf0e10cSrcweir if ( SW_TABCOL_NONE != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPt ) ) && 3642cdf0e10cSrcweir !rSh.IsObjSelectable( aDocPt ) ) 3643cdf0e10cSrcweir { 3644cdf0e10cSrcweir sal_uInt16 nPointer = USHRT_MAX; 3645cdf0e10cSrcweir bool bChkTblSel = false; 3646cdf0e10cSrcweir 3647cdf0e10cSrcweir switch ( nMouseTabCol ) 3648cdf0e10cSrcweir { 3649cdf0e10cSrcweir case SW_TABCOL_VERT : 3650cdf0e10cSrcweir case SW_TABROW_HORI : 3651cdf0e10cSrcweir nPointer = POINTER_VSIZEBAR; 3652cdf0e10cSrcweir bChkTblSel = true; 3653cdf0e10cSrcweir break; 3654cdf0e10cSrcweir case SW_TABROW_VERT : 3655cdf0e10cSrcweir case SW_TABCOL_HORI : 3656cdf0e10cSrcweir nPointer = POINTER_HSIZEBAR; 3657cdf0e10cSrcweir bChkTblSel = true; 3658cdf0e10cSrcweir break; 3659cdf0e10cSrcweir // --> FME 2004-07-30 #i20126# Enhanced table selection 3660cdf0e10cSrcweir case SW_TABSEL_HORI : 3661cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_SE; 3662cdf0e10cSrcweir break; 3663cdf0e10cSrcweir case SW_TABSEL_HORI_RTL : 3664cdf0e10cSrcweir case SW_TABSEL_VERT : 3665cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_SW; 3666cdf0e10cSrcweir break; 3667cdf0e10cSrcweir case SW_TABCOLSEL_HORI : 3668cdf0e10cSrcweir case SW_TABROWSEL_VERT : 3669cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_S; 3670cdf0e10cSrcweir break; 3671cdf0e10cSrcweir case SW_TABROWSEL_HORI : 3672cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_E; 3673cdf0e10cSrcweir break; 3674cdf0e10cSrcweir case SW_TABROWSEL_HORI_RTL : 3675cdf0e10cSrcweir case SW_TABCOLSEL_VERT : 3676cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_W; 3677cdf0e10cSrcweir break; 3678cdf0e10cSrcweir // <-- 3679cdf0e10cSrcweir } 3680cdf0e10cSrcweir 3681cdf0e10cSrcweir if ( USHRT_MAX != nPointer && 3682cdf0e10cSrcweir // --> FME 2004-10-20 #i35543# 3683cdf0e10cSrcweir // Enhanced table selection is explicitely allowed in table mode 3684cdf0e10cSrcweir ( !bChkTblSel || !rSh.IsTableMode() ) ) 3685cdf0e10cSrcweir // <-- 3686cdf0e10cSrcweir { 3687cdf0e10cSrcweir SetPointer( nPointer ); 3688cdf0e10cSrcweir } 3689cdf0e10cSrcweir 3690cdf0e10cSrcweir return; 3691cdf0e10cSrcweir } 3692cdf0e10cSrcweir // #i23726# 3693cdf0e10cSrcweir else if (rSh.IsNumLabel(aDocPt, RULER_MOUSE_MARGINWIDTH)) 3694cdf0e10cSrcweir { 3695cdf0e10cSrcweir // --> OD 2005-02-21 #i42921# - consider vertical mode 3696cdf0e10cSrcweir SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPt ); 3697cdf0e10cSrcweir const sal_uInt16 nPointer = 3698cdf0e10cSrcweir rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPt ) 3699cdf0e10cSrcweir ? POINTER_VSIZEBAR 3700cdf0e10cSrcweir : POINTER_HSIZEBAR; 3701cdf0e10cSrcweir SetPointer( nPointer ); 3702cdf0e10cSrcweir // <-- 3703cdf0e10cSrcweir 3704cdf0e10cSrcweir return; 3705cdf0e10cSrcweir } 3706cdf0e10cSrcweir } 3707cdf0e10cSrcweir 3708cdf0e10cSrcweir sal_Bool bDelShadCrsr = sal_True; 3709cdf0e10cSrcweir 3710cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() ) 3711cdf0e10cSrcweir { 3712cdf0e10cSrcweir case MOUSE_LEFT: 3713cdf0e10cSrcweir if( pAnchorMarker ) 3714cdf0e10cSrcweir { 3715cdf0e10cSrcweir // Now we need to refresh the SdrHdl pointer of pAnchorMarker. 3716cdf0e10cSrcweir // This looks a little bit tricky, but it solves the following 3717cdf0e10cSrcweir // problem: the pAnchorMarker contains a pointer to an SdrHdl, 3718cdf0e10cSrcweir // if the FindAnchorPos-call cause a scrolling of the visible 3719cdf0e10cSrcweir // area, it's possible that the SdrHdl will be destroyed and a 3720cdf0e10cSrcweir // new one will initialized at the original position(GetHdlPos). 3721cdf0e10cSrcweir // So the pAnchorMarker has to find the right SdrHdl, if it's 3722cdf0e10cSrcweir // the old one, it will find it with position aOld, if this one 3723cdf0e10cSrcweir // is destroyed, it will find a new one at position GetHdlPos(). 3724cdf0e10cSrcweir // --> OD 2010-09-16 #i114522# 3725cdf0e10cSrcweir // const Point aOld = pAnchorMarker->GetPos(); 3726cdf0e10cSrcweir const Point aOld = pAnchorMarker->GetPosForHitTest( *(rSh.GetOut()) ); 3727cdf0e10cSrcweir // <-- 3728cdf0e10cSrcweir Point aNew = rSh.FindAnchorPos( aDocPt ); 3729cdf0e10cSrcweir SdrHdl* pHdl; 3730cdf0e10cSrcweir if( (0!=( pHdl = pSdrView->PickHandle( aOld ) )|| 3731cdf0e10cSrcweir 0 !=(pHdl = pSdrView->PickHandle( pAnchorMarker->GetHdlPos()) ) ) && 3732cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR || 3733cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) ) 3734cdf0e10cSrcweir { 3735cdf0e10cSrcweir pAnchorMarker->ChgHdl( pHdl ); 3736cdf0e10cSrcweir if( aNew.X() || aNew.Y() ) 3737cdf0e10cSrcweir { 3738cdf0e10cSrcweir pAnchorMarker->SetPos( aNew ); 3739cdf0e10cSrcweir pAnchorMarker->SetLastPos( aDocPt ); 3740cdf0e10cSrcweir //OLMpSdrView->RefreshAllIAOManagers(); 3741cdf0e10cSrcweir } 3742cdf0e10cSrcweir } 3743cdf0e10cSrcweir else 3744cdf0e10cSrcweir { 3745cdf0e10cSrcweir delete pAnchorMarker; 3746cdf0e10cSrcweir pAnchorMarker = NULL; 3747cdf0e10cSrcweir } 3748cdf0e10cSrcweir } 3749cdf0e10cSrcweir if ( bInsDraw ) 3750cdf0e10cSrcweir { 3751cdf0e10cSrcweir if ( !bMBPressed ) 3752cdf0e10cSrcweir break; 3753cdf0e10cSrcweir if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) ) 3754cdf0e10cSrcweir { 3755cdf0e10cSrcweir if ( !bInsWin ) 3756cdf0e10cSrcweir LeaveArea( aDocPt ); 3757cdf0e10cSrcweir else 3758cdf0e10cSrcweir EnterArea(); 3759cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() ) 3760cdf0e10cSrcweir { 3761cdf0e10cSrcweir pSdrView->SetOrtho(sal_False); 3762cdf0e10cSrcweir rView.GetDrawFuncPtr()->MouseMove( rMEvt ); 3763cdf0e10cSrcweir } 3764cdf0e10cSrcweir bIsInMove = sal_True; 3765cdf0e10cSrcweir } 3766cdf0e10cSrcweir return; 3767cdf0e10cSrcweir } 3768cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT: 3769cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1: 3770cdf0e10cSrcweir if ( !bMBPressed ) 3771cdf0e10cSrcweir break; 3772cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1: 3773cdf0e10cSrcweir if ( bFrmDrag && rSh.IsSelFrmMode() ) 3774cdf0e10cSrcweir { 3775cdf0e10cSrcweir if( !bMBPressed ) 3776cdf0e10cSrcweir break; 3777cdf0e10cSrcweir 3778cdf0e10cSrcweir if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) ) 3779cdf0e10cSrcweir { 3780cdf0e10cSrcweir // Event-Verarbeitung fuers Resizen 3781cdf0e10cSrcweir if( pSdrView->AreObjectsMarked() ) 3782cdf0e10cSrcweir { 3783cdf0e10cSrcweir const SwFrmFmt* pFlyFmt; 3784cdf0e10cSrcweir const SvxMacro* pMacro; 3785cdf0e10cSrcweir 3786cdf0e10cSrcweir const Point aSttPt( PixelToLogic( aStartPos ) ); 3787cdf0e10cSrcweir 3788cdf0e10cSrcweir // geht es los? 3789cdf0e10cSrcweir if( HDL_USER == eSdrMoveHdl ) 3790cdf0e10cSrcweir { 3791cdf0e10cSrcweir SdrHdl* pHdl = pSdrView->PickHandle( aSttPt ); 3792cdf0e10cSrcweir eSdrMoveHdl = pHdl ? pHdl->GetKind() : HDL_MOVE; 3793cdf0e10cSrcweir } 3794cdf0e10cSrcweir 3795cdf0e10cSrcweir sal_uInt16 nEvent = HDL_MOVE == eSdrMoveHdl 3796cdf0e10cSrcweir ? SW_EVENT_FRM_MOVE 3797cdf0e10cSrcweir : SW_EVENT_FRM_RESIZE; 3798cdf0e10cSrcweir 3799cdf0e10cSrcweir if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) && 3800cdf0e10cSrcweir 0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable(). 3801cdf0e10cSrcweir Get( nEvent )) && 3802cdf0e10cSrcweir // oder nur z.B. alle 20 Twip bescheid sagen? 3803cdf0e10cSrcweir // ( 20 > Abs( aRszMvHdlPt.X() - aDocPt.X() ) || 3804cdf0e10cSrcweir // 20 > Abs( aRszMvHdlPt.Y() - aDocPt.Y() ) ) 3805cdf0e10cSrcweir aRszMvHdlPt != aDocPt ) 3806cdf0e10cSrcweir { 3807cdf0e10cSrcweir aRszMvHdlPt = aDocPt; 3808cdf0e10cSrcweir sal_uInt16 nPos = 0; 3809cdf0e10cSrcweir String sRet; 3810cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray; 3811cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable; 3812cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() ); 3813cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 3814cdf0e10cSrcweir 3815cdf0e10cSrcweir if( SW_EVENT_FRM_RESIZE == nEvent ) 3816cdf0e10cSrcweir { 3817cdf0e10cSrcweir xVar = new SbxVariable; 3818cdf0e10cSrcweir xVar->PutUShort( static_cast< sal_uInt16 >(eSdrMoveHdl) ); 3819cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 3820cdf0e10cSrcweir } 3821cdf0e10cSrcweir 3822cdf0e10cSrcweir xVar = new SbxVariable; 3823cdf0e10cSrcweir xVar->PutLong( aDocPt.X() - aSttPt.X() ); 3824cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 3825cdf0e10cSrcweir xVar = new SbxVariable; 3826cdf0e10cSrcweir xVar->PutLong( aDocPt.Y() - aSttPt.Y() ); 3827cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 3828cdf0e10cSrcweir 3829cdf0e10cSrcweir ReleaseMouse(); 3830cdf0e10cSrcweir 3831cdf0e10cSrcweir rSh.ExecMacro( *pMacro, &sRet, &xArgs ); 3832cdf0e10cSrcweir 3833cdf0e10cSrcweir CaptureMouse(); 3834cdf0e10cSrcweir 3835cdf0e10cSrcweir if( sRet.Len() && 0 != sRet.ToInt32() ) 3836cdf0e10cSrcweir return ; 3837cdf0e10cSrcweir } 3838cdf0e10cSrcweir } 3839cdf0e10cSrcweir // Event-Verarbeitung fuers Resizen 3840cdf0e10cSrcweir 3841cdf0e10cSrcweir if( bIsDocReadOnly ) 3842cdf0e10cSrcweir break; 3843cdf0e10cSrcweir 3844cdf0e10cSrcweir if ( rMEvt.IsShift() ) 3845cdf0e10cSrcweir { 3846cdf0e10cSrcweir pSdrView->SetOrtho(sal_True); 3847cdf0e10cSrcweir pSdrView->SetAngleSnapEnabled(sal_True); 3848cdf0e10cSrcweir } 3849cdf0e10cSrcweir else 3850cdf0e10cSrcweir { 3851cdf0e10cSrcweir pSdrView->SetOrtho(sal_False); 3852cdf0e10cSrcweir pSdrView->SetAngleSnapEnabled(sal_False); 3853cdf0e10cSrcweir } 3854cdf0e10cSrcweir 3855cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt, rMEvt.IsShift() ); 3856cdf0e10cSrcweir bIsInMove = sal_True; 3857cdf0e10cSrcweir } 3858cdf0e10cSrcweir else if( bIsDocReadOnly ) 3859cdf0e10cSrcweir break; 3860cdf0e10cSrcweir 3861cdf0e10cSrcweir if ( !bInsWin ) 3862cdf0e10cSrcweir { 3863cdf0e10cSrcweir Point aTmp( aDocPt ); 3864cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt; 3865cdf0e10cSrcweir LeaveArea( aTmp ); 3866cdf0e10cSrcweir } 3867cdf0e10cSrcweir else if(bIsInMove) 3868cdf0e10cSrcweir EnterArea(); 3869cdf0e10cSrcweir return; 3870cdf0e10cSrcweir } 3871cdf0e10cSrcweir if ( !rSh.IsSelFrmMode() && !bDDINetAttr && 3872cdf0e10cSrcweir (IsMinMove( aStartPos,aPixPt ) || bIsInMove) && 3873cdf0e10cSrcweir (rSh.IsInSelect() || !rSh.ChgCurrPam( aDocPt )) ) 3874cdf0e10cSrcweir { 3875cdf0e10cSrcweir if ( pSdrView ) 3876cdf0e10cSrcweir { 3877cdf0e10cSrcweir if ( rMEvt.IsShift() ) 3878cdf0e10cSrcweir pSdrView->SetOrtho(sal_True); 3879cdf0e10cSrcweir else 3880cdf0e10cSrcweir pSdrView->SetOrtho(sal_False); 3881cdf0e10cSrcweir } 3882cdf0e10cSrcweir if ( !bInsWin ) 3883cdf0e10cSrcweir { 3884cdf0e10cSrcweir Point aTmp( aDocPt ); 3885cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt; 3886cdf0e10cSrcweir LeaveArea( aTmp ); 3887cdf0e10cSrcweir } 3888cdf0e10cSrcweir else 3889cdf0e10cSrcweir { 3890cdf0e10cSrcweir //JP 24.09.98: Fix fuer die Bugs 55592 / 55931 3891cdf0e10cSrcweir //JP 23.04.99: Fix fuer den Bugs 65289 3892cdf0e10cSrcweir //JP 06.07.99: Fix fuer den Bugs 67360 3893cdf0e10cSrcweir if( !rMEvt.IsSynthetic() && 3894cdf0e10cSrcweir !(( MOUSE_LEFT + KEY_MOD1 == 3895cdf0e10cSrcweir rMEvt.GetModifier() + rMEvt.GetButtons() ) && 3896cdf0e10cSrcweir rSh.Is_FnDragEQBeginDrag() && !rSh.IsAddMode() )) 3897cdf0e10cSrcweir { 3898cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt,sal_False ); 3899cdf0e10cSrcweir 3900cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False)); 3901cdf0e10cSrcweir EnterArea(); 3902cdf0e10cSrcweir } 3903cdf0e10cSrcweir } 3904cdf0e10cSrcweir } 3905cdf0e10cSrcweir bDDINetAttr = sal_False; 3906cdf0e10cSrcweir break; 3907cdf0e10cSrcweir case 0: 3908cdf0e10cSrcweir { 3909cdf0e10cSrcweir if ( pApplyTempl ) 3910cdf0e10cSrcweir { 3911cdf0e10cSrcweir UpdatePointer(aDocPt, 0); // evtl. muss hier ein Rahmen markiert werden 3912cdf0e10cSrcweir break; 3913cdf0e10cSrcweir } 3914cdf0e10cSrcweir //#i6193#, change ui if mouse is over SwPostItField 3915cdf0e10cSrcweir // TODO: do the same thing for redlines SW_REDLINE 3916cdf0e10cSrcweir SwRect aFldRect; 3917cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_FIELD); 3918cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_False, &aFldRect ) ) 3919cdf0e10cSrcweir { 3920cdf0e10cSrcweir const SwField* pFld = aCntntAtPos.aFnd.pFld; 3921cdf0e10cSrcweir if (pFld->Which()== RES_POSTITFLD) 3922cdf0e10cSrcweir { 3923cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(reinterpret_cast<const SwPostItField*>(pFld),false); 3924cdf0e10cSrcweir } 3925cdf0e10cSrcweir else 3926cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(0,false); 3927cdf0e10cSrcweir } 3928cdf0e10cSrcweir else 3929cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(0,false); 3930cdf0e10cSrcweir // no break; 3931cdf0e10cSrcweir } 3932cdf0e10cSrcweir case KEY_SHIFT: 3933cdf0e10cSrcweir case KEY_MOD2: 3934cdf0e10cSrcweir case KEY_MOD1: 3935cdf0e10cSrcweir if ( !bInsDraw ) 3936cdf0e10cSrcweir { 3937cdf0e10cSrcweir sal_Bool bTstShdwCrsr = sal_True; 3938cdf0e10cSrcweir 3939cdf0e10cSrcweir UpdatePointer( aDocPt, rMEvt.GetModifier() ); 3940cdf0e10cSrcweir 3941cdf0e10cSrcweir const SwFrmFmt* pFmt = 0; 3942cdf0e10cSrcweir const SwFmtINetFmt* pINet = 0; 3943cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR ); 3944cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos ) ) 3945cdf0e10cSrcweir pINet = (SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr; 3946cdf0e10cSrcweir 3947cdf0e10cSrcweir const void* pTmp = pINet; 3948cdf0e10cSrcweir 3949cdf0e10cSrcweir if( pINet || 3950cdf0e10cSrcweir 0 != ( pTmp = pFmt = rSh.GetFmtFromAnyObj( aDocPt ))) 3951cdf0e10cSrcweir { 3952cdf0e10cSrcweir bTstShdwCrsr = sal_False; 3953cdf0e10cSrcweir if( pTmp == pINet ) 3954cdf0e10cSrcweir aSaveCallEvent.Set( pINet ); 3955cdf0e10cSrcweir else 3956cdf0e10cSrcweir { 3957cdf0e10cSrcweir IMapObject* pIMapObj = pFmt->GetIMapObject( aDocPt ); 3958cdf0e10cSrcweir if( pIMapObj ) 3959cdf0e10cSrcweir aSaveCallEvent.Set( pFmt, pIMapObj ); 3960cdf0e10cSrcweir else 3961cdf0e10cSrcweir aSaveCallEvent.Set( EVENT_OBJECT_URLITEM, pFmt ); 3962cdf0e10cSrcweir } 3963cdf0e10cSrcweir 3964cdf0e10cSrcweir // sollte wir ueber einem InternetFeld mit einem 3965cdf0e10cSrcweir // gebundenen Macro stehen? 3966cdf0e10cSrcweir if( aSaveCallEvent != aLastCallEvent ) 3967cdf0e10cSrcweir { 3968cdf0e10cSrcweir if( aLastCallEvent.HasEvent() ) 3969cdf0e10cSrcweir rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT, 3970cdf0e10cSrcweir aLastCallEvent, sal_True ); 3971cdf0e10cSrcweir // 0 besagt, das das Object gar keine Tabelle hat 3972cdf0e10cSrcweir if( !rSh.CallEvent( SFX_EVENT_MOUSEOVER_OBJECT, 3973cdf0e10cSrcweir aSaveCallEvent )) 3974cdf0e10cSrcweir aSaveCallEvent.Clear(); 3975cdf0e10cSrcweir } 3976cdf0e10cSrcweir } 3977cdf0e10cSrcweir else if( aLastCallEvent.HasEvent() ) 3978cdf0e10cSrcweir { 3979cdf0e10cSrcweir // Cursor stand auf einem Object 3980cdf0e10cSrcweir rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT, 3981cdf0e10cSrcweir aLastCallEvent, sal_True ); 3982cdf0e10cSrcweir } 3983cdf0e10cSrcweir 3984cdf0e10cSrcweir if( bTstShdwCrsr && bInsWin && !bIsDocReadOnly && 3985cdf0e10cSrcweir !bInsFrm && 3986cdf0e10cSrcweir !rSh.GetViewOptions()->getBrowseMode() && 3987cdf0e10cSrcweir rSh.GetViewOptions()->IsShadowCursor() && 3988cdf0e10cSrcweir !(rMEvt.GetModifier() + rMEvt.GetButtons()) && 3989cdf0e10cSrcweir !rSh.HasSelection() && !GetConnectMetaFile() ) 3990cdf0e10cSrcweir { 3991cdf0e10cSrcweir SwRect aRect; 3992cdf0e10cSrcweir sal_Int16 eOrient; 3993cdf0e10cSrcweir SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode(); 3994cdf0e10cSrcweir if( rSh.GetShadowCrsrPos( aDocPt, eMode, aRect, eOrient )) 3995cdf0e10cSrcweir { 3996cdf0e10cSrcweir if( !pShadCrsr ) 3997cdf0e10cSrcweir pShadCrsr = new SwShadowCursor( *this, 3998cdf0e10cSrcweir SwViewOption::GetDirectCursorColor() ); 3999cdf0e10cSrcweir if( text::HoriOrientation::RIGHT != eOrient && text::HoriOrientation::CENTER != eOrient ) 4000cdf0e10cSrcweir eOrient = text::HoriOrientation::LEFT; 4001cdf0e10cSrcweir pShadCrsr->SetPos( aRect.Pos(), aRect.Height(), static_cast< sal_uInt16 >(eOrient) ); 4002cdf0e10cSrcweir bDelShadCrsr = sal_False; 4003cdf0e10cSrcweir } 4004cdf0e10cSrcweir } 4005cdf0e10cSrcweir } 4006cdf0e10cSrcweir break; 4007cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2: 4008cdf0e10cSrcweir if( rSh.IsBlockMode() && !rMEvt.IsSynthetic() ) 4009cdf0e10cSrcweir { 4010cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt,sal_False ); 4011cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False)); 4012cdf0e10cSrcweir EnterArea(); 4013cdf0e10cSrcweir } 4014cdf0e10cSrcweir break; 4015cdf0e10cSrcweir } 4016cdf0e10cSrcweir 4017cdf0e10cSrcweir if( bDelShadCrsr && pShadCrsr ) 4018cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 4019cdf0e10cSrcweir bWasShdwCrsr = sal_False; 4020cdf0e10cSrcweir } 4021cdf0e10cSrcweir 4022cdf0e10cSrcweir /*-------------------------------------------------------------------- 4023cdf0e10cSrcweir Beschreibung: Button Up 4024cdf0e10cSrcweir --------------------------------------------------------------------*/ 4025cdf0e10cSrcweir 4026cdf0e10cSrcweir 4027cdf0e10cSrcweir void SwEditWin::MouseButtonUp(const MouseEvent& rMEvt) 4028cdf0e10cSrcweir { 4029cdf0e10cSrcweir sal_Bool bCallBase = sal_True; 4030cdf0e10cSrcweir 4031cdf0e10cSrcweir sal_Bool bCallShadowCrsr = bWasShdwCrsr; 4032cdf0e10cSrcweir bWasShdwCrsr = sal_False; 4033cdf0e10cSrcweir if( pShadCrsr ) 4034cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 4035cdf0e10cSrcweir 4036cdf0e10cSrcweir if( pRowColumnSelectionStart ) 4037cdf0e10cSrcweir DELETEZ( pRowColumnSelectionStart ); 4038cdf0e10cSrcweir 4039cdf0e10cSrcweir SdrHdlKind eOldSdrMoveHdl = eSdrMoveHdl; 4040cdf0e10cSrcweir eSdrMoveHdl = HDL_USER; // fuer die MoveEvents - wieder zuruecksetzen 4041cdf0e10cSrcweir 4042cdf0e10cSrcweir // sicherheitshalber zuruecksetzen Bug 27900 4043cdf0e10cSrcweir rView.SetTabColFromDoc( sal_False ); 4044cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc(NULL); 4045cdf0e10cSrcweir 4046cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 4047cdf0e10cSrcweir SET_CURR_SHELL( &rSh ); 4048cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 4049cdf0e10cSrcweir if ( pSdrView ) 4050cdf0e10cSrcweir { 4051cdf0e10cSrcweir pSdrView->SetOrtho(sal_False); 4052cdf0e10cSrcweir 4053cdf0e10cSrcweir if ( pSdrView->MouseButtonUp( rMEvt,this ) ) 4054cdf0e10cSrcweir { 4055cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False); 4056cdf0e10cSrcweir return; // Event von der SdrView ausgewertet 4057cdf0e10cSrcweir } 4058cdf0e10cSrcweir } 4059cdf0e10cSrcweir //MouseButtonUp nur bearbeiten, wenn auch das Down an dieses Fenster ging. 4060cdf0e10cSrcweir if ( !bMBPressed ) 4061cdf0e10cSrcweir { 4062cdf0e10cSrcweir // OS 25.02.97 Undo fuer die Giesskann ist bereits im CommandHdl 4063cdf0e10cSrcweir //JP 29.09.95: so sollte es sein!!! if(pApplyTempl->bUndo) 4064cdf0e10cSrcweir // if( pApplyTempl && MOUSE_RIGHT == rMEvt.GetModifier() + rMEvt.GetButtons() ) 4065cdf0e10cSrcweir // rSh.Do( SwWrtShell::UNDO ); 4066cdf0e10cSrcweir return; 4067cdf0e10cSrcweir } 4068cdf0e10cSrcweir 4069cdf0e10cSrcweir Point aDocPt( PixelToLogic( rMEvt.GetPosPixel() ) ); 4070cdf0e10cSrcweir 4071cdf0e10cSrcweir if ( bDDTimerStarted ) 4072cdf0e10cSrcweir { 4073cdf0e10cSrcweir StopDDTimer( &rSh, aDocPt ); 4074cdf0e10cSrcweir bMBPressed = sal_False; 4075cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 4076cdf0e10cSrcweir { 4077cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False ); 4078cdf0e10cSrcweir bFrmDrag = sal_False; 4079cdf0e10cSrcweir } 4080cdf0e10cSrcweir bNoInterrupt = sal_False; 4081cdf0e10cSrcweir ReleaseMouse(); 4082cdf0e10cSrcweir return; 4083cdf0e10cSrcweir } 4084cdf0e10cSrcweir 4085cdf0e10cSrcweir if( pAnchorMarker ) 4086cdf0e10cSrcweir { 40874772d9afSArmin Le Grand if(pAnchorMarker->GetHdl()) 40884772d9afSArmin Le Grand { 40894772d9afSArmin Le Grand // #121463# delete selected after drag 40904772d9afSArmin Le Grand pAnchorMarker->GetHdl()->SetSelected(false); 40914772d9afSArmin Le Grand } 40924772d9afSArmin Le Grand 4093cdf0e10cSrcweir Point aPnt( pAnchorMarker->GetLastPos() ); 4094cdf0e10cSrcweir //OLMpSdrView->RefreshAllIAOManagers(); 4095cdf0e10cSrcweir DELETEZ( pAnchorMarker ); 4096cdf0e10cSrcweir if( aPnt.X() || aPnt.Y() ) 4097cdf0e10cSrcweir rSh.FindAnchorPos( aPnt, sal_True ); 4098cdf0e10cSrcweir } 4099cdf0e10cSrcweir if ( bInsDraw && rView.GetDrawFuncPtr() ) 4100cdf0e10cSrcweir { 4101cdf0e10cSrcweir if ( rView.GetDrawFuncPtr()->MouseButtonUp( rMEvt ) ) 4102cdf0e10cSrcweir { 4103cdf0e10cSrcweir if (rView.GetDrawFuncPtr()) // Koennte im MouseButtonUp zerstoert worden sein 4104cdf0e10cSrcweir { 4105cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 4106cdf0e10cSrcweir 4107cdf0e10cSrcweir if (!rView.IsDrawMode()) 4108cdf0e10cSrcweir { 4109cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 4110cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings(); 4111cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_SIZE ); 4112cdf0e10cSrcweir rBind.Invalidate( SID_TABLE_CELL ); 4113cdf0e10cSrcweir } 4114cdf0e10cSrcweir } 4115cdf0e10cSrcweir 4116cdf0e10cSrcweir if ( rSh.IsObjSelected() ) 4117cdf0e10cSrcweir { 4118cdf0e10cSrcweir rSh.EnterSelFrmMode(); 4119cdf0e10cSrcweir if (!rView.GetDrawFuncPtr()) 4120cdf0e10cSrcweir StdDrawMode( OBJ_NONE, sal_True ); 4121cdf0e10cSrcweir } 4122cdf0e10cSrcweir else if ( rSh.IsFrmSelected() ) 4123cdf0e10cSrcweir { 4124cdf0e10cSrcweir rSh.EnterSelFrmMode(); 4125cdf0e10cSrcweir StopInsFrm(); 4126cdf0e10cSrcweir } 4127cdf0e10cSrcweir else 4128cdf0e10cSrcweir { 4129cdf0e10cSrcweir const Point aDocPos( PixelToLogic( aStartPos ) ); 4130cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False)); 4131cdf0e10cSrcweir rSh.Edit(); 4132cdf0e10cSrcweir } 4133cdf0e10cSrcweir 4134cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 4135cdf0e10cSrcweir } 4136cdf0e10cSrcweir else if (rMEvt.GetButtons() == MOUSE_RIGHT && rSh.IsDrawCreate()) 4137cdf0e10cSrcweir rView.GetDrawFuncPtr()->BreakCreate(); // Zeichnen abbrechen 4138cdf0e10cSrcweir 4139cdf0e10cSrcweir bNoInterrupt = sal_False; 4140cdf0e10cSrcweir ReleaseMouse(); 4141cdf0e10cSrcweir return; 4142cdf0e10cSrcweir } 4143cdf0e10cSrcweir sal_Bool bPopMode = sal_False; 4144cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() ) 4145cdf0e10cSrcweir { 4146cdf0e10cSrcweir case MOUSE_LEFT: 4147cdf0e10cSrcweir if ( bInsDraw && rSh.IsDrawCreate() ) 4148cdf0e10cSrcweir { 4149cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->MouseButtonUp(rMEvt) == sal_True ) 4150cdf0e10cSrcweir { 4151cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 4152cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 4153cdf0e10cSrcweir if ( rSh.IsObjSelected() ) 4154cdf0e10cSrcweir rSh.EnterSelFrmMode(); 4155cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm ) 4156cdf0e10cSrcweir StopInsFrm(); 4157cdf0e10cSrcweir } 4158cdf0e10cSrcweir bCallBase = sal_False; 4159cdf0e10cSrcweir break; 4160cdf0e10cSrcweir } 4161cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1: 4162cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2: 4163cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1: 4164cdf0e10cSrcweir if ( bFrmDrag && rSh.IsSelFrmMode() ) 4165cdf0e10cSrcweir { 4166cdf0e10cSrcweir if ( rMEvt.IsMod1() ) //Kopieren und nicht moven. 4167cdf0e10cSrcweir { 4168cdf0e10cSrcweir //Drag abbrechen, statt dessen internes Copy verwenden 4169cdf0e10cSrcweir Rectangle aRect; 4170cdf0e10cSrcweir rSh.GetDrawView()->TakeActionRect( aRect ); 4171cdf0e10cSrcweir if (!aRect.IsEmpty()) 4172cdf0e10cSrcweir { 4173cdf0e10cSrcweir rSh.BreakDrag(); 4174cdf0e10cSrcweir Point aEndPt, aSttPt; 4175cdf0e10cSrcweir if ( rSh.GetSelFrmType() & FRMTYPE_FLY_ATCNT ) 4176cdf0e10cSrcweir { 4177cdf0e10cSrcweir aEndPt = aRect.TopLeft(); 4178cdf0e10cSrcweir aSttPt = rSh.GetDrawView()->GetAllMarkedRect().TopLeft(); 4179cdf0e10cSrcweir } 4180cdf0e10cSrcweir else 4181cdf0e10cSrcweir { 4182cdf0e10cSrcweir aEndPt = aRect.Center(); 4183cdf0e10cSrcweir aSttPt = rSh.GetDrawView()->GetAllMarkedRect().Center(); 4184cdf0e10cSrcweir } 4185cdf0e10cSrcweir if ( aSttPt != aEndPt ) 4186cdf0e10cSrcweir { 4187cdf0e10cSrcweir rSh.StartUndo( UNDO_UI_DRAG_AND_COPY ); 4188cdf0e10cSrcweir rSh.Copy(&rSh, aSttPt, aEndPt, sal_False); 4189cdf0e10cSrcweir rSh.EndUndo( UNDO_UI_DRAG_AND_COPY ); 4190cdf0e10cSrcweir } 4191cdf0e10cSrcweir } 4192cdf0e10cSrcweir else 4193cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt,sal_False ); 4194cdf0e10cSrcweir } 4195cdf0e10cSrcweir else 4196cdf0e10cSrcweir { 4197cdf0e10cSrcweir { 4198cdf0e10cSrcweir const SwFrmFmt* pFlyFmt; 4199cdf0e10cSrcweir const SvxMacro* pMacro; 4200cdf0e10cSrcweir 4201cdf0e10cSrcweir sal_uInt16 nEvent = HDL_MOVE == eOldSdrMoveHdl 4202cdf0e10cSrcweir ? SW_EVENT_FRM_MOVE 4203cdf0e10cSrcweir : SW_EVENT_FRM_RESIZE; 4204cdf0e10cSrcweir 4205cdf0e10cSrcweir if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) && 4206cdf0e10cSrcweir 0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable(). 4207cdf0e10cSrcweir Get( nEvent )) ) 4208cdf0e10cSrcweir { 4209cdf0e10cSrcweir const Point aSttPt( PixelToLogic( aStartPos ) ); 4210cdf0e10cSrcweir aRszMvHdlPt = aDocPt; 4211cdf0e10cSrcweir sal_uInt16 nPos = 0; 4212cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray; 4213cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable; 4214cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() ); 4215cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 4216cdf0e10cSrcweir 4217cdf0e10cSrcweir if( SW_EVENT_FRM_RESIZE == nEvent ) 4218cdf0e10cSrcweir { 4219cdf0e10cSrcweir xVar = new SbxVariable; 4220cdf0e10cSrcweir xVar->PutUShort( static_cast< sal_uInt16 >(eOldSdrMoveHdl) ); 4221cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 4222cdf0e10cSrcweir } 4223cdf0e10cSrcweir 4224cdf0e10cSrcweir xVar = new SbxVariable; 4225cdf0e10cSrcweir xVar->PutLong( aDocPt.X() - aSttPt.X() ); 4226cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 4227cdf0e10cSrcweir xVar = new SbxVariable; 4228cdf0e10cSrcweir xVar->PutLong( aDocPt.Y() - aSttPt.Y() ); 4229cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 4230cdf0e10cSrcweir 4231cdf0e10cSrcweir xVar = new SbxVariable; 4232cdf0e10cSrcweir xVar->PutUShort( 1 ); 4233cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos ); 4234cdf0e10cSrcweir 4235cdf0e10cSrcweir ReleaseMouse(); 4236cdf0e10cSrcweir 4237cdf0e10cSrcweir rSh.ExecMacro( *pMacro, 0, &xArgs ); 4238cdf0e10cSrcweir 4239cdf0e10cSrcweir CaptureMouse(); 4240cdf0e10cSrcweir } 4241cdf0e10cSrcweir } 4242cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt,sal_False ); 4243cdf0e10cSrcweir } 4244cdf0e10cSrcweir bFrmDrag = sal_False; 4245cdf0e10cSrcweir bCallBase = sal_False; 4246cdf0e10cSrcweir break; 4247cdf0e10cSrcweir } 4248cdf0e10cSrcweir bPopMode = sal_True; 4249cdf0e10cSrcweir // no break 4250cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT: 4251cdf0e10cSrcweir if (rSh.IsSelFrmMode()) 4252cdf0e10cSrcweir { 4253cdf0e10cSrcweir 4254cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False ); 4255cdf0e10cSrcweir bFrmDrag = sal_False; 4256cdf0e10cSrcweir bCallBase = sal_False; 4257cdf0e10cSrcweir break; 4258cdf0e10cSrcweir } 4259cdf0e10cSrcweir 4260cdf0e10cSrcweir if( bHoldSelection ) 4261cdf0e10cSrcweir { 4262cdf0e10cSrcweir //JP 27.04.99: Bug 65389 - das EndDrag sollte auf jedenfall 4263cdf0e10cSrcweir // gerufen werden. 4264cdf0e10cSrcweir bHoldSelection = sal_False; 4265cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False ); 4266cdf0e10cSrcweir } 4267cdf0e10cSrcweir else 4268cdf0e10cSrcweir { 4269cdf0e10cSrcweir if ( !rSh.IsInSelect() && rSh.ChgCurrPam( aDocPt ) ) 4270cdf0e10cSrcweir { 4271cdf0e10cSrcweir const sal_Bool bTmpNoInterrupt = bNoInterrupt; 4272cdf0e10cSrcweir bNoInterrupt = sal_False; 4273cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die 4274cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!! 4275cdf0e10cSrcweir MV_KONTEXT( &rSh ); 4276cdf0e10cSrcweir const Point aDocPos( PixelToLogic( aStartPos ) ); 4277cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False)); 4278cdf0e10cSrcweir } 4279cdf0e10cSrcweir bNoInterrupt = bTmpNoInterrupt; 4280cdf0e10cSrcweir 4281cdf0e10cSrcweir } 4282cdf0e10cSrcweir else 4283cdf0e10cSrcweir { 4284cdf0e10cSrcweir sal_Bool bInSel = rSh.IsInSelect(); 4285cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False ); 4286cdf0e10cSrcweir 4287cdf0e10cSrcweir // Internetfield? --> Link-Callen (DocLaden!!) 4288cdf0e10cSrcweir //JP 18.10.96: Bug 32437 - 4289cdf0e10cSrcweir // if( !rSh.HasSelection() ) 4290cdf0e10cSrcweir if( !bInSel ) 4291cdf0e10cSrcweir { 4292cdf0e10cSrcweir sal_uInt16 nFilter = URLLOAD_NOFILTER; 4293cdf0e10cSrcweir if( KEY_MOD1 == rMEvt.GetModifier() ) 4294cdf0e10cSrcweir nFilter |= URLLOAD_NEWVIEW; 4295cdf0e10cSrcweir 4296cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly(); 4297cdf0e10cSrcweir if ( !bExecHyperlinks ) 4298cdf0e10cSrcweir { 4299cdf0e10cSrcweir SvtSecurityOptions aSecOpts; 4300cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK ); 4301cdf0e10cSrcweir if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) || 4302cdf0e10cSrcweir ( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) ) 4303cdf0e10cSrcweir bExecHyperlinks = sal_True; 4304cdf0e10cSrcweir } 4305cdf0e10cSrcweir 4306cdf0e10cSrcweir const sal_Bool bExecSmarttags = rMEvt.GetModifier() == KEY_MOD1; 4307cdf0e10cSrcweir 4308cdf0e10cSrcweir if(pApplyTempl) 4309cdf0e10cSrcweir bExecHyperlinks = sal_False; 4310cdf0e10cSrcweir 4311cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD | 4312cdf0e10cSrcweir SwContentAtPos::SW_INETATTR | 4313cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG | SwContentAtPos::SW_FORMCTRL); 4314cdf0e10cSrcweir 4315cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) ) 4316cdf0e10cSrcweir { 4317cdf0e10cSrcweir sal_Bool bViewLocked = rSh.IsViewLocked(); 4318cdf0e10cSrcweir if( !bViewLocked && !rSh.IsReadOnlyAvailable() && 4319cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() ) 4320cdf0e10cSrcweir rSh.LockView( sal_True ); 4321cdf0e10cSrcweir 4322cdf0e10cSrcweir ReleaseMouse(); 4323cdf0e10cSrcweir 4324cdf0e10cSrcweir if( SwContentAtPos::SW_FIELD == aCntntAtPos.eCntntAtPos ) 4325cdf0e10cSrcweir { 4326cdf0e10cSrcweir rSh.ClickToField( *aCntntAtPos.aFnd.pFld ); 4327cdf0e10cSrcweir } 4328cdf0e10cSrcweir else if ( SwContentAtPos::SW_SMARTTAG == aCntntAtPos.eCntntAtPos ) 4329cdf0e10cSrcweir { 4330cdf0e10cSrcweir // execute smarttag menu 4331cdf0e10cSrcweir if ( bExecSmarttags && SwSmartTagMgr::Get().IsSmartTagsEnabled() ) 4332cdf0e10cSrcweir rView.ExecSmartTagPopup( aDocPt ); 4333cdf0e10cSrcweir } 4334cdf0e10cSrcweir else if ( SwContentAtPos::SW_FORMCTRL == aCntntAtPos.eCntntAtPos ) 4335cdf0e10cSrcweir { 4336cdf0e10cSrcweir ASSERT( aCntntAtPos.aFnd.pFldmark != NULL, "where is my field ptr???"); 4337cdf0e10cSrcweir if ( aCntntAtPos.aFnd.pFldmark != NULL) 4338cdf0e10cSrcweir { 4339cdf0e10cSrcweir IFieldmark *fieldBM = const_cast< IFieldmark* > ( aCntntAtPos.aFnd.pFldmark ); 4340cdf0e10cSrcweir //SwDocShell* pDocSh = rView.GetDocShell(); 4341cdf0e10cSrcweir //SwDoc *pDoc=pDocSh->GetDoc(); 4342cdf0e10cSrcweir if (fieldBM->GetFieldname( ).equalsAscii( ODF_FORMCHECKBOX ) ) 4343cdf0e10cSrcweir { 4344cdf0e10cSrcweir ICheckboxFieldmark* pCheckboxFm = dynamic_cast<ICheckboxFieldmark*>(fieldBM); 4345cdf0e10cSrcweir pCheckboxFm->SetChecked(!pCheckboxFm->IsChecked()); 4346cdf0e10cSrcweir pCheckboxFm->Invalidate(); 4347cdf0e10cSrcweir rSh.InvalidateWindows( rView.GetVisArea() ); 4348cdf0e10cSrcweir } else if (fieldBM->GetFieldname().equalsAscii( ODF_FORMDROPDOWN) ) { 4349cdf0e10cSrcweir rView.ExecFieldPopup( aDocPt, fieldBM ); 4350cdf0e10cSrcweir fieldBM->Invalidate(); 4351cdf0e10cSrcweir rSh.InvalidateWindows( rView.GetVisArea() ); 4352cdf0e10cSrcweir } else { 4353cdf0e10cSrcweir // unknown type.. 4354cdf0e10cSrcweir } 4355cdf0e10cSrcweir } 4356cdf0e10cSrcweir } 4357cdf0e10cSrcweir else // if ( SwContentAtPos::SW_INETATTR == aCntntAtPos.eCntntAtPos ) 4358cdf0e10cSrcweir { 4359cdf0e10cSrcweir if ( bExecHyperlinks ) 4360cdf0e10cSrcweir rSh.ClickToINetAttr( *(SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr, nFilter ); 4361cdf0e10cSrcweir } 4362cdf0e10cSrcweir 4363cdf0e10cSrcweir rSh.LockView( bViewLocked ); 4364cdf0e10cSrcweir bCallShadowCrsr = sal_False; 4365cdf0e10cSrcweir } 4366cdf0e10cSrcweir else 4367cdf0e10cSrcweir { 4368cdf0e10cSrcweir aCntntAtPos = SwContentAtPos( SwContentAtPos::SW_FTN ); 4369cdf0e10cSrcweir if( !rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) && bExecHyperlinks ) 4370cdf0e10cSrcweir { 4371cdf0e10cSrcweir SdrViewEvent aVEvt; 4372cdf0e10cSrcweir 4373cdf0e10cSrcweir if (pSdrView) 4374cdf0e10cSrcweir pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt); 4375cdf0e10cSrcweir 4376cdf0e10cSrcweir if (pSdrView && aVEvt.eEvent == SDREVENT_EXECUTEURL) 4377cdf0e10cSrcweir { 4378cdf0e10cSrcweir // URL-Feld getroffen 4379cdf0e10cSrcweir const SvxURLField *pField = aVEvt.pURLField; 4380cdf0e10cSrcweir if (pField) 4381cdf0e10cSrcweir { 4382cdf0e10cSrcweir String sURL(pField->GetURL()); 4383cdf0e10cSrcweir String sTarget(pField->GetTargetFrame()); 4384cdf0e10cSrcweir ::LoadURL( sURL, &rSh, nFilter, &sTarget); 4385cdf0e10cSrcweir } 4386cdf0e10cSrcweir bCallShadowCrsr = sal_False; 4387cdf0e10cSrcweir } 4388cdf0e10cSrcweir else 4389cdf0e10cSrcweir { 4390cdf0e10cSrcweir // Grafik getroffen 4391cdf0e10cSrcweir ReleaseMouse(); 4392cdf0e10cSrcweir if( rSh.ClickToINetGrf( aDocPt, nFilter )) 4393cdf0e10cSrcweir bCallShadowCrsr = sal_False; 4394cdf0e10cSrcweir } 4395cdf0e10cSrcweir } 4396cdf0e10cSrcweir } 4397cdf0e10cSrcweir 4398cdf0e10cSrcweir if( bCallShadowCrsr && 4399cdf0e10cSrcweir rSh.GetViewOptions()->IsShadowCursor() && 4400cdf0e10cSrcweir MOUSE_LEFT == (rMEvt.GetModifier() + rMEvt.GetButtons()) && 4401cdf0e10cSrcweir !rSh.HasSelection() && 4402cdf0e10cSrcweir !GetConnectMetaFile() && 4403cdf0e10cSrcweir rSh.VisArea().IsInside( aDocPt )) 4404cdf0e10cSrcweir { 4405cdf0e10cSrcweir SwUndoId nLastUndoId(UNDO_EMPTY); 4406cdf0e10cSrcweir if (rSh.GetLastUndoInfo(0, & nLastUndoId)) 4407cdf0e10cSrcweir { 4408cdf0e10cSrcweir if (UNDO_INS_FROM_SHADOWCRSR == nLastUndoId) 4409cdf0e10cSrcweir { 4410cdf0e10cSrcweir rSh.Undo(); 4411cdf0e10cSrcweir } 4412cdf0e10cSrcweir } 4413cdf0e10cSrcweir SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode(); 4414cdf0e10cSrcweir rSh.SetShadowCrsrPos( aDocPt, eMode ); 4415cdf0e10cSrcweir } 4416cdf0e10cSrcweir } 4417cdf0e10cSrcweir } 4418cdf0e10cSrcweir bCallBase = sal_False; 4419cdf0e10cSrcweir 4420cdf0e10cSrcweir } 4421cdf0e10cSrcweir 4422cdf0e10cSrcweir // gfs. im Down gepushten Mode wieder zuruecksetzen 4423cdf0e10cSrcweir if ( bPopMode && bModePushed ) 4424cdf0e10cSrcweir { 4425cdf0e10cSrcweir rSh.PopMode(); 4426cdf0e10cSrcweir bModePushed = sal_False; 4427cdf0e10cSrcweir bCallBase = sal_False; 4428cdf0e10cSrcweir } 4429cdf0e10cSrcweir break; 4430cdf0e10cSrcweir 4431cdf0e10cSrcweir default: 4432cdf0e10cSrcweir ReleaseMouse(); 4433cdf0e10cSrcweir return; 4434cdf0e10cSrcweir } 4435cdf0e10cSrcweir 4436cdf0e10cSrcweir if( pApplyTempl ) 4437cdf0e10cSrcweir { 4438cdf0e10cSrcweir int eSelection = rSh.GetSelectionType(); 4439cdf0e10cSrcweir SwFormatClipboard* pFormatClipboard = pApplyTempl->pFormatClipboard; 4440cdf0e10cSrcweir if( pFormatClipboard )//apply format paintbrush 4441cdf0e10cSrcweir { 4442cdf0e10cSrcweir //get some parameters 4443cdf0e10cSrcweir SwWrtShell& rWrtShell = rView.GetWrtShell(); 4444cdf0e10cSrcweir SfxStyleSheetBasePool* pPool=0; 4445cdf0e10cSrcweir bool bNoCharacterFormats = false; 4446cdf0e10cSrcweir bool bNoParagraphFormats = false; 4447cdf0e10cSrcweir { 4448cdf0e10cSrcweir SwDocShell* pDocSh = rView.GetDocShell(); 4449cdf0e10cSrcweir if(pDocSh) 4450cdf0e10cSrcweir pPool = pDocSh->GetStyleSheetPool(); 4451cdf0e10cSrcweir if( (rMEvt.GetModifier()&KEY_MOD1) && (rMEvt.GetModifier()&KEY_SHIFT) ) 4452cdf0e10cSrcweir bNoCharacterFormats = true; 4453cdf0e10cSrcweir else if( rMEvt.GetModifier() & KEY_MOD1 ) 4454cdf0e10cSrcweir bNoParagraphFormats = true; 4455cdf0e10cSrcweir } 4456cdf0e10cSrcweir //execute paste 4457cdf0e10cSrcweir pFormatClipboard->Paste( rWrtShell, pPool, bNoCharacterFormats, bNoParagraphFormats ); 4458cdf0e10cSrcweir 4459cdf0e10cSrcweir //if the clipboard is empty after paste remove the ApplyTemplate 4460cdf0e10cSrcweir if(!pFormatClipboard->HasContent()) 4461cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate()); 4462cdf0e10cSrcweir } 4463cdf0e10cSrcweir else if( pApplyTempl->nColor ) 4464cdf0e10cSrcweir { 4465cdf0e10cSrcweir sal_uInt16 nId = 0; 4466cdf0e10cSrcweir switch( pApplyTempl->nColor ) 4467cdf0e10cSrcweir { 4468cdf0e10cSrcweir case SID_ATTR_CHAR_COLOR_EXT: 4469cdf0e10cSrcweir nId = RES_CHRATR_COLOR; 4470cdf0e10cSrcweir break; 4471cdf0e10cSrcweir case SID_ATTR_CHAR_COLOR_BACKGROUND_EXT: 4472cdf0e10cSrcweir nId = RES_CHRATR_BACKGROUND; 4473cdf0e10cSrcweir break; 4474cdf0e10cSrcweir } 4475cdf0e10cSrcweir if( nId && (nsSelectionType::SEL_TXT|nsSelectionType::SEL_TBL) & eSelection) 4476cdf0e10cSrcweir { 4477cdf0e10cSrcweir if( rSh.IsSelection() && !rSh.HasReadonlySel() ) 4478cdf0e10cSrcweir { 4479cdf0e10cSrcweir if(nId == RES_CHRATR_BACKGROUND) 4480cdf0e10cSrcweir { 4481cdf0e10cSrcweir Color aColor( COL_TRANSPARENT ); 4482cdf0e10cSrcweir if( !SwEditWin::bTransparentBackColor ) 4483cdf0e10cSrcweir aColor = SwEditWin::aTextBackColor; 4484cdf0e10cSrcweir rSh.SetAttr( SvxBrushItem( aColor, nId ) ); 4485cdf0e10cSrcweir } 4486cdf0e10cSrcweir else 4487cdf0e10cSrcweir rSh.SetAttr( SvxColorItem(SwEditWin::aTextColor, nId) ); 4488cdf0e10cSrcweir rSh.UnSetVisCrsr(); 4489cdf0e10cSrcweir rSh.EnterStdMode(); 4490cdf0e10cSrcweir rSh.SetVisCrsr(aDocPt); 4491cdf0e10cSrcweir 4492cdf0e10cSrcweir pApplyTempl->bUndo = sal_True; 4493cdf0e10cSrcweir bCallBase = sal_False; 4494cdf0e10cSrcweir aTemplateTimer.Stop(); 4495cdf0e10cSrcweir } 4496cdf0e10cSrcweir else if(rMEvt.GetClicks() == 1) 4497cdf0e10cSrcweir { 4498cdf0e10cSrcweir // keine Selektion -> also Giesskanne abschalten 4499cdf0e10cSrcweir aTemplateTimer.Start(); 4500cdf0e10cSrcweir } 4501cdf0e10cSrcweir } 4502cdf0e10cSrcweir } 4503cdf0e10cSrcweir else 4504cdf0e10cSrcweir { 4505cdf0e10cSrcweir String aStyleName; 4506cdf0e10cSrcweir switch ( pApplyTempl->eType ) 4507cdf0e10cSrcweir { 4508cdf0e10cSrcweir case SFX_STYLE_FAMILY_PARA: 4509cdf0e10cSrcweir if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL ) 4510cdf0e10cSrcweir & eSelection ) && !rSh.HasReadonlySel() ) 4511cdf0e10cSrcweir { 4512cdf0e10cSrcweir rSh.SetTxtFmtColl( pApplyTempl->aColl.pTxtColl ); 4513cdf0e10cSrcweir pApplyTempl->bUndo = sal_True; 4514cdf0e10cSrcweir bCallBase = sal_False; 4515cdf0e10cSrcweir if ( pApplyTempl->aColl.pTxtColl ) 4516cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pTxtColl->GetName(); 4517cdf0e10cSrcweir } 4518cdf0e10cSrcweir break; 4519cdf0e10cSrcweir case SFX_STYLE_FAMILY_CHAR: 4520cdf0e10cSrcweir if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL ) 4521cdf0e10cSrcweir & eSelection ) && !rSh.HasReadonlySel() ) 4522cdf0e10cSrcweir { 4523cdf0e10cSrcweir rSh.SetAttr( SwFmtCharFmt(pApplyTempl->aColl.pCharFmt) ); 4524cdf0e10cSrcweir rSh.UnSetVisCrsr(); 4525cdf0e10cSrcweir rSh.EnterStdMode(); 4526cdf0e10cSrcweir rSh.SetVisCrsr(aDocPt); 4527cdf0e10cSrcweir pApplyTempl->bUndo = sal_True; 4528cdf0e10cSrcweir bCallBase = sal_False; 4529cdf0e10cSrcweir if ( pApplyTempl->aColl.pCharFmt ) 4530cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pCharFmt->GetName(); 4531cdf0e10cSrcweir } 4532cdf0e10cSrcweir break; 4533cdf0e10cSrcweir case SFX_STYLE_FAMILY_FRAME : 4534cdf0e10cSrcweir { 4535cdf0e10cSrcweir const SwFrmFmt* pFmt = rSh.GetFmtFromObj( aDocPt ); 4536cdf0e10cSrcweir if(PTR_CAST(SwFlyFrmFmt, pFmt)) 4537cdf0e10cSrcweir { 4538cdf0e10cSrcweir rSh.SetFrmFmt( pApplyTempl->aColl.pFrmFmt, sal_False, &aDocPt ); 4539cdf0e10cSrcweir pApplyTempl->bUndo = sal_True; 4540cdf0e10cSrcweir bCallBase = sal_False; 4541cdf0e10cSrcweir if( pApplyTempl->aColl.pFrmFmt ) 4542cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pFrmFmt->GetName(); 4543cdf0e10cSrcweir } 4544cdf0e10cSrcweir break; 4545cdf0e10cSrcweir } 4546cdf0e10cSrcweir case SFX_STYLE_FAMILY_PAGE: 4547cdf0e10cSrcweir // Kein Undo bei Seitenvorlagen 4548cdf0e10cSrcweir rSh.ChgCurPageDesc( *pApplyTempl->aColl.pPageDesc ); 4549cdf0e10cSrcweir if ( pApplyTempl->aColl.pPageDesc ) 4550cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pPageDesc->GetName(); 4551cdf0e10cSrcweir bCallBase = sal_False; 4552cdf0e10cSrcweir break; 4553cdf0e10cSrcweir case SFX_STYLE_FAMILY_PSEUDO: 4554cdf0e10cSrcweir if( !rSh.HasReadonlySel() ) 4555cdf0e10cSrcweir { 4556cdf0e10cSrcweir // --> OD 2008-03-17 #refactorlists# 4557cdf0e10cSrcweir rSh.SetCurNumRule( *pApplyTempl->aColl.pNumRule, 4558cdf0e10cSrcweir false, 4559cdf0e10cSrcweir pApplyTempl->aColl.pNumRule->GetDefaultListId() ); 4560cdf0e10cSrcweir // <-- 4561cdf0e10cSrcweir bCallBase = sal_False; 4562cdf0e10cSrcweir pApplyTempl->bUndo = sal_True; 4563cdf0e10cSrcweir if( pApplyTempl->aColl.pNumRule ) 4564cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pNumRule->GetName(); 4565cdf0e10cSrcweir } 4566cdf0e10cSrcweir break; 4567cdf0e10cSrcweir } 4568cdf0e10cSrcweir 4569cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder = 4570cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder(); 4571cdf0e10cSrcweir if ( aStyleName.Len() && xRecorder.is() ) 4572cdf0e10cSrcweir { 4573cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) ); 4574cdf0e10cSrcweir if ( pSfxShell ) 4575cdf0e10cSrcweir { 4576cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), SID_STYLE_APPLY ); 4577cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aStyleName ) ); 4578cdf0e10cSrcweir aReq.AppendItem( SfxUInt16Item( SID_STYLE_FAMILY, (sal_uInt16) pApplyTempl->eType ) ); 4579cdf0e10cSrcweir aReq.Done(); 4580cdf0e10cSrcweir } 4581cdf0e10cSrcweir } 4582cdf0e10cSrcweir } 4583cdf0e10cSrcweir 4584cdf0e10cSrcweir } 4585cdf0e10cSrcweir ReleaseMouse(); 4586cdf0e10cSrcweir // Hier kommen nur verarbeitete MouseEvents an; nur bei diesen duerfen 4587cdf0e10cSrcweir // die Modi zurueckgesetzt werden. 4588cdf0e10cSrcweir bMBPressed = sal_False; 4589cdf0e10cSrcweir 4590cdf0e10cSrcweir //sicherheitshalber aufrufen, da jetzt das Selektieren bestimmt zu Ende ist. 4591cdf0e10cSrcweir //Andernfalls koennte der Timeout des Timers Kummer machen. 4592cdf0e10cSrcweir EnterArea(); 4593cdf0e10cSrcweir bNoInterrupt = sal_False; 4594cdf0e10cSrcweir 4595cdf0e10cSrcweir if (bCallBase) 4596cdf0e10cSrcweir Window::MouseButtonUp(rMEvt); 4597cdf0e10cSrcweir } 4598cdf0e10cSrcweir 4599cdf0e10cSrcweir 4600cdf0e10cSrcweir /*-------------------------------------------------------------------- 4601cdf0e10cSrcweir Beschreibung: Vorlage anwenden 4602cdf0e10cSrcweir --------------------------------------------------------------------*/ 4603cdf0e10cSrcweir 4604cdf0e10cSrcweir 4605cdf0e10cSrcweir void SwEditWin::SetApplyTemplate(const SwApplyTemplate &rTempl) 4606cdf0e10cSrcweir { 4607cdf0e10cSrcweir static sal_Bool bIdle = sal_False; 4608cdf0e10cSrcweir DELETEZ(pApplyTempl); 4609cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 4610cdf0e10cSrcweir 4611cdf0e10cSrcweir if(rTempl.pFormatClipboard) 4612cdf0e10cSrcweir { 4613cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl ); 4614cdf0e10cSrcweir SetPointer( POINTER_FILL );//@todo #i20119# maybe better a new brush pointer here in future 4615cdf0e10cSrcweir rSh.NoEdit( sal_False ); 4616cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle(); 4617cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False ); 4618cdf0e10cSrcweir } 4619cdf0e10cSrcweir else if(rTempl.nColor) 4620cdf0e10cSrcweir { 4621cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl ); 4622cdf0e10cSrcweir SetPointer( POINTER_FILL ); 4623cdf0e10cSrcweir rSh.NoEdit( sal_False ); 4624cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle(); 4625cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False ); 4626cdf0e10cSrcweir } 4627cdf0e10cSrcweir else if( rTempl.eType ) 4628cdf0e10cSrcweir { 4629cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl ); 4630cdf0e10cSrcweir SetPointer( POINTER_FILL ); 4631cdf0e10cSrcweir rSh.NoEdit( sal_False ); 4632cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle(); 4633cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False ); 4634cdf0e10cSrcweir } 4635cdf0e10cSrcweir else 4636cdf0e10cSrcweir { 4637cdf0e10cSrcweir SetPointer( POINTER_TEXT ); 4638cdf0e10cSrcweir rSh.UnSetVisCrsr(); 4639cdf0e10cSrcweir 4640cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( bIdle ); 4641cdf0e10cSrcweir if ( !rSh.IsSelFrmMode() ) 4642cdf0e10cSrcweir rSh.Edit(); 4643cdf0e10cSrcweir } 4644cdf0e10cSrcweir 4645cdf0e10cSrcweir static sal_uInt16 __READONLY_DATA aInva[] = 4646cdf0e10cSrcweir { 4647cdf0e10cSrcweir SID_STYLE_WATERCAN, 4648cdf0e10cSrcweir SID_ATTR_CHAR_COLOR_EXT, 4649cdf0e10cSrcweir SID_ATTR_CHAR_COLOR_BACKGROUND_EXT, 4650cdf0e10cSrcweir 0 4651cdf0e10cSrcweir }; 4652cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(aInva); 4653cdf0e10cSrcweir } 4654cdf0e10cSrcweir 4655cdf0e10cSrcweir /*-------------------------------------------------------------------- 4656cdf0e10cSrcweir Beschreibung: ctor 4657cdf0e10cSrcweir --------------------------------------------------------------------*/ 4658cdf0e10cSrcweir 4659cdf0e10cSrcweir 4660cdf0e10cSrcweir SwEditWin::SwEditWin(Window *pParent, SwView &rMyView): 4661cdf0e10cSrcweir Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)), 4662cdf0e10cSrcweir DropTargetHelper( this ), 4663cdf0e10cSrcweir DragSourceHelper( this ), 4664cdf0e10cSrcweir 4665cdf0e10cSrcweir eBufferLanguage(LANGUAGE_DONTKNOW), 4666cdf0e10cSrcweir pApplyTempl(0), 4667cdf0e10cSrcweir pAnchorMarker( 0 ), 4668cdf0e10cSrcweir pUserMarker( 0 ), 4669cdf0e10cSrcweir pUserMarkerObj( 0 ), 4670cdf0e10cSrcweir pShadCrsr( 0 ), 4671cdf0e10cSrcweir pRowColumnSelectionStart( 0 ), 4672cdf0e10cSrcweir 4673cdf0e10cSrcweir rView( rMyView ), 4674cdf0e10cSrcweir 4675cdf0e10cSrcweir aActHitType(SDRHIT_NONE), 4676cdf0e10cSrcweir m_nDropFormat( 0 ), 4677cdf0e10cSrcweir m_nDropAction( 0 ), 4678cdf0e10cSrcweir m_nDropDestination( 0 ), 4679cdf0e10cSrcweir 4680cdf0e10cSrcweir nInsFrmColCount( 1 ), 4681cdf0e10cSrcweir eDrawMode(OBJ_NONE), 4682cdf0e10cSrcweir 4683cdf0e10cSrcweir bLockInput(sal_False), 4684cdf0e10cSrcweir bObjectSelect( sal_False ), 4685cdf0e10cSrcweir nKS_NUMDOWN_Count(0), // #i23725# 4686cdf0e10cSrcweir nKS_NUMINDENTINC_Count(0) // #i23725# 4687cdf0e10cSrcweir { 4688cdf0e10cSrcweir SetHelpId(HID_EDIT_WIN); 4689cdf0e10cSrcweir EnableChildTransparentMode(); 4690cdf0e10cSrcweir SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS ); 4691cdf0e10cSrcweir 4692cdf0e10cSrcweir bLinkRemoved = bMBPressed = bInsDraw = bInsFrm = 4693cdf0e10cSrcweir bIsInDrag = bOldIdle = bOldIdleSet = bChainMode = bWasShdwCrsr = sal_False; 4694cdf0e10cSrcweir //#i42732# initially use the input language 4695cdf0e10cSrcweir bUseInputLanguage = sal_True; 4696cdf0e10cSrcweir 4697cdf0e10cSrcweir SetMapMode(MapMode(MAP_TWIP)); 4698cdf0e10cSrcweir 4699cdf0e10cSrcweir SetPointer( POINTER_TEXT ); 4700cdf0e10cSrcweir aTimer.SetTimeoutHdl(LINK(this, SwEditWin, TimerHandler)); 4701cdf0e10cSrcweir 4702cdf0e10cSrcweir bTblInsDelMode = sal_False; 4703cdf0e10cSrcweir aKeyInputTimer.SetTimeout( 3000 ); 4704cdf0e10cSrcweir aKeyInputTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputTimerHandler)); 4705cdf0e10cSrcweir 4706cdf0e10cSrcweir aKeyInputFlushTimer.SetTimeout( 200 ); 4707cdf0e10cSrcweir aKeyInputFlushTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputFlushHandler)); 4708cdf0e10cSrcweir 4709cdf0e10cSrcweir // TemplatePointer fuer Farben soll nach Einfachclick 4710cdf0e10cSrcweir // ohne Selektion zurueckgesetzt werden 4711cdf0e10cSrcweir aTemplateTimer.SetTimeout(400); 4712cdf0e10cSrcweir aTemplateTimer.SetTimeoutHdl(LINK(this, SwEditWin, TemplateTimerHdl)); 4713cdf0e10cSrcweir 4714cdf0e10cSrcweir //JP 16.12.98: temporaere Loesung!!! Sollte bei jeder Cursorbewegung 4715cdf0e10cSrcweir // den Font von der akt. einfuege Position setzen! 4716cdf0e10cSrcweir if( !rMyView.GetDocShell()->IsReadOnly() ) 4717cdf0e10cSrcweir { 4718cdf0e10cSrcweir Font aFont; 4719cdf0e10cSrcweir SetInputContext( InputContext( aFont, INPUTCONTEXT_TEXT | 4720cdf0e10cSrcweir INPUTCONTEXT_EXTTEXTINPUT ) ); 4721cdf0e10cSrcweir } 4722cdf0e10cSrcweir } 4723cdf0e10cSrcweir 4724cdf0e10cSrcweir 4725cdf0e10cSrcweir 4726cdf0e10cSrcweir SwEditWin::~SwEditWin() 4727cdf0e10cSrcweir { 4728cdf0e10cSrcweir aKeyInputTimer.Stop(); 4729cdf0e10cSrcweir delete pShadCrsr; 4730cdf0e10cSrcweir delete pRowColumnSelectionStart; 4731cdf0e10cSrcweir if( pQuickHlpData->bClear && rView.GetWrtShellPtr() ) 4732cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() ); 4733cdf0e10cSrcweir bExecuteDrag = sal_False; 4734cdf0e10cSrcweir delete pApplyTempl; 4735cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 4736cdf0e10cSrcweir 4737cdf0e10cSrcweir if(pUserMarker) 4738cdf0e10cSrcweir { 4739cdf0e10cSrcweir delete pUserMarker; 4740cdf0e10cSrcweir } 4741cdf0e10cSrcweir 4742cdf0e10cSrcweir delete pAnchorMarker; 4743cdf0e10cSrcweir } 4744cdf0e10cSrcweir 4745cdf0e10cSrcweir 4746cdf0e10cSrcweir /****************************************************************************** 4747cdf0e10cSrcweir * Beschreibung: DrawTextEditMode einschalten 4748cdf0e10cSrcweir ******************************************************************************/ 4749cdf0e10cSrcweir 4750cdf0e10cSrcweir 4751cdf0e10cSrcweir void SwEditWin::EnterDrawTextMode( const Point& aDocPos ) 4752cdf0e10cSrcweir { 4753cdf0e10cSrcweir if ( rView.EnterDrawTextMode(aDocPos) == sal_True ) 4754cdf0e10cSrcweir { 4755cdf0e10cSrcweir if (rView.GetDrawFuncPtr()) 4756cdf0e10cSrcweir { 4757cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 4758cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 4759cdf0e10cSrcweir rView.LeaveDrawCreate(); 4760cdf0e10cSrcweir } 4761cdf0e10cSrcweir rView.NoRotate(); 4762cdf0e10cSrcweir rView.AttrChangedNotify( &rView.GetWrtShell() ); 4763cdf0e10cSrcweir } 4764cdf0e10cSrcweir } 4765cdf0e10cSrcweir 4766cdf0e10cSrcweir /****************************************************************************** 4767cdf0e10cSrcweir * Beschreibung: DrawMode einschalten 4768cdf0e10cSrcweir ******************************************************************************/ 4769cdf0e10cSrcweir 4770cdf0e10cSrcweir 4771cdf0e10cSrcweir 4772cdf0e10cSrcweir sal_Bool SwEditWin::EnterDrawMode(const MouseEvent& rMEvt, const Point& aDocPos) 4773cdf0e10cSrcweir { 4774cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 4775cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 4776cdf0e10cSrcweir 4777cdf0e10cSrcweir // if ( GetDrawFuncPtr() && (aActHitType == SDRHIT_NONE || rSh.IsDrawCreate()) ) 4778cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() ) 4779cdf0e10cSrcweir { 4780cdf0e10cSrcweir if (rSh.IsDrawCreate()) 4781cdf0e10cSrcweir return sal_True; 4782cdf0e10cSrcweir 4783cdf0e10cSrcweir sal_Bool bRet = rView.GetDrawFuncPtr()->MouseButtonDown( rMEvt ); 4784cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 4785cdf0e10cSrcweir return bRet; 4786cdf0e10cSrcweir } 4787cdf0e10cSrcweir 4788cdf0e10cSrcweir if ( pSdrView && pSdrView->IsTextEdit() ) 4789cdf0e10cSrcweir { 4790cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 4791cdf0e10cSrcweir rSh.LockView( sal_True ); 4792cdf0e10cSrcweir 4793cdf0e10cSrcweir rSh.EndTextEdit(); // Danebengeklickt, Ende mit Edit 4794cdf0e10cSrcweir rSh.SelectObj( aDocPos ); 4795cdf0e10cSrcweir if ( !rSh.IsObjSelected() && !rSh.IsFrmSelected() ) 4796cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 4797cdf0e10cSrcweir else 4798cdf0e10cSrcweir { 4799cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y(); 4800cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X(); 4801cdf0e10cSrcweir bFrmDrag = sal_True; 4802cdf0e10cSrcweir } 4803cdf0e10cSrcweir if( bUnLockView ) 4804cdf0e10cSrcweir rSh.LockView( sal_False ); 4805cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 4806cdf0e10cSrcweir return sal_True; 4807cdf0e10cSrcweir } 4808cdf0e10cSrcweir return sal_False; 4809cdf0e10cSrcweir } 4810cdf0e10cSrcweir 4811cdf0e10cSrcweir /****************************************************************************** 4812cdf0e10cSrcweir * Beschreibung: 4813cdf0e10cSrcweir ******************************************************************************/ 4814cdf0e10cSrcweir 4815cdf0e10cSrcweir 4816cdf0e10cSrcweir 4817cdf0e10cSrcweir sal_Bool SwEditWin::IsDrawSelMode() 4818cdf0e10cSrcweir { 4819cdf0e10cSrcweir // return (IsFrmAction() == sal_False && GetSdrDrawMode() == OBJ_NONE); 4820cdf0e10cSrcweir return IsObjectSelect(); 4821cdf0e10cSrcweir } 4822cdf0e10cSrcweir 4823cdf0e10cSrcweir /****************************************************************************** 4824cdf0e10cSrcweir * Beschreibung: 4825cdf0e10cSrcweir ******************************************************************************/ 4826cdf0e10cSrcweir 4827cdf0e10cSrcweir 4828cdf0e10cSrcweir void SwEditWin::GetFocus() 4829cdf0e10cSrcweir { 4830cdf0e10cSrcweir if ( rView.GetPostItMgr()->HasActiveSidebarWin() ) 4831cdf0e10cSrcweir { 4832cdf0e10cSrcweir rView.GetPostItMgr()->GrabFocusOnActiveSidebarWin(); 4833cdf0e10cSrcweir } 4834cdf0e10cSrcweir else 4835cdf0e10cSrcweir { 4836cdf0e10cSrcweir rView.GotFocus(); 4837cdf0e10cSrcweir Window::GetFocus(); 4838cdf0e10cSrcweir rView.GetWrtShell().InvalidateAccessibleFocus(); 4839cdf0e10cSrcweir } 4840cdf0e10cSrcweir } 4841cdf0e10cSrcweir 4842cdf0e10cSrcweir /****************************************************************************** 4843cdf0e10cSrcweir * Beschreibung: 4844cdf0e10cSrcweir ******************************************************************************/ 4845cdf0e10cSrcweir 4846cdf0e10cSrcweir 4847cdf0e10cSrcweir 4848cdf0e10cSrcweir void SwEditWin::LoseFocus() 4849cdf0e10cSrcweir { 4850cdf0e10cSrcweir rView.GetWrtShell().InvalidateAccessibleFocus(); 4851cdf0e10cSrcweir Window::LoseFocus(); 4852cdf0e10cSrcweir if( pQuickHlpData->bClear ) 4853cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() ); 4854cdf0e10cSrcweir rView.LostFocus(); 4855cdf0e10cSrcweir } 4856cdf0e10cSrcweir 4857cdf0e10cSrcweir /****************************************************************************** 4858cdf0e10cSrcweir * Beschreibung: 4859cdf0e10cSrcweir ******************************************************************************/ 4860cdf0e10cSrcweir 4861cdf0e10cSrcweir 4862cdf0e10cSrcweir 4863cdf0e10cSrcweir void SwEditWin::Command( const CommandEvent& rCEvt ) 4864cdf0e10cSrcweir { 4865cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell(); 4866cdf0e10cSrcweir 4867cdf0e10cSrcweir if ( !rView.GetViewFrame() ) 4868cdf0e10cSrcweir { 4869cdf0e10cSrcweir //Wenn der ViewFrame in Kuerze stirbt kein Popup mehr! 4870cdf0e10cSrcweir Window::Command(rCEvt); 4871cdf0e10cSrcweir return; 4872cdf0e10cSrcweir } 4873cdf0e10cSrcweir 4874cdf0e10cSrcweir // The command event is send to the window after a possible context 4875cdf0e10cSrcweir // menu from an inplace client has been closed. Now we have the chance 4876cdf0e10cSrcweir // to deactivate the inplace client without any problem regarding parent 4877cdf0e10cSrcweir // windows and code on the stack. 4878cdf0e10cSrcweir // For more information, see #126086# and #128122# 4879cdf0e10cSrcweir SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient(); 4880cdf0e10cSrcweir sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() ); 4881cdf0e10cSrcweir if ( bIsOleActive && ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )) 4882cdf0e10cSrcweir { 4883cdf0e10cSrcweir rSh.FinishOLEObj(); 4884cdf0e10cSrcweir return; 4885cdf0e10cSrcweir } 4886cdf0e10cSrcweir 4887cdf0e10cSrcweir sal_Bool bCallBase = sal_True; 4888cdf0e10cSrcweir 4889cdf0e10cSrcweir switch ( rCEvt.GetCommand() ) 4890cdf0e10cSrcweir { 4891cdf0e10cSrcweir case COMMAND_CONTEXTMENU: 4892cdf0e10cSrcweir { 4893cdf0e10cSrcweir const sal_uInt16 nId = SwInputChild::GetChildWindowId(); 4894cdf0e10cSrcweir SwInputChild* pChildWin = (SwInputChild*)GetView().GetViewFrame()-> 4895cdf0e10cSrcweir GetChildWindow( nId ); 4896cdf0e10cSrcweir 4897cdf0e10cSrcweir if (rView.GetPostItMgr()->IsHit(rCEvt.GetMousePosPixel())) 4898cdf0e10cSrcweir return; 4899cdf0e10cSrcweir 4900cdf0e10cSrcweir if((!pChildWin || pChildWin->GetView() != &rView) && 4901cdf0e10cSrcweir !rSh.IsDrawCreate() && !IsDrawAction()) 4902cdf0e10cSrcweir { 4903cdf0e10cSrcweir SET_CURR_SHELL( &rSh ); 4904cdf0e10cSrcweir if (!pApplyTempl) 4905cdf0e10cSrcweir { 4906cdf0e10cSrcweir if (bNoInterrupt == sal_True) 4907cdf0e10cSrcweir { 4908cdf0e10cSrcweir ReleaseMouse(); 4909cdf0e10cSrcweir bNoInterrupt = sal_False; 4910cdf0e10cSrcweir bMBPressed = sal_False; 4911cdf0e10cSrcweir } 4912cdf0e10cSrcweir Point aDocPos( PixelToLogic( rCEvt.GetMousePosPixel() ) ); 4913cdf0e10cSrcweir if ( !rCEvt.IsMouseEvent() ) 4914cdf0e10cSrcweir aDocPos = rSh.GetCharRect().Center(); 4915cdf0e10cSrcweir else 4916cdf0e10cSrcweir { 4917cdf0e10cSrcweir SelectMenuPosition(rSh, rCEvt.GetMousePosPixel()); 4918cdf0e10cSrcweir rView.StopShellTimer(); 4919cdf0e10cSrcweir 4920cdf0e10cSrcweir } 4921cdf0e10cSrcweir const Point aPixPos = LogicToPixel( aDocPos ); 4922cdf0e10cSrcweir 4923cdf0e10cSrcweir if ( rView.GetDocShell()->IsReadOnly() ) 4924cdf0e10cSrcweir { 4925cdf0e10cSrcweir SwReadOnlyPopup* pROPopup = new SwReadOnlyPopup( aDocPos, rView ); 4926cdf0e10cSrcweir 4927cdf0e10cSrcweir ui::ContextMenuExecuteEvent aEvent; 4928cdf0e10cSrcweir aEvent.SourceWindow = VCLUnoHelper::GetInterface( this ); 4929cdf0e10cSrcweir aEvent.ExecutePosition.X = aPixPos.X(); 4930cdf0e10cSrcweir aEvent.ExecutePosition.Y = aPixPos.Y(); 4931cdf0e10cSrcweir Menu* pMenu = 0; 4932cdf0e10cSrcweir ::rtl::OUString sMenuName = 4933cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "private:resource/ReadonlyContextMenu"); 4934cdf0e10cSrcweir if( GetView().TryContextMenuInterception( *pROPopup, sMenuName, pMenu, aEvent ) ) 4935cdf0e10cSrcweir { 4936cdf0e10cSrcweir if ( pMenu ) 4937cdf0e10cSrcweir { 4938cdf0e10cSrcweir sal_uInt16 nExecId = ((PopupMenu*)pMenu)->Execute(this, aPixPos); 4939cdf0e10cSrcweir if( !::ExecuteMenuCommand( *static_cast<PopupMenu*>(pMenu), *rView.GetViewFrame(), nExecId )) 4940cdf0e10cSrcweir pROPopup->Execute(this, nExecId); 4941cdf0e10cSrcweir } 4942cdf0e10cSrcweir else 4943cdf0e10cSrcweir pROPopup->Execute(this, aPixPos); 4944cdf0e10cSrcweir } 4945cdf0e10cSrcweir delete pROPopup; 4946cdf0e10cSrcweir } 4947cdf0e10cSrcweir else if ( !rView.ExecSpellPopup( aDocPos ) ) 4948cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->ExecutePopup( 0, this, &aPixPos); 4949cdf0e10cSrcweir } 4950cdf0e10cSrcweir else if (pApplyTempl->bUndo) 4951cdf0e10cSrcweir rSh.Do(SwWrtShell::UNDO); 4952cdf0e10cSrcweir bCallBase = sal_False; 4953cdf0e10cSrcweir } 4954cdf0e10cSrcweir } 4955cdf0e10cSrcweir break; 4956cdf0e10cSrcweir 4957cdf0e10cSrcweir case COMMAND_WHEEL: 4958cdf0e10cSrcweir case COMMAND_STARTAUTOSCROLL: 4959cdf0e10cSrcweir case COMMAND_AUTOSCROLL: 4960cdf0e10cSrcweir if( pShadCrsr ) 4961cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0; 4962cdf0e10cSrcweir bCallBase = !rView.HandleWheelCommands( rCEvt ); 4963cdf0e10cSrcweir break; 4964cdf0e10cSrcweir 4965cdf0e10cSrcweir case COMMAND_VOICE: 4966cdf0e10cSrcweir { 4967cdf0e10cSrcweir //ggf. an Outliner weiterleiten 4968cdf0e10cSrcweir if ( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() ) 4969cdf0e10cSrcweir { 4970cdf0e10cSrcweir bCallBase = sal_False; 4971cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt ); 4972cdf0e10cSrcweir break; 4973cdf0e10cSrcweir } 4974cdf0e10cSrcweir 4975cdf0e10cSrcweir const CommandVoiceData *pCData = rCEvt.GetVoiceData(); 4976cdf0e10cSrcweir if ( VOICECOMMANDTYPE_CONTROL == pCData->GetType() ) 4977cdf0e10cSrcweir break; 4978cdf0e10cSrcweir 4979cdf0e10cSrcweir 4980cdf0e10cSrcweir sal_uInt16 nSlotId = 0; 4981cdf0e10cSrcweir SfxPoolItem *pItem = 0; 4982cdf0e10cSrcweir 4983cdf0e10cSrcweir switch ( pCData->GetCommand() ) 4984cdf0e10cSrcweir { 4985cdf0e10cSrcweir case DICTATIONCOMMAND_NEWPARAGRAPH: nSlotId = FN_INSERT_BREAK; break; 4986cdf0e10cSrcweir case DICTATIONCOMMAND_NEWLINE: nSlotId = FN_INSERT_LINEBREAK; break; 4987cdf0e10cSrcweir case DICTATIONCOMMAND_LEFT: nSlotId = FN_PREV_WORD; break; 4988cdf0e10cSrcweir case DICTATIONCOMMAND_RIGHT: nSlotId = FN_NEXT_WORD; break; 4989cdf0e10cSrcweir case DICTATIONCOMMAND_UP: nSlotId = FN_LINE_UP; break; 4990cdf0e10cSrcweir case DICTATIONCOMMAND_DOWN: nSlotId = FN_LINE_DOWN; break; 4991cdf0e10cSrcweir case DICTATIONCOMMAND_UNDO: nSlotId = SID_UNDO; break; 4992cdf0e10cSrcweir case DICTATIONCOMMAND_REPEAT: nSlotId = SID_REPEAT; break; 4993cdf0e10cSrcweir case DICTATIONCOMMAND_DEL: nSlotId = FN_DELETE_BACK_WORD; break; 4994cdf0e10cSrcweir 4995cdf0e10cSrcweir case DICTATIONCOMMAND_BOLD_ON: nSlotId = SID_ATTR_CHAR_WEIGHT; 4996cdf0e10cSrcweir pItem = new SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT ); 4997cdf0e10cSrcweir break; 4998cdf0e10cSrcweir case DICTATIONCOMMAND_BOLD_OFF: nSlotId = SID_ATTR_CHAR_WEIGHT; 4999cdf0e10cSrcweir pItem = new SvxWeightItem( WEIGHT_NORMAL, RES_CHRATR_WEIGHT ); 5000cdf0e10cSrcweir break; 5001cdf0e10cSrcweir case DICTATIONCOMMAND_UNDERLINE_ON: nSlotId = SID_ATTR_CHAR_UNDERLINE; 5002cdf0e10cSrcweir pItem = new SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_WEIGHT ); 5003cdf0e10cSrcweir break; 5004cdf0e10cSrcweir case DICTATIONCOMMAND_UNDERLINE_OFF:nSlotId = SID_ATTR_CHAR_UNDERLINE; 5005cdf0e10cSrcweir pItem = new SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE ); 5006cdf0e10cSrcweir break; 5007cdf0e10cSrcweir case DICTATIONCOMMAND_ITALIC_ON: nSlotId = SID_ATTR_CHAR_POSTURE; 5008cdf0e10cSrcweir pItem = new SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE ); 5009cdf0e10cSrcweir break; 5010cdf0e10cSrcweir case DICTATIONCOMMAND_ITALIC_OFF: nSlotId = SID_ATTR_CHAR_POSTURE; 5011cdf0e10cSrcweir pItem = new SvxPostureItem( ITALIC_NONE, RES_CHRATR_POSTURE ); 5012cdf0e10cSrcweir break; 5013cdf0e10cSrcweir case DICTATIONCOMMAND_NUMBERING_ON: 5014cdf0e10cSrcweir if ( !rSh.GetCurNumRule() ) 5015cdf0e10cSrcweir nSlotId = FN_NUM_NUMBERING_ON; 5016cdf0e10cSrcweir break; 5017cdf0e10cSrcweir case DICTATIONCOMMAND_NUMBERING_OFF: 5018cdf0e10cSrcweir if ( rSh.GetCurNumRule() ) 5019cdf0e10cSrcweir nSlotId = FN_NUM_NUMBERING_ON; 5020cdf0e10cSrcweir break; 5021cdf0e10cSrcweir case DICTATIONCOMMAND_TAB: 5022cdf0e10cSrcweir { 5023cdf0e10cSrcweir rSh.Insert( '\t' ); 5024cdf0e10cSrcweir } 5025cdf0e10cSrcweir break; 5026cdf0e10cSrcweir case DICTATIONCOMMAND_UNKNOWN: 5027cdf0e10cSrcweir { 5028cdf0e10cSrcweir rView.GetWrtShell().Insert( pCData->GetText() ); 5029cdf0e10cSrcweir } 5030cdf0e10cSrcweir break; 5031cdf0e10cSrcweir 5032cdf0e10cSrcweir #ifdef DBG_UTIL 5033cdf0e10cSrcweir default: 5034cdf0e10cSrcweir ASSERT( !this, "unknown speech command." ); 5035cdf0e10cSrcweir #endif 5036cdf0e10cSrcweir } 5037cdf0e10cSrcweir if ( nSlotId ) 5038cdf0e10cSrcweir { 5039cdf0e10cSrcweir bCallBase = sal_False; 5040cdf0e10cSrcweir if ( pItem ) 5041cdf0e10cSrcweir { 5042cdf0e10cSrcweir const SfxPoolItem* aArgs[2]; 5043cdf0e10cSrcweir aArgs[0] = pItem; 5044cdf0e10cSrcweir aArgs[1] = 0; 5045cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( 5046cdf0e10cSrcweir nSlotId, aArgs, 0, SFX_CALLMODE_STANDARD ); 5047cdf0e10cSrcweir delete pItem; 5048cdf0e10cSrcweir } 5049cdf0e10cSrcweir else 5050cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( nSlotId ); 5051cdf0e10cSrcweir } 5052cdf0e10cSrcweir } 5053cdf0e10cSrcweir break; 5054cdf0e10cSrcweir 5055cdf0e10cSrcweir case COMMAND_STARTEXTTEXTINPUT: 5056cdf0e10cSrcweir { 5057cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() && 5058cdf0e10cSrcweir rSh.IsCrsrReadonly(); 5059cdf0e10cSrcweir if(!bIsDocReadOnly) 5060cdf0e10cSrcweir { 5061cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() ) 5062cdf0e10cSrcweir { 5063cdf0e10cSrcweir bCallBase = sal_False; 5064cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt ); 5065cdf0e10cSrcweir } 5066cdf0e10cSrcweir else 5067cdf0e10cSrcweir { 5068cdf0e10cSrcweir if( rSh.HasSelection() ) 5069cdf0e10cSrcweir rSh.DelRight(); 5070cdf0e10cSrcweir 5071cdf0e10cSrcweir bCallBase = sal_False; 5072cdf0e10cSrcweir LanguageType eInputLanguage = GetInputLanguage(); 5073cdf0e10cSrcweir rSh.CreateExtTextInput(eInputLanguage); 5074cdf0e10cSrcweir } 5075cdf0e10cSrcweir } 5076cdf0e10cSrcweir break; 5077cdf0e10cSrcweir } 5078cdf0e10cSrcweir case COMMAND_ENDEXTTEXTINPUT: 5079cdf0e10cSrcweir { 5080cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() && 5081cdf0e10cSrcweir rSh.IsCrsrReadonly(); 5082cdf0e10cSrcweir if(!bIsDocReadOnly) 5083cdf0e10cSrcweir { 5084cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() ) 5085cdf0e10cSrcweir { 5086cdf0e10cSrcweir bCallBase = sal_False; 5087cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt ); 5088cdf0e10cSrcweir } 5089cdf0e10cSrcweir else 5090cdf0e10cSrcweir { 5091cdf0e10cSrcweir bCallBase = sal_False; 5092cdf0e10cSrcweir String sRecord = rSh.DeleteExtTextInput(); 5093cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder = 5094cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder(); 5095cdf0e10cSrcweir 5096cdf0e10cSrcweir if ( sRecord.Len() ) 5097cdf0e10cSrcweir { 5098cdf0e10cSrcweir // #102812# convert quotes in IME text 5099cdf0e10cSrcweir // works on the last input character, this is escpecially in Korean text often done 5100cdf0e10cSrcweir // quotes that are inside of the string are not replaced! 5101cdf0e10cSrcweir const sal_Unicode aCh = sRecord.GetChar(sRecord.Len() - 1); 5102cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get(); 5103cdf0e10cSrcweir SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect(); 5104cdf0e10cSrcweir if(pACorr && 5105cdf0e10cSrcweir (( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))|| 5106cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh)))) 5107cdf0e10cSrcweir { 5108cdf0e10cSrcweir rSh.DelLeft(); 5109cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh ); 5110cdf0e10cSrcweir } 5111cdf0e10cSrcweir 5112cdf0e10cSrcweir if ( xRecorder.is() ) 5113cdf0e10cSrcweir { 5114cdf0e10cSrcweir //Shell ermitteln 5115cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) ); 5116cdf0e10cSrcweir // Request generieren und recorden 5117cdf0e10cSrcweir if (pSfxShell) 5118cdf0e10cSrcweir { 5119cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING ); 5120cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, sRecord ) ); 5121cdf0e10cSrcweir aReq.Done(); 5122cdf0e10cSrcweir } 5123cdf0e10cSrcweir } 5124cdf0e10cSrcweir } 5125cdf0e10cSrcweir } 5126cdf0e10cSrcweir } 5127cdf0e10cSrcweir } 5128cdf0e10cSrcweir break; 5129cdf0e10cSrcweir case COMMAND_EXTTEXTINPUT: 5130cdf0e10cSrcweir { 5131cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() && 5132cdf0e10cSrcweir rSh.IsCrsrReadonly(); 5133cdf0e10cSrcweir if(!bIsDocReadOnly) 5134cdf0e10cSrcweir { 5135cdf0e10cSrcweir QuickHelpData aTmpQHD; 5136cdf0e10cSrcweir if( pQuickHlpData->bClear ) 5137cdf0e10cSrcweir { 5138cdf0e10cSrcweir aTmpQHD.Move( *pQuickHlpData ); 5139cdf0e10cSrcweir pQuickHlpData->Stop( rSh ); 5140cdf0e10cSrcweir } 5141cdf0e10cSrcweir String sWord; 5142cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() ) 5143cdf0e10cSrcweir { 5144cdf0e10cSrcweir bCallBase = sal_False; 5145cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt ); 5146cdf0e10cSrcweir } 5147cdf0e10cSrcweir else 5148cdf0e10cSrcweir { 5149cdf0e10cSrcweir const CommandExtTextInputData* pData = rCEvt.GetExtTextInputData(); 5150cdf0e10cSrcweir if( pData ) 5151cdf0e10cSrcweir { 5152cdf0e10cSrcweir sWord = pData->GetText(); 5153cdf0e10cSrcweir bCallBase = sal_False; 5154cdf0e10cSrcweir rSh.SetExtTextInputData( *pData ); 5155cdf0e10cSrcweir } 5156cdf0e10cSrcweir } 5157cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder = 5158cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder(); 5159cdf0e10cSrcweir if(!xRecorder.is()) 5160cdf0e10cSrcweir { 5161cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get(); 5162cdf0e10cSrcweir SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect(); 5163cdf0e10cSrcweir if( pACfg && pACorr && 5164cdf0e10cSrcweir ( pACfg->IsAutoTextTip() || 5165cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCompleteWords ) && 5166cdf0e10cSrcweir rSh.GetPrevAutoCorrWord( *pACorr, sWord ) ) 5167cdf0e10cSrcweir { 5168cdf0e10cSrcweir ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr, sal_True); 5169cdf0e10cSrcweir } 5170cdf0e10cSrcweir } 5171cdf0e10cSrcweir } 5172cdf0e10cSrcweir } 5173cdf0e10cSrcweir break; 5174cdf0e10cSrcweir case COMMAND_CURSORPOS: 5175cdf0e10cSrcweir // will be handled by the base class 5176cdf0e10cSrcweir break; 5177cdf0e10cSrcweir 5178cdf0e10cSrcweir case COMMAND_PASTESELECTION: 5179cdf0e10cSrcweir if( !rView.GetDocShell()->IsReadOnly() ) 5180cdf0e10cSrcweir { 5181cdf0e10cSrcweir TransferableDataHelper aDataHelper( 5182cdf0e10cSrcweir TransferableDataHelper::CreateFromSelection( this )); 5183cdf0e10cSrcweir if( !aDataHelper.GetXTransferable().is() ) 5184cdf0e10cSrcweir break; 5185cdf0e10cSrcweir 5186cdf0e10cSrcweir sal_uLong nDropFormat; 5187cdf0e10cSrcweir sal_uInt16 nEventAction, nDropAction, nDropDestination; 5188cdf0e10cSrcweir nDropDestination = GetDropDestination( rCEvt.GetMousePosPixel() ); 5189cdf0e10cSrcweir if( !nDropDestination ) 5190cdf0e10cSrcweir break; 5191cdf0e10cSrcweir 5192cdf0e10cSrcweir nDropAction = SotExchange::GetExchangeAction( 5193cdf0e10cSrcweir aDataHelper.GetDataFlavorExVector(), 5194cdf0e10cSrcweir nDropDestination, EXCHG_IN_ACTION_COPY, 5195cdf0e10cSrcweir EXCHG_IN_ACTION_COPY, nDropFormat, 5196cdf0e10cSrcweir nEventAction ); 5197cdf0e10cSrcweir if( EXCHG_INOUT_ACTION_NONE != nDropAction ) 5198cdf0e10cSrcweir { 5199cdf0e10cSrcweir const Point aDocPt( PixelToLogic( rCEvt.GetMousePosPixel() ) ); 5200cdf0e10cSrcweir SwTransferable::PasteData( aDataHelper, rSh, nDropAction, 5201cdf0e10cSrcweir nDropFormat, nDropDestination, sal_False, 5202cdf0e10cSrcweir sal_False, &aDocPt, EXCHG_IN_ACTION_COPY, 5203cdf0e10cSrcweir sal_True ); 5204cdf0e10cSrcweir } 5205cdf0e10cSrcweir } 5206cdf0e10cSrcweir break; 5207cdf0e10cSrcweir case COMMAND_MODKEYCHANGE : 5208cdf0e10cSrcweir { 5209cdf0e10cSrcweir const CommandModKeyData* pCommandData = (const CommandModKeyData*)rCEvt.GetData(); 5210cdf0e10cSrcweir if(pCommandData->IsMod1() && !pCommandData->IsMod2()) 5211cdf0e10cSrcweir { 5212cdf0e10cSrcweir sal_uInt16 nSlot = 0; 5213cdf0e10cSrcweir if(pCommandData->IsLeftShift() && !pCommandData->IsRightShift()) 5214cdf0e10cSrcweir nSlot = SID_ATTR_PARA_LEFT_TO_RIGHT; 5215cdf0e10cSrcweir else if(!pCommandData->IsLeftShift() && pCommandData->IsRightShift()) 5216cdf0e10cSrcweir nSlot = SID_ATTR_PARA_RIGHT_TO_LEFT; 5217cdf0e10cSrcweir if(nSlot && SW_MOD()->GetCTLOptions().IsCTLFontEnabled()) 5218cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->Execute(nSlot); 5219cdf0e10cSrcweir } 5220cdf0e10cSrcweir } 5221cdf0e10cSrcweir break; 5222cdf0e10cSrcweir case COMMAND_HANGUL_HANJA_CONVERSION : 5223cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->Execute(SID_HANGUL_HANJA_CONVERSION); 5224cdf0e10cSrcweir break; 5225cdf0e10cSrcweir case COMMAND_INPUTLANGUAGECHANGE : 5226cdf0e10cSrcweir //#i42732# update state of fontname if input language changes 5227cdf0e10cSrcweir bInputLanguageSwitched = true; 5228cdf0e10cSrcweir SetUseInputLanguage( sal_True ); 5229cdf0e10cSrcweir break; 5230cdf0e10cSrcweir case COMMAND_SELECTIONCHANGE: 5231cdf0e10cSrcweir { 5232cdf0e10cSrcweir const CommandSelectionChangeData *pData = rCEvt.GetSelectionChangeData(); 5233cdf0e10cSrcweir rSh.SttCrsrMove(); 5234cdf0e10cSrcweir rSh.GoStartSentence(); 5235cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetStart()); 5236cdf0e10cSrcweir rSh.SetMark(); 5237cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetEnd() - pData->GetStart()); 5238cdf0e10cSrcweir rSh.EndCrsrMove( sal_True ); 5239cdf0e10cSrcweir } 5240cdf0e10cSrcweir break; 5241cdf0e10cSrcweir case COMMAND_PREPARERECONVERSION: 5242cdf0e10cSrcweir if( rSh.HasSelection() ) 5243cdf0e10cSrcweir { 5244cdf0e10cSrcweir SwPaM *pCrsr = (SwPaM*)rSh.GetCrsr(); 5245cdf0e10cSrcweir 5246cdf0e10cSrcweir if( rSh.IsMultiSelection() ) 5247cdf0e10cSrcweir { 5248cdf0e10cSrcweir if( pCrsr && !pCrsr->HasMark() && 5249cdf0e10cSrcweir pCrsr->GetPoint() == pCrsr->GetMark() ) 5250cdf0e10cSrcweir { 5251cdf0e10cSrcweir rSh.GoPrevCrsr(); 5252cdf0e10cSrcweir pCrsr = (SwPaM*)rSh.GetCrsr(); 5253cdf0e10cSrcweir } 5254cdf0e10cSrcweir 5255cdf0e10cSrcweir // Cancel all selections other than the last selected one. 5256cdf0e10cSrcweir while( rSh.GetCrsr()->GetNext() != rSh.GetCrsr() ) 5257cdf0e10cSrcweir delete rSh.GetCrsr()->GetNext(); 5258cdf0e10cSrcweir } 5259cdf0e10cSrcweir 5260cdf0e10cSrcweir if( pCrsr ) 5261cdf0e10cSrcweir { 5262cdf0e10cSrcweir sal_uLong nPosNodeIdx = pCrsr->GetPoint()->nNode.GetIndex(); 5263cdf0e10cSrcweir xub_StrLen nPosIdx = pCrsr->GetPoint()->nContent.GetIndex(); 5264cdf0e10cSrcweir sal_uLong nMarkNodeIdx = pCrsr->GetMark()->nNode.GetIndex(); 5265cdf0e10cSrcweir xub_StrLen nMarkIdx = pCrsr->GetMark()->nContent.GetIndex(); 5266cdf0e10cSrcweir 5267cdf0e10cSrcweir if( !rSh.GetCrsr()->HasMark() ) 5268cdf0e10cSrcweir rSh.GetCrsr()->SetMark(); 5269cdf0e10cSrcweir 5270cdf0e10cSrcweir rSh.SttCrsrMove(); 5271cdf0e10cSrcweir 5272cdf0e10cSrcweir if( nPosNodeIdx < nMarkNodeIdx ) 5273cdf0e10cSrcweir { 5274cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx; 5275cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent = nPosIdx; 5276cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nPosNodeIdx; 5277cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = 5278cdf0e10cSrcweir rSh.GetCrsr()->GetCntntNode( sal_True )->Len(); 5279cdf0e10cSrcweir } 5280cdf0e10cSrcweir else if( nPosNodeIdx == nMarkNodeIdx ) 5281cdf0e10cSrcweir { 5282cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx; 5283cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent = nPosIdx; 5284cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx; 5285cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = nMarkIdx; 5286cdf0e10cSrcweir } 5287cdf0e10cSrcweir else 5288cdf0e10cSrcweir { 5289cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx; 5290cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = nMarkIdx; 5291cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nMarkNodeIdx; 5292cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent = 5293cdf0e10cSrcweir rSh.GetCrsr()->GetCntntNode( sal_False )->Len(); 5294cdf0e10cSrcweir } 5295cdf0e10cSrcweir 5296cdf0e10cSrcweir rSh.EndCrsrMove( sal_True ); 5297cdf0e10cSrcweir } 5298cdf0e10cSrcweir } 5299cdf0e10cSrcweir break; 5300cdf0e10cSrcweir #ifdef DBG_UTIL 5301cdf0e10cSrcweir default: 5302cdf0e10cSrcweir ASSERT( !this, "unknown command." ); 5303cdf0e10cSrcweir #endif 5304cdf0e10cSrcweir } 5305cdf0e10cSrcweir if (bCallBase) 5306cdf0e10cSrcweir Window::Command(rCEvt); 5307cdf0e10cSrcweir } 5308cdf0e10cSrcweir 5309cdf0e10cSrcweir /* -----------------25.08.2003 10:12----------------- 5310cdf0e10cSrcweir #i18686#: select the object/cursor at the mouse 5311cdf0e10cSrcweir position of the context menu request 5312cdf0e10cSrcweir --------------------------------------------------*/ 5313cdf0e10cSrcweir sal_Bool SwEditWin::SelectMenuPosition(SwWrtShell& rSh, const Point& rMousePos ) 5314cdf0e10cSrcweir { 5315cdf0e10cSrcweir sal_Bool bRet = sal_False; 5316cdf0e10cSrcweir const Point aDocPos( PixelToLogic( rMousePos ) ); 5317cdf0e10cSrcweir // --> OD 2005-02-17 #i42258# 5318cdf0e10cSrcweir const bool bIsInsideSelectedObj( rSh.IsInsideSelectedObj( aDocPos ) ); 5319cdf0e10cSrcweir // <-- 5320cdf0e10cSrcweir //create a synthetic mouse event out of the coordinates 5321cdf0e10cSrcweir MouseEvent aMEvt(rMousePos); 5322cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView(); 5323cdf0e10cSrcweir if ( pSdrView ) 5324cdf0e10cSrcweir { 5325cdf0e10cSrcweir // --> OD 2005-02-17 #i42258# - no close of insert_draw and reset of 5326cdf0e10cSrcweir // draw mode, if context menu position is inside a selected object. 5327cdf0e10cSrcweir if ( !bIsInsideSelectedObj && rView.GetDrawFuncPtr() ) 5328cdf0e10cSrcweir // <-- 5329cdf0e10cSrcweir { 5330cdf0e10cSrcweir 5331cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 5332cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 5333cdf0e10cSrcweir rView.LeaveDrawCreate(); 5334cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings(); 5335cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_SIZE ); 5336cdf0e10cSrcweir rBind.Invalidate( SID_TABLE_CELL ); 5337cdf0e10cSrcweir } 5338cdf0e10cSrcweir 5339cdf0e10cSrcweir // if draw text is active and there's a text selection 5340cdf0e10cSrcweir // at the mouse position then do nothing 5341cdf0e10cSrcweir if(rSh.GetSelectionType() & nsSelectionType::SEL_DRW_TXT) 5342cdf0e10cSrcweir { 5343cdf0e10cSrcweir OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView(); 5344cdf0e10cSrcweir ESelection aSelection = pOLV->GetSelection(); 5345cdf0e10cSrcweir if(!aSelection.IsZero()) 5346cdf0e10cSrcweir { 5347cdf0e10cSrcweir SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner(); 5348cdf0e10cSrcweir sal_Bool bVertical = pOutliner->IsVertical(); 5349cdf0e10cSrcweir const EditEngine& rEditEng = pOutliner->GetEditEngine(); 5350cdf0e10cSrcweir Point aEEPos(aDocPos); 5351cdf0e10cSrcweir const Rectangle& rOutputArea = pOLV->GetOutputArea(); 5352cdf0e10cSrcweir // regard vertical mode 5353cdf0e10cSrcweir if(bVertical) 5354cdf0e10cSrcweir { 5355cdf0e10cSrcweir aEEPos -= rOutputArea.TopRight(); 5356cdf0e10cSrcweir //invert the horizontal direction and exchange X and Y 5357cdf0e10cSrcweir long nTemp = -aEEPos.X(); 5358cdf0e10cSrcweir aEEPos.X() = aEEPos.Y(); 5359cdf0e10cSrcweir aEEPos.Y() = nTemp; 5360cdf0e10cSrcweir } 5361cdf0e10cSrcweir else 5362cdf0e10cSrcweir aEEPos -= rOutputArea.TopLeft(); 5363cdf0e10cSrcweir 5364cdf0e10cSrcweir EPosition aDocPosition = rEditEng.FindDocPosition(aEEPos); 5365cdf0e10cSrcweir ESelection aCompare(aDocPosition.nPara, aDocPosition.nIndex); 5366cdf0e10cSrcweir // make it a forward selection - otherwise the IsLess/IsGreater do not work :-( 5367cdf0e10cSrcweir aSelection.Adjust(); 5368cdf0e10cSrcweir if(!aCompare.IsLess(aSelection) && !aCompare.IsGreater(aSelection)) 5369cdf0e10cSrcweir { 5370cdf0e10cSrcweir return sal_False; 5371cdf0e10cSrcweir } 5372cdf0e10cSrcweir } 5373cdf0e10cSrcweir 5374cdf0e10cSrcweir } 5375cdf0e10cSrcweir 5376cdf0e10cSrcweir if (pSdrView->MouseButtonDown( aMEvt, this ) ) 5377cdf0e10cSrcweir { 5378cdf0e10cSrcweir pSdrView->MouseButtonUp( aMEvt, this ); 5379cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False); 5380cdf0e10cSrcweir return sal_True; 5381cdf0e10cSrcweir } 5382cdf0e10cSrcweir } 5383cdf0e10cSrcweir rSh.ResetCursorStack(); 5384cdf0e10cSrcweir 5385cdf0e10cSrcweir if ( EnterDrawMode( aMEvt, aDocPos ) ) 5386cdf0e10cSrcweir { 5387cdf0e10cSrcweir return sal_True; 5388cdf0e10cSrcweir } 5389cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm ) 5390cdf0e10cSrcweir { 5391cdf0e10cSrcweir StopInsFrm(); 5392cdf0e10cSrcweir rSh.Edit(); 5393cdf0e10cSrcweir } 5394cdf0e10cSrcweir 5395cdf0e10cSrcweir UpdatePointer( aDocPos, 0 ); 5396cdf0e10cSrcweir 5397cdf0e10cSrcweir if( !rSh.IsSelFrmMode() && 5398cdf0e10cSrcweir !GetView().GetViewFrame()->GetDispatcher()->IsLocked() ) 5399cdf0e10cSrcweir { 5400cdf0e10cSrcweir // #107513# 5401cdf0e10cSrcweir // Test if there is a draw object at that position and if it should be selected. 5402cdf0e10cSrcweir sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos); 5403cdf0e10cSrcweir 5404cdf0e10cSrcweir if(bShould) 5405cdf0e10cSrcweir { 5406cdf0e10cSrcweir rView.NoRotate(); 5407cdf0e10cSrcweir rSh.HideCrsr(); 5408cdf0e10cSrcweir 5409cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 5410cdf0e10cSrcweir rSh.LockView( sal_True ); 5411cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, 0); 5412cdf0e10cSrcweir if( bUnLockView ) 5413cdf0e10cSrcweir rSh.LockView( sal_False ); 5414cdf0e10cSrcweir 5415cdf0e10cSrcweir if( bSelObj ) 5416cdf0e10cSrcweir { 5417cdf0e10cSrcweir bRet = sal_True; 5418cdf0e10cSrcweir // falls im Macro der Rahmen deselektiert 5419cdf0e10cSrcweir // wurde, muss nur noch der Cursor 5420cdf0e10cSrcweir // wieder angezeigt werden. 5421cdf0e10cSrcweir if( FRMTYPE_NONE == rSh.GetSelFrmType() ) 5422cdf0e10cSrcweir rSh.ShowCrsr(); 5423cdf0e10cSrcweir else 5424cdf0e10cSrcweir { 5425cdf0e10cSrcweir if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr()) 5426cdf0e10cSrcweir { 5427cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 5428cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 5429cdf0e10cSrcweir rView.LeaveDrawCreate(); 5430cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 5431cdf0e10cSrcweir } 5432cdf0e10cSrcweir 5433cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 5434cdf0e10cSrcweir bFrmDrag = sal_True; 5435cdf0e10cSrcweir UpdatePointer( aDocPos, 0 ); 5436cdf0e10cSrcweir return bRet; 5437cdf0e10cSrcweir } 5438cdf0e10cSrcweir } 5439cdf0e10cSrcweir 5440cdf0e10cSrcweir if (!rView.GetDrawFuncPtr()) 5441cdf0e10cSrcweir rSh.ShowCrsr(); 5442cdf0e10cSrcweir } 5443cdf0e10cSrcweir } 5444cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() && 5445cdf0e10cSrcweir (aActHitType == SDRHIT_NONE || 5446cdf0e10cSrcweir !bIsInsideSelectedObj)) 5447cdf0e10cSrcweir { 5448cdf0e10cSrcweir rView.NoRotate(); 5449cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked(); 5450cdf0e10cSrcweir rSh.LockView( sal_True ); 5451cdf0e10cSrcweir sal_uInt8 nFlag = 0; 5452cdf0e10cSrcweir 5453cdf0e10cSrcweir if ( rSh.IsSelFrmMode() ) 5454cdf0e10cSrcweir { 5455cdf0e10cSrcweir rSh.UnSelectFrm(); 5456cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 5457cdf0e10cSrcweir rView.AttrChangedNotify(&rSh); 5458cdf0e10cSrcweir bRet = sal_True; 5459cdf0e10cSrcweir } 5460cdf0e10cSrcweir 5461cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag ); 5462cdf0e10cSrcweir if( bUnLockView ) 5463cdf0e10cSrcweir rSh.LockView( sal_False ); 5464cdf0e10cSrcweir 5465cdf0e10cSrcweir if( !bSelObj ) 5466cdf0e10cSrcweir { 5467cdf0e10cSrcweir // Cursor hier umsetzen, damit er nicht zuerst 5468cdf0e10cSrcweir // im Rahmen gezeichnet wird; ShowCrsr() geschieht 5469cdf0e10cSrcweir // in LeaveSelFrmMode() 5470cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False)); 5471cdf0e10cSrcweir rSh.LeaveSelFrmMode(); 5472cdf0e10cSrcweir rView.LeaveDrawCreate(); 5473cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 5474cdf0e10cSrcweir bRet = sal_True; 5475cdf0e10cSrcweir } 5476cdf0e10cSrcweir else 5477cdf0e10cSrcweir { 5478cdf0e10cSrcweir rSh.HideCrsr(); 5479cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos ); 5480cdf0e10cSrcweir rSh.SelFlyGrabCrsr(); 5481cdf0e10cSrcweir rSh.MakeSelVisible(); 5482cdf0e10cSrcweir bFrmDrag = sal_True; 5483cdf0e10cSrcweir if( rSh.IsFrmSelected() && 5484cdf0e10cSrcweir rView.GetDrawFuncPtr() ) 5485cdf0e10cSrcweir { 5486cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate(); 5487cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL); 5488cdf0e10cSrcweir rView.LeaveDrawCreate(); 5489cdf0e10cSrcweir rView.AttrChangedNotify( &rSh ); 5490cdf0e10cSrcweir } 5491cdf0e10cSrcweir UpdatePointer( aDocPos, 0 ); 5492cdf0e10cSrcweir bRet = sal_True; 5493cdf0e10cSrcweir } 5494cdf0e10cSrcweir } 5495cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() && bIsInsideSelectedObj ) 5496cdf0e10cSrcweir { 5497cdf0e10cSrcweir // ## object at the mouse cursor is already selected - do nothing 5498cdf0e10cSrcweir return sal_False; 5499cdf0e10cSrcweir } 5500cdf0e10cSrcweir 5501cdf0e10cSrcweir if ( rSh.IsGCAttr() ) 5502cdf0e10cSrcweir { 5503cdf0e10cSrcweir rSh.GCAttr(); 5504cdf0e10cSrcweir rSh.ClearGCAttr(); 5505cdf0e10cSrcweir } 5506cdf0e10cSrcweir 5507cdf0e10cSrcweir sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False; 5508cdf0e10cSrcweir if( !bOverSelect ) 5509cdf0e10cSrcweir bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos ); 5510cdf0e10cSrcweir 5511cdf0e10cSrcweir if ( !bOverSelect ) 5512cdf0e10cSrcweir { 5513cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die 5514cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!! 5515cdf0e10cSrcweir MV_KONTEXT( &rSh ); 5516cdf0e10cSrcweir (rSh.*rSh.fnSetCrsr)(&aDocPos, sal_False); 5517cdf0e10cSrcweir bRet = sal_True; 5518cdf0e10cSrcweir } 5519cdf0e10cSrcweir } 5520cdf0e10cSrcweir if( !bOverURLGrf ) 5521cdf0e10cSrcweir { 5522cdf0e10cSrcweir const int nSelType = rSh.GetSelectionType(); 5523cdf0e10cSrcweir if( nSelType == nsSelectionType::SEL_OLE || 5524cdf0e10cSrcweir nSelType == nsSelectionType::SEL_GRF ) 5525cdf0e10cSrcweir { 5526cdf0e10cSrcweir MV_KONTEXT( &rSh ); 5527cdf0e10cSrcweir if( !rSh.IsFrmSelected() ) 5528cdf0e10cSrcweir rSh.GotoNextFly(); 5529cdf0e10cSrcweir rSh.EnterSelFrmMode(); 5530cdf0e10cSrcweir bRet = sal_True; 5531cdf0e10cSrcweir } 5532cdf0e10cSrcweir } 5533cdf0e10cSrcweir return bRet; 5534cdf0e10cSrcweir } 5535cdf0e10cSrcweir 5536cdf0e10cSrcweir SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType ) 5537cdf0e10cSrcweir { 5538cdf0e10cSrcweir //Shell ermitteln 5539cdf0e10cSrcweir SfxShell* pShell; 5540cdf0e10cSrcweir SfxDispatcher* pDispatcher = rView.GetViewFrame()->GetDispatcher(); 5541cdf0e10cSrcweir for(sal_uInt16 i = 0; sal_True; ++i ) 5542cdf0e10cSrcweir { 5543cdf0e10cSrcweir pShell = pDispatcher->GetShell( i ); 5544cdf0e10cSrcweir if( !pShell || pShell->IsA( nType ) ) 5545cdf0e10cSrcweir break; 5546cdf0e10cSrcweir } 5547cdf0e10cSrcweir return pShell; 5548cdf0e10cSrcweir } 5549cdf0e10cSrcweir 5550cdf0e10cSrcweir 5551cdf0e10cSrcweir 5552cdf0e10cSrcweir void SwEditWin::ClearTip() 5553cdf0e10cSrcweir { 5554cdf0e10cSrcweir } 5555cdf0e10cSrcweir 5556cdf0e10cSrcweir IMPL_LINK( SwEditWin, KeyInputFlushHandler, Timer *, EMPTYARG ) 5557cdf0e10cSrcweir { 5558cdf0e10cSrcweir FlushInBuffer(); 5559cdf0e10cSrcweir return 0; 5560cdf0e10cSrcweir } 5561cdf0e10cSrcweir 5562cdf0e10cSrcweir 5563cdf0e10cSrcweir IMPL_LINK( SwEditWin, KeyInputTimerHandler, Timer *, EMPTYARG ) 5564cdf0e10cSrcweir { 5565cdf0e10cSrcweir bTblInsDelMode = sal_False; 5566cdf0e10cSrcweir return 0; 5567cdf0e10cSrcweir } 5568cdf0e10cSrcweir 5569cdf0e10cSrcweir void SwEditWin::_InitStaticData() 5570cdf0e10cSrcweir { 5571cdf0e10cSrcweir pQuickHlpData = new QuickHelpData(); 5572cdf0e10cSrcweir } 5573cdf0e10cSrcweir 5574cdf0e10cSrcweir void SwEditWin::_FinitStaticData() 5575cdf0e10cSrcweir { 5576cdf0e10cSrcweir delete pQuickHlpData; 5577cdf0e10cSrcweir } 5578cdf0e10cSrcweir /* -----------------23.01.2003 12:15----------------- 5579cdf0e10cSrcweir * #i3370# remove quick help to prevent saving 5580cdf0e10cSrcweir * of autocorrection suggestions 5581cdf0e10cSrcweir * --------------------------------------------------*/ 5582cdf0e10cSrcweir void SwEditWin::StopQuickHelp() 5583cdf0e10cSrcweir { 5584cdf0e10cSrcweir if( HasFocus() && pQuickHlpData && pQuickHlpData->bClear ) 5585cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() ); 5586cdf0e10cSrcweir } 5587cdf0e10cSrcweir 5588cdf0e10cSrcweir /*-----------------23.02.97 18:39------------------- 5589cdf0e10cSrcweir 5590cdf0e10cSrcweir --------------------------------------------------*/ 5591cdf0e10cSrcweir 5592cdf0e10cSrcweir 5593cdf0e10cSrcweir IMPL_LINK(SwEditWin, TemplateTimerHdl, Timer*, EMPTYARG) 5594cdf0e10cSrcweir { 5595cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate()); 5596cdf0e10cSrcweir return 0; 5597cdf0e10cSrcweir } 5598cdf0e10cSrcweir 5599cdf0e10cSrcweir 5600cdf0e10cSrcweir void SwEditWin::SetChainMode( sal_Bool bOn ) 5601cdf0e10cSrcweir { 5602cdf0e10cSrcweir if ( !bChainMode ) 5603cdf0e10cSrcweir StopInsFrm(); 5604cdf0e10cSrcweir 5605cdf0e10cSrcweir if ( pUserMarker ) 5606cdf0e10cSrcweir { 5607cdf0e10cSrcweir delete pUserMarker; 5608cdf0e10cSrcweir pUserMarker = 0L; 5609cdf0e10cSrcweir } 5610cdf0e10cSrcweir 5611cdf0e10cSrcweir bChainMode = bOn; 5612cdf0e10cSrcweir if ( !bChainMode ) 5613cdf0e10cSrcweir rView.GetViewFrame()->HideStatusText(); 5614cdf0e10cSrcweir 5615cdf0e10cSrcweir static sal_uInt16 __READONLY_DATA aInva[] = 5616cdf0e10cSrcweir { 5617cdf0e10cSrcweir FN_FRAME_CHAIN, FN_FRAME_UNCHAIN, 0 5618cdf0e10cSrcweir }; 5619cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(aInva); 5620cdf0e10cSrcweir } 5621cdf0e10cSrcweir 5622cdf0e10cSrcweir uno::Reference< ::com::sun::star::accessibility::XAccessible > SwEditWin::CreateAccessible() 5623cdf0e10cSrcweir { 5624cdf0e10cSrcweir vos::OGuard aGuard(Application::GetSolarMutex()); // this should have 5625cdf0e10cSrcweir // happend already!!! 5626cdf0e10cSrcweir SwWrtShell *pSh = rView.GetWrtShellPtr(); 5627cdf0e10cSrcweir ASSERT( pSh, "no writer shell, no accessible object" ); 5628cdf0e10cSrcweir uno::Reference< 5629cdf0e10cSrcweir ::com::sun::star::accessibility::XAccessible > xAcc; 5630cdf0e10cSrcweir if( pSh ) 5631cdf0e10cSrcweir xAcc = pSh->CreateAccessible(); 5632cdf0e10cSrcweir 5633cdf0e10cSrcweir return xAcc; 5634cdf0e10cSrcweir } 5635cdf0e10cSrcweir 5636cdf0e10cSrcweir //------------------------------------------------------------- 5637cdf0e10cSrcweir 5638cdf0e10cSrcweir void QuickHelpData::Move( QuickHelpData& rCpy ) 5639cdf0e10cSrcweir { 5640cdf0e10cSrcweir // Pointer verschieben 5641cdf0e10cSrcweir aArr.Insert( &rCpy.aArr ); 5642cdf0e10cSrcweir rCpy.aArr.Remove( (sal_uInt16)0, rCpy.aArr.Count() ); 5643cdf0e10cSrcweir // nTipId = rCpy.nTipId; 5644cdf0e10cSrcweir bClear = rCpy.bClear; 5645cdf0e10cSrcweir nLen = rCpy.nLen; 5646cdf0e10cSrcweir nCurArrPos = rCpy.nCurArrPos; 5647cdf0e10cSrcweir bChkInsBlank = rCpy.bChkInsBlank; 5648cdf0e10cSrcweir bIsTip = rCpy.bIsTip; 5649cdf0e10cSrcweir bIsAutoText = rCpy.bIsAutoText; 5650cdf0e10cSrcweir 5651cdf0e10cSrcweir if( pCETID ) delete pCETID; 5652cdf0e10cSrcweir pCETID = rCpy.pCETID; 5653cdf0e10cSrcweir rCpy.pCETID = 0; 5654cdf0e10cSrcweir 5655cdf0e10cSrcweir if( pAttrs ) 5656cdf0e10cSrcweir delete[] pAttrs; 5657cdf0e10cSrcweir pAttrs = rCpy.pAttrs; 5658cdf0e10cSrcweir rCpy.pAttrs = 0; 5659cdf0e10cSrcweir } 5660cdf0e10cSrcweir 5661cdf0e10cSrcweir void QuickHelpData::ClearCntnt() 5662cdf0e10cSrcweir { 5663cdf0e10cSrcweir nLen = nCurArrPos = 0; 5664cdf0e10cSrcweir bClear = bChkInsBlank = sal_False; 5665cdf0e10cSrcweir nTipId = 0; 5666cdf0e10cSrcweir aArr.DeleteAndDestroy( 0 , aArr.Count() ); 5667cdf0e10cSrcweir bIsTip = sal_True; 5668cdf0e10cSrcweir bIsAutoText = sal_True; 5669cdf0e10cSrcweir delete pCETID, pCETID = 0; 5670cdf0e10cSrcweir delete[] pAttrs, pAttrs = 0; 5671cdf0e10cSrcweir } 5672cdf0e10cSrcweir 5673cdf0e10cSrcweir 5674cdf0e10cSrcweir void QuickHelpData::Start( SwWrtShell& rSh, sal_uInt16 nWrdLen ) 5675cdf0e10cSrcweir { 5676cdf0e10cSrcweir if( pCETID ) delete pCETID, pCETID = 0; 5677cdf0e10cSrcweir if( pAttrs ) delete[] pAttrs, pAttrs = 0; 5678cdf0e10cSrcweir 5679cdf0e10cSrcweir if( USHRT_MAX != nWrdLen ) 5680cdf0e10cSrcweir { 5681cdf0e10cSrcweir nLen = nWrdLen; 5682cdf0e10cSrcweir nCurArrPos = 0; 5683cdf0e10cSrcweir } 5684cdf0e10cSrcweir bClear = sal_True; 5685cdf0e10cSrcweir 5686cdf0e10cSrcweir Window& rWin = rSh.GetView().GetEditWin(); 5687cdf0e10cSrcweir if( bIsTip ) 5688cdf0e10cSrcweir { 5689cdf0e10cSrcweir Point aPt( rWin.OutputToScreenPixel( rWin.LogicToPixel( 5690cdf0e10cSrcweir rSh.GetCharRect().Pos() ))); 5691cdf0e10cSrcweir aPt.Y() -= 3; 5692cdf0e10cSrcweir nTipId = Help::ShowTip( &rWin, Rectangle( aPt, Size( 1, 1 )), 5693cdf0e10cSrcweir *aArr[ nCurArrPos ], 5694cdf0e10cSrcweir QUICKHELP_LEFT | QUICKHELP_BOTTOM ); 5695cdf0e10cSrcweir } 5696cdf0e10cSrcweir else 5697cdf0e10cSrcweir { 5698cdf0e10cSrcweir String sStr( *aArr[ nCurArrPos ] ); 5699cdf0e10cSrcweir sStr.Erase( 0, nLen ); 5700cdf0e10cSrcweir sal_uInt16 nL = sStr.Len(); 5701cdf0e10cSrcweir pAttrs = new sal_uInt16[ nL ]; 5702cdf0e10cSrcweir for( sal_uInt16 n = nL; n; ) 5703cdf0e10cSrcweir *(pAttrs + --n ) = EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE | 5704cdf0e10cSrcweir EXTTEXTINPUT_ATTR_HIGHLIGHT; 5705cdf0e10cSrcweir pCETID = new CommandExtTextInputData( sStr, pAttrs, nL, 5706cdf0e10cSrcweir 0, 0, 0, sal_False ); 5707cdf0e10cSrcweir rSh.CreateExtTextInput(rWin.GetInputLanguage()); 5708cdf0e10cSrcweir rSh.SetExtTextInputData( *pCETID ); 5709cdf0e10cSrcweir } 5710cdf0e10cSrcweir } 5711cdf0e10cSrcweir 5712cdf0e10cSrcweir void QuickHelpData::Stop( SwWrtShell& rSh ) 5713cdf0e10cSrcweir { 5714cdf0e10cSrcweir if( !bIsTip ) 5715cdf0e10cSrcweir rSh.DeleteExtTextInput( 0, sal_False ); 5716cdf0e10cSrcweir else if( nTipId ) 5717cdf0e10cSrcweir Help::HideTip( nTipId ); 5718cdf0e10cSrcweir ClearCntnt(); 5719cdf0e10cSrcweir } 5720cdf0e10cSrcweir 5721cdf0e10cSrcweir void QuickHelpData::FillStrArr( SwWrtShell& rSh, const String& rWord ) 5722cdf0e10cSrcweir { 5723b10a5c0bSHerbert Dürr // #i22961# get the letter-case context 5724b10a5c0bSHerbert Dürr const CharClass& rCharClass = GetAppCharClass(); 5725b10a5c0bSHerbert Dürr const String aLWord = rCharClass.toLower( rWord, 0, rWord.Len() ); 5726b10a5c0bSHerbert Dürr const bool bIsUpper = (rWord == rCharClass.toUpper( rWord, 0, rWord.Len() ) ); 5727b10a5c0bSHerbert Dürr const bool bIsLower = (rWord == aLWord); 5728b10a5c0bSHerbert Dürr 5729b10a5c0bSHerbert Dürr // add all matching month/day names from the calendar 5730cdf0e10cSrcweir salhelper::SingletonRef<SwCalendarWrapper>* pCalendar = s_getCalendarWrapper(); 5731cdf0e10cSrcweir (*pCalendar)->LoadDefaultCalendar( rSh.GetCurLang() ); 5732cdf0e10cSrcweir 5733cdf0e10cSrcweir { 5734cdf0e10cSrcweir uno::Sequence< i18n::CalendarItem > aNames( 5735cdf0e10cSrcweir (*pCalendar)->getMonths() ); 5736cdf0e10cSrcweir for( int n = 0; n < 2; ++n ) 5737cdf0e10cSrcweir { 5738cdf0e10cSrcweir for( long nPos = 0, nEnd = aNames.getLength(); nPos < nEnd; ++nPos ) 5739cdf0e10cSrcweir { 5740b10a5c0bSHerbert Dürr const String& rS = aNames[ nPos ].FullName; 5741b10a5c0bSHerbert Dürr if( rS.Len() <= rWord.Len() + 1 ) 5742b10a5c0bSHerbert Dürr continue; 5743b10a5c0bSHerbert Dürr const String aLName = rCharClass.toLower( rS, 0, rWord.Len() ); 5744b10a5c0bSHerbert Dürr if( aLName != aLWord ) 5745b10a5c0bSHerbert Dürr continue; 5746b10a5c0bSHerbert Dürr // #i22961# provide case-sensitive autocompletion suggestions 5747b10a5c0bSHerbert Dürr String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) ); 5748b10a5c0bSHerbert Dürr if( !aArr.Insert( pNew ) ) 5749b10a5c0bSHerbert Dürr delete pNew; 5750cdf0e10cSrcweir } 5751cdf0e10cSrcweir if( !n ) // get data for the second loop 5752cdf0e10cSrcweir aNames = (*pCalendar)->getDays(); 5753cdf0e10cSrcweir } 5754cdf0e10cSrcweir } 5755cdf0e10cSrcweir 57563234e392SHerbert Dürr // and then add all words from the AutoCompleteWord-List 5757cdf0e10cSrcweir const SwAutoCompleteWord& rACLst = rSh.GetAutoCompleteWords(); 5758cdf0e10cSrcweir sal_uInt16 nStt, nEnd; 5759cdf0e10cSrcweir if( rACLst.GetRange( rWord, nStt, nEnd ) ) 5760cdf0e10cSrcweir { 57613234e392SHerbert Dürr for(; nStt < nEnd; ++nStt ) 5762cdf0e10cSrcweir { 5763cdf0e10cSrcweir const String& rS = rACLst[ nStt ]; 57643234e392SHerbert Dürr if( rS.Len() <= rWord.Len() ) 57653234e392SHerbert Dürr continue; 57663234e392SHerbert Dürr // #i22961# provide case-sensitive autocompletion suggestions 57673234e392SHerbert Dürr String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) ); 57683234e392SHerbert Dürr if( !aArr.Insert( pNew ) ) 57693234e392SHerbert Dürr delete pNew; 5770cdf0e10cSrcweir } 5771cdf0e10cSrcweir } 5772cdf0e10cSrcweir } 5773b10a5c0bSHerbert Dürr 5774cdf0e10cSrcweir void SwEditWin::ShowAutoTextCorrectQuickHelp( 5775cdf0e10cSrcweir const String& rWord, SvxAutoCorrCfg* pACfg, SvxAutoCorrect* pACorr, 5776cdf0e10cSrcweir sal_Bool bFromIME ) 5777cdf0e10cSrcweir { 5778cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell(); 5779cdf0e10cSrcweir pQuickHlpData->ClearCntnt(); 5780cdf0e10cSrcweir if( pACfg->IsAutoTextTip() ) 5781cdf0e10cSrcweir { 5782cdf0e10cSrcweir SwGlossaryList* pList = ::GetGlossaryList(); 5783cdf0e10cSrcweir pList->HasLongName( rWord, &pQuickHlpData->aArr ); 5784cdf0e10cSrcweir } 5785cdf0e10cSrcweir 5786cdf0e10cSrcweir if( pQuickHlpData->aArr.Count() ) 5787cdf0e10cSrcweir { 5788cdf0e10cSrcweir pQuickHlpData->bIsTip = sal_True; 5789cdf0e10cSrcweir pQuickHlpData->bIsAutoText = sal_True; 5790cdf0e10cSrcweir } 5791cdf0e10cSrcweir else if( pACorr->GetSwFlags().bAutoCompleteWords ) 5792cdf0e10cSrcweir { 5793cdf0e10cSrcweir pQuickHlpData->bIsAutoText = sal_False; 5794cdf0e10cSrcweir pQuickHlpData->bIsTip = bFromIME || 5795cdf0e10cSrcweir !pACorr || 5796cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCmpltShowAsTip; 5797cdf0e10cSrcweir 5798cdf0e10cSrcweir pQuickHlpData->FillStrArr( rSh, rWord ); 5799cdf0e10cSrcweir } 5800cdf0e10cSrcweir 5801cdf0e10cSrcweir if( pQuickHlpData->aArr.Count() ) 5802cdf0e10cSrcweir pQuickHlpData->Start( rSh, rWord.Len() ); 5803cdf0e10cSrcweir } 5804cdf0e10cSrcweir 5805cdf0e10cSrcweir /* -----------------29.03.2006 11:01----------------- 5806cdf0e10cSrcweir * 5807cdf0e10cSrcweir * --------------------------------------------------*/ 5808cdf0e10cSrcweir 5809cdf0e10cSrcweir void SwEditWin::SetUseInputLanguage( sal_Bool bNew ) 5810cdf0e10cSrcweir { 5811cdf0e10cSrcweir if ( bNew || bUseInputLanguage ) 5812cdf0e10cSrcweir { 5813cdf0e10cSrcweir SfxBindings& rBind = GetView().GetViewFrame()->GetBindings(); 5814cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_CHAR_FONT ); 5815cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); 5816cdf0e10cSrcweir } 5817cdf0e10cSrcweir bUseInputLanguage = bNew; 5818cdf0e10cSrcweir } 5819cdf0e10cSrcweir 5820cdf0e10cSrcweir /*-- 13.11.2008 10:18:17--------------------------------------------------- 5821cdf0e10cSrcweir 5822cdf0e10cSrcweir -----------------------------------------------------------------------*/ 5823cdf0e10cSrcweir XubString SwEditWin::GetSurroundingText() const 5824cdf0e10cSrcweir { 5825cdf0e10cSrcweir String sReturn; 5826cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell(); 5827cdf0e10cSrcweir if( rSh.HasSelection() && !rSh.IsMultiSelection() && rSh.IsSelOnePara() ) 5828cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR ); 5829cdf0e10cSrcweir else if( !rSh.HasSelection() ) 5830cdf0e10cSrcweir { 5831cdf0e10cSrcweir SwPosition *pPos = rSh.GetCrsr()->GetPoint(); 5832cdf0e10cSrcweir xub_StrLen nPos = pPos->nContent.GetIndex(); 5833cdf0e10cSrcweir 5834cdf0e10cSrcweir // get the sentence around the cursor 5835cdf0e10cSrcweir rSh.HideCrsr(); 5836cdf0e10cSrcweir rSh.GoStartSentence(); 5837cdf0e10cSrcweir rSh.SetMark(); 5838cdf0e10cSrcweir rSh.GoEndSentence(); 5839cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR ); 5840cdf0e10cSrcweir 5841cdf0e10cSrcweir pPos->nContent = nPos; 5842cdf0e10cSrcweir rSh.ClearMark(); 5843cdf0e10cSrcweir rSh.HideCrsr(); 5844cdf0e10cSrcweir } 5845cdf0e10cSrcweir 5846cdf0e10cSrcweir return sReturn; 5847cdf0e10cSrcweir } 5848cdf0e10cSrcweir /*-- 13.11.2008 10:18:17--------------------------------------------------- 5849cdf0e10cSrcweir 5850cdf0e10cSrcweir -----------------------------------------------------------------------*/ 5851cdf0e10cSrcweir Selection SwEditWin::GetSurroundingTextSelection() const 5852cdf0e10cSrcweir { 5853cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell(); 5854cdf0e10cSrcweir if( rSh.HasSelection() ) 5855cdf0e10cSrcweir { 5856cdf0e10cSrcweir String sReturn; 5857cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR ); 5858cdf0e10cSrcweir return Selection( 0, sReturn.Len() ); 5859cdf0e10cSrcweir } 5860cdf0e10cSrcweir else 5861cdf0e10cSrcweir { 5862cdf0e10cSrcweir // Return the position of the visible cursor in the sentence 5863cdf0e10cSrcweir // around the visible cursor. 5864cdf0e10cSrcweir SwPosition *pPos = rSh.GetCrsr()->GetPoint(); 5865cdf0e10cSrcweir xub_StrLen nPos = pPos->nContent.GetIndex(); 5866cdf0e10cSrcweir 5867cdf0e10cSrcweir rSh.HideCrsr(); 5868cdf0e10cSrcweir rSh.GoStartSentence(); 5869cdf0e10cSrcweir xub_StrLen nStartPos = rSh.GetCrsr()->GetPoint()->nContent.GetIndex(); 5870cdf0e10cSrcweir 5871cdf0e10cSrcweir pPos->nContent = nPos; 5872cdf0e10cSrcweir rSh.ClearMark(); 5873cdf0e10cSrcweir rSh.ShowCrsr(); 5874cdf0e10cSrcweir 5875cdf0e10cSrcweir return Selection( nPos - nStartPos, nPos - nStartPos ); 5876cdf0e10cSrcweir } 5877cdf0e10cSrcweir } 5878