LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdetc.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 402 0.0 %
Date: 2014-04-14 Functions: 0 38 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10