svx/source/svdraw/svdetc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <algorithm>
  23
  24 #include <officecfg/Office/Common.hxx>
  25 #include <svtools/colorcfg.hxx>
  26 #include <svx/svdetc.hxx>
  27 #include <svx/svdedxv.hxx>
  28 #include <svx/svdmodel.hxx>
  29 #include <svx/svdoutl.hxx>
  30 #include <vcl/BitmapReadAccess.hxx>
  31 #include <editeng/eeitem.hxx>
  32 #include <svl/itemset.hxx>
  33 #include <svl/whiter.hxx>
  34 #include <svx/xfillit0.hxx>
  35 #include <svx/xflclit.hxx>
  36 #include <svx/xflhtit.hxx>
  37 #include <svx/xbtmpit.hxx>
  38 #include <svx/xflgrit.hxx>
  39 #include <svx/svdoole2.hxx>
  40 #include <svl/itempool.hxx>
  41 #include <unotools/configmgr.hxx>
  42 #include <unotools/localedatawrapper.hxx>
  43 #include <unotools/syslocale.hxx>
  44 #include <svx/xflbckit.hxx>
  45 #include <svx/extrusionbar.hxx>
  46 #include <svx/fontworkbar.hxx>
  47 #include <vcl/svapp.hxx>
  48 #include <vcl/settings.hxx>
  49 #include <svx/sdr/contact/viewcontact.hxx>
  50 #include <svx/svdpage.hxx>
  51 #include <svx/svdpagv.hxx>
  52 #include <svx/svdotable.hxx>
  53 #include <svx/sdrhittesthelper.hxx>
  54
  55 #include <com/sun/star/frame/XModel.hpp>
  56 #include <com/sun/star/embed/XEmbeddedObject.hpp>
  57
  58 using namespace ::com::sun::star;
  59
  60 // Global data of the DrawingEngine
  61 SdrGlobalData::SdrGlobalData()
  62 {
  63     if (!utl::ConfigManager::IsFuzzing())
  64     {
  65         svx::ExtrusionBar::RegisterInterface();
  66         svx::FontworkBar::RegisterInterface();
  67     }
  68 }
  69
  70 const LocaleDataWrapper& SdrGlobalData::GetLocaleData()
  71 {
  72     return GetSysLocale().GetLocaleData();
  73 }
  74
  75 namespace {
  76
  77 struct TheSdrGlobalData: public rtl::Static<SdrGlobalData, TheSdrGlobalData> {};
  78
  79 }
  80
  81 SdrGlobalData & GetSdrGlobalData() {
  82     return TheSdrGlobalData::get();
  83 }
  84
  85 OLEObjCache::OLEObjCache()
  86 {
  87     if (!utl::ConfigManager::IsFuzzing())
  88     {
  89 // This limit is only useful on 32-bit windows, where we can run out of virtual memory (see tdf#95579)
  90 // For everything else, we are better off keeping it in main memory rather than using our hacky page-out thing
  91 #if defined _WIN32 && !defined _WIN64
  92         nSize = officecfg::Office::Common::Cache::DrawingEngine::OLE_Objects::get();
  93 #else
  94         nSize = SAL_MAX_INT32; // effectively disable the page-out mechanism
  95 #endif
  96     }
  97     else
  98         nSize = 100;
  99     pTimer.reset( new AutoTimer( "svx OLEObjCache pTimer UnloadCheck" ) );
 100     pTimer->SetInvokeHandler( LINK(this, OLEObjCache, UnloadCheckHdl) );
 101     pTimer->SetTimeout(20000);
 102     pTimer->SetStatic();
 103 }
 104
 105 OLEObjCache::~OLEObjCache()
 106 {
 107     pTimer->Stop();
 108 }
 109
 110 IMPL_LINK_NOARG(OLEObjCache, UnloadCheckHdl, Timer*, void)
 111 {
 112     if (nSize >= maObjs.size())
 113         return;
 114
 115     // more objects than configured cache size try to remove objects
 116     // of course not the freshly inserted one at nIndex=0
 117     size_t nCount2 = maObjs.size();
 118     size_t nIndex = nCount2-1;
 119     while( nIndex && nCount2 > nSize )
 120     {
 121         SdrOle2Obj* pUnloadObj = maObjs[nIndex--];
 122         if (!pUnloadObj)
 123             continue;
 124
 125         try
 126         {
 127             // it is important to get object without reinitialization to avoid reentrance
 128             const uno::Reference< embed::XEmbeddedObject > & xUnloadObj = pUnloadObj->GetObjRef_NoInit();
 129
 130             bool bUnload = !xUnloadObj || SdrOle2Obj::CanUnloadRunningObj( xUnloadObj, pUnloadObj->GetAspect() );
 131
 132             // check whether the object can be unloaded before looking for the parent objects
 133             if ( xUnloadObj.is() && bUnload )
 134             {
 135                 uno::Reference< frame::XModel > xUnloadModel( xUnloadObj->getComponent(), uno::UNO_QUERY );
 136                 if ( xUnloadModel.is() )
 137                 {
 138                     for (SdrOle2Obj* pCacheObj : maObjs)
 139                     {
 140                         if ( pCacheObj && pCacheObj != pUnloadObj )
 141                         {
 142                             uno::Reference< frame::XModel > xParentModel = pCacheObj->GetParentXModel();
 143                             if ( xUnloadModel == xParentModel )
 144                             {
 145                                 bUnload = false; // the object has running embedded objects
 146                                 break;
 147                             }
 148                         }
 149                     }
 150                 }
 151             }
 152
 153             if (bUnload && UnloadObj(*pUnloadObj))
 154             {
 155                 // object was successfully unloaded
 156                 RemoveObj(pUnloadObj);
 157                 nCount2 = std::min(nCount2 - 1, maObjs.size());
 158                 if (nIndex >= nCount2)
 159                     nIndex = nCount2 - 1;
 160             }
 161         }
 162         catch( uno::Exception& )
 163         {}
 164     }
 165 }
 166
 167 void OLEObjCache::InsertObj(SdrOle2Obj* pObj)
 168 {
 169     if (!maObjs.empty())
 170     {
 171         SdrOle2Obj* pExistingObj = maObjs.front();
 172         if ( pObj == pExistingObj )
 173             // the object is already on the top, nothing has to be changed
 174             return;
 175     }
 176
 177     // get the old position of the object to know whether it is already in container
 178     std::vector<SdrOle2Obj*>::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj);
 179     bool bFound = it != maObjs.end();
 180
 181     if (bFound)
 182         maObjs.erase(it);
 183     // insert object into first position
 184     maObjs.insert(maObjs.begin(), pObj);
 185
 186     // if a new object was inserted, recalculate the cache
 187     if (!bFound)
 188         pTimer->Invoke();
 189
 190     if (!bFound || !pTimer->IsActive())
 191         pTimer->Start();
 192 }
 193
 194 void OLEObjCache::RemoveObj(SdrOle2Obj* pObj)
 195 {
 196     std::vector<SdrOle2Obj*>::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj);
 197     if (it != maObjs.end())
 198         maObjs.erase(it);
 199     if (maObjs.empty())
 200         pTimer->Stop();
 201 }
 202
 203 size_t OLEObjCache::size() const
 204 {
 205     return maObjs.size();
 206 }
 207
 208 SdrOle2Obj* OLEObjCache::operator[](size_t nPos)
 209 {
 210     return maObjs[nPos];
 211 }
 212
 213 const SdrOle2Obj* OLEObjCache::operator[](size_t nPos) const
 214 {
 215     return maObjs[nPos];
 216 }
 217
 218 bool OLEObjCache::UnloadObj(SdrOle2Obj& rObj)
 219 {
 220     bool bUnloaded = false;
 221
 222     //#i80528# The old mechanism is completely useless, only taking into account if
 223     // in all views the GrafDraft feature is used. This will nearly never have been the
 224     // case since no one ever used this option.
 225
 226     // A much better (and working) criteria would be the VOC contact count.
 227     // The question is what will happen when i make it work now suddenly? I
 228     // will try it for 2.4.
 229     const sdr::contact::ViewContact& rViewContact = rObj.GetViewContact();
 230     const bool bVisible(rViewContact.HasViewObjectContacts());
 231
 232     if(!bVisible)
 233     {
 234         bUnloaded = rObj.Unload();
 235     }
 236
 237     return bUnloaded;
 238 }
 239
 240 bool GetDraftFillColor(const SfxItemSet& rSet, Color& rCol)
 241 {
 242     drawing::FillStyle eFill=rSet.Get(XATTR_FILLSTYLE).GetValue();
 243     bool bRetval = false;
 244
 245     switch(eFill)
 246     {
 247         case drawing::FillStyle_SOLID:
 248         {
 249             rCol = rSet.Get(XATTR_FILLCOLOR).GetColorValue();
 250             bRetval = true;
 251
 252             break;
 253         }
 254         case drawing::FillStyle_HATCH:
 255         {
 256             Color aCol1(rSet.Get(XATTR_FILLHATCH).GetHatchValue().GetColor());
 257             Color aCol2(COL_WHITE);
 258
 259             // when hatched background is activated, use object fill color as hatch color
 260             bool bFillHatchBackground = rSet.Get(XATTR_FILLBACKGROUND).GetValue();
 261             if(bFillHatchBackground)
 262             {
 263                 aCol2 = rSet.Get(XATTR_FILLCOLOR).GetColorValue();
 264             }
 265
 266             const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
 267             rCol = Color(aAverageColor);
 268             bRetval = true;
 269
 270             break;
 271         }
 272         case drawing::FillStyle_GRADIENT: {
 273             const basegfx::BGradient& rGrad=rSet.Get(XATTR_FILLGRADIENT).GetGradientValue();
 274             Color aCol1(Color(rGrad.GetColorStops().front().getStopColor()));
 275             Color aCol2(Color(rGrad.GetColorStops().back().getStopColor()));
 276             const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
 277             rCol = Color(aAverageColor);
 278             bRetval = true;
 279
 280             break;
 281         }
 282         case drawing::FillStyle_BITMAP:
 283         {
 284             Bitmap aBitmap(rSet.Get(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic().GetBitmapEx().GetBitmap());
 285             const Size aSize(aBitmap.GetSizePixel());
 286             const sal_uInt32 nWidth = aSize.Width();
 287             const sal_uInt32 nHeight = aSize.Height();
 288             if (nWidth <= 0 || nHeight <= 0)
 289                 return bRetval;
 290
 291             Bitmap::ScopedReadAccess pAccess(aBitmap);
 292
 293             if (pAccess)
 294             {
 295                 sal_uInt32 nRt(0);
 296                 sal_uInt32 nGn(0);
 297                 sal_uInt32 nBl(0);
 298                 const sal_uInt32 nMaxSteps(8);
 299                 const sal_uInt32 nXStep((nWidth > nMaxSteps) ? nWidth / nMaxSteps : 1);
 300                 const sal_uInt32 nYStep((nHeight > nMaxSteps) ? nHeight / nMaxSteps : 1);
 301                 sal_uInt32 nCount(0);
 302
 303                 for(sal_uInt32 nY(0); nY < nHeight; nY += nYStep)
 304                 {
 305                     for(sal_uInt32 nX(0); nX < nWidth; nX += nXStep)
 306                     {
 307                         const BitmapColor& rCol2 = pAccess->GetColor(nY, nX);
 308
 309                         nRt += rCol2.GetRed();
 310                         nGn += rCol2.GetGreen();
 311                         nBl += rCol2.GetBlue();
 312                         nCount++;
 313                     }
 314                 }
 315
 316                 nRt /= nCount;
 317                 nGn /= nCount;
 318                 nBl /= nCount;
 319
 320                 rCol = Color(sal_uInt8(nRt), sal_uInt8(nGn), sal_uInt8(nBl));
 321
 322                 bRetval = true;
 323             }
 324             break;
 325         }
 326         default: break;
 327     }
 328
 329     return bRetval;
 330 }
 331
 332 std::unique_ptr<SdrOutliner> SdrMakeOutliner(OutlinerMode nOutlinerMode, SdrModel& rModel)
 333 {
 334     SfxItemPool* pPool = &rModel.GetItemPool();
 335     std::unique_ptr<SdrOutliner> pOutl(new SdrOutliner( pPool, nOutlinerMode ));
 336     pOutl->SetEditTextObjectPool( pPool );
 337     pOutl->SetStyleSheetPool( static_cast<SfxStyleSheetPool*>(rModel.GetStyleSheetPool()));
 338     pOutl->SetDefTab(rModel.GetDefaultTabulator());
 339     Outliner::SetForbiddenCharsTable(rModel.GetForbiddenCharsTable());
 340     pOutl->SetAsianCompressionMode(rModel.GetCharCompressType());
 341     pOutl->SetKernAsianPunctuation(rModel.IsKernAsianPunctuation());
 342     pOutl->SetAddExtLeading(rModel.IsAddExtLeading());
 343     return pOutl;
 344 }
 345
 346 std::vector<Link<SdrObjCreatorParams, rtl::Reference<SdrObject>>>& ImpGetUserMakeObjHdl()
 347 {
 348     SdrGlobalData& rGlobalData=GetSdrGlobalData();
 349     return rGlobalData.aUserMakeObjHdl;
 350 }
 351
 352 bool SearchOutlinerItems(const SfxItemSet& rSet, bool bInklDefaults, bool* pbOnlyEE)
 353 {
 354     bool bHas=false;
 355     bool bOnly=true;
 356     bool bLookOnly=pbOnlyEE!=nullptr;
 357     SfxWhichIter aIter(rSet);
 358     sal_uInt16 nWhich=aIter.FirstWhich();
 359     while (((bLookOnly && bOnly) || !bHas) && nWhich!=0) {
 360         // For bInklDefaults, the entire Which range is decisive,
 361         // in other cases only the set items are.
 362         // Disabled and DontCare are regarded as holes in the Which range.
 363         SfxItemState eState=aIter.GetItemState();
 364         if ((eState==SfxItemState::DEFAULT && bInklDefaults) || eState==SfxItemState::SET) {
 365             if (nWhich<EE_ITEMS_START || nWhich>EE_ITEMS_END) bOnly=false;
 366             else bHas=true;
 367         }
 368         nWhich=aIter.NextWhich();
 369     }
 370     if (!bHas) bOnly=false;
 371     if (pbOnlyEE!=nullptr) *pbOnlyEE=bOnly;
 372     return bHas;
 373 }
 374
 375 WhichRangesContainer RemoveWhichRange(const WhichRangesContainer& pOldWhichTable, sal_uInt16 nRangeBeg, sal_uInt16 nRangeEnd)
 376 {
 377     // Six possible cases (per range):
 378     //         [Beg..End]          [nRangeBeg, nRangeEnd], to delete
 379     // [b..e]    [b..e]    [b..e]  Cases 1,3,2: doesn't matter, delete, doesn't matter  + Ranges
 380     // [b........e]  [b........e]  Cases 4,5  : shrink range                            | in
 381     // [b......................e]  Case  6    : splitting                               + pOldWhichTable
 382     std::vector<WhichPair> buf;
 383     for (const auto & rPair : pOldWhichTable) {
 384         auto const begin = rPair.first;
 385         auto const end = rPair.second;
 386         if (end < nRangeBeg || begin > nRangeEnd) { // cases 1, 2
 387             buf.push_back({begin, end});
 388         } else if (begin >= nRangeBeg && end <= nRangeEnd) { // case 3
 389             // drop
 390         } else if (end <= nRangeEnd) { // case 4
 391             buf.push_back({begin, nRangeBeg - 1});
 392         } else if (begin >= nRangeBeg) { // case 5
 393             buf.push_back({nRangeEnd + 1, end});
 394         } else { // case 6
 395             buf.push_back({begin, nRangeBeg - 1});
 396             buf.push_back({nRangeEnd + 1, end});
 397         }
 398     }
 399     std::unique_ptr<WhichPair[]> pNewWhichTable(new WhichPair[buf.size()]);
 400     std::copy(buf.begin(), buf.end(), pNewWhichTable.get());
 401     return WhichRangesContainer(std::move(pNewWhichTable), buf.size());
 402 }
 403
 404
 405 SvdProgressInfo::SvdProgressInfo( const Link<void*,bool>&_rLink )
 406 {
 407     maLink = _rLink;
 408     m_nSumCurAction   = 0;
 409
 410     m_nObjCount = 0;
 411     m_nCurObj   = 0;
 412
 413     m_nActionCount = 0;
 414     m_nCurAction   = 0;
 415
 416     m_nInsertCount = 0;
 417     m_nCurInsert   = 0;
 418 }
 419
 420 void SvdProgressInfo::Init( size_t nObjCount )
 421 {
 422     m_nObjCount = nObjCount;
 423 }
 424
 425 bool SvdProgressInfo::ReportActions( size_t nActionCount )
 426 {
 427     m_nSumCurAction += nActionCount;
 428     m_nCurAction += nActionCount;
 429     if(m_nCurAction > m_nActionCount)
 430         m_nCurAction = m_nActionCount;
 431
 432     return maLink.Call(nullptr);
 433 }
 434
 435 void SvdProgressInfo::ReportInserts( size_t nInsertCount )
 436 {
 437     m_nSumCurAction += nInsertCount;
 438     m_nCurInsert += nInsertCount;
 439
 440     maLink.Call(nullptr);
 441 }
 442
 443 void SvdProgressInfo::ReportRescales( size_t nRescaleCount )
 444 {
 445     m_nSumCurAction += nRescaleCount;
 446     maLink.Call(nullptr);
 447 }
 448
 449 void SvdProgressInfo::SetActionCount( size_t nActionCount )
 450 {
 451     m_nActionCount = nActionCount;
 452 }
 453
 454 void SvdProgressInfo::SetInsertCount( size_t nInsertCount )
 455 {
 456     m_nInsertCount = nInsertCount;
 457 }
 458
 459 void SvdProgressInfo::SetNextObject()
 460 {
 461     m_nActionCount = 0;
 462     m_nCurAction   = 0;
 463
 464     m_nInsertCount = 0;
 465     m_nCurInsert   = 0;
 466
 467     m_nCurObj++;
 468     ReportActions(0);
 469 }
 470
 471 // #i101872# isolate GetTextEditBackgroundColor to tooling; it will anyways only be used as long
 472 // as text edit is not running on overlay
 473
 474 namespace
 475 {
 476     bool impGetSdrObjListFillColor(
 477         const SdrObjList& rList,
 478         const Point& rPnt,
 479         const SdrPageView& rTextEditPV,
 480         const SdrLayerIDSet& rVisLayers,
 481         Color& rCol)
 482     {
 483         bool bRet(false);
 484         bool bMaster(rList.getSdrPageFromSdrObjList() && rList.getSdrPageFromSdrObjList()->IsMasterPage());
 485
 486         for(size_t no(rList.GetObjCount()); !bRet && no > 0; )
 487         {
 488             no--;
 489             SdrObject* pObj = rList.GetObj(no);
 490             SdrObjList* pOL = pObj->GetSubList();
 491
 492             if(pOL)
 493             {
 494                 // group object
 495                 bRet = impGetSdrObjListFillColor(*pOL, rPnt, rTextEditPV, rVisLayers, rCol);
 496             }
 497             else
 498             {
 499                 SdrTextObj* pText = DynCastSdrTextObj(pObj);
 500
 501                 // Exclude zero master page object (i.e. background shape) from color query
 502                 if(pText
 503                     && pObj->IsClosedObj()
 504                     && (!bMaster || (!pObj->IsNotVisibleAsMaster() && 0 != no))
 505                     && pObj->GetCurrentBoundRect().Contains(rPnt)
 506                     && !pText->IsHideContour()
 507                     && SdrObjectPrimitiveHit(*pObj, rPnt, {0, 0}, rTextEditPV, &rVisLayers, false))
 508                 {
 509                     bRet = GetDraftFillColor(pObj->GetMergedItemSet(), rCol);
 510                 }
 511             }
 512         }
 513
 514         return bRet;
 515     }
 516
 517     bool impGetSdrPageFillColor(
 518         const SdrPage& rPage,
 519         const Point& rPnt,
 520         const SdrPageView& rTextEditPV,
 521         const SdrLayerIDSet& rVisLayers,
 522         Color& rCol,
 523         bool bSkipBackgroundShape)
 524     {
 525         bool bRet(impGetSdrObjListFillColor(rPage, rPnt, rTextEditPV, rVisLayers, rCol));
 526
 527         if(!bRet && !rPage.IsMasterPage())
 528         {
 529             if(rPage.TRG_HasMasterPage())
 530             {
 531                 SdrLayerIDSet aSet(rVisLayers);
 532                 aSet &= rPage.TRG_GetMasterPageVisibleLayers();
 533                 SdrPage& rMasterPage = rPage.TRG_GetMasterPage();
 534
 535                 // Don't fall back to background shape on
 536                 // master pages. This is later handled by
 537                 // GetBackgroundColor, and is necessary to cater for
 538                 // the silly ordering: 1. shapes, 2. master page
 539                 // shapes, 3. page background, 4. master page
 540                 // background.
 541                 bRet = impGetSdrPageFillColor(rMasterPage, rPnt, rTextEditPV, aSet, rCol, true);
 542             }
 543         }
 544
 545         // Only now determine background color from background shapes
 546         if(!bRet && !bSkipBackgroundShape)
 547         {
 548             rCol = rPage.GetPageBackgroundColor();
 549             return true;
 550         }
 551
 552         return bRet;
 553     }
 554
 555     Color impCalcBackgroundColor(
 556         const tools::Rectangle& rArea,
 557         const SdrPageView& rTextEditPV,
 558         const SdrPage& rPage)
 559     {
 560         svtools::ColorConfig aColorConfig;
 561         Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
 562         const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 563
 564         if(!rStyleSettings.GetHighContrastMode())
 565         {
 566             // search in page
 567             const sal_uInt16 SPOTCOUNT(5);
 568             Point aSpotPos[SPOTCOUNT];
 569             Color aSpotColor[SPOTCOUNT];
 570             sal_uInt32 nHeight( rArea.GetSize().Height() );
 571             sal_uInt32 nWidth( rArea.GetSize().Width() );
 572             sal_uInt32 nWidth14  = nWidth / 4;
 573             sal_uInt32 nHeight14 = nHeight / 4;
 574             sal_uInt32 nWidth34  = ( 3 * nWidth ) / 4;
 575             sal_uInt32 nHeight34 = ( 3 * nHeight ) / 4;
 576
 577             sal_uInt16 i;
 578             for ( i = 0; i < SPOTCOUNT; i++ )
 579             {
 580                 // five spots are used
 581                 switch ( i )
 582                 {
 583                     case 0 :
 584                     {
 585                         // Center-Spot
 586                         aSpotPos[i] = rArea.Center();
 587                     }
 588                     break;
 589
 590                     case 1 :
 591                     {
 592                         // TopLeft-Spot
 593                         aSpotPos[i] = rArea.TopLeft();
 594                         aSpotPos[i].AdjustX(nWidth14 );
 595                         aSpotPos[i].AdjustY(nHeight14 );
 596                     }
 597                     break;
 598
 599                     case 2 :
 600                     {
 601                         // TopRight-Spot
 602                         aSpotPos[i] = rArea.TopLeft();
 603                         aSpotPos[i].AdjustX(nWidth34 );
 604                         aSpotPos[i].AdjustY(nHeight14 );
 605                     }
 606                     break;
 607
 608                     case 3 :
 609                     {
 610                         // BottomLeft-Spot
 611                         aSpotPos[i] = rArea.TopLeft();
 612                         aSpotPos[i].AdjustX(nWidth14 );
 613                         aSpotPos[i].AdjustY(nHeight34 );
 614                     }
 615                     break;
 616
 617                     case 4 :
 618                     {
 619                         // BottomRight-Spot
 620                         aSpotPos[i] = rArea.TopLeft();
 621                         aSpotPos[i].AdjustX(nWidth34 );
 622                         aSpotPos[i].AdjustY(nHeight34 );
 623                     }
 624                     break;
 625
 626                 }
 627
 628                 aSpotColor[i] = COL_WHITE;
 629                 impGetSdrPageFillColor(rPage, aSpotPos[i], rTextEditPV, rTextEditPV.GetVisibleLayers(), aSpotColor[i], false);
 630             }
 631
 632             sal_uInt16 aMatch[SPOTCOUNT];
 633
 634             for ( i = 0; i < SPOTCOUNT; i++ )
 635             {
 636                 // were same spot colors found?
 637                 aMatch[i] = 0;
 638
 639                 for ( sal_uInt16 j = 0; j < SPOTCOUNT; j++ )
 640                 {
 641                     if( j != i )
 642                     {
 643                         if( aSpotColor[i] == aSpotColor[j] )
 644                         {
 645                             aMatch[i]++;
 646                         }
 647                     }
 648                 }
 649             }
 650
 651             // highest weight to center spot
 652             aBackground = aSpotColor[0];
 653
 654             for ( sal_uInt16 nMatchCount = SPOTCOUNT - 1; nMatchCount > 1; nMatchCount-- )
 655             {
 656                 // which spot color was found most?
 657                 for ( i = 0; i < SPOTCOUNT; i++ )
 658                 {
 659                     if( aMatch[i] == nMatchCount )
 660                     {
 661                         aBackground = aSpotColor[i];
 662                         nMatchCount = 1;   // break outer for-loop
 663                         break;
 664                     }
 665                 }
 666             }
 667         }
 668
 669         return aBackground;
 670     }
 671 } // end of anonymous namespace
 672
 673 Color GetTextEditBackgroundColor(const SdrObjEditView& rView)
 674 {
 675     svtools::ColorConfig aColorConfig;
 676     Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
 677     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 678
 679     if(!rStyleSettings.GetHighContrastMode())
 680     {
 681         bool bFound(false);
 682         SdrTextObj* pText = rView.GetTextEditObject();
 683
 684         if(pText && pText->IsClosedObj())
 685         {
 686             sdr::table::SdrTableObj* pTable = dynamic_cast< sdr::table::SdrTableObj * >( pText );
 687
 688             if( pTable )
 689                 bFound = GetDraftFillColor(pTable->GetActiveCellItemSet(), aBackground );
 690
 691             if( !bFound )
 692                 bFound=GetDraftFillColor(pText->GetMergedItemSet(), aBackground);
 693         }
 694
 695         if(!bFound && pText)
 696         {
 697             SdrPageView* pTextEditPV = rView.GetTextEditPageView();
 698
 699             if(pTextEditPV)
 700             {
 701                 Point aPvOfs(pText->GetTextEditOffset());
 702                 const SdrPage* pPg = pTextEditPV->GetPage();
 703
 704                 if(pPg)
 705                 {
 706                     tools::Rectangle aSnapRect( pText->GetSnapRect() );
 707                     aSnapRect.Move(aPvOfs.X(), aPvOfs.Y());
 708
 709                     return impCalcBackgroundColor(aSnapRect, *pTextEditPV, *pPg);
 710                 }
 711             }
 712         }
 713     }
 714
 715     return aBackground;
 716 }
 717
 718 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */