LCOV - code coverage report
Current view: top level - sc/source/ui/miscdlgs - autofmt.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 259 0.0 %
Date: 2014-04-14 Functions: 0 24 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 "scitems.hxx"
      21             : #include <svx/algitem.hxx>
      22             : #include <editeng/boxitem.hxx>
      23             : #include <editeng/brushitem.hxx>
      24             : #include <editeng/contouritem.hxx>
      25             : #include <editeng/colritem.hxx>
      26             : #include <editeng/crossedoutitem.hxx>
      27             : #include <editeng/fontitem.hxx>
      28             : #include <editeng/postitem.hxx>
      29             : #include <editeng/shdditem.hxx>
      30             : #include <editeng/udlnitem.hxx>
      31             : #include <editeng/wghtitem.hxx>
      32             : #include <vcl/svapp.hxx>
      33             : #include <svl/zforlist.hxx>
      34             : #include <vcl/msgbox.hxx>
      35             : #include <vcl/settings.hxx>
      36             : #include <sfx2/viewfrm.hxx>
      37             : #include <comphelper/processfactory.hxx>
      38             : 
      39             : #include "sc.hrc"
      40             : #include "scmod.hxx"
      41             : #include "attrib.hxx"
      42             : #include "zforauto.hxx"
      43             : #include "global.hxx"
      44             : #include "globstr.hrc"
      45             : #include "autoform.hxx"
      46             : #include "miscdlgs.hrc"
      47             : #include "autofmt.hxx"
      48             : #include "scresid.hxx"
      49             : #include "document.hxx"
      50             : #include "docsh.hxx"
      51             : #include "tabvwsh.hxx"
      52             : 
      53             : #define FRAME_OFFSET 4
      54             : 
      55             : // ScAutoFmtPreview
      56             : 
      57           0 : ScAutoFmtPreview::ScAutoFmtPreview(Window* pParent)
      58             :     : Window(pParent)
      59             :     , pCurData(NULL)
      60             :     , aVD(*this)
      61             :     , aScriptedText(aVD)
      62             :     , bFitWidth(false)
      63             :     , mbRTL(false)
      64             :     , aStrJan(ScResId(STR_JAN))
      65             :     , aStrFeb(ScResId(STR_FEB))
      66             :     , aStrMar(ScResId(STR_MAR))
      67             :     , aStrNorth(ScResId(STR_NORTH))
      68             :     , aStrMid(ScResId(STR_MID))
      69             :     , aStrSouth(ScResId(STR_SOUTH))
      70             :     , aStrSum(ScResId(STR_SUM))
      71           0 :     , pNumFmt(new SvNumberFormatter(::comphelper::getProcessComponentContext(), ScGlobal::eLnge))
      72             : {
      73           0 :     Init();
      74           0 : }
      75             : 
      76           0 : extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeScAutoFmtPreview(Window *pParent, VclBuilder::stringmap &)
      77             : {
      78           0 :     return new ScAutoFmtPreview(pParent);
      79             : }
      80             : 
      81           0 : void ScAutoFmtPreview::Resize()
      82             : {
      83           0 :     aPrvSize  = Size(GetSizePixel().Width() - 6, GetSizePixel().Height() - 30);
      84           0 :     mnLabelColWidth = (aPrvSize.Width() - 4) / 4 - 12;
      85           0 :     mnDataColWidth1 = (aPrvSize.Width() - 4 - 2 * mnLabelColWidth) / 3;
      86           0 :     mnDataColWidth2 = (aPrvSize.Width() - 4 - 2 * mnLabelColWidth) / 4;
      87           0 :     mnRowHeight = (aPrvSize.Height() - 4) / 5;
      88           0 :     NotifyChange(pCurData);
      89           0 : }
      90             : 
      91           0 : ScAutoFmtPreview::~ScAutoFmtPreview()
      92             : {
      93           0 :     delete pNumFmt;
      94           0 : }
      95             : 
      96           0 : static void lcl_SetFontProperties(
      97             :         Font& rFont,
      98             :         const SvxFontItem& rFontItem,
      99             :         const SvxWeightItem& rWeightItem,
     100             :         const SvxPostureItem& rPostureItem )
     101             : {
     102           0 :     rFont.SetFamily     ( rFontItem.GetFamily() );
     103           0 :     rFont.SetName       ( rFontItem.GetFamilyName() );
     104           0 :     rFont.SetStyleName  ( rFontItem.GetStyleName() );
     105           0 :     rFont.SetCharSet    ( rFontItem.GetCharSet() );
     106           0 :     rFont.SetPitch      ( rFontItem.GetPitch() );
     107           0 :     rFont.SetWeight     ( (FontWeight)rWeightItem.GetValue() );
     108           0 :     rFont.SetItalic     ( (FontItalic)rPostureItem.GetValue() );
     109           0 : }
     110             : 
     111           0 : void ScAutoFmtPreview::MakeFonts( sal_uInt16 nIndex, Font& rFont, Font& rCJKFont, Font& rCTLFont )
     112             : {
     113           0 :     if ( pCurData )
     114             :     {
     115           0 :         rFont = rCJKFont = rCTLFont = GetFont();
     116           0 :         Size aFontSize( rFont.GetSize().Width(), 10 * GetDPIScaleFactor() );
     117             : 
     118           0 :         const SvxFontItem*        pFontItem       = (const SvxFontItem*)      pCurData->GetItem( nIndex, ATTR_FONT );
     119           0 :         const SvxWeightItem*      pWeightItem     = (const SvxWeightItem*)    pCurData->GetItem( nIndex, ATTR_FONT_WEIGHT );
     120           0 :         const SvxPostureItem*     pPostureItem    = (const SvxPostureItem*)   pCurData->GetItem( nIndex, ATTR_FONT_POSTURE );
     121           0 :         const SvxFontItem*        pCJKFontItem    = (const SvxFontItem*)      pCurData->GetItem( nIndex, ATTR_CJK_FONT );
     122           0 :         const SvxWeightItem*      pCJKWeightItem  = (const SvxWeightItem*)    pCurData->GetItem( nIndex, ATTR_CJK_FONT_WEIGHT );
     123           0 :         const SvxPostureItem*     pCJKPostureItem = (const SvxPostureItem*)   pCurData->GetItem( nIndex, ATTR_CJK_FONT_POSTURE );
     124           0 :         const SvxFontItem*        pCTLFontItem    = (const SvxFontItem*)      pCurData->GetItem( nIndex, ATTR_CTL_FONT );
     125           0 :         const SvxWeightItem*      pCTLWeightItem  = (const SvxWeightItem*)    pCurData->GetItem( nIndex, ATTR_CTL_FONT_WEIGHT );
     126           0 :         const SvxPostureItem*     pCTLPostureItem = (const SvxPostureItem*)   pCurData->GetItem( nIndex, ATTR_CTL_FONT_POSTURE );
     127           0 :         const SvxUnderlineItem*   pUnderlineItem  = (const SvxUnderlineItem*) pCurData->GetItem( nIndex, ATTR_FONT_UNDERLINE );
     128           0 :         const SvxOverlineItem*    pOverlineItem   = (const SvxOverlineItem*)  pCurData->GetItem( nIndex, ATTR_FONT_OVERLINE );
     129           0 :         const SvxCrossedOutItem*  pCrossedOutItem = (const SvxCrossedOutItem*)pCurData->GetItem( nIndex, ATTR_FONT_CROSSEDOUT );
     130           0 :         const SvxContourItem*     pContourItem    = (const SvxContourItem*)   pCurData->GetItem( nIndex, ATTR_FONT_CONTOUR );
     131           0 :         const SvxShadowedItem*    pShadowedItem   = (const SvxShadowedItem*)  pCurData->GetItem( nIndex, ATTR_FONT_SHADOWED );
     132           0 :         const SvxColorItem*       pColorItem      = (const SvxColorItem*)     pCurData->GetItem( nIndex, ATTR_FONT_COLOR );
     133             : 
     134           0 :         lcl_SetFontProperties( rFont, *pFontItem, *pWeightItem, *pPostureItem );
     135           0 :         lcl_SetFontProperties( rCJKFont, *pCJKFontItem, *pCJKWeightItem, *pCJKPostureItem );
     136           0 :         lcl_SetFontProperties( rCTLFont, *pCTLFontItem, *pCTLWeightItem, *pCTLPostureItem );
     137             : 
     138           0 :         Color aColor( pColorItem->GetValue() );
     139           0 :         if( aColor.GetColor() == COL_TRANSPARENT )
     140           0 :             aColor = GetSettings().GetStyleSettings().GetWindowTextColor();
     141             : 
     142             : #define SETONALLFONTS( MethodName, Value ) \
     143             : rFont.MethodName( Value ); rCJKFont.MethodName( Value ); rCTLFont.MethodName( Value );
     144             : 
     145           0 :         SETONALLFONTS( SetUnderline,    (FontUnderline)pUnderlineItem->GetValue() )
     146           0 :         SETONALLFONTS( SetOverline,     (FontUnderline)pOverlineItem->GetValue() )
     147           0 :         SETONALLFONTS( SetStrikeout,    (FontStrikeout)pCrossedOutItem->GetValue() )
     148           0 :         SETONALLFONTS( SetOutline,      pContourItem->GetValue() )
     149           0 :         SETONALLFONTS( SetShadow,       pShadowedItem->GetValue() )
     150           0 :         SETONALLFONTS( SetColor,        aColor )
     151           0 :         SETONALLFONTS( SetSize,         aFontSize )
     152           0 :         SETONALLFONTS( SetTransparent,  true )
     153             : 
     154             : #undef SETONALLFONTS
     155             :     }
     156           0 : }
     157             : 
     158           0 : sal_uInt16 ScAutoFmtPreview::GetFormatIndex( size_t nCol, size_t nRow ) const
     159             : {
     160             :     static const sal_uInt16 pnFmtMap[] =
     161             :     {
     162             :         0,  1,  2,  1,  3,
     163             :         4,  5,  6,  5,  7,
     164             :         8,  9,  10, 9,  11,
     165             :         4,  5,  6,  5,  7,
     166             :         12, 13, 14, 13, 15
     167             :     };
     168           0 :     return pnFmtMap[ maArray.GetCellIndex( nCol, nRow, mbRTL ) ];
     169             : }
     170             : 
     171           0 : const SvxBoxItem& ScAutoFmtPreview::GetBoxItem( size_t nCol, size_t nRow ) const
     172             : {
     173             :     OSL_ENSURE( pCurData, "ScAutoFmtPreview::GetBoxItem - no format data found" );
     174           0 :     return *static_cast< const SvxBoxItem* >( pCurData->GetItem( GetFormatIndex( nCol, nRow ), ATTR_BORDER ) );
     175             : }
     176             : 
     177           0 : const SvxLineItem& ScAutoFmtPreview::GetDiagItem( size_t nCol, size_t nRow, bool bTLBR ) const
     178             : {
     179             :     OSL_ENSURE( pCurData, "ScAutoFmtPreview::GetDiagItem - no format data found" );
     180           0 :     return *static_cast< const SvxLineItem* >( pCurData->GetItem( GetFormatIndex( nCol, nRow ), bTLBR ? ATTR_BORDER_TLBR : ATTR_BORDER_BLTR ) );
     181             : }
     182             : 
     183           0 : void ScAutoFmtPreview::DrawString( size_t nCol, size_t nRow )
     184             : {
     185           0 :     if ( pCurData )
     186             :     {
     187             : 
     188             :         // Ausgabe des Zelltextes:
     189             : 
     190             : 
     191           0 :         OUString  cellString;
     192           0 :         sal_Bool    bNumFormat  = pCurData->GetIncludeValueFormat();
     193             :         sal_uLong   nNum;
     194             :         double  nVal;
     195           0 :         Color*  pDummy = NULL;
     196           0 :         sal_uInt16  nIndex = static_cast< sal_uInt16 >( maArray.GetCellIndex( nCol, nRow, mbRTL ) );
     197             : 
     198           0 :         switch( nIndex )
     199             :         {
     200           0 :             case  1: cellString = aStrJan;          break;
     201           0 :             case  2: cellString = aStrFeb;          break;
     202           0 :             case  3: cellString = aStrMar;          break;
     203           0 :             case  5: cellString = aStrNorth;        break;
     204           0 :             case 10: cellString = aStrMid;          break;
     205           0 :             case 15: cellString = aStrSouth;        break;
     206             :             case  4:
     207           0 :             case 20: cellString = aStrSum;          break;
     208             : 
     209             :             case  6:
     210             :             case  8:
     211             :             case 16:
     212           0 :             case 18: nVal = nIndex;
     213           0 :                      nNum = 5;
     214           0 :                      goto mknum;
     215             :             case 17:
     216           0 :             case  7: nVal = nIndex;
     217           0 :                      nNum = 6;
     218           0 :                      goto mknum;
     219             :             case 11:
     220             :             case 12:
     221           0 :             case 13: nVal = nIndex;
     222           0 :                      nNum = 12 == nIndex ? 10 : 9;
     223           0 :                      goto mknum;
     224             : 
     225           0 :             case  9: nVal = 21; nNum = 7; goto mknum;
     226           0 :             case 14: nVal = 36; nNum = 11; goto mknum;
     227           0 :             case 19: nVal = 51; nNum = 7; goto mknum;
     228           0 :             case 21: nVal = 33; nNum = 13; goto mknum;
     229           0 :             case 22: nVal = 36; nNum = 14; goto mknum;
     230           0 :             case 23: nVal = 39; nNum = 13; goto mknum;
     231           0 :             case 24: nVal = 108; nNum = 15;
     232             :             mknum:
     233           0 :                 if( bNumFormat )
     234             :                 {
     235           0 :                     ScNumFormatAbbrev& rNumFormat = (ScNumFormatAbbrev&)pCurData->GetNumFormat( (sal_uInt16) nNum );
     236           0 :                     nNum = rNumFormat.GetFormatIndex( *pNumFmt );
     237             :                 }
     238             :                 else
     239           0 :                     nNum = 0;
     240           0 :                 pNumFmt->GetOutputString( nVal, nNum, cellString, &pDummy );
     241           0 :                 break;
     242             :         }
     243             : 
     244           0 :         if ( !cellString.isEmpty())
     245             :         {
     246           0 :             Size                aStrSize;
     247           0 :             sal_uInt16              nFmtIndex       = GetFormatIndex( nCol, nRow );
     248           0 :             Rectangle           cellRect        = maArray.GetCellRect( nCol, nRow );
     249           0 :             Point               aPos            = cellRect.TopLeft();
     250           0 :             sal_uInt16              nRightX         = 0;
     251           0 :             sal_Bool                bJustify        = pCurData->GetIncludeJustify();
     252           0 :             SvxHorJustifyItem    aHorJustifyItem( SVX_HOR_JUSTIFY_STANDARD, ATTR_HOR_JUSTIFY );
     253             :             SvxCellHorJustify      eJustification;
     254             : 
     255             : 
     256             :             // Ausrichtung:
     257             : 
     258             :             eJustification  = mbRTL ? SVX_HOR_JUSTIFY_RIGHT : bJustify ?
     259           0 :                 (SvxCellHorJustify)(((const SvxHorJustifyItem*)pCurData->GetItem( nFmtIndex, ATTR_HOR_JUSTIFY ))->GetValue()) :
     260           0 :                 SVX_HOR_JUSTIFY_STANDARD;
     261             : 
     262           0 :             if ( pCurData->GetIncludeFont() )
     263             :             {
     264           0 :                 Font aFont, aCJKFont, aCTLFont;
     265           0 :                 Size theMaxStrSize;
     266             : 
     267           0 :                 MakeFonts( nFmtIndex, aFont, aCJKFont, aCTLFont );
     268             : 
     269           0 :                 theMaxStrSize           = cellRect.GetSize();
     270           0 :                 theMaxStrSize.Width()  -= FRAME_OFFSET;
     271           0 :                 theMaxStrSize.Height() -= FRAME_OFFSET;
     272             : 
     273           0 :                 aScriptedText.SetFonts( &aFont, &aCJKFont, &aCTLFont );
     274           0 :                 aScriptedText.SetText( cellString, xBreakIter );
     275           0 :                 aStrSize = aScriptedText.GetTextSize();
     276             : 
     277           0 :                 if ( theMaxStrSize.Height() < aStrSize.Height() )
     278             :                 {
     279             :                     // wenn der String in diesem Font nicht
     280             :                     // in die Zelle passt, wird wieder der
     281             :                     // Standard-Font genommen:
     282           0 :                     aScriptedText.SetDefaultFont();
     283           0 :                     aStrSize = aScriptedText.GetTextSize();
     284             :                 }
     285           0 :                 while ( ( theMaxStrSize.Width() <= aStrSize.Width() )
     286           0 :                     && ( cellString.getLength() > 1 ) )
     287             :                 {
     288           0 :                     if( eJustification == SVX_HOR_JUSTIFY_RIGHT )
     289           0 :                         cellString = cellString.copy(1);
     290             :                     else
     291           0 :                         cellString = cellString.copy(0, cellString.getLength() - 1 );
     292             : 
     293           0 :                     aScriptedText.SetText( cellString, xBreakIter );
     294           0 :                     aStrSize = aScriptedText.GetTextSize();
     295           0 :                 }
     296             :             }
     297             :             else
     298             :             {
     299           0 :                 aScriptedText.SetDefaultFont();
     300           0 :                 aScriptedText.SetText( cellString, xBreakIter );
     301           0 :                 aStrSize = aScriptedText.GetTextSize();
     302             :             }
     303             : 
     304           0 :             nRightX  = (sal_uInt16)(  cellRect.GetWidth()
     305           0 :                                   - aStrSize.Width()
     306           0 :                                   - FRAME_OFFSET );
     307             : 
     308             : 
     309             :             // vertikal (immer zentrieren):
     310             : 
     311           0 :             aPos.Y() += (mnRowHeight - (sal_uInt16)aStrSize.Height()) / 2;
     312             : 
     313             : 
     314             :             // horizontal
     315             : 
     316           0 :             if ( eJustification != SVX_HOR_JUSTIFY_STANDARD )
     317             :             {
     318             :                 sal_uInt16 nHorPos = (sal_uInt16)
     319           0 :                                  ((cellRect.GetWidth()-aStrSize.Width())/2);
     320             : 
     321           0 :                 switch ( eJustification )
     322             :                 {
     323             :                     case SVX_HOR_JUSTIFY_LEFT:
     324           0 :                         aPos.X() += FRAME_OFFSET;
     325           0 :                         break;
     326             :                     case SVX_HOR_JUSTIFY_RIGHT:
     327           0 :                         aPos.X() += nRightX;
     328           0 :                         break;
     329             :                     case SVX_HOR_JUSTIFY_BLOCK:
     330             :                     case SVX_HOR_JUSTIFY_REPEAT:
     331             :                     case SVX_HOR_JUSTIFY_CENTER:
     332           0 :                         aPos.X() += nHorPos;
     333           0 :                         break;
     334             :                     case SVX_HOR_JUSTIFY_STANDARD:
     335             :                     default:
     336             :                         // Standard wird hier nicht behandelt
     337           0 :                         break;
     338             :                 }
     339             :             }
     340             :             else
     341             :             {
     342             : 
     343             :                 // Standardausrichtung:
     344             : 
     345           0 :                 if ( (nCol == 0) || (nRow == 0) )
     346             :                 {
     347             :                     // Text-Label links oder Summe linksbuendig
     348           0 :                     aPos.X() += FRAME_OFFSET;
     349             :                 }
     350             :                 else
     351             :                 {
     352             :                      // Zahlen/Datum rechtsbuendig
     353           0 :                     aPos.X() += nRightX;
     354             :                 }
     355             :             }
     356             : 
     357             : 
     358           0 :             aScriptedText.DrawText( aPos );
     359             : 
     360           0 :         }
     361             :     }
     362           0 : }
     363             : 
     364             : #undef FRAME_OFFSET
     365             : 
     366           0 : void ScAutoFmtPreview::DrawStrings()
     367             : {
     368           0 :     for( size_t nRow = 0; nRow < 5; ++nRow )
     369           0 :         for( size_t nCol = 0; nCol < 5; ++nCol )
     370           0 :             DrawString( nCol, nRow );
     371           0 : }
     372             : 
     373           0 : void ScAutoFmtPreview::DrawBackground()
     374             : {
     375           0 :     if( pCurData )
     376             :     {
     377           0 :         for( size_t nRow = 0; nRow < 5; ++nRow )
     378             :         {
     379           0 :             for( size_t nCol = 0; nCol < 5; ++nCol )
     380             :             {
     381             :                 const SvxBrushItem* pItem = static_cast< const SvxBrushItem* >(
     382           0 :                     pCurData->GetItem( GetFormatIndex( nCol, nRow ), ATTR_BACKGROUND ) );
     383             : 
     384           0 :                 aVD.Push( PUSH_LINECOLOR | PUSH_FILLCOLOR );
     385           0 :                 aVD.SetLineColor();
     386           0 :                 aVD.SetFillColor( pItem->GetColor() );
     387           0 :                 aVD.DrawRect( maArray.GetCellRect( nCol, nRow ) );
     388           0 :                 aVD.Pop();
     389             :             }
     390             :         }
     391             :     }
     392           0 : }
     393             : 
     394           0 : void ScAutoFmtPreview::PaintCells()
     395             : {
     396           0 :     if ( pCurData )
     397             :     {
     398             :         // 1) background
     399           0 :         if ( pCurData->GetIncludeBackground() )
     400           0 :             DrawBackground();
     401             : 
     402             :         // 2) values
     403           0 :         DrawStrings();
     404             : 
     405             :         // 3) border
     406           0 :         if ( pCurData->GetIncludeFrame() )
     407           0 :             maArray.DrawArray( aVD );
     408             :     }
     409           0 : }
     410             : 
     411           0 : void ScAutoFmtPreview::Init()
     412             : {
     413           0 :     SetBorderStyle( WINDOW_BORDER_MONO );
     414           0 :     maArray.Initialize( 5, 5 );
     415           0 :     maArray.SetUseDiagDoubleClipping( false );
     416           0 :     CalcCellArray( false );
     417           0 :     CalcLineMap();
     418           0 : }
     419             : 
     420           0 : void ScAutoFmtPreview::DetectRTL(ScViewData *pViewData)
     421             : {
     422           0 :     SCTAB nCurrentTab = pViewData->GetTabNo();
     423           0 :     ScDocument* pDoc = pViewData->GetDocument();
     424           0 :     mbRTL = pDoc->IsLayoutRTL(nCurrentTab);
     425           0 :     xBreakIter = pDoc->GetBreakIterator();
     426           0 : }
     427             : 
     428           0 : void ScAutoFmtPreview::CalcCellArray( bool bFitWidthP )
     429             : {
     430           0 :     maArray.SetXOffset( 2 );
     431           0 :     maArray.SetAllColWidths( bFitWidthP ? mnDataColWidth2 : mnDataColWidth1 );
     432           0 :     maArray.SetColWidth( 0, mnLabelColWidth );
     433           0 :     maArray.SetColWidth( 4, mnLabelColWidth );
     434             : 
     435           0 :     maArray.SetYOffset( 2 );
     436           0 :     maArray.SetAllRowHeights( mnRowHeight );
     437             : 
     438           0 :     aPrvSize.Width() = maArray.GetWidth() + 4;
     439           0 :     aPrvSize.Height() = maArray.GetHeight() + 4;
     440           0 : }
     441             : 
     442           0 : inline void lclSetStyleFromBorder( svx::frame::Style& rStyle, const ::editeng::SvxBorderLine* pBorder )
     443             : {
     444           0 :     rStyle.Set( pBorder, 1.0 / TWIPS_PER_POINT, 5 );
     445           0 : }
     446             : 
     447           0 : void ScAutoFmtPreview::CalcLineMap()
     448             : {
     449           0 :     if ( pCurData )
     450             :     {
     451           0 :         for( size_t nRow = 0; nRow < 5; ++nRow )
     452             :         {
     453           0 :             for( size_t nCol = 0; nCol < 5; ++nCol )
     454             :             {
     455           0 :                 svx::frame::Style aStyle;
     456             : 
     457           0 :                 const SvxBoxItem& rItem = GetBoxItem( nCol, nRow );
     458           0 :                 lclSetStyleFromBorder( aStyle, rItem.GetLeft() );
     459           0 :                 maArray.SetCellStyleLeft( nCol, nRow, aStyle );
     460           0 :                 lclSetStyleFromBorder( aStyle, rItem.GetRight() );
     461           0 :                 maArray.SetCellStyleRight( nCol, nRow, aStyle );
     462           0 :                 lclSetStyleFromBorder( aStyle, rItem.GetTop() );
     463           0 :                 maArray.SetCellStyleTop( nCol, nRow, aStyle );
     464           0 :                 lclSetStyleFromBorder( aStyle, rItem.GetBottom() );
     465           0 :                 maArray.SetCellStyleBottom( nCol, nRow, aStyle );
     466             : 
     467           0 :                 lclSetStyleFromBorder( aStyle, GetDiagItem( nCol, nRow, true ).GetLine() );
     468           0 :                 maArray.SetCellStyleTLBR( nCol, nRow, aStyle );
     469           0 :                 lclSetStyleFromBorder( aStyle, GetDiagItem( nCol, nRow, false ).GetLine() );
     470           0 :                 maArray.SetCellStyleBLTR( nCol, nRow, aStyle );
     471             :             }
     472             :         }
     473             :     }
     474           0 : }
     475             : 
     476           0 : void ScAutoFmtPreview::NotifyChange( ScAutoFormatData* pNewData )
     477             : {
     478           0 :     if (pNewData)
     479             :     {
     480           0 :         pCurData = pNewData;
     481           0 :         bFitWidth = pNewData->GetIncludeWidthHeight();
     482             :     }
     483             : 
     484           0 :     CalcCellArray( bFitWidth );
     485           0 :     CalcLineMap();
     486             : 
     487           0 :     DoPaint( Rectangle( Point(0,0), GetSizePixel() ) );
     488           0 : }
     489             : 
     490           0 : void ScAutoFmtPreview::DoPaint( const Rectangle& /* rRect */ )
     491             : {
     492           0 :     sal_uInt32 nOldDrawMode = aVD.GetDrawMode();
     493             : 
     494           0 :     Size aWndSize( GetSizePixel() );
     495           0 :     Font aFont( aVD.GetFont() );
     496           0 :     Color aBackCol( GetSettings().GetStyleSettings().GetWindowColor() );
     497           0 :     Point aTmpPoint;
     498           0 :     Rectangle aRect( aTmpPoint, aWndSize );
     499             : 
     500           0 :     aFont.SetTransparent( true );
     501           0 :     aVD.SetFont( aFont );
     502           0 :     aVD.SetLineColor();
     503           0 :     aVD.SetFillColor( aBackCol );
     504           0 :     aVD.SetOutputSize( aWndSize );
     505           0 :     aVD.DrawRect( aRect );
     506             : 
     507           0 :     PaintCells();
     508           0 :     SetLineColor();
     509           0 :     SetFillColor( aBackCol );
     510           0 :     DrawRect( aRect );
     511             : 
     512           0 :     Point aPos( (aWndSize.Width() - aPrvSize.Width()) / 2, (aWndSize.Height() - aPrvSize.Height()) / 2 );
     513           0 :     if (Application::GetSettings().GetLayoutRTL())
     514           0 :        aPos.X() = -aPos.X();
     515           0 :     DrawOutDev( aPos, aWndSize, Point(), aWndSize, aVD );
     516             : 
     517           0 :     aVD.SetDrawMode( nOldDrawMode );
     518           0 : }
     519             : 
     520           0 : void ScAutoFmtPreview::Paint( const Rectangle& rRect )
     521             : {
     522           0 :     DoPaint( rRect );
     523           0 : }
     524             : 
     525             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10