sw/source/ui/wrtsh/select.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: select.cxx,v $
  10  * $Revision: 1.33 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34
  35 #include <limits.h>
  36 #include <hintids.hxx>
  37 #include <sfx2/bindings.hxx>
  38 #include <svtools/eitem.hxx>
  39 #include <svtools/macitem.hxx>
  40 #include <unotools/charclass.hxx>
  41 #include <svx/scripttypeitem.hxx>
  42 #ifndef _CMDID_H
  43 #include <cmdid.h>
  44 #endif
  45 #ifndef _VIEW_HXX
  46 #include <view.hxx>
  47 #endif
  48 #ifndef _BASESH_HXX
  49 #include <basesh.hxx>
  50 #endif
  51 #include <wrtsh.hxx>
  52 #include <frmatr.hxx>
  53 #include <initui.hxx>
  54 #include <mdiexp.hxx>
  55 #include <fmtcol.hxx>
  56 #include <frmfmt.hxx>
  57 #include <swundo.hxx>                   // fuer Undo-Ids
  58 #include <swevent.hxx>
  59 #include <swdtflvr.hxx>
  60 #include <crsskip.hxx>
  61
  62 #if OSL_DEBUG_LEVEL > 1
  63 #include <pam.hxx>
  64 #endif
  65
  66 namespace com { namespace sun { namespace star { namespace util {
  67     struct SearchOptions;
  68 } } } }
  69
  70 using namespace ::com::sun::star::util;
  71
  72
  73 static long nStartDragX = 0, nStartDragY = 0;
  74 static BOOL  bStartDrag = FALSE;
  75
  76 void SwWrtShell::Invalidate()
  77 {
  78     // to avoid making the slot volatile, invalidate it everytime if something could have been changed
  79     // this is still much cheaper than asking for the state every 200 ms (and avoid background processing)
  80     GetView().GetViewFrame()->GetBindings().Invalidate( FN_STAT_SELMODE );
  81 }
  82
  83 BOOL SwWrtShell::SelNearestWrd()
  84 {
  85     MV_KONTEXT(this);
  86     if( !IsInWrd() && !IsEndWrd() && !IsSttWrd() )
  87         PrvWrd();
  88     if( IsEndWrd() )
  89         Left(CRSR_SKIP_CELLS, FALSE, 1, FALSE );
  90     return SelWrd();
  91 }
  92
  93
  94
  95 BOOL SwWrtShell::SelWrd(const Point *pPt, BOOL )
  96 {
  97     BOOL bRet;
  98     {
  99         MV_KONTEXT(this);
 100         SttSelect();
 101         bRet = SwCrsrShell::SelectWord( pPt );
 102     }
 103     EndSelect();
 104     if( bRet )
 105     {
 106         bSelWrd = TRUE;
 107         if(pPt)
 108             aStart = *pPt;
 109     }
 110     return bRet;
 111 }
 112
 113 void SwWrtShell::SelSentence(const Point *pPt, BOOL )
 114 {
 115     {
 116         MV_KONTEXT(this);
 117         ClearMark();
 118         SwCrsrShell::GoStartSentence();
 119         SttSelect();
 120         SwCrsrShell::GoEndSentence();
 121     }
 122     EndSelect();
 123     if(pPt)
 124         aStart = *pPt;
 125     bSelLn = TRUE;
 126     bSelWrd = FALSE;    // SelWord abschalten, sonst geht kein SelLine weiter
 127 }
 128
 129 void SwWrtShell::SelPara(const Point *pPt, BOOL )
 130 {
 131     {
 132         MV_KONTEXT(this);
 133         ClearMark();
 134         SwCrsrShell::MovePara( fnParaCurr, fnParaStart );
 135         SttSelect();
 136         SwCrsrShell::MovePara( fnParaCurr, fnParaEnd );
 137     }
 138     EndSelect();
 139     if(pPt)
 140         aStart = *pPt;
 141     bSelLn = FALSE;
 142     bSelWrd = FALSE;    // SelWord abschalten, sonst geht kein SelLine weiter
 143 }
 144
 145
 146 long SwWrtShell::SelAll()
 147 {
 148     const BOOL bLockedView = IsViewLocked();
 149     LockView( TRUE );
 150     {
 151         if(bBlockMode)
 152             LeaveBlockMode();
 153         MV_KONTEXT(this);
 154         BOOL bMoveTable = FALSE;
 155         SwPosition *pStartPos = 0;
 156         SwPosition *pEndPos = 0;
 157         SwShellCrsr* pTmpCrsr = 0;
 158         if( !HasWholeTabSelection() )
 159         {
 160             if ( IsSelection() && IsCrsrPtAtEnd() )
 161                 SwapPam();
 162             pTmpCrsr = getShellCrsr( false );
 163             if( pTmpCrsr )
 164             {
 165                 pStartPos = new SwPosition( *pTmpCrsr->GetPoint() );
 166                 pEndPos = new SwPosition( *pTmpCrsr->GetMark() );
 167             }
 168             Push();
 169             BOOL bIsFullSel = !MoveSection( fnSectionCurr, fnSectionStart);
 170             SwapPam();
 171             bIsFullSel &= !MoveSection( fnSectionCurr, fnSectionEnd);
 172             Pop(FALSE);
 173             GoStart(TRUE, &bMoveTable, FALSE, !bIsFullSel);
 174         }
 175         else
 176         {
 177             EnterStdMode();
 178             SttEndDoc(TRUE);
 179         }
 180         SttSelect();
 181         GoEnd(TRUE, &bMoveTable);
 182         if( pStartPos )
 183         {
 184             pTmpCrsr = getShellCrsr( false );
 185             if( pTmpCrsr )
 186             {
 187                 // Some special handling for sections (e.g. TOC) at the beginning of the document body
 188                 // to avoid the selection of the first section
 189                 // if the last selection was behind the first section or
 190                 // if the last selection was already the first section
 191                 // In this both cases we select to the end of document
 192                 if( *pTmpCrsr->GetPoint() < *pEndPos ||
 193                     ( *pStartPos == *pTmpCrsr->GetMark() &&
 194                       *pEndPos == *pTmpCrsr->GetPoint() ) )
 195                     SwCrsrShell::SttEndDoc(FALSE);
 196             }
 197             delete pStartPos;
 198             delete pEndPos;
 199         }
 200     }
 201     EndSelect();
 202     LockView( bLockedView );
 203     return 1;
 204 }
 205
 206 /*------------------------------------------------------------------------
 207  Beschreibung:  Textsuche
 208 ------------------------------------------------------------------------*/
 209
 210
 211 ULONG SwWrtShell::SearchPattern( const SearchOptions& rSearchOpt, BOOL bSearchInNotes,
 212                                 SwDocPositions eStt, SwDocPositions eEnd,
 213                                 FindRanges eFlags, int bReplace )
 214 {
 215         // keine Erweiterung bestehender Selektionen
 216     if(!(eFlags & FND_IN_SEL))
 217         ClearMark();
 218     BOOL bCancel = FALSE;
 219     ULONG nRet = Find( rSearchOpt, bSearchInNotes, eStt, eEnd, bCancel, eFlags, bReplace );
 220     if(bCancel)
 221     {
 222         Undo(UNDO_EMPTY, 1);
 223         nRet = ULONG_MAX;
 224     }
 225     return nRet;
 226 }
 227 /*------------------------------------------------------------------------
 228  Beschreibung:  Suche nach Vorlagen
 229 ------------------------------------------------------------------------*/
 230
 231
 232
 233 ULONG SwWrtShell::SearchTempl( const String &rTempl,
 234                                SwDocPositions eStt, SwDocPositions eEnd,
 235                                FindRanges eFlags, const String* pReplTempl )
 236 {
 237         // keine Erweiterung bestehender Selektionen
 238     if(!(eFlags & FND_IN_SEL))
 239         ClearMark();
 240     SwTxtFmtColl *pColl = GetParaStyle(rTempl, SwWrtShell::GETSTYLE_CREATESOME);
 241     SwTxtFmtColl *pReplaceColl = 0;
 242     if( pReplTempl )
 243         pReplaceColl = GetParaStyle(*pReplTempl, SwWrtShell::GETSTYLE_CREATESOME );
 244
 245     BOOL bCancel = FALSE;
 246     ULONG nRet = Find(pColl? *pColl: GetDfltTxtFmtColl(),
 247                                eStt,eEnd, bCancel, eFlags, pReplaceColl);
 248     if(bCancel)
 249     {
 250         Undo(UNDO_EMPTY, 1);
 251         nRet = ULONG_MAX;
 252     }
 253     return nRet;
 254 }
 255
 256 // Suche nach Attributen ----------------------------------------------------
 257
 258
 259
 260 ULONG SwWrtShell::SearchAttr( const SfxItemSet& rFindSet, BOOL bNoColls,
 261                                 SwDocPositions eStart, SwDocPositions eEnde,
 262                                 FindRanges eFlags, const SearchOptions* pSearchOpt,
 263                                 const SfxItemSet* pReplaceSet )
 264 {
 265     // Keine Erweiterung bestehender Selektionen
 266     if (!(eFlags & FND_IN_SEL))
 267         ClearMark();
 268
 269     // Suchen
 270     BOOL bCancel = FALSE;
 271     ULONG nRet = Find( rFindSet, bNoColls, eStart, eEnde, bCancel, eFlags, pSearchOpt, pReplaceSet);
 272
 273     if(bCancel)
 274     {
 275         Undo(UNDO_EMPTY, 1);
 276         nRet = ULONG_MAX;
 277     }
 278     return nRet;
 279 }
 280
 281 // ---------- Selektionsmodi ----------
 282
 283
 284
 285 void SwWrtShell::PushMode()
 286 {
 287     pModeStack = new ModeStack( pModeStack, bIns, bExtMode, bAddMode, bBlockMode );
 288 }
 289
 290
 291
 292 void SwWrtShell::PopMode()
 293 {
 294     if ( 0 == pModeStack )
 295         return;
 296
 297     if ( bExtMode && !pModeStack->bExt )
 298         LeaveExtMode();
 299     if ( bAddMode && !pModeStack->bAdd )
 300         LeaveAddMode();
 301     if ( bBlockMode && !pModeStack->bBlock )
 302         LeaveBlockMode();
 303     bIns = pModeStack->bIns;
 304
 305     ModeStack *pTmp = pModeStack->pNext;
 306     delete pModeStack;
 307     pModeStack = pTmp;
 308 }
 309
 310 /*
 311  * Zwei Methoden fuer das Cursorsetzen; die erste mappt auf die
 312  * gleichnamige Methoden an der CursorShell, die zweite hebt
 313  * zuerst alle Selektionen auf.
 314  */
 315
 316
 317
 318 long SwWrtShell::SetCrsr(const Point *pPt, BOOL bTextOnly)
 319 {
 320         /*
 321         * eine gfs.  bestehende Selektion an der Position des
 322         * Mausklicks aufheben
 323         */
 324     if(!IsInSelect() && ChgCurrPam(*pPt)) {
 325         ClearMark();
 326     }
 327
 328     return SwCrsrShell::SetCrsr(*pPt, bTextOnly);
 329 }
 330
 331
 332 long SwWrtShell::SetCrsrKillSel(const Point *pPt, BOOL bTextOnly )
 333 {
 334     ACT_KONTEXT(this);
 335     ResetSelect(pPt,FALSE);
 336     return SwCrsrShell::SetCrsr(*pPt, bTextOnly);
 337 }
 338
 339
 340
 341 void SwWrtShell::UnSelectFrm()
 342 {
 343     // Rahmenselektion aufheben mit garantiert ungueltiger Position
 344     Point aPt(LONG_MIN, LONG_MIN);
 345     SelectObj(aPt, 0);
 346     GetView().LeaveDrawCreate();
 347     SwTransferable::ClearSelection( *this );
 348 }
 349
 350 /*
 351  * Aufheben aller Selektionen
 352  */
 353
 354
 355
 356 long SwWrtShell::ResetSelect(const Point *,BOOL)
 357 {
 358     if(IsSelFrmMode())
 359     {
 360         UnSelectFrm();
 361         LeaveSelFrmMode();
 362     }
 363     else
 364     {
 365         /*      ACT_KONTEXT() macht eine Action auf -
 366             um im Basicablauf keine Probleme mit der
 367             Shellumschaltung zu bekommen, darf
 368             GetChgLnk().Call() erst nach
 369             EndAction() gerufen werden.
 370         */
 371         {
 372             ACT_KONTEXT(this);
 373             bSelWrd = bSelLn = FALSE;
 374             KillPams();
 375             ClearMark();
 376             fnKillSel = &SwWrtShell::Ignore;
 377             fnSetCrsr = &SwWrtShell::SetCrsr;
 378         }
 379         /*
 380             * nach dem Aufheben aller Selektionen koennte ein Update der
 381             * Attr-Controls notwendig sein.
 382         */
 383         GetChgLnk().Call(this);
 384     }
 385     Invalidate();
 386     SwTransferable::ClearSelection( *this );
 387     return 1;
 388 }
 389
 390
 391
 392 /*
 393  * tue nichts
 394  */
 395 long SwWrtShell::Ignore(const Point *, BOOL ) {
 396     return 1;
 397 }
 398
 399 /*
 400  * Start eines Selektionsvorganges.
 401  */
 402
 403
 404
 405 void SwWrtShell::SttSelect()
 406 {
 407     if(bInSelect)
 408         return;
 409     if(!HasMark())
 410         SetMark();
 411     if( bBlockMode )
 412     {
 413         SwShellCrsr* pTmp = getShellCrsr( true );
 414         if( !pTmp->HasMark() )
 415             pTmp->SetMark();
 416     }
 417     fnKillSel = &SwWrtShell::Ignore;
 418     fnSetCrsr = &SwWrtShell::SetCrsr;
 419     bInSelect = TRUE;
 420     Invalidate();
 421     SwTransferable::CreateSelection( *this );
 422 }
 423 /*
 424  * Ende eines Selektionsvorganges.
 425  */
 426
 427
 428
 429 void SwWrtShell::EndSelect()
 430 {
 431     if(!bInSelect || bExtMode)
 432         return;
 433     bInSelect = FALSE;
 434     (this->*fnLeaveSelect)(0,FALSE);
 435     if(!bAddMode) {
 436         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 437         fnKillSel = &SwWrtShell::ResetSelect;
 438     }
 439 }
 440 /* Methode, um eine bestehende wortweise oder zeilenweise Selektion
 441  * zu erweitern.
 442  */
 443
 444 inline BOOL operator<(const Point &rP1,const Point &rP2)
 445 {
 446     return rP1.Y() < rP2.Y() || (rP1.Y() == rP2.Y() && rP1.X() < rP2.X());
 447 }
 448
 449
 450
 451 long SwWrtShell::ExtSelWrd(const Point *pPt, BOOL )
 452 {
 453     MV_KONTEXT(this);
 454     if( IsTableMode() )
 455         return 1;
 456
 457     // Bug 66823: actual crsr has in additional mode no selection?
 458     // Then destroy the actual an go to prev, this will be expand
 459     if( !HasMark() && GoPrevCrsr() )
 460     {
 461         BOOL bHasMark = HasMark(); // thats wrong!
 462         GoNextCrsr();
 463         if( bHasMark )
 464         {
 465             DestroyCrsr();
 466             GoPrevCrsr();
 467         }
 468     }
 469
 470     // check the direction of the selection with the new point
 471     BOOL bRet = FALSE, bMoveCrsr = TRUE, bToTop = FALSE;
 472     SwCrsrShell::SelectWord( &aStart );         // select the startword
 473     SwCrsrShell::Push();                                        // save the cursor
 474     SwCrsrShell::SetCrsr( *pPt );                       // and check the direction
 475
 476     switch( SwCrsrShell::CompareCursor( StackMkCurrPt ))
 477     {
 478     case -1:    bToTop = FALSE;         break;
 479     case 1:     bToTop = TRUE;          break;
 480     default:    bMoveCrsr = FALSE;      break;
 481     }
 482
 483     SwCrsrShell::Pop( FALSE );                          // retore the saved cursor
 484
 485     if( bMoveCrsr )
 486     {
 487         // select to Top but cursor select to Bottom? or
 488         // select to Bottom but cursor select to Top?           --> swap the cursor
 489         if( bToTop )
 490             SwapPam();
 491
 492         SwCrsrShell::Push();                    // save cur cursor
 493         if( SwCrsrShell::SelectWord( pPt ))     // select the current word
 494         {
 495             if( bToTop )
 496                 SwapPam();
 497             Combine();
 498             bRet = TRUE;
 499         }
 500         else
 501         {
 502             SwCrsrShell::Pop( FALSE );
 503             if( bToTop )
 504                 SwapPam();
 505         }
 506     }
 507     else
 508         bRet = TRUE;
 509     return bRet;
 510 }
 511
 512
 513 long SwWrtShell::ExtSelLn(const Point *pPt, BOOL )
 514 {
 515     MV_KONTEXT(this);
 516     SwCrsrShell::SetCrsr(*pPt);
 517     if( IsTableMode() )
 518         return 1;
 519
 520     // Bug 66823: actual crsr has in additional mode no selection?
 521     // Then destroy the actual an go to prev, this will be expand
 522     if( !HasMark() && GoPrevCrsr() )
 523     {
 524         BOOL bHasMark = HasMark(); // thats wrong!
 525         GoNextCrsr();
 526         if( bHasMark )
 527         {
 528             DestroyCrsr();
 529             GoPrevCrsr();
 530         }
 531     }
 532
 533     // ggfs. den Mark der Selektion anpassen
 534     BOOL bToTop = !IsCrsrPtAtEnd();
 535     SwapPam();
 536
 537     // der "Mark" muss am Zeilenende/-anfang stehen
 538     if( bToTop ? !IsEndSentence() : !IsStartSentence() )
 539     {
 540         if( bToTop )
 541         {
 542             if( !IsEndPara() )
 543                 SwCrsrShell::Right(1,CRSR_SKIP_CHARS);
 544             SwCrsrShell::GoEndSentence();
 545         }
 546         else
 547             SwCrsrShell::GoStartSentence();
 548     }
 549     SwapPam();
 550
 551     return bToTop ? SwCrsrShell::GoStartSentence() : SwCrsrShell::GoEndSentence();
 552 }
 553
 554
 555 /*
 556  * zurueck in den Standard Mode: kein Mode, keine Selektionen.
 557  */
 558
 559 void SwWrtShell::EnterStdMode()
 560 {
 561     if(bAddMode)
 562         LeaveAddMode();
 563     if(bBlockMode)
 564         LeaveBlockMode();
 565     bBlockMode = FALSE;
 566     bExtMode = FALSE;
 567     bInSelect = FALSE;
 568     if(IsSelFrmMode())
 569     {
 570         UnSelectFrm();
 571         LeaveSelFrmMode();
 572     }
 573     else
 574     {
 575         /*  ACT_KONTEXT() opens and action which has to be
 576             closed prior to the call of
 577             GetChgLnk().Call()
 578         */
 579         {
 580             ACT_KONTEXT(this);
 581             bSelWrd = bSelLn = FALSE;
 582             if( !IsRetainSelection() )
 583                 KillPams();
 584             ClearMark();
 585             fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 586             fnKillSel = &SwWrtShell::ResetSelect;
 587         }
 588     }
 589     Invalidate();
 590     SwTransferable::ClearSelection( *this );
 591 }
 592
 593 /*
 594  * Extended Mode
 595  */
 596
 597
 598
 599 void SwWrtShell::EnterExtMode()
 600 {
 601     if(bBlockMode)
 602     {
 603         LeaveBlockMode();
 604         KillPams();
 605         ClearMark();
 606     }
 607     bExtMode = TRUE;
 608     bAddMode = FALSE;
 609     bBlockMode = FALSE;
 610     SttSelect();
 611 }
 612
 613
 614
 615 void SwWrtShell::LeaveExtMode()
 616 {
 617     bExtMode = FALSE;
 618     EndSelect();
 619 }
 620 /*
 621  * Ende einer Selektion; falls die Selektion leer ist,
 622  * ClearMark().
 623  */
 624
 625
 626
 627 long SwWrtShell::SttLeaveSelect(const Point *, BOOL )
 628 {
 629     if(SwCrsrShell::HasSelection() && !IsSelTblCells() && bClearMark) {
 630         return 0;
 631     }
 632 //      if( IsSelTblCells() ) aSelTblLink.Call(this);
 633     ClearMark();
 634     return 1;
 635 }
 636 /*
 637  * Verlassen des Selektionsmodus in Additional Mode
 638  */
 639
 640
 641
 642 long SwWrtShell::AddLeaveSelect(const Point *, BOOL )
 643 {
 644     if(IsTableMode()) LeaveAddMode();
 645     else if(SwCrsrShell::HasSelection())
 646         CreateCrsr();
 647     return 1;
 648 }
 649 /*
 650  * Additional Mode
 651  */
 652
 653
 654
 655 void SwWrtShell::EnterAddMode()
 656 {
 657     if(IsTableMode()) return;
 658     if(bBlockMode)
 659         LeaveBlockMode();
 660     fnLeaveSelect = &SwWrtShell::AddLeaveSelect;
 661     fnKillSel = &SwWrtShell::Ignore;
 662     fnSetCrsr = &SwWrtShell::SetCrsr;
 663     bAddMode = TRUE;
 664     bBlockMode = FALSE;
 665     bExtMode = FALSE;
 666     if(SwCrsrShell::HasSelection())
 667         CreateCrsr();
 668     Invalidate();
 669 }
 670
 671
 672
 673 void SwWrtShell::LeaveAddMode()
 674 {
 675     fnLeaveSelect = &SwWrtShell::SttLeaveSelect;
 676     fnKillSel = &SwWrtShell::ResetSelect;
 677     fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 678     bAddMode = FALSE;
 679     Invalidate();
 680 }
 681
 682 /*
 683  * Block Mode
 684  */
 685
 686 void SwWrtShell::EnterBlockMode()
 687 {
 688     bBlockMode = FALSE;
 689     EnterStdMode();
 690     bBlockMode = TRUE;
 691     CrsrToBlockCrsr();
 692     Invalidate();
 693 }
 694
 695
 696
 697 void SwWrtShell::LeaveBlockMode()
 698 {
 699     bBlockMode = FALSE;
 700     BlockCrsrToCrsr();
 701     EndSelect();
 702     Invalidate();
 703 }
 704
 705 // Einfuegemodus
 706
 707
 708
 709 void SwWrtShell::SetInsMode( BOOL bOn )
 710 {
 711     bIns = bOn;
 712     SwCrsrShell::SetOverwriteCrsr( !bIns );
 713     const SfxBoolItem aTmp( SID_ATTR_INSERT, bIns );
 714     GetView().GetViewFrame()->GetBindings().SetState( aTmp );
 715     StartAction();
 716     EndAction();
 717     Invalidate();
 718 }
 719 //Overwrite mode is incompatible with red-lining
 720 void SwWrtShell::SetRedlineModeAndCheckInsMode( USHORT eMode )
 721 {
 722    SetRedlineMode( eMode );
 723    if (IsRedlineOn())
 724        SetInsMode( true );
 725 }
 726
 727 /*
 728  * Rahmen bearbeiten
 729  */
 730
 731
 732 long SwWrtShell::BeginFrmDrag(const Point *pPt, BOOL)
 733 {
 734     fnDrag = &SwFEShell::Drag;
 735     if(bStartDrag)
 736     {
 737         Point aTmp( nStartDragX, nStartDragY );
 738         SwFEShell::BeginDrag( &aTmp, FALSE );
 739     }
 740     else
 741         SwFEShell::BeginDrag( pPt, FALSE );
 742     return 1;
 743 }
 744
 745
 746
 747 void SwWrtShell::EnterSelFrmMode(const Point *pPos)
 748 {
 749     if(pPos)
 750     {
 751         nStartDragX = pPos->X();
 752         nStartDragY = pPos->Y();
 753         bStartDrag = TRUE;
 754     }
 755     bNoEdit = bLayoutMode = TRUE;
 756     HideCrsr();
 757
 758         // gleicher Aufruf von BeginDrag an der SwFEShell
 759     fnDrag                      = &SwWrtShell::BeginFrmDrag;
 760     fnEndDrag           = &SwWrtShell::UpdateLayoutFrm;
 761     SwBaseShell::SetFrmMode( FLY_DRAG_START, this );
 762     Invalidate();
 763 }
 764
 765
 766
 767 void SwWrtShell::LeaveSelFrmMode()
 768 {
 769     fnDrag                      = &SwWrtShell::BeginDrag;
 770     fnEndDrag           = &SwWrtShell::EndDrag;
 771     bLayoutMode = FALSE;
 772     bStartDrag = FALSE;
 773     Edit();
 774     SwBaseShell::SetFrmMode( FLY_DRAG_END, this );
 775     Invalidate();
 776 }
 777 /*------------------------------------------------------------------------
 778  Beschreibung:  Rahmengebundenes Macro ausfuehren
 779 ------------------------------------------------------------------------*/
 780
 781
 782
 783 IMPL_LINK( SwWrtShell, ExecFlyMac, void *, pFlyFmt )
 784 {
 785     const SwFrmFmt *pFmt = pFlyFmt ? (SwFrmFmt*)pFlyFmt : GetFlyFrmFmt();
 786     ASSERT(pFmt, kein FrameFormat.);
 787     const SvxMacroItem &rFmtMac = pFmt->GetMacro();
 788
 789     if(rFmtMac.HasMacro(SW_EVENT_OBJECT_SELECT))
 790     {
 791         const SvxMacro &rMac = rFmtMac.GetMacro(SW_EVENT_OBJECT_SELECT);
 792         if( IsFrmSelected() )
 793             bLayoutMode = TRUE;
 794         CallChgLnk();
 795         ExecMacro( rMac );
 796     }
 797     return 0;
 798 }
 799
 800
 801
 802 long SwWrtShell::UpdateLayoutFrm(const Point *pPt, BOOL )
 803 {
 804         // voerst Dummy
 805     SwFEShell::EndDrag( pPt, FALSE );
 806     fnDrag = &SwWrtShell::BeginFrmDrag;
 807     return 1;
 808 }
 809
 810 /*
 811  * Handler fuer das Togglen der Modi. Liefern alten Mode zurueck.
 812  */
 813
 814
 815
 816 long SwWrtShell::ToggleAddMode()
 817 {
 818     bAddMode ? LeaveAddMode(): EnterAddMode();
 819     Invalidate();
 820     return !bAddMode;
 821 }
 822
 823
 824 long SwWrtShell::ToggleBlockMode()
 825 {
 826     bBlockMode ? LeaveBlockMode(): EnterBlockMode();
 827     Invalidate();
 828     return !bBlockMode;
 829 }
 830
 831
 832 long SwWrtShell::ToggleExtMode()
 833 {
 834     bExtMode ? LeaveExtMode() : EnterExtMode();
 835     Invalidate();
 836     return !bExtMode;
 837 }
 838 /*
 839  * Draggen im Standard Modus (Selektieren von Inhalt)
 840  */
 841
 842
 843
 844 long SwWrtShell::BeginDrag(const Point * /*pPt*/, BOOL )
 845 {
 846     if(bSelWrd)
 847     {
 848         bInSelect = TRUE;
 849         if( !IsCrsrPtAtEnd() )
 850             SwapPam();
 851
 852         fnDrag = &SwWrtShell::ExtSelWrd;
 853         fnSetCrsr = &SwWrtShell::Ignore;
 854     }
 855     else if(bSelLn)
 856     {
 857         bInSelect = TRUE;
 858         fnDrag = &SwWrtShell::ExtSelLn;
 859         fnSetCrsr = &SwWrtShell::Ignore;
 860     }
 861     else
 862     {
 863         fnDrag = &SwWrtShell::Drag;
 864         SttSelect();
 865     }
 866
 867     return 1;
 868 }
 869
 870
 871
 872 long SwWrtShell::Drag(const Point *, BOOL )
 873 {
 874     if( IsSelTblCells() )
 875         aSelTblLink.Call(this);
 876
 877     return 1;
 878 }
 879
 880
 881
 882 long SwWrtShell::EndDrag(const Point * /*pPt*/, BOOL )
 883 {
 884     fnDrag = &SwWrtShell::BeginDrag;
 885     if( IsExtSel() )
 886         LeaveExtSel();
 887
 888     if( IsSelTblCells() )
 889         aSelTblLink.Call(this);
 890     EndSelect();
 891     return 1;
 892 }
 893
 894 // --> FME 2004-07-30 #i32329# Enhanced table selection
 895 BOOL SwWrtShell::SelectTableRowCol( const Point& rPt, const Point* pEnd, bool bRowDrag )
 896 {
 897     MV_KONTEXT(this);
 898     SttSelect();
 899     if(SelTblRowCol( rPt, pEnd, bRowDrag ))
 900     {
 901         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 902         fnKillSel = &SwWrtShell::ResetSelect;
 903         return TRUE;
 904     }
 905     return FALSE;
 906 }
 907 // <--
 908
 909 /*------------------------------------------------------------------------
 910  Beschreibung:  Selektion einer Tabellenzeile / Spalte
 911 ------------------------------------------------------------------------*/
 912
 913 BOOL SwWrtShell::SelectTableRow()
 914 {
 915     if ( SelTblRow() )
 916     {
 917         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 918         fnKillSel = &SwWrtShell::ResetSelect;
 919         return TRUE;
 920     }
 921     return FALSE;
 922 }
 923
 924
 925
 926 BOOL SwWrtShell::SelectTableCol()
 927 {
 928     if ( SelTblCol() )
 929     {
 930         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 931         fnKillSel = &SwWrtShell::ResetSelect;
 932         return TRUE;
 933     }
 934     return FALSE;
 935 }
 936
 937 BOOL SwWrtShell::SelectTableCell()
 938 {
 939     if ( SelTblBox() )
 940     {
 941         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
 942         fnKillSel = &SwWrtShell::ResetSelect;
 943         return TRUE;
 944     }
 945     return FALSE;
 946 }
 947 /*------------------------------------------------------------------------
 948  Beschreibung:    Prueft, ob eine Wortselektion vorliegt.
 949                   Gemaess den Regeln fuer intelligentes Cut / Paste
 950                   werden umgebende Spaces rausgeschnitten.
 951  Return:                  Liefert Art der Wortselektion zurueck.
 952 ------------------------------------------------------------------------*/
 953
 954
 955
 956 int SwWrtShell::IntelligentCut(int nSelection, BOOL bCut)
 957 {
 958         // kein intelligentes Drag and Drop bei Mehrfachselektion
 959         // es existieren mehrere Cursor, da ein zweiter bereits
 960         // an die Zielposition gesetzt wurde
 961     if( IsAddMode() || !(nSelection & nsSelectionType::SEL_TXT) )
 962         return FALSE;
 963
 964     String sTxt;
 965     CharClass& rCC = GetAppCharClass();
 966
 967         // wenn das erste und das letzte Zeichen kein Wortzeichen ist,
 968         // ist kein Wort selektiert.
 969     sal_Unicode cPrev = GetChar(FALSE);
 970     sal_Unicode cNext = GetChar(TRUE, -1);
 971     if( !cPrev || !cNext ||
 972         !rCC.isLetterNumeric( ( sTxt = cPrev), 0 ) ||
 973         !rCC.isLetterNumeric( ( sTxt = cNext), 0 ) )
 974         return NO_WORD;
 975
 976     cPrev = GetChar(FALSE, -1);
 977     cNext = GetChar(TRUE);
 978
 979     int cWord = NO_WORD;
 980         // ist ein Wort selektiert?
 981     if(!cWord && cPrev && cNext &&
 982         CH_TXTATR_BREAKWORD != cPrev && CH_TXTATR_INWORD != cPrev &&
 983         CH_TXTATR_BREAKWORD != cNext && CH_TXTATR_INWORD != cNext &&
 984         !rCC.isLetterNumeric( ( sTxt = cPrev), 0 ) &&
 985         !rCC.isLetterNumeric( ( sTxt = cNext), 0 ) )
 986        cWord = WORD_NO_SPACE;
 987
 988     if(cWord == WORD_NO_SPACE && ' ' == cPrev )
 989     {
 990         cWord = WORD_SPACE_BEFORE;
 991             // Space davor loeschen
 992         if(bCut)
 993         {
 994             Push();
 995             if(IsCrsrPtAtEnd())
 996                 SwapPam();
 997             ClearMark();
 998             SetMark();
 999             SwCrsrShell::Left(1,CRSR_SKIP_CHARS);
1000             SwFEShell::Delete();
1001             Pop( FALSE );
1002         }
1003     }
1004     else if(cWord == WORD_NO_SPACE && cNext == ' ')
1005     {
1006         cWord = WORD_SPACE_AFTER;
1007             // Space dahinter loeschen
1008         if(bCut) {
1009             Push();
1010             if(!IsCrsrPtAtEnd()) SwapPam();
1011             ClearMark();
1012             SetMark();
1013             SwCrsrShell::Right(1,CRSR_SKIP_CHARS);
1014             SwFEShell::Delete();
1015             Pop( FALSE );
1016         }
1017     }
1018     return cWord;
1019 }
1020
1021
1022
1023     // jump to the next / previous hyperlink - inside text and also
1024     // on graphics
1025 BOOL SwWrtShell::SelectNextPrevHyperlink( BOOL bNext )
1026 {
1027     StartAction();
1028     BOOL bRet = SwCrsrShell::SelectNxtPrvHyperlink( bNext );
1029     if( !bRet )
1030     {
1031         // will we have this feature?
1032         EnterStdMode();
1033         if( bNext )
1034             SttEndDoc(TRUE);
1035         else
1036             SttEndDoc(FALSE);
1037         bRet = SwCrsrShell::SelectNxtPrvHyperlink( bNext );
1038     }
1039     EndAction();
1040
1041     BOOL bCreateXSelection = FALSE;
1042     const BOOL bFrmSelected = IsFrmSelected() || IsObjSelected();
1043     if( IsSelection() )
1044     {
1045         if ( bFrmSelected )
1046             UnSelectFrm();
1047
1048         // Funktionspointer fuer das Aufheben der Selektion setzen
1049         // bei Cursor setzen
1050         fnKillSel = &SwWrtShell::ResetSelect;
1051         fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
1052         bCreateXSelection = TRUE;
1053     }
1054     else if( bFrmSelected )
1055     {
1056         EnterSelFrmMode();
1057         bCreateXSelection = TRUE;
1058     }
1059     else if( (CNT_GRF | CNT_OLE ) & GetCntType() )
1060     {
1061         SelectObj( GetCharRect().Pos() );
1062         EnterSelFrmMode();
1063         bCreateXSelection = TRUE;
1064     }
1065
1066     if( bCreateXSelection )
1067         SwTransferable::CreateSelection( *this );
1068
1069     return bRet;
1070 }
1071
1072
1073 /* fuer den Erhalt der Selektion wird nach SetMark() der Cursor
1074  * nach links bewegt, damit er durch das Einfuegen von Text nicht
1075  * verschoben wird.  Da auf der CORE-Seite am aktuellen Cursor
1076  * eine bestehende Selektion aufgehoben wird, wird der Cursor auf
1077  * den Stack gepushed. Nach dem Verschieben werden sie wieder
1078  * zusammengefasst. */
1079
1080
1081
1082