Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 748 insertions, 0 deletions

diff --git a/svx/source/svdraw/svdetc.cxx b/svx/source/svdraw/svdetc.cxx
new file mode 100644
index 000000000..0d82f6632
--- /dev/null
+++ b/svx/source/svdraw/svdetc.cxx
@@ -0,0 +1,748 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <officecfg/Office/Common.hxx>
+#include <svtools/colorcfg.hxx>
+#include <svx/svdetc.hxx>
+#include <svx/svdedxv.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdoutl.hxx>
+#include <vcl/bitmapaccess.hxx>
+#include <editeng/eeitem.hxx>
+#include <svl/itemset.hxx>
+#include <svl/whiter.hxx>
+#include <svx/xgrad.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xflclit.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/xbtmpit.hxx>
+#include <svx/xflgrit.hxx>
+#include <svx/svdoole2.hxx>
+#include <svl/itempool.hxx>
+#include <tools/debug.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <svx/xflbckit.hxx>
+#include <svx/extrusionbar.hxx>
+#include <svx/fontworkbar.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <svx/sdr/contact/viewcontact.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdotable.hxx>
+#include <svx/sdrhittesthelper.hxx>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+
+using namespace ::com::sun::star;
+
+// Global data of the DrawingEngine
+SdrGlobalData::SdrGlobalData()
+    : pSysLocale(nullptr)
+    , pLocaleData(nullptr)
+{
+    if (!utl::ConfigManager::IsFuzzing())
+    {
+        svx::ExtrusionBar::RegisterInterface();
+        svx::FontworkBar::RegisterInterface();
+    }
+}
+
+const SvtSysLocale*         SdrGlobalData::GetSysLocale()
+{
+    if ( !pSysLocale )
+        pSysLocale = new SvtSysLocale;
+    return pSysLocale;
+}
+const LocaleDataWrapper*    SdrGlobalData::GetLocaleData()
+{
+    if ( !pLocaleData )
+        pLocaleData = GetSysLocale()->GetLocaleDataPtr();
+    return pLocaleData;
+}
+
+namespace {
+
+struct TheSdrGlobalData: public rtl::Static<SdrGlobalData, TheSdrGlobalData> {};
+
+}
+
+SdrGlobalData & GetSdrGlobalData() {
+    return TheSdrGlobalData::get();
+}
+
+OLEObjCache::OLEObjCache()
+{
+    if (!utl::ConfigManager::IsFuzzing())
+        nSize = officecfg::Office::Common::Cache::DrawingEngine::OLE_Objects::get();
+    else
+        nSize = 100;
+    pTimer.reset( new AutoTimer( "svx OLEObjCache pTimer UnloadCheck" ) );
+    pTimer->SetInvokeHandler( LINK(this, OLEObjCache, UnloadCheckHdl) );
+    pTimer->SetTimeout(20000);
+    pTimer->SetStatic();
+}
+
+OLEObjCache::~OLEObjCache()
+{
+    pTimer->Stop();
+}
+
+IMPL_LINK_NOARG(OLEObjCache, UnloadCheckHdl, Timer*, void)
+{
+    if (nSize >= maObjs.size())
+        return;
+
+    // more objects than configured cache size try to remove objects
+    // of course not the freshly inserted one at nIndex=0
+    size_t nCount2 = maObjs.size();
+    size_t nIndex = nCount2-1;
+    while( nIndex && nCount2 > nSize )
+    {
+        SdrOle2Obj* pUnloadObj = maObjs[nIndex--];
+        if (!pUnloadObj)
+            continue;
+
+        try
+        {
+            // it is important to get object without reinitialization to avoid reentrance
+            uno::Reference< embed::XEmbeddedObject > xUnloadObj = pUnloadObj->GetObjRef_NoInit();
+
+            bool bUnload = SdrOle2Obj::CanUnloadRunningObj( xUnloadObj, pUnloadObj->GetAspect() );
+
+            // check whether the object can be unloaded before looking for the parent objects
+            if ( xUnloadObj.is() && bUnload )
+            {
+                uno::Reference< frame::XModel > xUnloadModel( xUnloadObj->getComponent(), uno::UNO_QUERY );
+                if ( xUnloadModel.is() )
+                {
+                    for (SdrOle2Obj* pCacheObj : maObjs)
+                    {
+                        if ( pCacheObj && pCacheObj != pUnloadObj )
+                        {
+                            uno::Reference< frame::XModel > xParentModel = pCacheObj->GetParentXModel();
+                            if ( xUnloadModel == xParentModel )
+                                bUnload = false; // the object has running embedded objects
+                        }
+                    }
+                }
+            }
+
+            if ( bUnload && UnloadObj(pUnloadObj) )
+                // object was successfully unloaded
+                nCount2--;
+        }
+        catch( uno::Exception& )
+        {}
+    }
+}
+
+void OLEObjCache::InsertObj(SdrOle2Obj* pObj)
+{
+    if (!maObjs.empty())
+    {
+        SdrOle2Obj* pExistingObj = maObjs.front();
+        if ( pObj == pExistingObj )
+            // the object is already on the top, nothing has to be changed
+            return;
+    }
+
+    // get the old position of the object to know whether it is already in container
+    std::vector<SdrOle2Obj*>::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj);
+    bool bFound = it != maObjs.end();
+
+    if (bFound)
+        maObjs.erase(it);
+    // insert object into first position
+    maObjs.insert(maObjs.begin(), pObj);
+
+    // if a new object was inserted, recalculate the cache
+    if (!bFound)
+        pTimer->Invoke();
+
+    if (!bFound || !pTimer->IsActive())
+        pTimer->Start();
+}
+
+void OLEObjCache::RemoveObj(SdrOle2Obj* pObj)
+{
+    std::vector<SdrOle2Obj*>::iterator it = std::find(maObjs.begin(), maObjs.end(), pObj);
+    if (it != maObjs.end())
+        maObjs.erase(it);
+    if (maObjs.empty())
+        pTimer->Stop();
+}
+
+size_t OLEObjCache::size() const
+{
+    return maObjs.size();
+}
+
+SdrOle2Obj* OLEObjCache::operator[](size_t nPos)
+{
+    return maObjs[nPos];
+}
+
+const SdrOle2Obj* OLEObjCache::operator[](size_t nPos) const
+{
+    return maObjs[nPos];
+}
+
+bool OLEObjCache::UnloadObj(SdrOle2Obj* pObj)
+{
+    bool bUnloaded = false;
+    if (pObj)
+    {
+        //#i80528# The old mechanism is completely useless, only taking into account if
+        // in all views the GrafDraft feature is used. This will nearly never have been the
+        // case since no one ever used this option.
+
+        // A much better (and working) criteria would be the VOC contact count.
+        // The question is what will happen when i make it work now suddenly? I
+        // will try it for 2.4.
+        const sdr::contact::ViewContact& rViewContact = pObj->GetViewContact();
+        const bool bVisible(rViewContact.HasViewObjectContacts());
+
+        if(!bVisible)
+        {
+            bUnloaded = pObj->Unload();
+        }
+    }
+
+    return bUnloaded;
+}
+
+bool GetDraftFillColor(const SfxItemSet& rSet, Color& rCol)
+{
+    drawing::FillStyle eFill=rSet.Get(XATTR_FILLSTYLE).GetValue();
+    bool bRetval = false;
+
+    switch(eFill)
+    {
+        case drawing::FillStyle_SOLID:
+        {
+            rCol = rSet.Get(XATTR_FILLCOLOR).GetColorValue();
+            bRetval = true;
+
+            break;
+        }
+        case drawing::FillStyle_HATCH:
+        {
+            Color aCol1(rSet.Get(XATTR_FILLHATCH).GetHatchValue().GetColor());
+            Color aCol2(COL_WHITE);
+
+            // when hatched background is activated, use object fill color as hatch color
+            bool bFillHatchBackground = rSet.Get(XATTR_FILLBACKGROUND).GetValue();
+            if(bFillHatchBackground)
+            {
+                aCol2 = rSet.Get(XATTR_FILLCOLOR).GetColorValue();
+            }
+
+            const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
+            rCol = Color(aAverageColor);
+            bRetval = true;
+
+            break;
+        }
+        case drawing::FillStyle_GRADIENT: {
+            const XGradient& rGrad=rSet.Get(XATTR_FILLGRADIENT).GetGradientValue();
+            Color aCol1(rGrad.GetStartColor());
+            Color aCol2(rGrad.GetEndColor());
+            const basegfx::BColor aAverageColor(basegfx::average(aCol1.getBColor(), aCol2.getBColor()));
+            rCol = Color(aAverageColor);
+            bRetval = true;
+
+            break;
+        }
+        case drawing::FillStyle_BITMAP:
+        {
+            Bitmap aBitmap(rSet.Get(XATTR_FILLBITMAP).GetGraphicObject().GetGraphic().GetBitmapEx().GetBitmap());
+            const Size aSize(aBitmap.GetSizePixel());
+            const sal_uInt32 nWidth = aSize.Width();
+            const sal_uInt32 nHeight = aSize.Height();
+            if (nWidth <= 0 || nHeight <= 0)
+                return bRetval;
+
+            Bitmap::ScopedReadAccess pAccess(aBitmap);
+
+            if (pAccess)
+            {
+                sal_uInt32 nRt(0);
+                sal_uInt32 nGn(0);
+                sal_uInt32 nBl(0);
+                const sal_uInt32 nMaxSteps(8);
+                const sal_uInt32 nXStep((nWidth > nMaxSteps) ? nWidth / nMaxSteps : 1);
+                const sal_uInt32 nYStep((nHeight > nMaxSteps) ? nHeight / nMaxSteps : 1);
+                sal_uInt32 nCount(0);
+
+                for(sal_uInt32 nY(0); nY < nHeight; nY += nYStep)
+                {
+                    for(sal_uInt32 nX(0); nX < nWidth; nX += nXStep)
+                    {
+                        const BitmapColor& rCol2 = pAccess->GetColor(nY, nX);
+
+                        nRt += rCol2.GetRed();
+                        nGn += rCol2.GetGreen();
+                        nBl += rCol2.GetBlue();
+                        nCount++;
+                    }
+                }
+
+                nRt /= nCount;
+                nGn /= nCount;
+                nBl /= nCount;
+
+                rCol = Color(sal_uInt8(nRt), sal_uInt8(nGn), sal_uInt8(nBl));
+
+                bRetval = true;
+            }
+            break;
+        }
+        default: break;
+    }
+
+    return bRetval;
+}
+
+std::unique_ptr<SdrOutliner> SdrMakeOutliner(OutlinerMode nOutlinerMode, SdrModel& rModel)
+{
+    SfxItemPool* pPool = &rModel.GetItemPool();
+    std::unique_ptr<SdrOutliner> pOutl(new SdrOutliner( pPool, nOutlinerMode ));
+    pOutl->SetEditTextObjectPool( pPool );
+    pOutl->SetStyleSheetPool( static_cast<SfxStyleSheetPool*>(rModel.GetStyleSheetPool()));
+    pOutl->SetDefTab(rModel.GetDefaultTabulator());
+    Outliner::SetForbiddenCharsTable(rModel.GetForbiddenCharsTable());
+    pOutl->SetAsianCompressionMode(rModel.GetCharCompressType());
+    pOutl->SetKernAsianPunctuation(rModel.IsKernAsianPunctuation());
+    pOutl->SetAddExtLeading(rModel.IsAddExtLeading());
+    return pOutl;
+}
+
+std::vector<Link<SdrObjCreatorParams, SdrObject*>>& ImpGetUserMakeObjHdl()
+{
+    SdrGlobalData& rGlobalData=GetSdrGlobalData();
+    return rGlobalData.aUserMakeObjHdl;
+}
+
+bool SearchOutlinerItems(const SfxItemSet& rSet, bool bInklDefaults, bool* pbOnlyEE)
+{
+    bool bHas=false;
+    bool bOnly=true;
+    bool bLookOnly=pbOnlyEE!=nullptr;
+    SfxWhichIter aIter(rSet);
+    sal_uInt16 nWhich=aIter.FirstWhich();
+    while (((bLookOnly && bOnly) || !bHas) && nWhich!=0) {
+        // For bInklDefaults, the entire Which range is decisive,
+        // in other cases only the set items are.
+        // Disabled and DontCare are regarded as holes in the Which range.
+        SfxItemState eState=rSet.GetItemState(nWhich);
+        if ((eState==SfxItemState::DEFAULT && bInklDefaults) || eState==SfxItemState::SET) {
+            if (nWhich<EE_ITEMS_START || nWhich>EE_ITEMS_END) bOnly=false;
+            else bHas=true;
+        }
+        nWhich=aIter.NextWhich();
+    }
+    if (!bHas) bOnly=false;
+    if (pbOnlyEE!=nullptr) *pbOnlyEE=bOnly;
+    return bHas;
+}
+
+std::unique_ptr<sal_uInt16[]> RemoveWhichRange(const sal_uInt16* pOldWhichTable, sal_uInt16 nRangeBeg, sal_uInt16 nRangeEnd)
+{
+    // Six possible cases (per range):
+    //         [Beg..End]          Range, to delete
+    // [b..e]    [b..e]    [b..e]  Cases 1,3,2: doesn't matter, delete, doesn't matter  + Ranges
+    // [b........e]  [b........e]  Cases 4,5  : shrink range                            | in
+    // [b......................e]  Case  6    : splitting                               + pOldWhichTable
+    sal_uInt16 nCount=0;
+    while (pOldWhichTable[nCount]!=0) nCount++;
+    nCount++; // nCount should now be an odd number (0 for end of array)
+    DBG_ASSERT((nCount&1)==1,"RemoveWhichRange: WhichTable doesn't have an odd number of entries.");
+    sal_uInt16 nAlloc=nCount;
+    // check necessary size of new array
+    sal_uInt16 nNum=nCount-1;
+    while (nNum!=0) {
+        nNum-=2;
+        sal_uInt16 nBeg=pOldWhichTable[nNum];
+        sal_uInt16 nEnd=pOldWhichTable[nNum+1];
+        if (nEnd<nRangeBeg)  /*nCase=1*/ ;
+        else if (nBeg>nRangeEnd) /* nCase=2 */ ;
+        else if (nBeg>=nRangeBeg && nEnd<=nRangeEnd) /* nCase=3 */ nAlloc-=2;
+        else if (nEnd<=nRangeEnd) /* nCase=4 */;
+        else if (nBeg>=nRangeBeg) /* nCase=5*/ ;
+        else /* nCase=6 */ nAlloc+=2;
+    }
+
+    std::unique_ptr<sal_uInt16[]> pNewWhichTable(new sal_uInt16[nAlloc]);
+    memcpy(pNewWhichTable.get(), pOldWhichTable, nAlloc*sizeof(sal_uInt16));
+    pNewWhichTable[nAlloc-1]=0; // in case 3, there's no 0 at the end.
+    // now remove the unwanted ranges
+    nNum=nAlloc-1;
+    while (nNum!=0) {
+        nNum-=2;
+        sal_uInt16 nBeg=pNewWhichTable[nNum];
+        sal_uInt16 nEnd=pNewWhichTable[nNum+1];
+        unsigned nCase=0;
+        if (nEnd<nRangeBeg) nCase=1;
+        else if (nBeg>nRangeEnd) nCase=2;
+        else if (nBeg>=nRangeBeg && nEnd<=nRangeEnd) nCase=3;
+        else if (nEnd<=nRangeEnd) nCase=4;
+        else if (nBeg>=nRangeBeg) nCase=5;
+        else nCase=6;
+        switch (nCase) {
+            case 3: {
+                unsigned nTailBytes=(nCount-(nNum+2))*sizeof(sal_uInt16);
+                memcpy(&pNewWhichTable[nNum],&pNewWhichTable[nNum+2],nTailBytes);
+                nCount-=2; // remember: array is now smaller
+            } break;
+            case 4: pNewWhichTable[nNum+1]=nRangeBeg-1; break;
+            case 5: pNewWhichTable[nNum]=nRangeEnd+1;     break;
+            case 6: {
+                unsigned nTailBytes=(nCount-(nNum+2))*sizeof(sal_uInt16);
+                memcpy(&pNewWhichTable[nNum+4],&pNewWhichTable[nNum+2],nTailBytes);
+                nCount+=2; // remember:array is now larger
+                pNewWhichTable[nNum+2]=nRangeEnd+1;
+                pNewWhichTable[nNum+3]=pNewWhichTable[nNum+1];
+                pNewWhichTable[nNum+1]=nRangeBeg-1;
+            } break;
+        } // switch
+    }
+    return pNewWhichTable;
+}
+
+
+SvdProgressInfo::SvdProgressInfo( const Link<void*,bool>&_rLink )
+{
+    maLink = _rLink;
+    m_nSumCurAction   = 0;
+
+    m_nObjCount = 0;
+    m_nCurObj   = 0;
+
+    m_nActionCount = 0;
+    m_nCurAction   = 0;
+
+    m_nInsertCount = 0;
+    m_nCurInsert   = 0;
+}
+
+void SvdProgressInfo::Init( size_t nObjCount )
+{
+    m_nObjCount = nObjCount;
+}
+
+bool SvdProgressInfo::ReportActions( size_t nActionCount )
+{
+    m_nSumCurAction += nActionCount;
+    m_nCurAction += nActionCount;
+    if(m_nCurAction > m_nActionCount)
+        m_nCurAction = m_nActionCount;
+
+    return maLink.Call(nullptr);
+}
+
+void SvdProgressInfo::ReportInserts( size_t nInsertCount )
+{
+    m_nSumCurAction += nInsertCount;
+    m_nCurInsert += nInsertCount;
+
+    maLink.Call(nullptr);
+}
+
+void SvdProgressInfo::ReportRescales( size_t nRescaleCount )
+{
+    m_nSumCurAction += nRescaleCount;
+    maLink.Call(nullptr);
+}
+
+void SvdProgressInfo::SetActionCount( size_t nActionCount )
+{
+    m_nActionCount = nActionCount;
+}
+
+void SvdProgressInfo::SetInsertCount( size_t nInsertCount )
+{
+    m_nInsertCount = nInsertCount;
+}
+
+void SvdProgressInfo::SetNextObject()
+{
+    m_nActionCount = 0;
+    m_nCurAction   = 0;
+
+    m_nInsertCount = 0;
+    m_nCurInsert   = 0;
+
+    m_nCurObj++;
+    ReportActions(0);
+}
+
+// #i101872# isolate GetTextEditBackgroundColor to tooling; it will anyways only be used as long
+// as text edit is not running on overlay
+
+namespace
+{
+    bool impGetSdrObjListFillColor(
+        const SdrObjList& rList,
+        const Point& rPnt,
+        const SdrPageView& rTextEditPV,
+        const SdrLayerIDSet& rVisLayers,
+        Color& rCol)
+    {
+        bool bRet(false);
+        bool bMaster(rList.getSdrPageFromSdrObjList() && rList.getSdrPageFromSdrObjList()->IsMasterPage());
+
+        for(size_t no(rList.GetObjCount()); !bRet && no > 0; )
+        {
+            no--;
+            SdrObject* pObj = rList.GetObj(no);
+            SdrObjList* pOL = pObj->GetSubList();
+
+            if(pOL)
+            {
+                // group object
+                bRet = impGetSdrObjListFillColor(*pOL, rPnt, rTextEditPV, rVisLayers, rCol);
+            }
+            else
+            {
+                SdrTextObj* pText = dynamic_cast< SdrTextObj * >(pObj);
+
+                // Exclude zero master page object (i.e. background shape) from color query
+                if(pText
+                    && pObj->IsClosedObj()
+                    && (!bMaster || (!pObj->IsNotVisibleAsMaster() && 0 != no))
+                    && pObj->GetCurrentBoundRect().IsInside(rPnt)
+                    && !pText->IsHideContour()
+                    && SdrObjectPrimitiveHit(*pObj, rPnt, 0, rTextEditPV, &rVisLayers, false))
+                {
+                    bRet = GetDraftFillColor(pObj->GetMergedItemSet(), rCol);
+                }
+            }
+        }
+
+        return bRet;
+    }
+
+    bool impGetSdrPageFillColor(
+        const SdrPage& rPage,
+        const Point& rPnt,
+        const SdrPageView& rTextEditPV,
+        const SdrLayerIDSet& rVisLayers,
+        Color& rCol,
+        bool bSkipBackgroundShape)
+    {
+        bool bRet(impGetSdrObjListFillColor(rPage, rPnt, rTextEditPV, rVisLayers, rCol));
+
+        if(!bRet && !rPage.IsMasterPage())
+        {
+            if(rPage.TRG_HasMasterPage())
+            {
+                SdrLayerIDSet aSet(rVisLayers);
+                aSet &= rPage.TRG_GetMasterPageVisibleLayers();
+                SdrPage& rMasterPage = rPage.TRG_GetMasterPage();
+
+                // Don't fall back to background shape on
+                // master pages. This is later handled by
+                // GetBackgroundColor, and is necessary to cater for
+                // the silly ordering: 1. shapes, 2. master page
+                // shapes, 3. page background, 4. master page
+                // background.
+                bRet = impGetSdrPageFillColor(rMasterPage, rPnt, rTextEditPV, aSet, rCol, true);
+            }
+        }
+
+        // Only now determine background color from background shapes
+        if(!bRet && !bSkipBackgroundShape)
+        {
+            rCol = rPage.GetPageBackgroundColor();
+            return true;
+        }
+
+        return bRet;
+    }
+
+    Color impCalcBackgroundColor(
+        const tools::Rectangle& rArea,
+        const SdrPageView& rTextEditPV,
+        const SdrPage& rPage)
+    {
+        svtools::ColorConfig aColorConfig;
+        Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
+        const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
+
+        if(!rStyleSettings.GetHighContrastMode())
+        {
+            // search in page
+            const sal_uInt16 SPOTCOUNT(5);
+            Point aSpotPos[SPOTCOUNT];
+            Color aSpotColor[SPOTCOUNT];
+            sal_uInt32 nHeight( rArea.GetSize().Height() );
+            sal_uInt32 nWidth( rArea.GetSize().Width() );
+            sal_uInt32 nWidth14  = nWidth / 4;
+            sal_uInt32 nHeight14 = nHeight / 4;
+            sal_uInt32 nWidth34  = ( 3 * nWidth ) / 4;
+            sal_uInt32 nHeight34 = ( 3 * nHeight ) / 4;
+
+            sal_uInt16 i;
+            for ( i = 0; i < SPOTCOUNT; i++ )
+            {
+                // five spots are used
+                switch ( i )
+                {
+                    case 0 :
+                    {
+                        // Center-Spot
+                        aSpotPos[i] = rArea.Center();
+                    }
+                    break;
+
+                    case 1 :
+                    {
+                        // TopLeft-Spot
+                        aSpotPos[i] = rArea.TopLeft();
+                        aSpotPos[i].AdjustX(nWidth14 );
+                        aSpotPos[i].AdjustY(nHeight14 );
+                    }
+                    break;
+
+                    case 2 :
+                    {
+                        // TopRight-Spot
+                        aSpotPos[i] = rArea.TopLeft();
+                        aSpotPos[i].AdjustX(nWidth34 );
+                        aSpotPos[i].AdjustY(nHeight14 );
+                    }
+                    break;
+
+                    case 3 :
+                    {
+                        // BottomLeft-Spot
+                        aSpotPos[i] = rArea.TopLeft();
+                        aSpotPos[i].AdjustX(nWidth14 );
+                        aSpotPos[i].AdjustY(nHeight34 );
+                    }
+                    break;
+
+                    case 4 :
+                    {
+                        // BottomRight-Spot
+                        aSpotPos[i] = rArea.TopLeft();
+                        aSpotPos[i].AdjustX(nWidth34 );
+                        aSpotPos[i].AdjustY(nHeight34 );
+                    }
+                    break;
+
+                }
+
+                aSpotColor[i] = COL_WHITE;
+                impGetSdrPageFillColor(rPage, aSpotPos[i], rTextEditPV, rTextEditPV.GetVisibleLayers(), aSpotColor[i], false);
+            }
+
+            sal_uInt16 aMatch[SPOTCOUNT];
+
+            for ( i = 0; i < SPOTCOUNT; i++ )
+            {
+                // were same spot colors found?
+                aMatch[i] = 0;
+
+                for ( sal_uInt16 j = 0; j < SPOTCOUNT; j++ )
+                {
+                    if( j != i )
+                    {
+                        if( aSpotColor[i] == aSpotColor[j] )
+                        {
+                            aMatch[i]++;
+                        }
+                    }
+                }
+            }
+
+            // highest weight to center spot
+            aBackground = aSpotColor[0];
+
+            for ( sal_uInt16 nMatchCount = SPOTCOUNT - 1; nMatchCount > 1; nMatchCount-- )
+            {
+                // which spot color was found most?
+                for ( i = 0; i < SPOTCOUNT; i++ )
+                {
+                    if( aMatch[i] == nMatchCount )
+                    {
+                        aBackground = aSpotColor[i];
+                        nMatchCount = 1;   // break outer for-loop
+                        break;
+                    }
+                }
+            }
+        }
+
+        return aBackground;
+    }
+} // end of anonymous namespace
+
+Color GetTextEditBackgroundColor(const SdrObjEditView& rView)
+{
+    svtools::ColorConfig aColorConfig;
+    Color aBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor);
+    const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
+
+    if(!rStyleSettings.GetHighContrastMode())
+    {
+        bool bFound(false);
+        SdrTextObj* pText = rView.GetTextEditObject();
+
+        if(pText && pText->IsClosedObj())
+        {
+            sdr::table::SdrTableObj* pTable = dynamic_cast< sdr::table::SdrTableObj * >( pText );
+
+            if( pTable )
+                bFound = GetDraftFillColor(pTable->GetActiveCellItemSet(), aBackground );
+
+            if( !bFound )
+                bFound=GetDraftFillColor(pText->GetMergedItemSet(), aBackground);
+        }
+
+        if(!bFound && pText)
+        {
+            SdrPageView* pTextEditPV = rView.GetTextEditPageView();
+
+            if(pTextEditPV)
+            {
+                Point aPvOfs(pText->GetTextEditOffset());
+                const SdrPage* pPg = pTextEditPV->GetPage();
+
+                if(pPg)
+                {
+                    tools::Rectangle aSnapRect( pText->GetSnapRect() );
+                    aSnapRect.Move(aPvOfs.X(), aPvOfs.Y());
+
+                    return impCalcBackgroundColor(aSnapRect, *pTextEditPV, *pPg);
+                }
+            }
+        }
+    }
+
+    return aBackground;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */