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 #ifndef SW_CRSRSH_HXX 24 #define SW_CRSRSH_HXX 25 26 #include <com/sun/star/i18n/WordType.hpp> 27 28 #include <tools/string.hxx> 29 #include <tools/link.hxx> 30 #include <tools/rtti.hxx> 31 32 #include <IShellCursorSupplier.hxx> 33 #include "swdllapi.h" 34 #include <swtypes.hxx> // fuer SWPOSDOC 35 #include <viewsh.hxx> // fuer ViewShell 36 #include <calbck.hxx> // fuer SwClient 37 #include <cshtyp.hxx> // fuer die CursorShell Typen 38 #include <crstate.hxx> // fuer die CursorMove-Staties 39 #include <toxe.hxx> // SwTOXSearchDir 40 #include <tblsel.hxx> //SwTblSearchType 41 #include <viscrs.hxx> 42 #include <node.hxx> 43 #include <tblsel.hxx> 44 #include <IDocumentMarkAccess.hxx> 45 46 47 // einige Forward Deklarationen 48 49 class KeyCode; 50 class SfxItemSet; 51 class SfxPoolItem; 52 class SwCntntFrm; 53 class SwCrsrShell; 54 class SwCursor; 55 class SwField; 56 class SwFieldType; 57 class SwFmt; 58 class SwFmtFld; 59 class SwNodeIndex; 60 class SwPaM; 61 class SwShellCrsr; 62 class SwShellTableCrsr; 63 class SwTableNode; 64 class SwTxtFmtColl; 65 class SwVisCrsr; 66 class SwTxtINetFmt; 67 class SwFmtINetFmt; 68 class SwTxtAttr; 69 class SwTableBox; 70 class SwCellFrms; 71 class SwTOXMark; 72 class SwRedline; 73 class IBlockCursor; 74 class SwCntntNode; // #i23726# 75 // --> OD 2008-06-19 #i90516# 76 class SwPostItField; 77 // <-- 78 struct SwPosition; 79 80 namespace com { namespace sun { namespace star { namespace util { 81 struct SearchOptions; 82 } } } } 83 84 namespace com { namespace sun { namespace star { namespace text { 85 class XTextRange; 86 }}}} 87 88 namespace com { namespace sun { namespace star { namespace container { 89 class XStringKeyMap; 90 }}}} 91 92 // enum und struktur, um ueber die Doc-Position Informationen zu erfragen 93 94 struct SwContentAtPos 95 { 96 enum IsAttrAtPos 97 { 98 SW_NOTHING = 0x0000, 99 SW_FIELD = 0x0001, 100 SW_CLICKFIELD = 0x0002, 101 SW_FTN = 0x0004, 102 SW_INETATTR = 0x0008, 103 SW_TABLEBOXFML = 0x0010, 104 SW_REDLINE = 0x0020, 105 SW_OUTLINE = 0x0040, 106 SW_TOXMARK = 0x0080, 107 SW_REFMARK = 0x0100, 108 SW_NUMLABEL = 0x0200, // #i23726# 109 SW_CONTENT_CHECK = 0x0400, // --> FME 2005-05-13 #i43742# <-- 110 SW_SMARTTAG = 0x0800, 111 SW_FORMCTRL = 0x1000 112 #ifndef PRODUCT 113 ,SW_CURR_ATTRS = 0x4000 // nur zum Debuggen 114 ,SW_TABLEBOXVALUE = 0x8000 // nur zum Debuggen 115 #endif 116 } eCntntAtPos; 117 118 union { 119 const SwField* pFld; 120 const SfxPoolItem* pAttr; 121 const SwRedline* pRedl; 122 SwCntntNode * pNode; // #i23726# 123 const sw::mark::IFieldmark* pFldmark; 124 } aFnd; 125 126 int nDist; // #i23726# 127 128 String sStr; 129 const SwTxtAttr* pFndTxtAttr; 130 131 SwContentAtPos( int eGetAtPos = 0xffff ) 132 : eCntntAtPos( (IsAttrAtPos)eGetAtPos ) 133 { 134 aFnd.pFld = 0; 135 pFndTxtAttr = 0; 136 nDist = 0; // #i23726# 137 } 138 139 // befindet sich der Node in einem geschuetzten Bereich? 140 sal_Bool IsInProtectSect() const; 141 bool IsInRTLText()const; 142 }; 143 144 // ReturnWerte von SetCrsr (werden verodert) 145 const int CRSR_POSOLD = 0x01, // Cursor bleibt an alter Doc-Position 146 CRSR_POSCHG = 0x02; // Position vom Layout veraendert 147 148 // Helperfunction to resolve backward references in regular expressions 149 150 String *ReplaceBackReferences( const com::sun::star::util::SearchOptions& rSearchOpt, SwPaM* pPam ); 151 152 // die Cursor - Shell 153 class SW_DLLPUBLIC SwCrsrShell 154 : public ViewShell 155 , public SwModify 156 , public ::sw::IShellCursorSupplier 157 { 158 friend class SwCallLink; 159 friend class SwVisCrsr; 160 friend class SwSelPaintRects; 161 friend class SwChgLinkFlag; 162 163 //Braucht den Crsr als IntrnlCrsr. 164 friend sal_Bool GetAutoSumSel( const SwCrsrShell&, SwCellFrms& ); 165 166 public: // public, damit defaultet werden kann !! 167 168 /* ein enum fuer den Aufruf von UpdateCrsr */ 169 enum CrsrFlag { 170 UPDOWN = (1 << 0), // Up/Down auf Spalte halten 171 SCROLLWIN = (1 << 1), // Window Scrollen 172 CHKRANGE = (1 << 2), // ueberpruefen von ueberlappenden PaM's 173 NOCALRECT = (1 << 3), // CharRect nicht neu berechnen 174 READONLY = (1 << 4) // Sichtbar machen trotz Readonly 175 }; 176 177 private: 178 179 SwRect aCharRect; // Char-SRectangle auf dem der Cursor steht 180 Point aCrsrHeight; // Hohe&Offset von sichtbaren Cursor 181 Point aOldRBPos; // Right/Bottom von letzter VisArea 182 // (wird im Invalidate vom Cursor benutzt) 183 184 185 // um event. Macro was anhaengt auszufuehren. 186 Link aFlyMacroLnk; // Link will be called, if the Crsr is set 187 // into a fly. A macro can be then becalled 188 Link aChgLnk; // link will be called by every attribut/ 189 // format changes at cursor position. 190 Link aGrfArrivedLnk; // Link calls to UI if a grafik is arrived 191 192 193 SwShellCrsr* pCurCrsr; // der aktuelle Cursor 194 SwShellCrsr* pCrsrStk; // Stack fuer den Cursor 195 SwVisCrsr *pVisCrsr; // der Sichtbare-Cursor 196 197 IBlockCursor *pBlockCrsr; // interface of cursor for block (=rectangular) selection 198 199 SwShellTableCrsr* pTblCrsr; // Tabellen-Crsr; nur in Tabellen, wenn 200 // die Selection ueber 2 Spalten liegt 201 202 SwNodeIndex* pBoxIdx; // fuers erkennen der veraenderten 203 SwTableBox* pBoxPtr; // Tabellen-Zelle 204 205 long nUpDownX; // versuche den Cursor bei Up/Down immer in 206 // der gleichen Spalte zu bewegen 207 long nLeftFrmPos; 208 sal_uLong nAktNode; // save CursorPos at Start-Action 209 xub_StrLen nAktCntnt; 210 sal_uInt16 nAktNdTyp; 211 bool bAktSelection; 212 213 /* 214 * Mit den Methoden SttCrsrMove und EndCrsrMove wird dieser Zaehler 215 * Inc-/Decrementiert. Solange der Zaehler ungleich 0 ist, erfolgt 216 * auf den akt. Cursor kein Update. Dadurch koennen "komplizierte" 217 * Cursorbewegungen (ueber Find()) realisiert werden. 218 */ 219 sal_uInt16 nCrsrMove; 220 sal_uInt16 nBasicActionCnt; // Actions, die vom Basic geklammert wurden 221 CrsrMoveState eMvState; // Status fuers Crsr-Travelling - GetCrsrOfst 222 223 // --> OD 2008-04-02 #refactorlists# 224 String sMarkedListId; 225 int nMarkedListLevel; 226 // <-- 227 228 sal_Bool bHasFocus : 1; // Shell ist in einem Window "aktiv" 229 sal_Bool bSVCrsrVis : 1; // SV-Cursor Un-/Sichtbar 230 sal_Bool bChgCallFlag : 1; // Attributaenderung innerhalb von 231 // Start- und EndAction 232 sal_Bool bVisPortChgd : 1; // befindet sich im VisPortChg-Aufruf 233 // (wird im Invalidate vom Cursor benutzt) 234 235 sal_Bool bCallChgLnk : 1; // Flag fuer abgeleitete Klassen: 236 // sal_True -> ChgLnk callen 237 // Zugriff nur ueber SwChgLinkFlag 238 sal_Bool bAllProtect : 1; // Flag fuer Bereiche 239 // sal_True -> alles geschuetzt / versteckt 240 sal_Bool bInCMvVisportChgd : 1; // Flag fuer CrsrMoves 241 // sal_True -> die Sicht wurde verschoben 242 sal_Bool bGCAttr : 1; // sal_True -> es existieren nichtaufgespannte Attr. 243 sal_Bool bIgnoreReadonly : 1; // sal_True -> Beim naechsten EndAction trotz 244 // Readonly den Crsr sichtbar machen. 245 sal_Bool bSelTblCells : 1; // sal_True -> Zellen uebers InputWin selektieren 246 sal_Bool bAutoUpdateCells : 1; // sal_True -> Zellen werden autoformatiert 247 sal_Bool bBasicHideCrsr : 1; // sal_True -> HideCrsr vom Basic 248 sal_Bool bSetCrsrInReadOnly : 1;// sal_True -> Cursor darf in ReadOnly-Bereiche 249 sal_Bool bOverwriteCrsr : 1; // sal_True -> show Overwrite Crsr 250 251 // OD 11.02.2003 #100556# - flag to allow/avoid execution of marcos (default: true) 252 bool mbMacroExecAllowed : 1; 253 254 SW_DLLPRIVATE void UpdateCrsr( sal_uInt16 eFlags 255 =SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE, 256 sal_Bool bIdleEnd = sal_False ); 257 258 SW_DLLPRIVATE void _ParkPams( SwPaM* pDelRg, SwShellCrsr** ppDelRing ); 259 260 // -> #i27615# 261 262 /** Mark a certain list level of a certain list 263 264 OD 2008-04-02 #refactorlists# 265 levels of a certain lists are marked now 266 267 @param sListId list Id of the list whose level is marked 268 @param nLevel to be marked list level 269 270 An empty sListId denotes that no level of a list is marked. 271 */ 272 SW_DLLPRIVATE void MarkListLevel( const String& sListId, 273 const int nLevel ); 274 // <- #i27615# 275 276 // private method(s) accessed from public inline method(s) must be exported. 277 sal_Bool LeftRight( sal_Bool, sal_uInt16, sal_uInt16, sal_Bool ); 278 SW_DLLPRIVATE sal_Bool UpDown( sal_Bool, sal_uInt16 ); 279 SW_DLLPRIVATE sal_Bool LRMargin( sal_Bool, sal_Bool bAPI = sal_False ); 280 SW_DLLPRIVATE sal_Bool IsAtLRMargin( sal_Bool, sal_Bool bAPI = sal_False ) const; 281 282 SW_DLLPRIVATE short GetTextDirection( const Point* pPt = 0 ) const; 283 284 typedef sal_Bool (SwCursor:: *FNCrsr)(); 285 SW_DLLPRIVATE sal_Bool CallCrsrFN( FNCrsr ); 286 287 SW_DLLPRIVATE const SwRedline* _GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect ); 288 289 protected: 290 291 inline SwMoveFnCollection* MakeFindRange( sal_uInt16, sal_uInt16, SwPaM* ) const; 292 293 /* 294 * Compare-Methode for the StackCursor and the current Cursor. 295 * The Methods return -1, 0, 1 for lower, equal, greater. The enum 296 * CrsrCompareType says which position is compared. 297 */ 298 enum CrsrCompareType { 299 StackPtStackMk, 300 StackPtCurrPt, 301 StackPtCurrMk, 302 StackMkCurrPt, 303 StackMkCurrMk, 304 CurrPtCurrMk 305 }; 306 int CompareCursor( CrsrCompareType eType ) const; 307 308 // Setzt alle PaMs in OldNode auf NewPos + Offset 309 void PaMCorrAbs(const SwNodeIndex &rOldNode, const SwPosition &rNewPos, 310 const xub_StrLen nOffset = 0 ); 311 312 // --> FME 2004-07-30 #i32329# Enhanced table selection 313 sal_Bool _SelTblRowOrCol( bool bRow, bool bRowSimple = false ); 314 // <-- 315 316 // --> FME 2005-01-31 #i41424# Only update the marked number levels if necessary 317 bool SetInFrontOfLabel( sal_Bool bNew ); 318 // <-- 319 320 void RefreshBlockCursor(); 321 322 /** Updates the marked list level according to the cursor. 323 */ 324 SW_DLLPRIVATE void UpdateMarkedListLevel(); 325 326 protected: 327 virtual void Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew); 328 329 public: 330 TYPEINFO(); 331 SwCrsrShell( SwDoc& rDoc, Window *pWin, const SwViewOption *pOpt = 0 ); 332 // verkleideter Copy-Constructor 333 SwCrsrShell( SwCrsrShell& rShell, Window *pWin ); 334 virtual ~SwCrsrShell(); 335 336 // IShellCursorSupplier 337 virtual SwPaM & CreateNewShellCursor(); 338 virtual SwPaM & GetCurrentShellCursor(); 339 340 // neuen Cusror erzeugen und den alten anhaengen 341 SwPaM * CreateCrsr(); 342 // loesche den aktuellen Cursor und der folgende wird zum Aktuellen 343 sal_Bool DestroyCrsr(); 344 // TableCursor in normale Cursor verwandeln, Tablemode aufheben 345 void TblCrsrToCursor(); 346 // enter block mode, change normal cursor into block cursor 347 void CrsrToBlockCrsr(); 348 // leave block mode, change block cursor into normal cursor 349 void BlockCrsrToCrsr(); 350 351 // SelAll() selects the document body content 352 // if ExtendedSelect() is called afterwards, the whole nodes array is selected 353 // only for usage in special cases allowed! 354 void ExtendedSelectAll(); 355 356 SwPaM* GetCrsr( sal_Bool bMakeTblCrsr = sal_True ) const; 357 inline SwCursor* GetSwCrsr( sal_Bool bMakeTblCrsr = sal_True ) const; 358 // nur den akt. Cursor returnen 359 SwShellCrsr* _GetCrsr() { return pCurCrsr; } 360 const SwShellCrsr* _GetCrsr() const { return pCurCrsr; } 361 362 // uebergebenen Cursor anzeigen - fuer UNO 363 void SetSelection(const SwPaM& rCrsr); 364 365 // alle Cursor aus den ContentNodes entfernen und auf 0 setzen. 366 // Wurde aus der FEShell hierher verschoben. 367 void ParkCrsr( const SwNodeIndex &rIdx ); 368 369 // gebe den akt. Cursor-Stack zurueck. 370 // ( Wird in der EditShell beim Loeschen von Inhalten benoetigt! ) 371 inline SwPaM* GetStkCrsr() const; 372 373 // Start der Klammerung, SV-Cursor und selektierte Bereiche hiden 374 void StartAction(); 375 // Ende der Klammerung, SV-Cursor und selektierte Bereiche anzeigen 376 void EndAction( const sal_Bool bIdleEnd = sal_False ); 377 378 // Basiscursortravelling 379 long GetUpDownX() const { return nUpDownX; } 380 381 sal_Bool Left( sal_uInt16 nCnt, sal_uInt16 nMode, sal_Bool bAllowVisual = sal_False ) 382 { return LeftRight( sal_True, nCnt, nMode, bAllowVisual ); } 383 sal_Bool Right( sal_uInt16 nCnt, sal_uInt16 nMode, sal_Bool bAllowVisual = sal_False ) 384 { return LeftRight( sal_False, nCnt, nMode, bAllowVisual ); } 385 sal_Bool Up( sal_uInt16 nCnt = 1 ) { return UpDown( sal_True, nCnt ); } 386 sal_Bool Down( sal_uInt16 nCnt = 1 ) { return UpDown( sal_False, nCnt ); } 387 sal_Bool LeftMargin() { return LRMargin( sal_True ); } 388 sal_Bool RightMargin(sal_Bool bAPI = sal_False) { return LRMargin( sal_False, bAPI ); } 389 sal_Bool SttEndDoc( sal_Bool bStt ); 390 391 sal_Bool MovePage( SwWhichPage, SwPosPage ); 392 sal_Bool MovePara( SwWhichPara, SwPosPara ); 393 sal_Bool MoveSection( SwWhichSection, SwPosSection ); 394 sal_Bool MoveTable( SwWhichTable, SwPosTable ); 395 sal_Bool MoveColumn( SwWhichColumn, SwPosColumn ); 396 sal_Bool MoveRegion( SwWhichRegion, SwPosRegion ); 397 398 // die Suchfunktionen 399 sal_uLong Find( const com::sun::star::util::SearchOptions& rSearchOpt, 400 sal_Bool bSearchInNotes, 401 SwDocPositions eStart, SwDocPositions eEnde, 402 sal_Bool& bCancel, 403 FindRanges eRng, int bReplace = sal_False ); 404 405 sal_uLong Find( const SwTxtFmtColl& rFmtColl, 406 SwDocPositions eStart, SwDocPositions eEnde, 407 sal_Bool& bCancel, 408 FindRanges eRng, const SwTxtFmtColl* pReplFmt = 0 ); 409 410 sal_uLong Find( const SfxItemSet& rSet, sal_Bool bNoCollections, 411 SwDocPositions eStart, SwDocPositions eEnde, 412 sal_Bool& bCancel, 413 FindRanges eRng, 414 const com::sun::star::util::SearchOptions* pSearchOpt = 0, 415 const SfxItemSet* rReplSet = 0 ); 416 417 // Positionieren des Cursors 418 // returnt 419 // CRSR_POSCHG: wenn der ob der SPoint vom Layout korrigiert wurde. 420 // CRSR_POSOLD: wenn der Crsr nicht veraendert wurde 421 int SetCrsr( const Point &rPt, sal_Bool bOnlyText = sal_False, bool bBlock = true ); 422 423 424 /* 425 * Benachrichtung, dass der sichtbare Bereich sich geaendert 426 * hat. aVisArea wird neu gesetzt, anschliessend wird 427 * gescrollt. Das uebergebene Rectangle liegt auf 428 * Pixelgrenzen, um Pixelfehler beim Scrollen zu vermeiden. 429 */ 430 virtual void VisPortChgd( const SwRect & ); 431 432 /* 433 * Virtuelle PaintMethode, damit die Selection nach dem Paint wieder 434 * sichtbar wird. 435 */ 436 void Paint( const Rectangle & rRect ); 437 438 // Bereiche 439 inline void SetMark(); 440 inline sal_Bool HasMark(); 441 442 void ClearMark(); 443 444 /** 445 Ensure point and mark of the current PaM are in a specific order. 446 447 @param bPointFirst TRUE: If the point is behind the mark then 448 swap the PaM. FALSE: If the mark is behind the point then swap 449 the PaM. 450 */ 451 void NormalizePam(sal_Bool bPointFirst = sal_True); 452 453 void SwapPam(); 454 sal_Bool ChgCurrPam( const Point & rPt, 455 sal_Bool bTstOnly = sal_True, //Nur testen, nicht setzen 456 sal_Bool bTstHit = sal_False ); //Nur genaue Treffer 457 void KillPams(); 458 459 // erzeuge eine Kopie vom Cursor und speicher diese im Stack 460 void Push(); 461 /* 462 * Loescht einen Cursor (gesteuert durch bOldCrsr) 463 * - vom Stack oder ( bOldCrsr = sal_True ) 464 * - den aktuellen und der auf dem Stack stehende wird zum aktuellen 465 * 466 * Return: es war auf dem Stack noch einer vorhanden 467 */ 468 sal_Bool Pop( sal_Bool bOldCrsr = sal_True ); 469 /* 470 * Verbinde zwei Cursor miteinander. 471 * Loesche vom Stack den obersten und setzen dessen Mark im Aktuellen. 472 */ 473 void Combine(); 474 475 #if !defined(DBG_UTIL) 476 void SttCrsrMove() { ++nCrsrMove; StartAction(); } 477 void EndCrsrMove( const sal_Bool bIdleEnd = sal_False ) 478 { EndAction( bIdleEnd ); --nCrsrMove; } 479 #else 480 void SttCrsrMove(); 481 void EndCrsrMove( const sal_Bool bIdleEnd = sal_False ); 482 #endif 483 484 /* 485 * Beim Abgeben des Focuses werden die selektierten Bereiche nicht mehr 486 * angezeigt; andererseits beim Erhalten des Focuses, werden alle selek- 487 * tierten Bereiche wieder angezeigt. (Bereiche muessen neu berechnet 488 * werden!) 489 */ 490 sal_Bool HasShFcs() const { return bHasFocus; } 491 void ShLooseFcs(); 492 void ShGetFcs( sal_Bool bUpdate = sal_True ); 493 494 // Methoden zum Anzeigen bzw. Verstecken des sichtbaren Text-Cursors 495 void ShowCrsr(); 496 void HideCrsr(); 497 // Methoden zum Anzeigen bzw. Verstecken der selektierten Bereiche mit 498 // dem sichtbaren Cursor 499 void ShowCrsrs( sal_Bool bCrsrVis ); 500 void HideCrsrs(); 501 502 sal_Bool IsOverwriteCrsr() const { return bOverwriteCrsr; } 503 void SetOverwriteCrsr( sal_Bool bFlag ) { bOverwriteCrsr = bFlag; } 504 505 // gebe den aktuellen Frame, in dem der Cursor steht, zurueck 506 SwCntntFrm *GetCurrFrm( const sal_Bool bCalcFrm = sal_True ) const; 507 508 //sal_True wenn der Crsr wenn der Crsr wegen Readonly gehidet ist, 509 //sal_False wenn der arbeitet (trotz Readonly). 510 sal_Bool IsCrsrReadonly() const; 511 // Cursor steht in etwas geschuetztem oder in die Selektion umspannt 512 // etwas geschuetztes. 513 sal_Bool HasReadonlySel() const; 514 // darf der Cursor in ReadOnlyBereiche? 515 sal_Bool IsReadOnlyAvailable() const { return bSetCrsrInReadOnly; } 516 void SetReadOnlyAvailable( sal_Bool bFlag ); 517 sal_Bool IsOverReadOnlyPos( const Point& rPt ) const; 518 519 // Methoden fuer aFlyMacroLnk 520 void SetFlyMacroLnk( const Link& rLnk ) { aFlyMacroLnk = rLnk; } 521 const Link& GetFlyMacroLnk() const { return aFlyMacroLnk; } 522 523 // Methoden geben/aendern den Link fuer die Attribut/Format-Aenderungen 524 void SetChgLnk( const Link &rLnk ) { aChgLnk = rLnk; } 525 const Link& GetChgLnk() const { return aChgLnk; } 526 527 // Methoden geben/aendern den Link fuers "Grafik vollstaendig geladen" 528 void SetGrfArrivedLnk( const Link &rLnk ) { aGrfArrivedLnk = rLnk; } 529 const Link& GetGrfArrivedLnk() const { return aGrfArrivedLnk; } 530 531 //ChgLink callen, innerhalb einer Action wird der Ruf verzoegert. 532 void CallChgLnk(); 533 534 // Abfrage, ob der aktuelle Cursor eine Selektion aufspannt, 535 // also, ob Mark gesetzt und SPoint und Mark unterschiedlich sind. 536 sal_Bool HasSelection() const; 537 538 // Abfrage, ob ueberhaupt eine Selektion existiert, sprich der akt. Cursor 539 // aufgespannt oder nicht der einzigste ist. 540 inline sal_Bool IsSelection() const; 541 // returns if multiple cursors are available 542 inline sal_Bool IsMultiSelection() const; 543 544 // Abfrage, ob ein kompletter Absatz selektiert wurde 545 sal_Bool IsSelFullPara() const; 546 // Abfrage, ob die Selektion in einem Absatz ist 547 inline sal_Bool IsSelOnePara() const; 548 549 //Sollte fuer das Clipboard der WaitPtr geschaltet werden. 550 sal_Bool ShouldWait() const; 551 552 /* 553 * liefert das SRectangle, auf dem der Cursor steht. 554 */ 555 const SwRect &GetCharRect() const { return aCharRect; } 556 /* 557 * liefert zurueck, ob der Cursor sich ganz oder teilweise im 558 * sichtbaren Bereich befindet. 559 */ 560 sal_Bool IsCrsrVisible() const { return VisArea().IsOver( GetCharRect() ); } 561 562 // gebe die aktuelle Seitennummer zurueck: 563 // sal_True: in der der Cursor steht 564 // sal_False: die am oberen Rand sichtbar ist 565 void GetPageNum( sal_uInt16 &rnPhyNum, sal_uInt16 &rnVirtNum, 566 sal_Bool bAtCrsrPos = sal_True, const sal_Bool bCalcFrm = sal_True ); 567 // bestimme in welche Richtung "leere Seiten" behandelt werden! 568 // (wird benutzt im PhyPage.. ) 569 sal_uInt16 GetNextPrevPageNum( sal_Bool bNext = sal_True ); 570 571 // setze den Cursor auf die Seite "nPage" an den Anfang 572 sal_Bool GotoPage( sal_uInt16 nPage ); 573 574 // gebe alle Dokumentseiten zurueck 575 sal_uInt16 GetPageCnt(); 576 577 // Gehe zur naechsten Selection 578 sal_Bool GoNextCrsr(); 579 // gehe zur vorherigen Selection 580 sal_Bool GoPrevCrsr(); 581 582 // at CurCrsr.SPoint 583 ::sw::mark::IMark* SetBookmark( 584 const KeyCode&, 585 const ::rtl::OUString& rName, 586 const ::rtl::OUString& rShortName, 587 IDocumentMarkAccess::MarkType eMark = IDocumentMarkAccess::BOOKMARK); 588 bool GotoMark( const ::sw::mark::IMark* const pMark ); // sets CurCrsr.SPoint 589 bool GotoMark( const ::sw::mark::IMark* const pMark, bool bAtStart ); 590 bool GoNextBookmark(); // true, if there was one 591 bool GoPrevBookmark(); 592 593 bool IsFormProtected(); 594 ::sw::mark::IFieldmark* GetCurrentFieldmark(); 595 ::sw::mark::IFieldmark* GetFieldmarkAfter(); 596 ::sw::mark::IFieldmark* GetFieldmarkBefore(); 597 bool GotoFieldmark( const ::sw::mark::IFieldmark* const pMark ); 598 599 // aktualisiere den Crsrs, d.H. setze ihn wieder in den Content. 600 // Das sollte nur aufgerufen werden, wenn der Cursor z.B. beim 601 // Loeschen von Rahmen irgendwohin gesetzt wurde. Die Position 602 // ergibt sich aus seiner aktuellen Position im Layout !! 603 void UpdateCrsrPos(); 604 605 // returne den am akt. Cursor selektierten Text. Dieser wird mit 606 // Felder etc. aufgefuellt!! 607 String GetSelTxt() const; 608 // gebe nur den Text ab der akt. Cursor Position zurueck (bis zum NodeEnde) 609 String GetText() const; 610 611 // pruefe ob vom aktuellen Crsr der SPoint/Mark in einer Tabelle stehen 612 inline const SwTableNode* IsCrsrInTbl( sal_Bool bIsPtInTbl = sal_True ) const; 613 // erfrage die Document - Layout - Position vom akt. Crsr 614 inline Point& GetCrsrDocPos( sal_Bool bPoint = sal_True ) const; 615 inline sal_Bool IsCrsrPtAtEnd() const; 616 617 inline const SwPaM* GetTblCrs() const; 618 inline SwPaM* GetTblCrs(); 619 620 sal_Bool IsTblComplex() const; 621 sal_Bool IsTblComplexForChart(); 622 // erfrage die akt. TabellenSelektion als Text 623 String GetBoxNms() const; 624 625 // setze Crsr in die naechsten/vorherigen Celle 626 sal_Bool GoNextCell( sal_Bool bAppendLine = sal_True ); 627 sal_Bool GoPrevCell(); 628 // gehe zu dieser Box (wenn vorhanden und in Tabelle!) 629 sal_Bool GotoTable( const String& rName ); 630 631 // select a table row, column or box (based on the current cursor) 632 sal_Bool SelTblRow() { return _SelTblRowOrCol( true ); } 633 sal_Bool SelTblCol() { return _SelTblRowOrCol( false ); } 634 sal_Bool SelTblBox(); 635 // --> FME 2004-07-30 #i32329# Enhanced table selection 636 sal_Bool SelTbl(); 637 // <-- 638 639 // zum naechsten/vorhergehenden Punkt auf gleicher Ebene 640 sal_Bool GotoNextNum(); 641 sal_Bool GotoPrevNum(); 642 643 // zu diesem Gliederungspunkt 644 sal_Bool GotoOutline( const String& rName ); 645 // zum naechsten/vorhergehenden oder angegebenen OultineNode 646 void GotoOutline( sal_uInt16 nIdx ); 647 // suche die "Outline-Position" im Nodes-Array vom akt. Kaiptel 648 sal_uInt16 GetOutlinePos( sal_uInt8 nLevel = UCHAR_MAX ); 649 // selektiere den angeben Bereich von OutlineNodes. Optional 650 // inclusive der Childs. Die sal_uInt16 sind die Positionen im 651 // OutlineNds-Array!! (EditShell) 652 sal_Bool MakeOutlineSel( sal_uInt16 nSttPos, sal_uInt16 nEndPos, 653 sal_Bool bWithChilds = sal_False ); 654 655 sal_Bool GotoNextOutline(); // naechster Node mit Outline-Num. 656 sal_Bool GotoPrevOutline(); // vorheriger Node mit Outline-Num. 657 658 /** Delivers the current shell cursor 659 660 Some operations have to run on the current cursor ring, 661 some on the pTblCrsr (if exist) or the current cursor ring and 662 some on the pTblCrsr or pBlockCrsr or the current cursor ring. 663 This small function checks the existence and delivers the wished cursor. 664 665 @param bBlock [bool] 666 if the block cursor is of interest or not 667 668 @return pTblCrsr if exist, 669 pBlockCrsr if exist and of interest (param bBlock) 670 otherwise pCurCrsr 671 */ 672 SwShellCrsr* getShellCrsr( bool bBlock ); 673 const SwShellCrsr* getShellCrsr( bool bBlock ) const 674 { return (const_cast<SwCrsrShell*>(this))->getShellCrsr( bBlock ); } 675 676 FASTBOOL IsBlockMode() const { return 0 != pBlockCrsr; } 677 const IBlockCursor* GetBlockCrsr() const { return pBlockCrsr; } 678 IBlockCursor* GetBlockCrsr() { return pBlockCrsr; } 679 680 // ist der Crsr in einer Tabelle und ist die Selection ueber 681 // zwei Spalten 682 sal_Bool IsTableMode() const { return 0 != pTblCrsr; } 683 684 // erfrage den Tabellen Crsr; ausserhalb von Tabellen immer 0 685 const SwShellTableCrsr* GetTableCrsr() const { return pTblCrsr; } 686 SwShellTableCrsr* GetTableCrsr() { return pTblCrsr; } 687 sal_uInt16 UpdateTblSelBoxes(); 688 689 sal_Bool GotoFtnTxt(); // springe aus dem Content zur Fussnote 690 sal_Bool GotoFtnAnchor(); // springe aus der Fussnote zum Anker 691 sal_Bool GotoPrevFtnAnchor(); 692 sal_Bool GotoNextFtnAnchor(); 693 694 sal_Bool GotoFlyAnchor(); // springe aus dem Rahmen zum Anker 695 sal_Bool GotoHeaderTxt(); // springe aus dem Content zum Header 696 sal_Bool GotoFooterTxt(); // springe aus dem Content zum Footer 697 // springe in den Header/Footer des angegebenen oder akt. PageDesc 698 sal_Bool SetCrsrInHdFt( sal_uInt16 nDescNo = USHRT_MAX, 699 sal_Bool bInHeader = sal_True ); 700 // is point of cursor in header/footer. pbInHeader return sal_True if it is 701 // in a headerframe otherwise in a footerframe 702 sal_Bool IsInHeaderFooter( sal_Bool* pbInHeader = 0 ) const; 703 704 // springe zum naechsten Verzeichnis [mit dem Namen] 705 sal_Bool GotoNextTOXBase( const String* = 0 ); 706 // springe zum vorherigen Verzeichnis [mit dem Namen] 707 sal_Bool GotoPrevTOXBase( const String* = 0 ); 708 sal_Bool GotoTOXMarkBase(); // springe zum Verzeichnis vom TOXMark 709 // springe zum naechsten (vorherigen) Verzeichniseintrag 710 sal_Bool GotoNxtPrvTOXMark( sal_Bool bNext = sal_True ); 711 // Zur naechsten/ vorherigen Verzeichnismarke dieses Typs traveln 712 const SwTOXMark& GotoTOXMark( const SwTOXMark& rStart, SwTOXSearch eDir ); 713 714 // springe zum naechsten (vorherigen) Tabellenformel 715 // optional auch nur zu kaputten Formeln springen 716 sal_Bool GotoNxtPrvTblFormula( sal_Bool bNext = sal_True, 717 sal_Bool bOnlyErrors = sal_False ); 718 // jump to the next / previous hyperlink - inside text and also 719 // on graphics 720 sal_Bool SelectNxtPrvHyperlink( sal_Bool bNext = sal_True ); 721 722 // springe zu dieser Refmark 723 sal_Bool GotoRefMark( const String& rRefMark, sal_uInt16 nSubType = 0, 724 sal_uInt16 nSeqNo = 0 ); 725 726 // hole vom Start/Ende der akt. Selection das nte Zeichen 727 sal_Unicode GetChar( sal_Bool bEnd = sal_True, long nOffset = 0 ); 728 // erweiter die akt. Selection am Anfang/Ende um n Zeichen 729 sal_Bool ExtendSelection( sal_Bool bEnd = sal_True, xub_StrLen nCount = 1 ); 730 // setze nur den sichtbaren Cursor an die angegebene Dokument-Pos. 731 // returnt sal_False: wenn der ob der SPoint vom Layout korrigiert wurde. 732 // (wird zum Anzeigen von Drag&Drop/Copy-Cursor benoetigt) 733 sal_Bool SetVisCrsr( const Point &rPt ); 734 inline void UnSetVisCrsr(); 735 736 // springe zum nachsten/vorherigen Feld des entsprechenden Types 737 sal_Bool MoveFldType( const SwFieldType* pFldType, sal_Bool bNext, 738 sal_uInt16 nSubType = USHRT_MAX, 739 sal_uInt16 nResType = USHRT_MAX ); 740 // springe genau zu diesem Feld 741 sal_Bool GotoFld( const SwFmtFld& rFld ); 742 743 // returne die Anzahl der Cursor im Ring (Flag besagt ob man nur 744 // aufgepspannte haben will - sprich etwas selektiert ist (Basic)) 745 sal_uInt16 GetCrsrCnt( sal_Bool bAll = sal_True ) const; 746 747 // Char Travelling - Methoden (in crstrvl1.cxx) 748 sal_Bool GoStartWord(); 749 sal_Bool GoEndWord(); 750 sal_Bool GoNextWord(); 751 sal_Bool GoPrevWord(); 752 sal_Bool GoNextSentence(); 753 sal_Bool GoPrevSentence(); 754 sal_Bool GoStartSentence(); 755 sal_Bool GoEndSentence(); 756 sal_Bool SelectWord( const Point* pPt = 0 ); 757 sal_Bool ExpandToSentenceBorders(); 758 759 // Position vom akt. Cursor erfragen 760 sal_Bool IsStartWord( sal_Int16 nWordType = com::sun::star::i18n::WordType::ANYWORD_IGNOREWHITESPACES )const; 761 sal_Bool IsEndWord( sal_Int16 nWordType = com::sun::star::i18n::WordType::ANYWORD_IGNOREWHITESPACES ) const; 762 sal_Bool IsInWord( sal_Int16 nWordType = com::sun::star::i18n::WordType::ANYWORD_IGNOREWHITESPACES ) const; 763 sal_Bool IsStartSentence() const; 764 sal_Bool IsEndSentence() const; 765 sal_Bool IsSttPara() const; 766 sal_Bool IsEndPara() const; 767 sal_Bool IsStartOfDoc() const; 768 sal_Bool IsEndOfDoc() const; 769 sal_Bool IsInFrontOfLabel() const; 770 sal_Bool IsAtLeftMargin() const { return IsAtLRMargin( sal_True ); } 771 sal_Bool IsAtRightMargin(sal_Bool bAPI = sal_False) const { return IsAtLRMargin( sal_False, bAPI ); } 772 773 // loesche alle erzeugten Crsr, setze den Tabellen-Crsr und den letzten 774 // Cursor auf seinen TextNode (oder StartNode?). 775 // Beim naechsten ::GetCrsr werden sie wieder alle erzeugt. 776 // Wird fuers Drag&Drop/ClipBorad-Paste in Tabellen benoetigt. 777 sal_Bool ParkTblCrsr(); 778 779 // gibt es nicht aufgespannte Attribute? 780 sal_Bool IsGCAttr() const { return bGCAttr; } 781 void ClearGCAttr() { bGCAttr = sal_False; } 782 void UpdateAttr() { bGCAttr = sal_True; } 783 784 // ist das gesamte Dokument geschuetzt/versteckt?? (fuer UI,..) 785 sal_Bool IsAllProtect() const { return bAllProtect; } 786 787 #ifdef SW_CRSR_TIMER 788 // setze das Flag am VisCrsr, ob dieser ueber Timer getriggert (sal_True) 789 // oder direkt (sal_False) angezeigt wird. (default ist Timer getriggert) 790 sal_Bool ChgCrsrTimerFlag( sal_Bool bTimerOn = sal_True ); 791 #endif 792 793 sal_Bool BasicActionPend() const { return nBasicActionCnt != nStartAction; } 794 795 // springe zum benannten Bereich 796 sal_Bool GotoRegion( const String& rName ); 797 798 // zeige die aktuelle Selektion an 799 virtual void MakeSelVisible(); 800 801 // setzte den Cursor auf einen NICHT geschuetzten/versteckten Node 802 sal_Bool FindValidCntntNode( sal_Bool bOnlyText = sal_False ); 803 804 sal_Bool GetContentAtPos( const Point& rPt, 805 SwContentAtPos& rCntntAtPos, 806 sal_Bool bSetCrsr = sal_False, 807 SwRect* pFldRect = 0 ); 808 809 // --> OD 2008-06-19 #i90516# 810 const SwPostItField* GetPostItFieldAtCursor() const; 811 // <-- 812 813 // get smart tags at point position 814 void GetSmartTagTerm( const Point& rPt, 815 SwRect& rSelectRect, 816 ::com::sun::star::uno::Sequence< rtl::OUString >& rSmartTagTypes, 817 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::container::XStringKeyMap > >& rStringKeyMaps, 818 ::com::sun::star::uno::Reference<com::sun::star::text::XTextRange>& rRange ); 819 820 // get smart tags at current cursor position 821 void GetSmartTagTerm( ::com::sun::star::uno::Sequence< rtl::OUString >& rSmartTagTypes, 822 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::container::XStringKeyMap > >& rStringKeyMaps, 823 ::com::sun::star::uno::Reference<com::sun::star::text::XTextRange>& rRange ) const; 824 825 sal_Bool IsPageAtPos( const Point &rPt ) const; 826 827 // Attribut selelktieren 828 sal_Bool SelectTxtAttr( sal_uInt16 nWhich, sal_Bool bExpand, const SwTxtAttr* pAttr = 0 ); 829 sal_Bool GotoINetAttr( const SwTxtINetFmt& rAttr ); 830 const SwFmtINetFmt* FindINetAttr( const String& rName ) const; 831 832 sal_Bool CheckTblBoxCntnt( const SwPosition* pPos = 0 ); 833 void SaveTblBoxCntnt( const SwPosition* pPos = 0 ); 834 void ClearTblBoxCntnt(); 835 sal_Bool EndAllTblBoxEdit(); 836 837 // wird gerufen, wenn eine Tabellenselektion im UpdateCrsr erzeugt wird, 838 // ohne das die UI davon etaws weiss 839 virtual void NewCoreSelection(); 840 841 void SetSelTblCells( sal_Bool bFlag ) { bSelTblCells = bFlag; } 842 sal_Bool IsSelTblCells() const { return bSelTblCells; } 843 844 sal_Bool IsAutoUpdateCells() const { return bAutoUpdateCells; } 845 void SetAutoUpdateCells( sal_Bool bFlag ) { bAutoUpdateCells = bFlag; } 846 847 sal_Bool GetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode, 848 SwRect& rRect, short& rOrient ); 849 sal_Bool SetShadowCrsrPos( const Point& rPt, SwFillMode eFillMode ); 850 851 const SwRedline* SelNextRedline(); 852 const SwRedline* SelPrevRedline(); 853 const SwRedline* GotoRedline( sal_uInt16 nArrPos, sal_Bool bSelect = sal_False ); 854 855 // is cursor or the point in/over a vertical formatted text? 856 sal_Bool IsInVerticalText( const Point* pPt = 0 ) const; 857 // is cursor or the point in/over a right to left formatted text? 858 sal_Bool IsInRightToLeftText( const Point* pPt = 0 ) const; 859 860 // If the current cursor position is inside a hidden range, the hidden range 861 // is selected and true is returned: 862 bool SelectHiddenRange(); 863 864 // remove all invalid cursors 865 void ClearUpCrsrs(); 866 867 // OD 11.02.2003 #100556# - set/get flag to allow/avoid execution of macros 868 inline void SetMacroExecAllowed( const bool _bMacroExecAllowed ) 869 { 870 mbMacroExecAllowed = _bMacroExecAllowed; 871 } 872 inline bool IsMacroExecAllowed() 873 { 874 return mbMacroExecAllowed; 875 } 876 877 // #111827# 878 /** 879 Returns textual description of the current selection. 880 881 - If the current selection is a multi-selection the result is 882 STR_MULTISEL. 883 - Else the result is the text of the selection. 884 885 @return the textual description of the current selection 886 */ 887 String GetCrsrDescr() const; 888 889 SwRect GetRectOfCurrentChar(); 890 }; 891 892 893 // Cursor Inlines: 894 inline SwMoveFnCollection* SwCrsrShell::MakeFindRange( 895 sal_uInt16 nStt, sal_uInt16 nEnd, SwPaM* pPam ) const 896 { 897 return pCurCrsr->MakeFindRange( (SwDocPositions)nStt, (SwDocPositions)nEnd, pPam ); 898 } 899 900 inline SwCursor* SwCrsrShell::GetSwCrsr( sal_Bool bMakeTblCrsr ) const 901 { 902 return (SwCursor*)GetCrsr( bMakeTblCrsr ); 903 } 904 905 inline SwPaM* SwCrsrShell::GetStkCrsr() const { return pCrsrStk; } 906 907 inline void SwCrsrShell::SetMark() { pCurCrsr->SetMark(); } 908 909 inline sal_Bool SwCrsrShell::HasMark() { return( pCurCrsr->HasMark() ); } 910 911 inline sal_Bool SwCrsrShell::IsSelection() const 912 { 913 return IsTableMode() || pCurCrsr->HasMark() || 914 pCurCrsr->GetNext() != pCurCrsr; 915 } 916 inline sal_Bool SwCrsrShell::IsMultiSelection() const 917 { 918 return pCurCrsr->GetNext() != pCurCrsr; 919 } 920 921 inline sal_Bool SwCrsrShell::IsSelOnePara() const 922 { 923 return pCurCrsr == pCurCrsr->GetNext() && 924 pCurCrsr->GetPoint()->nNode == pCurCrsr->GetMark()->nNode; 925 } 926 927 inline const SwTableNode* SwCrsrShell::IsCrsrInTbl( sal_Bool bIsPtInTbl ) const 928 { 929 return pCurCrsr->GetNode( bIsPtInTbl )->FindTableNode(); 930 } 931 932 inline sal_Bool SwCrsrShell::IsCrsrPtAtEnd() const 933 { 934 return pCurCrsr->End() == pCurCrsr->GetPoint(); 935 } 936 937 inline Point& SwCrsrShell::GetCrsrDocPos( sal_Bool bPoint ) const 938 { 939 return bPoint ? pCurCrsr->GetPtPos() : pCurCrsr->GetMkPos(); 940 } 941 942 inline const SwPaM* SwCrsrShell::GetTblCrs() const 943 { 944 return pTblCrsr; 945 } 946 947 inline SwPaM* SwCrsrShell::GetTblCrs() 948 { 949 return pTblCrsr; 950 } 951 952 inline void SwCrsrShell::UnSetVisCrsr() 953 { 954 pVisCrsr->Hide(); 955 pVisCrsr->SetDragCrsr( sal_False ); 956 } 957 958 #endif // _CRSRSH_HXX 959