lwpparaborderoverride.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (the "License"); You may not use this file
 *  except in compliance with the License. You may obtain a copy of the
 *  License at http://www.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: IBM Corporation
 *
 *  Copyright: 2008 by IBM Corporation
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/
/*************************************************************************
* @file
* Border override of Wordpro.
************************************************************************/
#ifndef INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_LWPPARABORDEROVERRIDE_HXX
#define INCLUDED_LOTUSWORDPRO_SOURCE_FILTER_LWPPARABORDEROVERRIDE_HXX
 
#include <lwpoverride.hxx>
 
class LwpBorderStuff;
class LwpShadow;
class LwpMargins;
 
class LwpParaBorderOverride final : public LwpOverride
{
public:
    LwpParaBorderOverride();
    virtual ~LwpParaBorderOverride() override;
 
    virtual LwpParaBorderOverride* clone() const override;
 
    enum BorderWidthType
    {
        PB_NONE         = 0,        /* No border */
        PB_TEXTWIDTH    = 1,        /* Border is width of text */
        PB_MARGINWIDTH  = 2,        /* Border extends to margins */
        PB_CUSTOMWIDTH  = 3         /* Border width is specified explicitly */
    };
    virtual void Read(LwpObjectStream *pStrm) override;
 
    LwpShadow*  GetShadow(){ return m_pShadow.get(); }
    LwpBorderStuff* GetBorderStuff(){ return m_pBorderStuff.get(); }
    LwpMargins* GetMargins() { return m_pMargins.get(); };
 
    void Override(LwpParaBorderOverride* pOther);
 
    inline bool IsBorderStuffOverridden() const;
    inline bool IsBetweenStuffOverridden() const;
    inline bool IsShadowOverridden() const;
    inline bool IsMarginsOverridden() const;
    inline bool IsAboveTypeOverridden() const;
    inline bool IsBelowTypeOverridden() const;
    inline bool IsRightTypeOverridden() const;
    inline bool IsBetweenTypeOverridden() const;
    inline bool IsAboveWidthOverridden() const;
    inline bool IsBelowWidthOverridden() const;
    inline bool IsBetweenWidthOverridden() const;
    inline bool IsRightWidthOverridden() const;
    inline bool IsBetweenMarginOverridden() const;
 
    void OverrideBorderStuff(LwpBorderStuff const * pBorderStuff);
    void OverrideBetweenStuff(LwpBorderStuff const * pBorderStuff);
    void OverrideShadow(LwpShadow const * pShadow);
    void OverrideMargins(LwpMargins const * pMargins);
    void OverrideAboveType(BorderWidthType eNewType);
    void OverrideBelowType(BorderWidthType eNewType);
    void OverrideRightType(BorderWidthType eNewType);
    void OverrideBetweenType(BorderWidthType eNewType);
    void OverrideAboveWidth(sal_uInt32 nNewWidth);
    void OverrideBelowWidth(sal_uInt32 nNewWidth);
    void OverrideBetweenWidth(sal_uInt32 nNewWidth);
    void OverrideRightWidth(sal_uInt32 nNewWidth);
    void OverrideBetweenMargin(sal_uInt32 nNewMargin);
 
    inline void RevertBorderStuff();
    inline void RevertBetweenStuff();
    inline void RevertShadow();
    inline void RevertMargins();
    inline void RevertAboveType();
    inline void RevertBelowType();
    inline void RevertRightType();
    inline void RevertBetweenType();
    inline void RevertAboveWidth();
    inline void RevertBelowWidth();
    inline void RevertBetweenWidth();
    inline void RevertRightWidth();
    inline void RevertBetweenMargin();
 
    friend class LwpParaBorderPiece;
 
private:
    LwpParaBorderOverride(LwpParaBorderOverride const& rOther);
    LwpParaBorderOverride& operator=(LwpParaBorderOverride const& rOther) = delete;
 
    enum
    {
        PBO_STUFF           = 0x0001,
        PBO_SHADOW          = 0x0002,
        PBO_MARGINS         = 0x0004,
        PBO_ABOVETYPE       = 0x0008,
        PBO_BELOWTYPE       = 0x0010,
        PBO_RIGHTTYPE       = 0x0020,
        PBO_ABOVE           = 0x0040,
        PBO_BELOW           = 0x0080,
        PBO_BETWEENSTUFF    = 0x0100,
        PBO_BETWEENTYPE     = 0x0200,
        PBO_BETWEEN         = 0x0400,
        PBO_BETWEENMARGIN   = 0x0800,
        PBO_RIGHT           = 0x1000
    };
 
