svx/source/unoedit/unofored.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: unofored.cxx,v $
  10  * $Revision: 1.31 $
  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_svx.hxx"
  33
  34 #include <algorithm>
  35 #include <svx/eeitem.hxx>
  36 #include <com/sun/star/i18n/WordType.hpp>
  37
  38 #include <svtools/itemset.hxx>
  39 #include <svx/editeng.hxx>
  40 #include <svx/editview.hxx>
  41 #include <unoedhlp.hxx>
  42 #include <svx/editdata.hxx>
  43 #include <svx/outliner.hxx>
  44 #include <svx/editobj.hxx>              // nur fuer die GetText-Kruecke
  45
  46 #include <svx/unofored.hxx>
  47
  48 using namespace ::com::sun::star;
  49
  50 //------------------------------------------------------------------------
  51
  52 SvxEditEngineForwarder::SvxEditEngineForwarder( EditEngine& rEngine ) :
  53     rEditEngine( rEngine )
  54 {
  55 }
  56
  57 SvxEditEngineForwarder::~SvxEditEngineForwarder()
  58 {
  59     //  die EditEngine muss ggf. von aussen geloescht werden
  60 }
  61
  62 USHORT SvxEditEngineForwarder::GetParagraphCount() const
  63 {
  64     return rEditEngine.GetParagraphCount();
  65 }
  66
  67 USHORT SvxEditEngineForwarder::GetTextLen( USHORT nParagraph ) const
  68 {
  69     return rEditEngine.GetTextLen( nParagraph );
  70 }
  71
  72 String SvxEditEngineForwarder::GetText( const ESelection& rSel ) const
  73 {
  74     String aRet = rEditEngine.GetText( rSel, LINEEND_LF );
  75     aRet.ConvertLineEnd();
  76     return aRet;
  77 }
  78
  79 SfxItemSet SvxEditEngineForwarder::GetAttribs( const ESelection& rSel, BOOL bOnlyHardAttrib ) const
  80 {
  81     if( rSel.nStartPara == rSel.nEndPara )
  82     {
  83         sal_uInt8 nFlags = 0;
  84         switch( bOnlyHardAttrib )
  85         {
  86         case EditEngineAttribs_All:
  87             nFlags = GETATTRIBS_ALL;
  88             break;
  89         case EditEngineAttribs_HardAndPara:
  90             nFlags = GETATTRIBS_PARAATTRIBS|GETATTRIBS_CHARATTRIBS;
  91             break;
  92         case EditEngineAttribs_OnlyHard:
  93             nFlags = GETATTRIBS_CHARATTRIBS;
  94             break;
  95         default:
  96             DBG_ERROR("unknown flags for SvxOutlinerForwarder::GetAttribs");
  97         }
  98
  99         return rEditEngine.GetAttribs( rSel.nStartPara, rSel.nStartPos, rSel.nEndPos, nFlags );
 100     }
 101     else
 102     {
 103         return rEditEngine.GetAttribs( rSel, bOnlyHardAttrib );
 104     }
 105 }
 106
 107 SfxItemSet SvxEditEngineForwarder::GetParaAttribs( USHORT nPara ) const
 108 {
 109     SfxItemSet aSet( rEditEngine.GetParaAttribs( nPara ) );
 110
 111     USHORT nWhich = EE_PARA_START;
 112     while( nWhich <= EE_PARA_END )
 113     {
 114         if( aSet.GetItemState( nWhich, TRUE ) != SFX_ITEM_ON )
 115         {
 116             if( rEditEngine.HasParaAttrib( nPara, nWhich ) )
 117                 aSet.Put( rEditEngine.GetParaAttrib( nPara, nWhich ) );
 118         }
 119         nWhich++;
 120     }
 121
 122     return aSet;
 123 }
 124
 125 void SvxEditEngineForwarder::SetParaAttribs( USHORT nPara, const SfxItemSet& rSet )
 126 {
 127     rEditEngine.SetParaAttribs( nPara, rSet );
 128 }
 129
 130 void SvxEditEngineForwarder::RemoveAttribs( const ESelection& rSelection, sal_Bool bRemoveParaAttribs, sal_uInt16 nWhich )
 131 {
 132     rEditEngine.RemoveAttribs( rSelection, bRemoveParaAttribs, nWhich );
 133 }
 134
 135 SfxItemPool* SvxEditEngineForwarder::GetPool() const
 136 {
 137     return rEditEngine.GetEmptyItemSet().GetPool();
 138 }
 139
 140 void SvxEditEngineForwarder::GetPortions( USHORT nPara, SvUShorts& rList ) const
 141 {
 142     rEditEngine.GetPortions( nPara, rList );
 143 }
 144
 145 void SvxEditEngineForwarder::QuickInsertText( const String& rText, const ESelection& rSel )
 146 {
 147     rEditEngine.QuickInsertText( rText, rSel );
 148 }
 149
 150 void SvxEditEngineForwarder::QuickInsertLineBreak( const ESelection& rSel )
 151 {
 152     rEditEngine.QuickInsertLineBreak( rSel );
 153 }
 154
 155 void SvxEditEngineForwarder::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 156 {
 157     rEditEngine.QuickInsertField( rFld, rSel );
 158 }
 159
 160 void SvxEditEngineForwarder::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 161 {
 162     rEditEngine.QuickSetAttribs( rSet, rSel );
 163 }
 164
 165 BOOL SvxEditEngineForwarder::IsValid() const
 166 {
 167     // cannot reliably query EditEngine state
 168     // while in the middle of an update
 169     return rEditEngine.GetUpdateMode();
 170 }
 171
 172 XubString SvxEditEngineForwarder::CalcFieldValue( const SvxFieldItem& rField, USHORT nPara, USHORT nPos, Color*& rpTxtColor, Color*& rpFldColor )
 173 {
 174     return rEditEngine.CalcFieldValue( rField, nPara, nPos, rpTxtColor, rpFldColor );
 175 }
 176
 177 USHORT GetSvxEditEngineItemState( EditEngine& rEditEngine, const ESelection& rSel, USHORT nWhich )
 178 {
 179     EECharAttribArray aAttribs;
 180
 181     const SfxPoolItem*  pLastItem = NULL;
 182
 183     SfxItemState eState = SFX_ITEM_DEFAULT;
 184
 185     // check all paragraphs inside the selection
 186     for( USHORT nPara = rSel.nStartPara; nPara <= rSel.nEndPara; nPara++ )
 187     {
 188         SfxItemState eParaState = SFX_ITEM_DEFAULT;
 189
 190         // calculate start and endpos for this paragraph
 191         USHORT nPos = 0;
 192         if( rSel.nStartPara == nPara )
 193             nPos = rSel.nStartPos;
 194
 195         USHORT nEndPos = rSel.nEndPos;
 196         if( rSel.nEndPara != nPara )
 197             nEndPos = rEditEngine.GetTextLen( nPara );
 198
 199
 200         // get list of char attribs
 201         rEditEngine.GetCharAttribs( nPara, aAttribs );
 202
 203         BOOL bEmpty = TRUE;             // we found no item inside the selektion of this paragraph
 204         BOOL bGaps  = FALSE;    // we found items but theire gaps between them
 205         USHORT nLastEnd = nPos;
 206
 207         const SfxPoolItem* pParaItem = NULL;
 208
 209         for( USHORT nAttrib = 0; nAttrib < aAttribs.Count(); nAttrib++ )
 210         {
 211             struct EECharAttrib aAttrib = aAttribs.GetObject( nAttrib );
 212             DBG_ASSERT( aAttrib.pAttr, "GetCharAttribs gives corrupt data" );
 213
 214             const sal_Bool bEmptyPortion = aAttrib.nStart == aAttrib.nEnd;
 215             if( (!bEmptyPortion && (aAttrib.nStart >= nEndPos)) || (bEmptyPortion && (aAttrib.nStart > nEndPos)) )
 216                 break;  // break if we are already behind our selektion
 217
 218             if( (!bEmptyPortion && (aAttrib.nEnd <= nPos)) || (bEmptyPortion && (aAttrib.nEnd < nPos)) )
 219                 continue;       // or if the attribute ends before our selektion
 220
 221             if( aAttrib.pAttr->Which() != nWhich )
 222                 continue; // skip if is not the searched item
 223
 224             // if we already found an item
 225             if( pParaItem )
 226             {
 227                 // ... and its different to this one than the state is dont care
 228                 if( *pParaItem != *aAttrib.pAttr )
 229                     return SFX_ITEM_DONTCARE;
 230             }
 231             else
 232             {
 233                 pParaItem = aAttrib.pAttr;
 234             }
 235
 236             if( bEmpty )
 237                 bEmpty = FALSE;
 238
 239             if( !bGaps && aAttrib.nStart > nLastEnd )
 240                 bGaps = TRUE;
 241
 242             nLastEnd = aAttrib.nEnd;
 243         }
 244
 245         if( !bEmpty && !bGaps && nLastEnd < ( nEndPos - 1 ) )
 246             bGaps = TRUE;
 247 /*
 248         // since we have no portion with our item or if there were gaps
 249         if( bEmpty || bGaps )
 250         {
 251             // we need to check the paragraph item
 252             const SfxItemSet& rParaSet = rEditEngine.GetParaAttribs( nPara );
 253             if( rParaSet.GetItemState( nWhich ) == SFX_ITEM_SET )
 254             {
 255                 eState = SFX_ITEM_SET;
 256                 // get item from the paragraph
 257                 const SfxPoolItem* pTempItem = rParaSet.GetItem( nWhich );
 258                 if( pParaItem )
 259                 {
 260                     if( *pParaItem != *pTempItem )
 261                         return SFX_ITEM_DONTCARE;
 262                 }
 263                 else
 264                 {
 265                     pParaItem = pTempItem;
 266                 }
 267
 268                 // set if theres no last item or if its the same
 269                 eParaState = SFX_ITEM_SET;
 270             }
 271             else if( bEmpty )
 272             {
 273                 eParaState = SFX_ITEM_DEFAULT;
 274             }
 275             else if( bGaps )
 276             {
 277                 // gaps and item not set in paragraph, thats a dont care
 278                 return SFX_ITEM_DONTCARE;
 279             }
 280         }
 281         else
 282         {
 283             eParaState = SFX_ITEM_SET;
 284         }
 285 */
 286         if( bEmpty )
 287             eParaState = SFX_ITEM_DEFAULT;
 288         else if( bGaps )
 289             eParaState = SFX_ITEM_DONTCARE;
 290         else
 291             eParaState = SFX_ITEM_SET;
 292
 293         // if we already found an item check if we found the same
 294         if( pLastItem )
 295         {
 296             if( (pParaItem == NULL) || (*pLastItem != *pParaItem) )
 297                 return SFX_ITEM_DONTCARE;
 298         }
 299         else
 300         {
 301             pLastItem = pParaItem;
 302             eState = eParaState;
 303         }
 304     }
 305
 306     return eState;
 307 }
 308
 309 USHORT SvxEditEngineForwarder::GetItemState( const ESelection& rSel, USHORT nWhich ) const
 310 {
 311     return GetSvxEditEngineItemState( rEditEngine, rSel, nWhich );
 312 }
 313
 314 USHORT SvxEditEngineForwarder::GetItemState( USHORT nPara, USHORT nWhich ) const
 315 {
 316     const SfxItemSet& rSet = rEditEngine.GetParaAttribs( nPara );
 317     return rSet.GetItemState( nWhich );
 318 }
 319
 320 LanguageType SvxEditEngineForwarder::GetLanguage( USHORT nPara, USHORT nIndex ) const
 321 {
 322     return rEditEngine.GetLanguage(nPara, nIndex);
 323 }
 324
 325 USHORT SvxEditEngineForwarder::GetFieldCount( USHORT nPara ) const
 326 {
 327     return rEditEngine.GetFieldCount(nPara);
 328 }
 329
 330 EFieldInfo SvxEditEngineForwarder::GetFieldInfo( USHORT nPara, USHORT nField ) const
 331 {
 332     return rEditEngine.GetFieldInfo( nPara, nField );
 333 }
 334
 335 EBulletInfo SvxEditEngineForwarder::GetBulletInfo( USHORT ) const
 336 {
 337     return EBulletInfo();
 338 }
 339
 340 Rectangle SvxEditEngineForwarder::GetCharBounds( USHORT nPara, USHORT nIndex ) const
 341 {
 342     // #101701#
 343     // EditEngine's 'internal' methods like GetCharacterBounds()
 344     // don't rotate for vertical text.
 345     Size aSize( rEditEngine.CalcTextWidth(), rEditEngine.GetTextHeight() );
 346     ::std::swap( aSize.Width(), aSize.Height() );
 347     bool bIsVertical( rEditEngine.IsVertical() == TRUE );
 348
 349     // #108900# Handle virtual position one-past-the end of the string
 350     if( nIndex >= rEditEngine.GetTextLen(nPara) )
 351     {
 352         Rectangle aLast;
 353
 354         if( nIndex )
 355         {
 356             // use last character, if possible
 357             aLast = rEditEngine.GetCharacterBounds( EPosition(nPara, nIndex-1) );
 358
 359             // move at end of this last character, make one pixel wide
 360             aLast.Move( aLast.Right() - aLast.Left(), 0 );
 361             aLast.SetSize( Size(1, aLast.GetHeight()) );
 362
 363             // take care for CTL
 364             aLast = SvxEditSourceHelper::EEToUserSpace( aLast, aSize, bIsVertical );
 365         }
 366         else
 367         {
 368             // #109864# Bounds must lie within the paragraph
 369             aLast = GetParaBounds( nPara );
 370
 371             // #109151# Don't use paragraph height, but line height
 372             // instead. aLast is already CTL-correct
 373             if( bIsVertical)
 374                 aLast.SetSize( Size( rEditEngine.GetLineHeight(nPara,0), 1 ) );
 375             else
 376                 aLast.SetSize( Size( 1, rEditEngine.GetLineHeight(nPara,0) ) );
 377         }
 378
 379         return aLast;
 380     }
 381     else
 382     {
 383         return SvxEditSourceHelper::EEToUserSpace( rEditEngine.GetCharacterBounds( EPosition(nPara, nIndex) ),
 384                                                    aSize, bIsVertical );
 385     }
 386 }
 387
 388 Rectangle SvxEditEngineForwarder::GetParaBounds( USHORT nPara ) const
 389 {
 390     const Point aPnt = rEditEngine.GetDocPosTopLeft( nPara );
 391     ULONG nWidth;
 392     ULONG nHeight;
 393     ULONG nTextWidth;
 394
 395     if( rEditEngine.IsVertical() )
 396     {
 397         // #101701#
 398         // Hargl. EditEngine's 'external' methods return the rotated
 399         // dimensions, 'internal' methods like GetTextHeight( n )
 400         // don't rotate.
 401         nWidth = rEditEngine.GetTextHeight( nPara );
 402         nHeight = rEditEngine.GetTextHeight();
 403         nTextWidth = rEditEngine.GetTextHeight();
 404
 405         return Rectangle( nTextWidth - aPnt.Y() - nWidth, 0, nTextWidth - aPnt.Y(), nHeight );
 406     }
 407     else
 408     {
 409         nWidth = rEditEngine.CalcTextWidth();
 410         nHeight = rEditEngine.GetTextHeight( nPara );
 411
 412         return Rectangle( 0, aPnt.Y(), nWidth, aPnt.Y() + nHeight );
 413     }
 414 }
 415
 416 MapMode SvxEditEngineForwarder::GetMapMode() const
 417 {
 418     return rEditEngine.GetRefMapMode();
 419 }
 420
 421 OutputDevice* SvxEditEngineForwarder::GetRefDevice() const
 422 {
 423     return rEditEngine.GetRefDevice();
 424 }
 425
 426 sal_Bool SvxEditEngineForwarder::GetIndexAtPoint( const Point& rPos, USHORT& nPara, USHORT& nIndex ) const
 427 {
 428     // #101701#
 429     Size aSize( rEditEngine.CalcTextWidth(), rEditEngine.GetTextHeight() );
 430     ::std::swap( aSize.Width(), aSize.Height() );
 431     Point aEEPos( SvxEditSourceHelper::UserSpaceToEE( rPos,
 432                                                       aSize,
 433                                                       rEditEngine.IsVertical() == TRUE ));
 434
 435     EPosition aDocPos = rEditEngine.FindDocPosition( aEEPos );
 436
 437     nPara = aDocPos.nPara;
 438     nIndex = aDocPos.nIndex;
 439
 440     return sal_True;
 441 }
 442
 443 sal_Bool SvxEditEngineForwarder::GetWordIndices( USHORT nPara, USHORT nIndex, USHORT& nStart, USHORT& nEnd ) const
 444 {
 445     ESelection aRes = rEditEngine.GetWord( ESelection(nPara, nIndex, nPara, nIndex), com::sun::star::i18n::WordType::DICTIONARY_WORD );
 446
 447     if( aRes.nStartPara == nPara &&
 448         aRes.nStartPara == aRes.nEndPara )
 449     {
 450         nStart = aRes.nStartPos;
 451         nEnd = aRes.nEndPos;
 452
 453         return sal_True;
 454     }
 455
 456     return sal_False;
 457 }
 458
 459 sal_Bool SvxEditEngineForwarder::GetAttributeRun( USHORT& nStartIndex, USHORT& nEndIndex, USHORT nPara, USHORT nIndex ) const
 460 {
 461     return SvxEditSourceHelper::GetAttributeRun( nStartIndex, nEndIndex, rEditEngine, nPara, nIndex );
 462 }
 463
 464 USHORT SvxEditEngineForwarder::GetLineCount( USHORT nPara ) const
 465 {
 466     return rEditEngine.GetLineCount(nPara);
 467 }
 468
 469 USHORT SvxEditEngineForwarder::GetLineLen( USHORT nPara, USHORT nLine ) const
 470 {
 471     return rEditEngine.GetLineLen(nPara, nLine);
 472 }
 473
 474 void SvxEditEngineForwarder::GetLineBoundaries( /*out*/USHORT &rStart, /*out*/USHORT &rEnd, USHORT nPara, USHORT nLine ) const
 475 {
 476     rEditEngine.GetLineBoundaries(rStart, rEnd, nPara, nLine);
 477 }
 478
 479 USHORT SvxEditEngineForwarder::GetLineNumberAtIndex( USHORT nPara, USHORT nIndex ) const
 480 {
 481     return rEditEngine.GetLineNumberAtIndex(nPara, nIndex);
 482 }
 483
 484
 485 sal_Bool SvxEditEngineForwarder::QuickFormatDoc( BOOL )
 486 {
 487     rEditEngine.QuickFormatDoc();
 488
 489     return sal_True;
 490 }
 491
 492 sal_Bool SvxEditEngineForwarder::Delete( const ESelection& rSelection )
 493 {
 494     rEditEngine.QuickDelete( rSelection );
 495     rEditEngine.QuickFormatDoc();
 496
 497     return sal_True;
 498 }
 499
 500 sal_Bool SvxEditEngineForwarder::InsertText( const String& rStr, const ESelection& rSelection )
 501 {
 502     rEditEngine.QuickInsertText( rStr, rSelection );
 503     rEditEngine.QuickFormatDoc();
 504
 505     return sal_True;
 506 }
 507
 508 sal_Int16 SvxEditEngineForwarder::GetDepth( USHORT ) const
 509 {
 510     // EditEngine does not support outline depth
 511     return -1;
 512 }
 513
 514 sal_Bool SvxEditEngineForwarder::SetDepth( USHORT, sal_Int16 nNewDepth )
 515 {
 516     // EditEngine does not support outline depth
 517     return nNewDepth == -1 ? sal_True : sal_False;
 518 }
 519
 520 const SfxItemSet * SvxEditEngineForwarder::GetEmptyItemSetPtr()
 521 {
 522     return &rEditEngine.GetEmptyItemSet();
 523 }
 524
 525 void SvxEditEngineForwarder::AppendParagraph()
 526 {
 527     rEditEngine.InsertParagraph( rEditEngine.GetParagraphCount(), String::EmptyString() );
 528 }
 529
 530 xub_StrLen SvxEditEngineForwarder::AppendTextPortion( USHORT nPara, const String &rText, const SfxItemSet & /*rSet*/ )
 531 {
 532     xub_StrLen nLen = 0;
 533
 534     USHORT nParaCount = rEditEngine.GetParagraphCount();
 535     DBG_ASSERT( nPara < nParaCount, "paragraph index out of bounds" );
 536     if (/*0 <= nPara && */nPara < nParaCount)
 537     {
 538         nLen = rEditEngine.GetTextLen( nPara );
 539         rEditEngine.QuickInsertText( rText, ESelection( nPara, nLen, nPara, nLen ) );
 540     }
 541
 542     return nLen;
 543 }
 544
 545 void SvxEditEngineForwarder::CopyText(const SvxTextForwarder& rSource)
 546 {
 547     const SvxEditEngineForwarder* pSourceForwarder = dynamic_cast< const SvxEditEngineForwarder* >( &rSource );
 548     if( !pSourceForwarder )
 549         return;
 550     EditTextObject* pNewTextObject = pSourceForwarder->rEditEngine.CreateTextObject();
 551     rEditEngine.SetText( *pNewTextObject );
 552     delete pNewTextObject;
 553 }
 554
 555 //------------------------------------------------------------------------