LCOV - code coverage report
Current view: top level - sw/source/uibase/config - cfgitems.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 11 171 6.4 %
Date: 2014-11-03 Functions: 6 48 12.5 %
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 <basic/sbxvar.hxx>
      21             : 
      22             : #include <svx/svxids.hrc>
      23             : #include <editeng/svxenum.hxx>
      24             : 
      25             : #include "viewopt.hxx"
      26             : #include "swtypes.hxx"
      27             : #include "cmdid.h"
      28             : #include "prtopt.hxx"
      29             : #include "cfgitems.hxx"
      30             : #include "crstate.hxx"
      31             : 
      32           0 : TYPEINIT1_AUTOFACTORY(SwDocDisplayItem, SfxPoolItem)
      33           0 : TYPEINIT1_AUTOFACTORY(SwElemItem, SfxPoolItem)
      34          16 : TYPEINIT1_AUTOFACTORY(SwAddPrinterItem, SfxPoolItem)
      35           0 : TYPEINIT1_AUTOFACTORY(SwShadowCursorItem, SfxPoolItem)
      36             : 
      37           0 : SwDocDisplayItem::SwDocDisplayItem( sal_uInt16 _nWhich ) :
      38             :         SfxPoolItem(_nWhich),
      39           0 :         aIndexBackgrndCol(COL_GRAY)
      40             : {
      41             :     bParagraphEnd       =
      42             :     bTab                =
      43             :     bSpace              =
      44             :     bNonbreakingSpace   =
      45             :     bSoftHyphen         =
      46             :     bFldHiddenText      =
      47             :     bCharHiddenText     =
      48             :     bManualBreak        =
      49           0 :     bShowHiddenPara     = false;
      50             : 
      51           0 : };
      52             : 
      53             : // Item for the Settings dialog, page document view
      54           0 : SwDocDisplayItem::SwDocDisplayItem( const SwDocDisplayItem& rDocDisplayItem ):
      55           0 :             SfxPoolItem(rDocDisplayItem)
      56             : {
      57           0 :     *this = rDocDisplayItem;
      58           0 : };
      59             : 
      60           0 : SwDocDisplayItem::SwDocDisplayItem(const SwViewOption& rVOpt, sal_uInt16 _nWhich ) :
      61           0 :             SfxPoolItem( _nWhich )
      62             : {
      63           0 :     bParagraphEnd       = rVOpt.IsParagraph(true);
      64           0 :     bTab                = rVOpt.IsTab(true);
      65           0 :     bSpace              = rVOpt.IsBlank(true);
      66           0 :     bNonbreakingSpace   = rVOpt.IsHardBlank();
      67           0 :     bSoftHyphen         = rVOpt.IsSoftHyph();
      68           0 :     bCharHiddenText     = rVOpt.IsShowHiddenChar(true);
      69           0 :     bFldHiddenText      = rVOpt.IsShowHiddenField();
      70           0 :     bManualBreak        = rVOpt.IsLineBreak(true);
      71           0 :     bShowHiddenPara     = rVOpt.IsShowHiddenPara();
      72           0 : }
      73             : 
      74           0 : SfxPoolItem* SwDocDisplayItem::Clone( SfxItemPool*  ) const
      75             : {
      76           0 :     return new SwDocDisplayItem( *this );
      77             : }
      78             : 
      79           0 : bool SwDocDisplayItem::operator==( const SfxPoolItem& rAttr ) const
      80             : {
      81             :     assert(SfxPoolItem::operator==(rAttr));
      82             : 
      83           0 :     const SwDocDisplayItem& rItem = (SwDocDisplayItem&)rAttr;
      84             : 
      85           0 :     return (  bParagraphEnd         == rItem.bParagraphEnd       &&
      86           0 :               bTab                  == rItem.bTab                &&
      87           0 :               bSpace                == rItem.bSpace              &&
      88           0 :               bNonbreakingSpace     == rItem.bNonbreakingSpace   &&
      89           0 :               bSoftHyphen           == rItem.bSoftHyphen         &&
      90           0 :               bCharHiddenText       == rItem.bCharHiddenText         &&
      91           0 :               bFldHiddenText        == rItem.bFldHiddenText         &&
      92           0 :               bManualBreak          == rItem.bManualBreak        &&
      93           0 :               bShowHiddenPara       == rItem.bShowHiddenPara );
      94             : }
      95             : 
      96           0 : void  SwDocDisplayItem::operator=( const SwDocDisplayItem& rDocDisplayItem)
      97             : {
      98           0 :     bParagraphEnd       = rDocDisplayItem.bParagraphEnd         ;
      99           0 :     bTab                = rDocDisplayItem.bTab                  ;
     100           0 :     bSpace              = rDocDisplayItem.bSpace                ;
     101           0 :     bNonbreakingSpace   = rDocDisplayItem.bNonbreakingSpace     ;
     102           0 :     bSoftHyphen         = rDocDisplayItem.bSoftHyphen           ;
     103           0 :     bCharHiddenText     = rDocDisplayItem.bCharHiddenText           ;
     104           0 :     bFldHiddenText      = rDocDisplayItem.bFldHiddenText           ;
     105           0 :     bManualBreak        = rDocDisplayItem.bManualBreak          ;
     106           0 :     bShowHiddenPara     = rDocDisplayItem.bShowHiddenPara       ;
     107           0 : }
     108             : 
     109           0 : void SwDocDisplayItem::FillViewOptions( SwViewOption& rVOpt) const
     110             : {
     111           0 :     rVOpt.SetParagraph  (bParagraphEnd      );
     112           0 :     rVOpt.SetTab        (bTab               );
     113           0 :     rVOpt.SetBlank      (bSpace             );
     114           0 :     rVOpt.SetHardBlank  (bNonbreakingSpace  );
     115           0 :     rVOpt.SetSoftHyph   (bSoftHyphen        );
     116           0 :     rVOpt.SetShowHiddenChar(bCharHiddenText );
     117           0 :     rVOpt.SetShowHiddenField(bFldHiddenText        );
     118           0 :     rVOpt.SetLineBreak  (bManualBreak       );
     119           0 :     rVOpt.SetShowHiddenPara(bShowHiddenPara );
     120           0 : }
     121             : 
     122           0 : SwElemItem::SwElemItem( sal_uInt16 _nWhich ) :
     123           0 :     SfxPoolItem(_nWhich)
     124             : {
     125             :     bHorzScrollbar =
     126             :     bVertScrollbar =
     127             :     bAnyRuler =
     128             :     bHorzRuler     =
     129             :     bVertRuler     =
     130             :     bVertRulerRight=
     131             :     bCrosshair     =
     132             :     bSmoothScroll  =
     133             :     bTable              =
     134             :     bGraphic            =
     135             :     bDrawing            =
     136             :     bFieldName          =
     137           0 :     bNotes              = false;
     138           0 : }
     139             : 
     140           0 : SwElemItem::SwElemItem( const SwElemItem& rElemItem ):
     141           0 :             SfxPoolItem(rElemItem)
     142             : {
     143           0 :     *this = rElemItem;
     144           0 : }
     145             : 
     146           0 : SwElemItem::SwElemItem(const SwViewOption& rVOpt, sal_uInt16 _nWhich) :
     147           0 :             SfxPoolItem( _nWhich )
     148             : {
     149           0 :     bHorzScrollbar  = rVOpt.IsViewHScrollBar();
     150           0 :     bVertScrollbar  = rVOpt.IsViewVScrollBar();
     151           0 :     bAnyRuler       = rVOpt.IsViewAnyRuler();
     152           0 :     bHorzRuler      = rVOpt.IsViewHRuler(true);
     153           0 :     bVertRuler      = rVOpt.IsViewVRuler(true);
     154           0 :     bVertRulerRight = rVOpt.IsVRulerRight();
     155           0 :     bCrosshair      = rVOpt.IsCrossHair();
     156           0 :     bSmoothScroll   = rVOpt.IsSmoothScroll();
     157           0 :     bTable              = rVOpt.IsTable();
     158           0 :     bGraphic            = rVOpt.IsGraphic();
     159           0 :     bDrawing            = rVOpt.IsDraw() && rVOpt.IsControl();
     160           0 :     bFieldName          = rVOpt.IsFldName();
     161           0 :     bNotes              = rVOpt.IsPostIts();
     162             : 
     163           0 : }
     164             : 
     165           0 : SfxPoolItem* SwElemItem::Clone( SfxItemPool* ) const
     166             : {
     167           0 :     return new SwElemItem( *this );
     168             : }
     169             : 
     170           0 : bool SwElemItem::operator==( const SfxPoolItem& rAttr ) const
     171             : {
     172             :     assert(SfxPoolItem::operator==(rAttr));
     173             : 
     174           0 :     const SwElemItem& rItem = (SwElemItem&)rAttr;
     175             : 
     176           0 :     return (    bHorzScrollbar  == rItem.bHorzScrollbar &&
     177           0 :                 bVertScrollbar  == rItem.bVertScrollbar &&
     178           0 :                 bAnyRuler       == rItem.bAnyRuler &&
     179           0 :                 bHorzRuler      == rItem.bHorzRuler     &&
     180           0 :                 bVertRuler      == rItem.bVertRuler     &&
     181           0 :                 bVertRulerRight == rItem.bVertRulerRight&&
     182           0 :                 bCrosshair      == rItem.bCrosshair     &&
     183           0 :                 bSmoothScroll   == rItem.bSmoothScroll  &&
     184           0 :                 bTable                == rItem.bTable              &&
     185           0 :                 bGraphic              == rItem.bGraphic            &&
     186           0 :                 bDrawing              == rItem.bDrawing            &&
     187           0 :                 bFieldName            == rItem.bFieldName          &&
     188           0 :                 bNotes                == rItem.bNotes             );
     189             : }
     190             : 
     191           0 : void  SwElemItem::operator=( const SwElemItem& rElemItem)
     192             : {
     193           0 :     bHorzScrollbar  = rElemItem.  bHorzScrollbar    ;
     194           0 :     bVertScrollbar  = rElemItem.  bVertScrollbar    ;
     195           0 :     bAnyRuler       = rElemItem.  bAnyRuler;
     196           0 :     bHorzRuler      = rElemItem.  bHorzRuler        ;
     197           0 :     bVertRuler      = rElemItem.  bVertRuler        ;
     198           0 :     bVertRulerRight = rElemItem.  bVertRulerRight   ;
     199           0 :     bCrosshair      = rElemItem.  bCrosshair        ;
     200           0 :     bSmoothScroll   = rElemItem.  bSmoothScroll     ;
     201           0 :     bTable              = rElemItem.bTable                ;
     202           0 :     bGraphic            = rElemItem.bGraphic              ;
     203           0 :     bDrawing            = rElemItem.bDrawing              ;
     204           0 :     bFieldName          = rElemItem.bFieldName            ;
     205           0 :     bNotes              = rElemItem.bNotes                ;
     206           0 : }
     207             : 
     208           0 : void SwElemItem::FillViewOptions( SwViewOption& rVOpt) const
     209             : {
     210           0 :     rVOpt.SetViewHScrollBar(bHorzScrollbar );
     211           0 :     rVOpt.SetViewVScrollBar(bVertScrollbar );
     212           0 :     rVOpt.SetViewAnyRuler(bAnyRuler);
     213           0 :     rVOpt.SetViewHRuler(bHorzRuler    );
     214           0 :     rVOpt.SetViewVRuler(bVertRuler    );
     215           0 :     rVOpt.SetVRulerRight(bVertRulerRight );
     216           0 :     rVOpt.SetCrossHair(bCrosshair     );
     217           0 :     rVOpt.SetSmoothScroll(bSmoothScroll);
     218           0 :     rVOpt.SetTable      (bTable             );
     219           0 :     rVOpt.SetGraphic    (bGraphic           );
     220           0 :     rVOpt.SetDraw       (bDrawing           );
     221           0 :     rVOpt.SetControl    (bDrawing           );
     222           0 :     rVOpt.SetFldName    (bFieldName         );
     223           0 :     rVOpt.SetPostIts    (bNotes             );
     224           0 : }
     225             : 
     226             : // CopyCTOR
     227          44 : SwAddPrinterItem::SwAddPrinterItem( const SwAddPrinterItem& rAddPrinterItem ):
     228             :             SfxPoolItem(rAddPrinterItem),
     229          44 :             SwPrintData( rAddPrinterItem )
     230             : {
     231          44 : }
     232             : 
     233             : // CTOR for empty Item
     234           0 : SwAddPrinterItem::SwAddPrinterItem( sal_uInt16 _nWhich):
     235           0 :                 SfxPoolItem(_nWhich)
     236             : {
     237           0 : }
     238             : 
     239             : // CTOR from SwPrintOptions
     240          16 : SwAddPrinterItem::SwAddPrinterItem( sal_uInt16 _nWhich, const SwPrintData& rPrtData ) :
     241          16 :     SfxPoolItem(_nWhich)
     242             : {
     243          16 :     SwPrintData::operator=(rPrtData);
     244          16 : }
     245             : 
     246          44 : SfxPoolItem* SwAddPrinterItem::Clone( SfxItemPool* ) const
     247             : {
     248          44 :     return new SwAddPrinterItem( *this );
     249             : }
     250             : 
     251           0 : bool SwAddPrinterItem::operator==( const SfxPoolItem& rAttr ) const
     252             : {
     253             :     assert(SfxPoolItem::operator==(rAttr));
     254             : 
     255           0 :     const SwAddPrinterItem& rItem = (SwAddPrinterItem&)rAttr;
     256             : 
     257           0 :     return  SwPrintData::operator==(rItem);
     258             : }
     259             : 
     260             : // Item for Settings dialog, ShadowCursorPage
     261           0 : SwShadowCursorItem::SwShadowCursorItem( sal_uInt16 _nWhich )
     262             :     : SfxPoolItem( _nWhich ),
     263             :     eMode( FILL_TAB )
     264           0 :     ,bOn( false )
     265             : {
     266           0 : }
     267             : 
     268           0 : SwShadowCursorItem::SwShadowCursorItem( const SwShadowCursorItem& rCpy )
     269           0 :     : SfxPoolItem( rCpy.Which() ),
     270           0 :     eMode( rCpy.GetMode() )
     271           0 :     ,bOn( rCpy.IsOn() )
     272             : 
     273             : {
     274           0 : }
     275             : 
     276           0 : SwShadowCursorItem::SwShadowCursorItem( const SwViewOption& rVOpt, sal_uInt16 _nWhich )
     277             :     : SfxPoolItem( _nWhich ),
     278           0 :     eMode( rVOpt.GetShdwCrsrFillMode() )
     279           0 :     ,bOn( rVOpt.IsShadowCursor() )
     280             : 
     281             : {
     282           0 : }
     283             : 
     284           0 : SfxPoolItem* SwShadowCursorItem::Clone( SfxItemPool* ) const
     285             : {
     286           0 :     return new SwShadowCursorItem( *this );
     287             : }
     288             : 
     289           0 : bool SwShadowCursorItem::operator==( const SfxPoolItem& rCmp ) const
     290             : {
     291           0 :     return  IsOn() == ((SwShadowCursorItem&)rCmp).IsOn() &&
     292           0 :             GetMode() == ((SwShadowCursorItem&)rCmp).GetMode();
     293             : }
     294             : 
     295           0 : void SwShadowCursorItem::operator=( const SwShadowCursorItem& rCpy )
     296             : {
     297           0 :     SetOn( rCpy.IsOn() );
     298           0 :     SetMode( rCpy.GetMode() );
     299           0 : }
     300             : 
     301           0 : void SwShadowCursorItem::FillViewOptions( SwViewOption& rVOpt ) const
     302             : {
     303           0 :     rVOpt.SetShadowCursor( bOn );
     304           0 :     rVOpt.SetShdwCrsrFillMode( eMode );
     305         270 : }
     306             : 
     307             : #ifdef DBG_UTIL
     308             : SwTestItem::SwTestItem( const SwTestItem& rTestItem ):
     309             :             SfxPoolItem(rTestItem)
     310             : {
     311             :     bTest1=rTestItem.bTest1;
     312             :     bTest2=rTestItem.bTest2;
     313             :     bTest3=rTestItem.bTest3;
     314             :     bTest4=rTestItem.bTest4;
     315             :     bTest5=rTestItem.bTest5;
     316             :     bTest6=rTestItem.bTest6;
     317             :     bTest7=rTestItem.bTest7;
     318             :     bTest8=rTestItem.bTest8;
     319             :     bTest9=rTestItem.bTest9;
     320             :     bTest10=rTestItem.bTest10;
     321             : };
     322             : 
     323             : SfxPoolItem* SwTestItem::Clone( SfxItemPool* ) const
     324             : {
     325             :     return new SwTestItem( *this );
     326             : }
     327             : 
     328             : bool SwTestItem::operator==( const SfxPoolItem& rAttr ) const
     329             : {
     330             :     assert(SfxPoolItem::operator==(rAttr));
     331             : 
     332             :     const SwTestItem& rItem = (const SwTestItem&) rAttr;
     333             : 
     334             :     return ( bTest1==rItem.bTest1&&
     335             :              bTest2==rItem.bTest2&&
     336             :              bTest3==rItem.bTest3&&
     337             :              bTest4==rItem.bTest4&&
     338             :              bTest5==rItem.bTest5&&
     339             :              bTest6==rItem.bTest6&&
     340             :              bTest7==rItem.bTest7&&
     341             :              bTest8==rItem.bTest8&&
     342             :              bTest9==rItem.bTest9&&
     343             :              bTest10==rItem.bTest10);
     344             : }
     345             : 
     346             : #endif
     347             : 
     348             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10