svx/source/svdraw/svdetc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include "sal/config.h"
  30
  31 #include "editeng/forbiddencharacterstable.hxx"
  32 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  33 #include <com/sun/star/embed/EmbedStates.hpp>
  34 #include "officecfg/Office/Common.hxx"
  35 #include <svx/svdetc.hxx>
  36 #include "svx/svditext.hxx"
  37 #include <svx/svdmodel.hxx>
  38 #include <svx/svdtrans.hxx>
  39 #include "svx/svdglob.hxx"
  40 #include "svx/svdstr.hrc"
  41 #include "svx/svdviter.hxx"
  42 #include <svx/svdview.hxx>
  43 #include <svx/svdoutl.hxx>
  44 #include <vcl/bmpacc.hxx>
  45 #include <editeng/eeitem.hxx>
  46 #include <svl/itemset.hxx>
  47 #include <svl/whiter.hxx>
  48 #include "editeng/fontitem.hxx"
  49 #include <editeng/colritem.hxx>
  50 #include <editeng/fhgtitem.hxx>
  51 #include <svx/xgrad.hxx>
  52 #include <svx/xfillit0.hxx>
  53 #include <svx/xflclit.hxx>
  54 #include <svx/xflhtit.hxx>
  55 #include <svx/xbtmpit.hxx>
  56 #include <svx/xflgrit.hxx>
  57 #include <svx/svdoole2.hxx>
  58 #include <svl/itempool.hxx>
  59 #include <unotools/localedatawrapper.hxx>
  60 #include <com/sun/star/lang/Locale.hpp>
  61 #include <i18npool/lang.h>
  62 #include <unotools/charclass.hxx>
  63 #include <unotools/syslocale.hxx>
  64 #include <svx/xflbckit.hxx>
  65 #include <svx/extrusionbar.hxx>
  66 #include <svx/fontworkbar.hxx>
  67 #include <vcl/svapp.hxx>
  68 #include <svx/sdr/contact/viewcontact.hxx>
  69 #include <svx/svdpage.hxx>
  70 #include <svx/svdotable.hxx>
  71 #include <svx/sdrhittesthelper.hxx>
  72
  73 using namespace ::com::sun::star;
  74
  75 /******************************************************************************
  76 * Global data of the DrawingEngine
  77 ******************************************************************************/
  78
  79 SdrGlobalData::SdrGlobalData() :
  80     pSysLocale(NULL),
  81     pCharClass(NULL),
  82     pLocaleData(NULL),
  83     pOutliner(NULL),
  84     pDefaults(NULL),
  85     pResMgr(NULL),
  86     nExchangeFormat(0)
  87 {
  88
  89     svx::ExtrusionBar::RegisterInterface();
  90     svx::FontworkBar::RegisterInterface();
  91 }
  92
  93 const SvtSysLocale*         SdrGlobalData::GetSysLocale()
  94 {
  95     if ( !pSysLocale )
  96         pSysLocale = new SvtSysLocale;
  97     return pSysLocale;
  98 }
  99 const LocaleDataWrapper*    SdrGlobalData::GetLocaleData()
 100 {
 101     if ( !pLocaleData )
 102         pLocaleData = GetSysLocale()->GetLocaleDataPtr();
 103     return pLocaleData;
 104 }
 105 ////////////////////////////////////////////////////////////////////////////////////////////////////
 106
 107 OLEObjCache::OLEObjCache()
 108 :   Container( 0 )
 109 {
 110     nSize = officecfg::Office::Common::Cache::DrawingEngine::OLE_Objects::get();
 111     pTimer = new AutoTimer();
 112     Link aLink = LINK(this, OLEObjCache, UnloadCheckHdl);
 113
 114     pTimer->SetTimeoutHdl(aLink);
 115     pTimer->SetTimeout(20000);
 116     pTimer->Start();
 117
 118     aLink.Call(pTimer);
 119 }
 120
 121 OLEObjCache::~OLEObjCache()
 122 {
 123     pTimer->Stop();
 124     delete pTimer;
 125 }
 126
 127 void OLEObjCache::UnloadOnDemand()
 128 {
 129     if ( nSize < Count() )
 130     {
 131         // more objects than configured cache size try to remove objects
 132         // of course not the freshly inserted one at nIndex=0
 133         sal_uIntPtr nCount2 = Count();
 134         sal_uIntPtr nIndex = nCount2-1;
 135         while( nIndex && nCount2 > nSize )
 136         {
 137             SdrOle2Obj* pUnloadObj = (SdrOle2Obj*) GetObject(nIndex--);
 138             if ( pUnloadObj )
 139             {
 140                 try
 141                 {
 142                     // it is important to get object without reinitialization to avoid reentrance
 143                     uno::Reference< embed::XEmbeddedObject > xUnloadObj = pUnloadObj->GetObjRef_NoInit();
 144
 145                     sal_Bool bUnload = SdrOle2Obj::CanUnloadRunningObj( xUnloadObj, pUnloadObj->GetAspect() );
 146
 147                     // check whether the object can be unloaded before looking for the parent objects
 148                     if ( xUnloadObj.is() && bUnload )
 149                     {
 150                         uno::Reference< frame::XModel > xUnloadModel( xUnloadObj->getComponent(), uno::UNO_QUERY );
 151                         if ( xUnloadModel.is() )
 152                         {
 153                             for ( sal_uIntPtr nCheckInd = 0; nCheckInd < Count(); nCheckInd++ )
 154                             {
 155                                 SdrOle2Obj* pCacheObj = (SdrOle2Obj*) GetObject(nCheckInd);
 156                                 if ( pCacheObj && pCacheObj != pUnloadObj )
 157                                 {
 158                                     uno::Reference< frame::XModel > xParentModel = pCacheObj->GetParentXModel();
 159                                     if ( xUnloadModel == xParentModel )
 160                                         bUnload = sal_False; // the object has running embedded objects
 161                                 }
 162                             }
 163                         }
 164                     }
 165
 166                     if ( bUnload && UnloadObj(pUnloadObj) )
 167                         // object was successfully unloaded
 168                         nCount2--;
 169                 }
 170                 catch( uno::Exception& )
 171                 {}
 172             }
 173         }
 174     }
 175 }
 176
 177 void OLEObjCache::InsertObj(SdrOle2Obj* pObj)
 178 {
 179     if ( Count() )
 180     {
 181         SdrOle2Obj* pExistingObj = (SdrOle2Obj*)GetObject( 0 );
 182         if ( pObj == pExistingObj )
 183             // the object is already on the top, nothing has to be changed
 184             return;
 185     }
 186
 187     // get the old position of the object to know whether it is already in container
 188     sal_uIntPtr nOldPos = GetPos( pObj );
 189
 190     // insert object into first position
 191     Remove( nOldPos );
 192     Insert(pObj, (sal_uIntPtr) 0L);
 193
 194     if ( nOldPos == CONTAINER_ENTRY_NOTFOUND )
 195     {
 196         // a new object was inserted, recalculate the cache
 197         UnloadOnDemand();
 198     }
 199 }
 200
 201 void OLEObjCache::RemoveObj(SdrOle2Obj* pObj)
 202 {
 203     Remove(pObj);
 204 }
 205
 206 sal_Bool OLEObjCache::UnloadObj(SdrOle2Obj* pObj)
 207 {
 208     sal_Bool bUnloaded = sal_False;
 209     if (pObj)
 210     {
 211         //#i80528# The old mechanism is completely useless, only taking into account if
 212         // in all views the GrafDraft feature is used. This will nearly never have been the
 213         // case since no one ever used this option.
 214         //
 215         // A much better (and working) criteria would be the VOC contact count.
 216         // The question is what will happen when i make it work now suddenly? I
 217         // will try it for 2.4.
 218         const sdr::contact::ViewContact& rViewContact = pObj->GetViewContact();
 219         const bool bVisible(rViewContact.HasViewObjectContacts(true));
 220
 221         if(!bVisible)
 222         {
 223             bUnloaded = pObj->Unload();
 224         }
 225     }
 226
 227     return bUnloaded;
 228 }
 229
 230 IMPL_LINK(OLEObjCache, UnloadCheckHdl, AutoTimer*, /*pTim*/)
 231 {
 232     UnloadOnDemand();
 233     return 0;
 234 }
 235
 236 void ContainerSorter::DoSort(sal_uIntPtr a, sal_uIntPtr b) const
 237 {
 238     sal_uIntPtr nAnz=rCont.Count();
 239     if (b>nAnz) b=nAnz;
 240     if (b>0) b--;
 241     if (a<b) ImpSubSort(a,b);
 242 }
 243
 244 void ContainerSorter::Is1stLessThan2nd(const void* /*pElem1*/, const void* /*pElem2*/) const
 245 {
 246 }
 247
 248 void ContainerSorter::ImpSubSort(long nL, long nR) const
 249 {
 250     long i,j;
 251     const void* pX;
 252     void* pI;
 253     void* pJ;
 254     i=nL;
 255     j=nR;
 256     pX=rCont.GetObject((nL+nR)/2);
 257     do {
 258         pI=rCont.Seek(i);
 259         while (pI!=pX && Compare(pI,pX)<0) { i++; pI=rCont.Next(); }
 260         pJ=rCont.Seek(j);
 261         while (pJ!=pX && Compare(pX,pJ)<0) { j--; pJ=rCont.Prev(); }
 262         if (i<=j) {
 263             rCont.Replace(pJ,i);
 264             rCont.Replace(pI,j);
 265             i++;
 266             j--;
 267         }
 268     } while (i<=j);
 269     if (nL<j) ImpSubSort(nL,j);
 270     if (i<nR) ImpSubSort(i,nR);
 271 }
 272
 273 ////////////////////////////////////////////////////////////////////////////////////////////////////
 274
 275 class ImpUShortContainerSorter: public ContainerSorter {
 276 public:
 277     ImpUShortContainerSorter(Container& rNewCont): ContainerSorter(rNewCont) {}
 278     virtual ~ImpUShortContainerSorter() {}
 279     virtual int Compare(const void* pElem1, const void* pElem2) const;
 280 };
 281
 282 int ImpUShortContainerSorter::Compare(const void* pElem1, const void* pElem2) const
 283 {
 284     sal_uInt16 n1=sal_uInt16(sal_uIntPtr(pElem1));
 285     sal_uInt16 n2=sal_uInt16(sal_uIntPtr(pElem2));
 286     return n1<n2 ? -1 : n1>n2 ? 1 : 0;
 287 }
 288
 289 ////////////////////////////////////////////////////////////////////////////////////////////////////
 290
 291 void SdrLinkList::Clear()
 292 {
 293     unsigned nAnz=GetLinkCount();
 294     for (unsigned i=0; i<nAnz; i++) {
 295         delete (Link*)aList.GetObject(i);
 296     }
 297     aList.Clear();
 298 }
 299
 300 unsigned SdrLinkList::FindEntry(const Link& rLink) const
 301 {
 302     unsigned nAnz=GetLinkCount();
 303     for (unsigned i=0; i<nAnz; i++) {
 304         if (GetLink(i)==rLink) return i;
 305     }
 306     return 0xFFFF;
 307 }
 308
 309 void SdrLinkList::InsertLink(const Link& rLink, unsigned nPos)
 310 {
 311     unsigned nFnd=FindEntry(rLink);
 312     if (nFnd==0xFFFF) {
 313         if (rLink.IsSet()) {
 314             aList.Insert(new Link(rLink),nPos);
 315         } else {
 316             OSL_FAIL("SdrLinkList::InsertLink(): Tried to insert a link that was not set already.");
 317         }
 318     } else {
 319         OSL_FAIL("SdrLinkList::InsertLink(): Link already in place.");
 320     }
 321 }
 322
 323 void SdrLinkList::RemoveLink(const Link& rLink)
 324 {
 325     unsigned nFnd=FindEntry(rLink);
 326     if (nFnd!=0xFFFF) {
 327         Link* pLink=(Link*)aList.Remove(nFnd);
 328         delete pLink;
 329     } else {
 330         OSL_FAIL("SdrLinkList::RemoveLink(): Link not found.");
 331     }
 332 }
 333
 334 ////////////////////////////////////////////////////////////////////////////////////////////////////
 335
 336 bool GetDraftFillColor(const SfxItemSet& rSet, Color& rCol)
 337 {
 338     XFillStyle eFill=((XFillStyleItem&)rSet.Get(XATTR_FILLSTYLE)).GetValue();
 339     bool bRetval = false;
 340
 341     switch(eFill)
 342     {
 343         case XFILL_SOLID:
 344         {
 345             rCol = ((XFillColorItem&)rSet.Get(XATTR_FILLCOLOR)).GetColorValue();
 346             bRetval = true;
 347
 348             break;
 349         }
 350         case XFILL_HATCH:
 351         {
 352             Color aCol1(((XFillHatchItem&)rSet.Get(XATTR_FILLHATCH)).GetHatchValue().GetColor());
 353             Color aCol2(COL_WHITE);
 354
 355             // when hatched background is activated, use object fill color as hatch color
 356             sal_Bool bFillHatchBackground = ((const XFillBackgroundItem&)(rSet.Get(XATTR_FILLBACKGROUND))).GetValue();
 357             if(bFillHatchBackground)
 358             {
 359                 aCol2 = ((const XFillColorItem&)(rSet.Get(XATTR_FILLCOLOR))).GetColorValue();
 360             }
 361
 362             const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
 363             rCol = Color(aAverageColor);
 364             bRetval = true;
 365
 366             break;
 367         }
 368         case XFILL_GRADIENT: {
 369             const XGradient& rGrad=((XFillGradientItem&)rSet.Get(XATTR_FILLGRADIENT)).GetGradientValue();
 370             Color aCol1(rGrad.GetStartColor());
 371             Color aCol2(rGrad.GetEndColor());
 372             const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
 373             rCol = Color(aAverageColor);
 374             bRetval = true;
 375
 376             break;
 377         }
 378         case XFILL_BITMAP:
 379         {
 380             const Bitmap& rBitmap = ((XFillBitmapItem&)rSet.Get(XATTR_FILLBITMAP)).GetBitmapValue().GetBitmap();
 381             const Size aSize(rBitmap.GetSizePixel());
 382             const sal_uInt32 nWidth = aSize.Width();
 383             const sal_uInt32 nHeight = aSize.Height();
 384             Bitmap aBitmap(rBitmap);
 385             BitmapReadAccess* pAccess = aBitmap.AcquireReadAccess();
 386
 387             if(pAccess && nWidth > 0 && nHeight > 0)
 388             {
 389                 sal_uInt32 nRt(0L);
 390                 sal_uInt32 nGn(0L);
 391                 sal_uInt32 nBl(0L);
 392                 const sal_uInt32 nMaxSteps(8L);
 393                 const sal_uInt32 nXStep((nWidth > nMaxSteps) ? nWidth / nMaxSteps : 1L);
 394                 const sal_uInt32 nYStep((nHeight > nMaxSteps) ? nHeight / nMaxSteps : 1L);
 395                 sal_uInt32 nAnz(0L);
 396
 397                 for(sal_uInt32 nY(0L); nY < nHeight; nY += nYStep)
 398                 {
 399                     for(sal_uInt32 nX(0L); nX < nWidth; nX += nXStep)
 400                     {
 401                         const BitmapColor& rCol2 = (pAccess->HasPalette())
 402                             ? pAccess->GetPaletteColor((sal_uInt8)pAccess->GetPixel(nY, nX))
 403                             : pAccess->GetPixel(nY, nX);
 404
 405                         nRt += rCol2.GetRed();
 406                         nGn += rCol2.GetGreen();
 407                         nBl += rCol2.GetBlue();
 408                         nAnz++;
 409                     }
 410                 }
 411
 412                 nRt /= nAnz;
 413                 nGn /= nAnz;
 414                 nBl /= nAnz;
 415
 416                 rCol = Color(sal_uInt8(nRt), sal_uInt8(nGn), sal_uInt8(nBl));
 417
 418                 bRetval = true;
 419             }
 420
 421             if(pAccess)
 422             {
 423                 aBitmap.ReleaseAccess(pAccess);
 424             }
 425
 426             break;
 427         }
 428         default: break;
 429     }
 430
 431     return bRetval;
 432 }
 433
 434 ////////////////////////////////////////////////////////////////////////////////////////////////////
 435
 436 SdrEngineDefaults::SdrEngineDefaults():
 437     aFontName( OutputDevice::GetDefaultFont( DEFAULTFONT_SERIF, LANGUAGE_SYSTEM, DEFAULTFONT_FLAGS_ONLYONE ).GetName() ),
 438     eFontFamily(FAMILY_ROMAN),
 439     aFontColor(COL_AUTO),
 440     nFontHeight(847),             // 847/100mm = ca. 24 Point
 441     eMapUnit(MAP_100TH_MM),
 442     aMapFraction(1,1)
 443 {
 444 }
 445
 446 SdrEngineDefaults& SdrEngineDefaults::GetDefaults()
 447 {
 448     SdrGlobalData& rGlobalData=GetSdrGlobalData();
 449     if (rGlobalData.pDefaults==NULL) {
 450         rGlobalData.pDefaults=new SdrEngineDefaults;
 451     }
 452     return *rGlobalData.pDefaults;
 453 }
 454
 455 ////////////////////////////////////////////////////////////////////////////////////////////////////
 456
 457 SdrOutliner* SdrMakeOutliner( sal_uInt16 nOutlinerMode, SdrModel* pModel )
 458 {
 459     SfxItemPool* pPool = &pModel->GetItemPool();
 460     SdrOutliner* pOutl = new SdrOutliner( pPool, nOutlinerMode );
 461     pOutl->SetEditTextObjectPool( pPool );
 462     pOutl->SetStyleSheetPool( (SfxStyleSheetPool*) pModel->GetStyleSheetPool() );
 463     pOutl->SetDefTab( pModel->GetDefaultTabulator() );
 464     pOutl->SetForbiddenCharsTable( pModel->GetForbiddenCharsTable() );
 465     pOutl->SetAsianCompressionMode( pModel->GetCharCompressType() );
 466     pOutl->SetKernAsianPunctuation( pModel->IsKernAsianPunctuation() );
 467     pOutl->SetAddExtLeading( pModel->IsAddExtLeading() );
 468
 469     return pOutl;
 470 }
 471
 472 ////////////////////////////////////////////////////////////////////////////////////////////////////
 473
 474
 475 SdrLinkList& ImpGetUserMakeObjHdl()
 476 {
 477     SdrGlobalData& rGlobalData=GetSdrGlobalData();
 478     return rGlobalData.aUserMakeObjHdl;
 479 }
 480
 481 SdrLinkList& ImpGetUserMakeObjUserDataHdl()
 482 {
 483     SdrGlobalData& rGlobalData=GetSdrGlobalData();
 484     return rGlobalData.aUserMakeObjUserDataHdl;
 485 }
 486
 487 ////////////////////////////////////////////////////////////////////////////////////////////////////
 488
 489 ResMgr* ImpGetResMgr()
 490 {
 491     SdrGlobalData& rGlobalData = GetSdrGlobalData();
 492
 493     if(!rGlobalData.pResMgr)
 494     {
 495         rGlobalData.pResMgr =
 496             ResMgr::CreateResMgr( "svx", Application::GetSettings().GetUILocale() );
 497     }
 498
 499     return rGlobalData.pResMgr;
 500 }
 501
 502 ////////////////////////////////////////////////////////////////////////////////////////////////////
 503
 504 String ImpGetResStr(sal_uInt16 nResID)
 505 {
 506     return String(ResId(nResID, *ImpGetResMgr()));
 507 }
 508
 509 ////////////////////////////////////////////////////////////////////////////////////////////////////
 510
 511 namespace sdr
 512 {
 513 String GetResourceString(sal_uInt16 nResID)
 514 {
 515     return ImpGetResStr( nResID );
 516 }
 517 }
 518
 519 ////////////////////////////////////////////////////////////////////////////////////////////////////
 520
 521 sal_Bool SearchOutlinerItems(const SfxItemSet& rSet, sal_Bool bInklDefaults, sal_Bool* pbOnlyEE)
 522 {
 523     sal_Bool bHas=sal_False;
 524     sal_Bool bOnly=sal_True;
 525     sal_Bool bLookOnly=pbOnlyEE!=NULL;
 526     SfxWhichIter aIter(rSet);
 527     sal_uInt16 nWhich=aIter.FirstWhich();
 528     while (((bLookOnly && bOnly) || !bHas) && nWhich!=0) {
 529         // For bInklDefaults, the entire Which range is decisive,
 530         // in other cases only the set items are.
 531         // Disabled and DontCare are regarded as holes in the Which range.
 532         SfxItemState eState=rSet.GetItemState(nWhich);
 533         if ((eState==SFX_ITEM_DEFAULT && bInklDefaults) || eState==SFX_ITEM_SET) {
 534             if (nWhich<EE_ITEMS_START || nWhich>EE_ITEMS_END) bOnly=sal_False;
 535             else bHas=sal_True;
 536         }
 537         nWhich=aIter.NextWhich();
 538     }
 539     if (!bHas) bOnly=sal_False;
 540     if (pbOnlyEE!=NULL) *pbOnlyEE=bOnly;
 541     return bHas;
 542 }
 543
 544 sal_uInt16* RemoveWhichRange(const sal_uInt16* pOldWhichTable, sal_uInt16 nRangeBeg, sal_uInt16 nRangeEnd)
 545 {
 546     // Six possible cases (per range):
 547     //         [Beg..End]          Range, to delete
 548     // [b..e]    [b..e]    [b..e]  Cases 1,3,2: doesn't matter, delete, doesn't matter  + Ranges
 549     // [b........e]  [b........e]  Cases 4,5  : shrink range                            | in
 550     // [b......................e]  Case  6    : splitting                               + pOldWhichTable
 551     sal_uInt16 nAnz=0;
 552     while (pOldWhichTable[nAnz]!=0) nAnz++;
 553     nAnz++; // nAnz should now be an odd number (0 for end of array)
 554     DBG_ASSERT((nAnz&1)==1,"RemoveWhichRange: WhichTable doesn't have an odd number of entries.");
 555     sal_uInt16 nAlloc=nAnz;
 556     // check necessary size of new array
 557     sal_uInt16 nNum=nAnz-1;
 558     while (nNum!=0) {
 559         nNum-=2;
 560         sal_uInt16 nBeg=pOldWhichTable[nNum];
 561         sal_uInt16 nEnd=pOldWhichTable[nNum+1];
 562         if (nEnd<nRangeBeg)  /*nCase=1*/ ;
 563         else if (nBeg>nRangeEnd) /* nCase=2 */ ;
 564         else if (nBeg>=nRangeBeg && nEnd<=nRangeEnd) /* nCase=3 */ nAlloc-=2;
 565         else if (nEnd<=nRangeEnd) /* nCase=4 */;
 566         else if (nBeg>=nRangeBeg) /* nCase=5*/ ;
 567         else /* nCase=6 */ nAlloc+=2;
 568     }
 569
 570     sal_uInt16* pNewWhichTable=new sal_uInt16[nAlloc];
 571     memcpy(pNewWhichTable,pOldWhichTable,nAlloc*sizeof(sal_uInt16));
 572     pNewWhichTable[nAlloc-1]=0; // in case 3, there's no 0 at the end.
 573     // now remove the unwanted ranges
 574     nNum=nAlloc-1;
 575     while (nNum!=0) {
 576         nNum-=2;
 577         sal_uInt16 nBeg=pNewWhichTable[nNum];
 578         sal_uInt16 nEnd=pNewWhichTable[nNum+1];
 579         unsigned nCase=0;
 580         if (nEnd<nRangeBeg) nCase=1;
 581         else if (nBeg>nRangeEnd) nCase=2;
 582         else if (nBeg>=nRangeBeg && nEnd<=nRangeEnd) nCase=3;
 583         else if (nEnd<=nRangeEnd) nCase=4;
 584         else if (nBeg>=nRangeBeg) nCase=5;
 585         else nCase=6;
 586         switch (nCase) {
 587             case 3: {
 588                 unsigned nTailBytes=(nAnz-(nNum+2))*sizeof(sal_uInt16);
 589                 memcpy(&pNewWhichTable[nNum],&pNewWhichTable[nNum+2],nTailBytes);
 590                 nAnz-=2; // remember: array is now smaller
 591             } break;
 592             case 4: pNewWhichTable[nNum+1]=nRangeBeg-1; break;
 593             case 5: pNewWhichTable[nNum]=nRangeEnd+1;     break;
 594             case 6: {
 595                 unsigned nTailBytes=(nAnz-(nNum+2))*sizeof(sal_uInt16);
 596                 memcpy(&pNewWhichTable[nNum+4],&pNewWhichTable[nNum+2],nTailBytes);
 597                 nAnz+=2; // remember:array is now larger
 598                 pNewWhichTable[nNum+2]=nRangeEnd+1;
 599                 pNewWhichTable[nNum+3]=pNewWhichTable[nNum+1];
 600                 pNewWhichTable[nNum+1]=nRangeBeg-1;
 601             } break;
 602         } // switch
 603     }
 604     return pNewWhichTable;
 605 }
 606
 607 ////////////////////////////////////////////////////////////////////////////////////////////////////
 608
 609 SvdProgressInfo::SvdProgressInfo( Link *_pLink )
 610 {
 611     DBG_ASSERT(_pLink!=NULL,"SvdProgressInfo(): No Link stated!");
 612
 613     pLink = _pLink;
 614     nSumActionCount = 0;
 615     nSumCurAction   = 0;
 616
 617     nObjCount = 0;
 618     nCurObj   = 0;
 619
 620     nActionCount = 0;
 621     nCurAction   = 0;
 622
 623     nInsertCount = 0;
 624     nCurInsert   = 0;
 625 }
 626
 627 void SvdProgressInfo::Init( sal_uIntPtr _nSumActionCount, sal_uIntPtr _nObjCount )
 628 {
 629     nSumActionCount = _nSumActionCount;
 630     nObjCount = _nObjCount;
 631 }
 632
 633 sal_Bool SvdProgressInfo::ReportActions( sal_uIntPtr nAnzActions )
 634 {
 635     nSumCurAction += nAnzActions;
 636     nCurAction += nAnzActions;
 637     if(nCurAction > nActionCount)
 638         nCurAction = nActionCount;
 639
 640     return pLink->Call(NULL) == 1L;
 641 }
 642
 643 sal_Bool SvdProgressInfo::ReportInserts( sal_uIntPtr nAnzInserts )
 644 {
 645     nSumCurAction += nAnzInserts;
 646     nCurInsert += nAnzInserts;
 647
 648     return pLink->Call(NULL) == 1L;
 649 }
 650
 651 sal_Bool SvdProgressInfo::ReportRescales( sal_uIntPtr nAnzRescales )
 652 {
 653     nSumCurAction += nAnzRescales;
 654     return pLink->Call(NULL) == 1L;
 655 }
 656
 657 void SvdProgressInfo::SetActionCount( sal_uIntPtr _nActionCount )
 658 {
 659     nActionCount = _nActionCount;
 660 }
 661
 662 void SvdProgressInfo::SetInsertCount( sal_uIntPtr _nInsertCount )
 663 {
 664     nInsertCount = _nInsertCount;
 665 }
 666
 667 sal_Bool SvdProgressInfo::SetNextObject()
 668 {
 669     nActionCount = 0;
 670     nCurAction   = 0;
 671
 672     nInsertCount = 0;
 673     nCurInsert   = 0;
 674
 675     nCurObj++;
 676     return ReportActions(0);
 677 }
 678
 679 void SvdProgressInfo::ReportError()
 680 {
 681     pLink->Call((void *)1L);
 682 }
 683
 684 ////////////////////////////////////////////////////////////////////////////////////////////////////
 685 // #i101872# isolate GetTextEditBackgroundColor to tooling; it will anyways only be used as long
 686 // as text edit is not running on overlay
 687
 688 namespace
 689 {
 690     bool impGetSdrObjListFillColor(
 691         const SdrObjList& rList,
 692         const Point& rPnt,
 693         const SdrPageView& rTextEditPV,
 694         const SetOfByte& rVisLayers,
 695         Color& rCol)
 696     {
 697         if(!rList.GetModel())
 698             return false;
 699
 700         bool bRet(false);
 701         bool bMaster(rList.GetPage() ? rList.GetPage()->IsMasterPage() : false);
 702
 703         for(sal_uIntPtr no(rList.GetObjCount()); !bRet && no > 0; )
 704         {
 705             no--;
 706             SdrObject* pObj = rList.GetObj(no);
 707             SdrObjList* pOL = pObj->GetSubList();
 708
 709             if(pOL)
 710             {
 711                 // group object
 712                 bRet = impGetSdrObjListFillColor(*pOL, rPnt, rTextEditPV, rVisLayers, rCol);
 713             }
 714             else
 715             {
 716                 SdrTextObj* pText = dynamic_cast< SdrTextObj * >(pObj);
 717
 718                 // Exclude zero master page object (i.e. background shape) from color query
 719                 if(pText
 720                     && pObj->IsClosedObj()
 721                     && (!bMaster || (!pObj->IsNotVisibleAsMaster() && 0 != no))
 722                     && pObj->GetCurrentBoundRect().IsInside(rPnt)
 723                     && !pText->IsHideContour()
 724                     && SdrObjectPrimitiveHit(*pObj, rPnt, 0, rTextEditPV, &rVisLayers, false))
 725                 {
 726                     bRet = GetDraftFillColor(pObj->GetMergedItemSet(), rCol);
 727                 }
 728             }
 729         }
 730
 731         return bRet;
 732     }
 733
 734     bool impGetSdrPageFillColor(
 735         const SdrPage& rPage,
 736         const Point& rPnt,
 737         const SdrPageView& rTextEditPV,
 738         const SetOfByte& rVisLayers,
 739         Color& rCol,
 740         bool bSkipBackgroundShape)
 741     {
 742         if(!rPage.GetModel())
 743             return false;
 744
 745         bool bRet(impGetSdrObjListFillColor(rPage, rPnt, rTextEditPV, rVisLayers, rCol));
 746
 747         if(!bRet && !rPage.IsMasterPage())
 748         {
 749             if(rPage.TRG_HasMasterPage())
 750             {
 751                 SetOfByte aSet(rVisLayers);
 752                 aSet &= rPage.TRG_GetMasterPageVisibleLayers();
 753                 SdrPage& rMasterPage = rPage.TRG_GetMasterPage();
 754
 755                 // Don't fall back to background shape on
 756                 // master pages. This is later handled by
 757                 // GetBackgroundColor, and is necessary to cater for
 758                 // the silly ordering: 1. shapes, 2. master page
 759                 // shapes, 3. page background, 4. master page
 760                 // background.
 761                 bRet = impGetSdrPageFillColor(rMasterPage, rPnt, rTextEditPV, aSet, rCol, true);
 762             }
 763         }
 764
 765         // Only now determine background color from background shapes
 766         if(!bRet && !bSkipBackgroundShape)
 767         {
 768             rCol = rPage.GetPageBackgroundColor();
 769             return true;
 770         }
 771
 772         return bRet;
 773     }
 774
 775     Color impCalcBackgroundColor(
 776         const Rectangle& rArea,
 777         const SdrPageView& rTextEditPV,
 778         const SdrPage& rPage)
 779     {
 780         svtools::ColorConfig aColorConfig;
 781         Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
 782         const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 783
 784         if(!rStyleSettings.GetHighContrastMode())
 785         {
 786             // search in page
 787             const sal_uInt16 SPOTCOUNT(5);
 788             Point aSpotPos[SPOTCOUNT];
 789             Color aSpotColor[SPOTCOUNT];
 790             sal_uIntPtr nHeight( rArea.GetSize().Height() );
 791             sal_uIntPtr nWidth( rArea.GetSize().Width() );
 792             sal_uIntPtr nWidth14  = nWidth / 4;
 793             sal_uIntPtr nHeight14 = nHeight / 4;
 794             sal_uIntPtr nWidth34  = ( 3 * nWidth ) / 4;
 795             sal_uIntPtr nHeight34 = ( 3 * nHeight ) / 4;
 796
 797             sal_uInt16 i;
 798             for ( i = 0; i < SPOTCOUNT; i++ )
 799             {
 800                 // five spots are used
 801                 switch ( i )
 802                 {
 803                     case 0 :
 804                     {
 805                         // Center-Spot
 806                         aSpotPos[i] = rArea.Center();
 807                     }
 808                     break;
 809
 810                     case 1 :
 811                     {
 812                         // TopLeft-Spot
 813                         aSpotPos[i] = rArea.TopLeft();
 814                         aSpotPos[i].X() += nWidth14;
 815                         aSpotPos[i].Y() += nHeight14;
 816                     }
 817                     break;
 818
 819                     case 2 :
 820                     {
 821                         // TopRight-Spot
 822                         aSpotPos[i] = rArea.TopLeft();
 823                         aSpotPos[i].X() += nWidth34;
 824                         aSpotPos[i].Y() += nHeight14;
 825                     }
 826                     break;
 827
 828                     case 3 :
 829                     {
 830                         // BottomLeft-Spot
 831                         aSpotPos[i] = rArea.TopLeft();
 832                         aSpotPos[i].X() += nWidth14;
 833                         aSpotPos[i].Y() += nHeight34;
 834                     }
 835                     break;
 836
 837                     case 4 :
 838                     {
 839                         // BottomRight-Spot
 840                         aSpotPos[i] = rArea.TopLeft();
 841                         aSpotPos[i].X() += nWidth34;
 842                         aSpotPos[i].Y() += nHeight34;
 843                     }
 844                     break;
 845
 846                 }
 847
 848                 aSpotColor[i] = Color( COL_WHITE );
 849                 impGetSdrPageFillColor(rPage, aSpotPos[i], rTextEditPV, rTextEditPV.GetVisibleLayers(), aSpotColor[i], false);
 850             }
 851
 852             sal_uInt16 aMatch[SPOTCOUNT];
 853
 854             for ( i = 0; i < SPOTCOUNT; i++ )
 855             {
 856                 // were same spot colors found?
 857                 aMatch[i] = 0;
 858
 859                 for ( sal_uInt16 j = 0; j < SPOTCOUNT; j++ )
 860                 {
 861                     if( j != i )
 862                     {
 863                         if( aSpotColor[i] == aSpotColor[j] )
 864                         {
 865                             aMatch[i]++;
 866                         }
 867                     }
 868                 }
 869             }
 870
 871             // highest weight to center spot
 872             aBackground = aSpotColor[0];
 873
 874             for ( sal_uInt16 nMatchCount = SPOTCOUNT - 1; nMatchCount > 1; nMatchCount-- )
 875             {
 876                 // which spot color was found most?
 877                 for ( i = 0; i < SPOTCOUNT; i++ )
 878                 {
 879                     if( aMatch[i] == nMatchCount )
 880                     {
 881                         aBackground = aSpotColor[i];
 882                         nMatchCount = 1;   // break outer for-loop
 883                         break;
 884                     }
 885                 }
 886             }
 887         }
 888
 889         return aBackground;
 890     }
 891 } // end of anonymous namespace
 892
 893 Color GetTextEditBackgroundColor(const SdrObjEditView& rView)
 894 {
 895     svtools::ColorConfig aColorConfig;
 896     Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
 897     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 898
 899     if(!rStyleSettings.GetHighContrastMode())
 900     {
 901         bool bFound(false);
 902         SdrTextObj* pText = dynamic_cast< SdrTextObj * >(rView.GetTextEditObject());
 903
 904         if(pText && pText->IsClosedObj())
 905         {
 906             ::sdr::table::SdrTableObj* pTable = dynamic_cast< ::sdr::table::SdrTableObj * >( pText );
 907
 908             if( pTable )
 909                 bFound = GetDraftFillColor(pTable->GetActiveCellItemSet(), aBackground );
 910
 911             if( !bFound )
 912                 bFound=GetDraftFillColor(pText->GetMergedItemSet(), aBackground);
 913         }
 914
 915         if(!bFound && pText)
 916         {
 917             SdrPageView* pTextEditPV = rView.GetTextEditPageView();
 918
 919             if(pTextEditPV)
 920             {
 921                 Point aPvOfs(pText->GetTextEditOffset());
 922                 const SdrPage* pPg = pTextEditPV->GetPage();
 923
 924                 if(pPg)
 925                 {
 926                     Rectangle aSnapRect( pText->GetSnapRect() );
 927                     aSnapRect.Move(aPvOfs.X(), aPvOfs.Y());
 928
 929                     return impCalcBackgroundColor(aSnapRect, *pTextEditPV, *pPg);
 930                 }
 931             }
 932         }
 933     }
 934
 935     return aBackground;
 936 }
 937
 938 ////////////////////////////////////////////////////////////////////////////////////////////////////
 939 // eof
 940
 941 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */