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