    std::unique_ptr<LwpBorderStuff> m_pBorderStuff;
    std::unique_ptr<LwpBorderStuff> m_pBetweenStuff;
    std::unique_ptr<LwpShadow>      m_pShadow;
    std::unique_ptr<LwpMargins>     m_pMargins;
 
    BorderWidthType     m_eAboveType;
    BorderWidthType     m_eBelowType;
    BorderWidthType     m_eRightType;
    BorderWidthType     m_eBetweenType;
 
    sal_uInt32          m_nAboveWidth;
    sal_uInt32          m_nBelowWidth;
    sal_uInt32          m_nBetweenWidth;
    sal_uInt32          m_nRightWidth;
 
    sal_uInt32          m_nBetweenMargin;
};
 
inline bool LwpParaBorderOverride::IsBorderStuffOverridden() const
{
    return ((m_nOverride & PBO_STUFF) != 0);
}
inline bool LwpParaBorderOverride::IsBetweenStuffOverridden() const
{
    return ((m_nOverride & PBO_BETWEENSTUFF) != 0);
}
inline bool LwpParaBorderOverride::IsShadowOverridden() const
{
    return ((m_nOverride & PBO_SHADOW) != 0);
}
inline bool LwpParaBorderOverride::IsMarginsOverridden() const
{
    return ((m_nOverride & PBO_MARGINS) != 0);
}
inline bool LwpParaBorderOverride::IsAboveTypeOverridden() const
{
    return ((m_nOverride & PBO_ABOVETYPE) != 0);
}
inline bool LwpParaBorderOverride::IsBelowTypeOverridden() const
{
    return ((m_nOverride & PBO_BELOWTYPE) != 0);
}
inline bool LwpParaBorderOverride::IsRightTypeOverridden() const
{
    return ((m_nOverride & PBO_RIGHTTYPE) != 0);
}
inline bool LwpParaBorderOverride::IsBetweenTypeOverridden() const
{
    return ((m_nOverride & PBO_BETWEENTYPE) != 0);
}
inline bool LwpParaBorderOverride::IsAboveWidthOverridden() const
{
    return ((m_nOverride & PBO_ABOVE) != 0);
}
inline bool LwpParaBorderOverride::IsBelowWidthOverridden() const
{
    return ((m_nOverride & PBO_BELOW) != 0);
}
inline bool LwpParaBorderOverride::IsBetweenWidthOverridden() const
{
    return ((m_nOverride & PBO_BETWEEN) != 0);
}
inline bool LwpParaBorderOverride::IsRightWidthOverridden() const
{
    return ((m_nOverride & PBO_RIGHT) != 0);
}
inline bool LwpParaBorderOverride::IsBetweenMarginOverridden() const
{
    return ((m_nOverride & PBO_BETWEENMARGIN) != 0);
}
 
inline void LwpParaBorderOverride::RevertBorderStuff()
{
    LwpOverride::Override(PBO_STUFF, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBetweenStuff()
{
    LwpOverride::Override(PBO_BETWEENSTUFF, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertShadow()
{
    LwpOverride::Override(PBO_SHADOW, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertMargins()
{
    LwpOverride::Override(PBO_MARGINS, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertAboveType()
{
    LwpOverride::Override(PBO_ABOVETYPE, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBelowType()
{
    LwpOverride::Override(PBO_BELOWTYPE, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertRightType()
{
    LwpOverride::Override(PBO_RIGHTTYPE, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBetweenType()
{
    LwpOverride::Override(PBO_BETWEENTYPE, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertAboveWidth()
{
    LwpOverride::Override(PBO_ABOVE, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBelowWidth()
{
    LwpOverride::Override(PBO_BELOW, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBetweenWidth()
{
    LwpOverride::Override(PBO_BETWEEN, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertRightWidth()
{
    LwpOverride::Override(PBO_RIGHT, STATE_STYLE);
}
inline void LwpParaBorderOverride::RevertBetweenMargin()
{
    LwpOverride::Override(PBO_BETWEENMARGIN, STATE_STYLE);
}
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */