LCOV - code coverage report
Current view: top level - sc/source/ui/view - colrowba.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 54 184 29.3 %
Date: 2015-06-13 12:38:46 Functions: 20 35 57.1 %
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 <svx/svdtrans.hxx>
      21             : #include <unotools/localedatawrapper.hxx>
      22             : 
      23             : #include "colrowba.hxx"
      24             : #include "document.hxx"
      25             : #include "scmod.hxx"
      26             : #include "tabvwsh.hxx"
      27             : #include "docsh.hxx"
      28             : #include "appoptio.hxx"
      29             : #include "globstr.hrc"
      30             : #include "markdata.hxx"
      31             : #include <columnspanset.hxx>
      32             : 
      33             : // STATIC DATA -----------------------------------------------------------
      34             : 
      35           0 : static OUString lcl_MetricString( long nTwips, const OUString& rText )
      36             : {
      37           0 :     if ( nTwips <= 0 )
      38           0 :         return ScGlobal::GetRscString(STR_TIP_HIDE);
      39             :     else
      40             :     {
      41           0 :         FieldUnit eUserMet = SC_MOD()->GetAppOptions().GetAppMetric();
      42             : 
      43           0 :         sal_Int64 nUserVal = MetricField::ConvertValue( nTwips*100, 1, 2, FUNIT_TWIP, eUserMet );
      44             : 
      45           0 :         OUString aStr = rText;
      46           0 :         aStr += " ";
      47           0 :         aStr += ScGlobal::pLocaleData->getNum( nUserVal, 2 );
      48           0 :         aStr += " ";
      49           0 :         aStr += SdrFormatter::GetUnitStr(eUserMet);
      50             : 
      51           0 :         return aStr;
      52             :     }
      53             : }
      54             : 
      55         349 : ScColBar::ScColBar( vcl::Window* pParent, ScViewData* pData, ScHSplitPos eWhichPos,
      56             :                     ScHeaderFunctionSet* pFunc, ScHeaderSelectionEngine* pEng ) :
      57             :             ScHeaderControl( pParent, pEng, MAXCOL+1, false ),
      58             :             pViewData( pData ),
      59             :             eWhich( eWhichPos ),
      60         349 :             pFuncSet( pFunc )
      61             : {
      62         349 :     Show();
      63         349 : }
      64             : 
      65         692 : ScColBar::~ScColBar()
      66             : {
      67         692 : }
      68             : 
      69        4194 : inline bool ScColBar::UseNumericHeader() const
      70             : {
      71        4194 :     return pViewData->GetDocument()->GetAddressConvention() == formula::FormulaGrammar::CONV_XL_R1C1;
      72             : }
      73             : 
      74        2772 : SCCOLROW ScColBar::GetPos() const
      75             : {
      76        2772 :     return pViewData->GetPosX(eWhich);
      77             : }
      78             : 
      79       27884 : sal_uInt16 ScColBar::GetEntrySize( SCCOLROW nEntryNo ) const
      80             : {
      81       27884 :     ScDocument* pDoc = pViewData->GetDocument();
      82       27884 :     SCTAB nTab = pViewData->GetTabNo();
      83       27884 :     if (pDoc->ColHidden(static_cast<SCCOL>(nEntryNo), nTab))
      84           0 :         return 0;
      85             :     else
      86       27884 :         return (sal_uInt16) ScViewData::ToPixel( pDoc->GetColWidth( static_cast<SCCOL>(nEntryNo), nTab ), pViewData->GetPPTX() );
      87             : }
      88             : 
      89        4194 : OUString ScColBar::GetEntryText( SCCOLROW nEntryNo ) const
      90             : {
      91        4194 :     return UseNumericHeader()
      92             :         ? OUString::number(nEntryNo + 1)
      93        4194 :         : ScColToAlpha( static_cast<SCCOL>(nEntryNo) );
      94             : }
      95             : 
      96           0 : void ScColBar::SetEntrySize( SCCOLROW nPos, sal_uInt16 nNewSize )
      97             : {
      98             :     sal_uInt16 nSizeTwips;
      99           0 :     ScSizeMode eMode = SC_SIZE_DIRECT;
     100           0 :     if (nNewSize < 10) nNewSize = 10; // pixels
     101             : 
     102           0 :     if ( nNewSize == HDR_SIZE_OPTIMUM )
     103             :     {
     104           0 :         nSizeTwips = STD_EXTRA_WIDTH;
     105           0 :         eMode = SC_SIZE_OPTIMAL;
     106             :     }
     107             :     else
     108           0 :         nSizeTwips = (sal_uInt16) ( nNewSize / pViewData->GetPPTX() );
     109             : 
     110           0 :     ScMarkData& rMark = pViewData->GetMarkData();
     111             : 
     112           0 :     std::vector<sc::ColRowSpan> aRanges;
     113           0 :     if ( rMark.IsColumnMarked( static_cast<SCCOL>(nPos) ) )
     114             :     {
     115           0 :         SCCOL nStart = 0;
     116           0 :         while (nStart<=MAXCOL)
     117             :         {
     118           0 :             while (nStart<MAXCOL && !rMark.IsColumnMarked(nStart))
     119           0 :                 ++nStart;
     120           0 :             if (rMark.IsColumnMarked(nStart))
     121             :             {
     122           0 :                 SCCOL nEnd = nStart;
     123           0 :                 while (nEnd<MAXCOL && rMark.IsColumnMarked(nEnd))
     124           0 :                     ++nEnd;
     125           0 :                 if (!rMark.IsColumnMarked(nEnd))
     126           0 :                     --nEnd;
     127           0 :                 aRanges.push_back(sc::ColRowSpan(nStart,nEnd));
     128           0 :                 nStart = nEnd+1;
     129             :             }
     130             :             else
     131           0 :                 nStart = MAXCOL+1;
     132             :         }
     133             :     }
     134             :     else
     135             :     {
     136           0 :         aRanges.push_back(sc::ColRowSpan(nPos,nPos));
     137             :     }
     138             : 
     139           0 :     pViewData->GetView()->SetWidthOrHeight(true, aRanges, eMode, nSizeTwips);
     140           0 : }
     141             : 
     142           0 : void ScColBar::HideEntries( SCCOLROW nStart, SCCOLROW nEnd )
     143             : {
     144           0 :     std::vector<sc::ColRowSpan> aRanges(1, sc::ColRowSpan(nStart,nEnd));
     145           0 :     pViewData->GetView()->SetWidthOrHeight(true, aRanges, SC_SIZE_DIRECT, 0);
     146           0 : }
     147             : 
     148         689 : void ScColBar::SetMarking( bool bSet )
     149             : {
     150         689 :     pViewData->GetMarkData().SetMarking( bSet );
     151         689 :     if (!bSet)
     152             :     {
     153         689 :         pViewData->GetView()->UpdateAutoFillMark();
     154             :     }
     155         689 : }
     156             : 
     157           0 : void ScColBar::SelectWindow()
     158             : {
     159           0 :     ScTabViewShell* pViewSh = pViewData->GetViewShell();
     160             : 
     161           0 :     pViewSh->SetActive();           // Appear and SetViewFrame
     162           0 :     pViewSh->DrawDeselectAll();
     163             : 
     164           0 :     ScSplitPos eActive = pViewData->GetActivePart();
     165           0 :     if (eWhich==SC_SPLIT_LEFT)
     166             :     {
     167           0 :         if (eActive==SC_SPLIT_TOPRIGHT)     eActive=SC_SPLIT_TOPLEFT;
     168           0 :         if (eActive==SC_SPLIT_BOTTOMRIGHT)  eActive=SC_SPLIT_BOTTOMLEFT;
     169             :     }
     170             :     else
     171             :     {
     172           0 :         if (eActive==SC_SPLIT_TOPLEFT)      eActive=SC_SPLIT_TOPRIGHT;
     173           0 :         if (eActive==SC_SPLIT_BOTTOMLEFT)   eActive=SC_SPLIT_BOTTOMRIGHT;
     174             :     }
     175           0 :     pViewSh->ActivatePart( eActive );
     176             : 
     177           0 :     pFuncSet->SetColumn( true );
     178           0 :     pFuncSet->SetWhich( eActive );
     179             : 
     180           0 :     pViewSh->ActiveGrabFocus();
     181           0 : }
     182             : 
     183           0 : bool ScColBar::IsDisabled() const
     184             : {
     185           0 :     ScModule* pScMod = SC_MOD();
     186           0 :     return pScMod->IsFormulaMode() || pScMod->IsModalMode();
     187             : }
     188             : 
     189           0 : bool ScColBar::ResizeAllowed() const
     190             : {
     191           0 :     return !pViewData->HasEditView( pViewData->GetActivePart() );
     192             : }
     193             : 
     194           0 : void ScColBar::DrawInvert( long nDragPosP )
     195             : {
     196           0 :     Rectangle aRect( nDragPosP,0, nDragPosP+HDR_SLIDERSIZE-1,GetOutputSizePixel().Width()-1 );
     197           0 :     Update();
     198           0 :     Invert(aRect);
     199             : 
     200           0 :     pViewData->GetView()->InvertVertical(eWhich,nDragPosP);
     201           0 : }
     202             : 
     203           0 : OUString ScColBar::GetDragHelp( long nVal )
     204             : {
     205           0 :     long nTwips = (long) ( nVal / pViewData->GetPPTX() );
     206           0 :     return lcl_MetricString( nTwips, ScGlobal::GetRscString(STR_TIP_WIDTH) );
     207             : }
     208             : 
     209        3959 : bool ScColBar::IsLayoutRTL() const        // override only for columns
     210             : {
     211        3959 :     return pViewData->GetDocument()->IsLayoutRTL( pViewData->GetTabNo() );
     212             : }
     213             : 
     214         349 : ScRowBar::ScRowBar( vcl::Window* pParent, ScViewData* pData, ScVSplitPos eWhichPos,
     215             :                     ScHeaderFunctionSet* pFunc, ScHeaderSelectionEngine* pEng ) :
     216             :             ScHeaderControl( pParent, pEng, MAXROW+1, true ),
     217             :             pViewData( pData ),
     218             :             eWhich( eWhichPos ),
     219         349 :             pFuncSet( pFunc )
     220             : {
     221         349 :     Show();
     222         349 : }
     223             : 
     224         692 : ScRowBar::~ScRowBar()
     225             : {
     226         692 : }
     227             : 
     228        2845 : SCCOLROW ScRowBar::GetPos() const
     229             : {
     230        2845 :     return pViewData->GetPosY(eWhich);
     231             : }
     232             : 
     233       69944 : sal_uInt16 ScRowBar::GetEntrySize( SCCOLROW nEntryNo ) const
     234             : {
     235       69944 :     ScDocument* pDoc = pViewData->GetDocument();
     236       69944 :     SCTAB nTab = pViewData->GetTabNo();
     237       69944 :     SCROW nLastRow = -1;
     238       69944 :     if (pDoc->RowHidden(nEntryNo, nTab, NULL, &nLastRow))
     239          80 :         return 0;
     240             :     else
     241             :         return (sal_uInt16) ScViewData::ToPixel( pDoc->GetOriginalHeight( nEntryNo,
     242       69864 :                     nTab ), pViewData->GetPPTY() );
     243             : }
     244             : 
     245       11402 : OUString ScRowBar::GetEntryText( SCCOLROW nEntryNo ) const
     246             : {
     247       11402 :     return OUString::number( nEntryNo + 1 );
     248             : }
     249             : 
     250           0 : void ScRowBar::SetEntrySize( SCCOLROW nPos, sal_uInt16 nNewSize )
     251             : {
     252             :     sal_uInt16 nSizeTwips;
     253           0 :     ScSizeMode eMode = SC_SIZE_DIRECT;
     254           0 :     if (nNewSize < 10) nNewSize = 10; // pixels
     255             : 
     256           0 :     if ( nNewSize == HDR_SIZE_OPTIMUM )
     257             :     {
     258           0 :         nSizeTwips = 0;
     259           0 :         eMode = SC_SIZE_OPTIMAL;
     260             :     }
     261             :     else
     262           0 :         nSizeTwips = (sal_uInt16) ( nNewSize / pViewData->GetPPTY() );
     263             : 
     264           0 :     ScMarkData& rMark = pViewData->GetMarkData();
     265             : 
     266           0 :     std::vector<sc::ColRowSpan> aRanges;
     267           0 :     if ( rMark.IsRowMarked( nPos ) )
     268             :     {
     269           0 :         SCROW nStart = 0;
     270           0 :         while (nStart<=MAXROW)
     271             :         {
     272           0 :             while (nStart<MAXROW && !rMark.IsRowMarked(nStart))
     273           0 :                 ++nStart;
     274           0 :             if (rMark.IsRowMarked(nStart))
     275             :             {
     276           0 :                 SCROW nEnd = nStart;
     277           0 :                 while (nEnd<MAXROW && rMark.IsRowMarked(nEnd))
     278           0 :                     ++nEnd;
     279           0 :                 if (!rMark.IsRowMarked(nEnd))
     280           0 :                     --nEnd;
     281           0 :                 aRanges.push_back(sc::ColRowSpan(nStart,nEnd));
     282           0 :                 nStart = nEnd+1;
     283             :             }
     284             :             else
     285           0 :                 nStart = MAXROW+1;
     286             :         }
     287             :     }
     288             :     else
     289             :     {
     290           0 :         aRanges.push_back(sc::ColRowSpan(nPos,nPos));
     291             :     }
     292             : 
     293           0 :     pViewData->GetView()->SetWidthOrHeight(false, aRanges, eMode, nSizeTwips);
     294           0 : }
     295             : 
     296           0 : void ScRowBar::HideEntries( SCCOLROW nStart, SCCOLROW nEnd )
     297             : {
     298           0 :     std::vector<sc::ColRowSpan> aRange(1, sc::ColRowSpan(nStart,nEnd));
     299           0 :     pViewData->GetView()->SetWidthOrHeight(false, aRange, SC_SIZE_DIRECT, 0);
     300           0 : }
     301             : 
     302         689 : void ScRowBar::SetMarking( bool bSet )
     303             : {
     304         689 :     pViewData->GetMarkData().SetMarking( bSet );
     305         689 :     if (!bSet)
     306             :     {
     307         689 :         pViewData->GetView()->UpdateAutoFillMark();
     308             :     }
     309         689 : }
     310             : 
     311           0 : void ScRowBar::SelectWindow()
     312             : {
     313           0 :     ScTabViewShell* pViewSh = pViewData->GetViewShell();
     314             : 
     315           0 :     pViewSh->SetActive();           // Appear and SetViewFrame
     316           0 :     pViewSh->DrawDeselectAll();
     317             : 
     318           0 :     ScSplitPos eActive = pViewData->GetActivePart();
     319           0 :     if (eWhich==SC_SPLIT_TOP)
     320             :     {
     321           0 :         if (eActive==SC_SPLIT_BOTTOMLEFT)   eActive=SC_SPLIT_TOPLEFT;
     322           0 :         if (eActive==SC_SPLIT_BOTTOMRIGHT)  eActive=SC_SPLIT_TOPRIGHT;
     323             :     }
     324             :     else
     325             :     {
     326           0 :         if (eActive==SC_SPLIT_TOPLEFT)      eActive=SC_SPLIT_BOTTOMLEFT;
     327           0 :         if (eActive==SC_SPLIT_TOPRIGHT)     eActive=SC_SPLIT_BOTTOMRIGHT;
     328             :     }
     329           0 :     pViewSh->ActivatePart( eActive );
     330             : 
     331           0 :     pFuncSet->SetColumn( false );
     332           0 :     pFuncSet->SetWhich( eActive );
     333             : 
     334           0 :     pViewSh->ActiveGrabFocus();
     335           0 : }
     336             : 
     337           0 : bool ScRowBar::IsDisabled() const
     338             : {
     339           0 :     ScModule* pScMod = SC_MOD();
     340           0 :     return pScMod->IsFormulaMode() || pScMod->IsModalMode();
     341             : }
     342             : 
     343           0 : bool ScRowBar::ResizeAllowed() const
     344             : {
     345           0 :     return !pViewData->HasEditView( pViewData->GetActivePart() );
     346             : }
     347             : 
     348           0 : void ScRowBar::DrawInvert( long nDragPosP )
     349             : {
     350           0 :     Rectangle aRect( 0,nDragPosP, GetOutputSizePixel().Width()-1,nDragPosP+HDR_SLIDERSIZE-1 );
     351           0 :     Update();
     352           0 :     Invert(aRect);
     353             : 
     354           0 :     pViewData->GetView()->InvertHorizontal(eWhich,nDragPosP);
     355           0 : }
     356             : 
     357           0 : OUString ScRowBar::GetDragHelp( long nVal )
     358             : {
     359           0 :     long nTwips = (long) ( nVal / pViewData->GetPPTY() );
     360           0 :     return lcl_MetricString( nTwips, ScGlobal::GetRscString(STR_TIP_HEIGHT) );
     361             : }
     362             : 
     363          70 : SCROW ScRowBar::GetHiddenCount( SCROW nEntryNo ) const // override only for rows
     364             : {
     365          70 :     ScDocument* pDoc = pViewData->GetDocument();
     366          70 :     SCTAB nTab = pViewData->GetTabNo();
     367          70 :     return pDoc->GetHiddenRowCount( nEntryNo, nTab );
     368             : }
     369             : 
     370        1438 : bool ScRowBar::IsMirrored() const // override only for rows
     371             : {
     372        1438 :     return pViewData->GetDocument()->IsLayoutRTL( pViewData->GetTabNo() );
     373         156 : }
     374             : 
     375             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11