/* -*- 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
 *  For LWP filter architecture prototype
 ************************************************************************/
/*************************************************************************
 * Change History
 Jan 2005			Created
 ************************************************************************/

#ifndef _LWPOVERRIDE_HXX
#define _LWPOVERRIDE_HXX

#include "lwpobjid.hxx"
#include "lwptools.hxx"

class LwpObjectStream;

enum STATE
{
    STATE_OFF	= 0,
    STATE_ON	= 1,
    STATE_STYLE	= 2
};

class LwpOverride
{
public:
    LwpOverride() : m_nValues(0), m_nOverride(0), m_nApply(0) {};

    virtual ~LwpOverride(){}

    virtual void Read(LwpObjectStream* pStrm) = 0;

    virtual void operator=(const LwpOverride& rOther);

    void ReadCommon(LwpObjectStream* pStrm);

    void Clear();

    void Override(sal_uInt16 nBits, STATE eState);

protected:
    sal_uInt16	m_nValues;
    sal_uInt16	m_nOverride;
    sal_uInt16	m_nApply;
};

/////////////////////////////////////////////////////////////////
class LwpTextLanguageOverride : public LwpOverride
{
public:
    LwpTextLanguageOverride() : m_nLanguage(0) {};

    void Read(LwpObjectStream* pStrm);

private:
    sal_uInt16	m_nLanguage;
};

/////////////////////////////////////////////////////////////////
class LwpTextAttributeOverride : public LwpOverride
{
public:
    LwpTextAttributeOverride() : m_nHideLevels(0), m_nBaseLineOffset(0) {};

    void Read(LwpObjectStream* pStrm);

    inline sal_uInt16 GetHideLevels() const;

    sal_Bool IsHighLight();

private:
    enum{
    TAO_HIGHLIGHT = 0x08,
    };
    sal_uInt16	m_nHideLevels;
    sal_uInt32	m_nBaseLineOffset;
};

inline sal_uInt16 LwpTextAttributeOverride::GetHideLevels() const
{
    return m_nHideLevels;
}
/////////////////////////////////////////////////////////////////
class LwpKinsokuOptsOverride : public LwpOverride
{
public:
    LwpKinsokuOptsOverride() : m_nLevels(0) {};

    void Read(LwpObjectStream* pStrm);

private:
    sal_uInt16	m_nLevels;
};

/////////////////////////////////////////////////////////////////
class LwpBulletOverride : public LwpOverride
{
public:
    LwpBulletOverride() {m_bIsNull = sal_True;}

    void Read(LwpObjectStream* pStrm);

    inline LwpObjectID GetSilverBullet() const;

    void operator=(const LwpOverride& rOther);

    void Override(LwpBulletOverride* pOther);

    inline sal_Bool IsSilverBulletOverridden();
    inline sal_Bool IsSkipOverridden();
    inline sal_Bool IsRightAlignedOverridden();
    inline sal_Bool IsSkip();
    inline sal_Bool IsRightAligned();
    inline sal_Bool IsEditable();


    void OverrideSilverBullet(LwpObjectID aID);
    void OverrideSkip(sal_Bool bOver);
    void OverrideRightAligned(sal_Bool bOver);

    inline void RevertSilverBullet();
    inline void RevertSkip();
    inline void RevertRightAligned();

    sal_Bool IsInValid(){return m_bIsNull;}
private:
    enum
    {
        BO_SILVERBULLET	= 0x01,
        // 0x02 is free
        BO_RIGHTALIGN	= 0x04,
        BO_EDITABLE		= 0x08,
        BO_SKIP			= 0x10
    };

    LwpObjectID	m_SilverBullet;
    sal_Bool m_bIsNull;
};
inline LwpObjectID LwpBulletOverride::GetSilverBullet() const
{
    return m_SilverBullet;
}

inline sal_Bool LwpBulletOverride::IsSilverBulletOverridden()
{
    return (sal_Bool)((m_nOverride & BO_SILVERBULLET) != 0);
}

inline sal_Bool LwpBulletOverride::IsSkipOverridden()
{
    return (sal_Bool)((m_nOverride & BO_SKIP) != 0);
}

inline sal_Bool LwpBulletOverride::IsRightAlignedOverridden()
{
    return (sal_Bool)((m_nOverride & BO_RIGHTALIGN) != 0);
}

inline sal_Bool LwpBulletOverride::IsSkip()
{
    return (sal_Bool)((m_nValues & BO_SKIP) != 0);
}

inline sal_Bool LwpBulletOverride::IsEditable()
{
    return (sal_Bool)((m_nValues & BO_EDITABLE) != 0);
}

inline sal_Bool LwpBulletOverride::IsRightAligned()
{
    return (sal_Bool)((m_nValues & BO_RIGHTALIGN) != 0);
}

inline void LwpBulletOverride::RevertSilverBullet()
{
    LwpOverride::Override(BO_SILVERBULLET, STATE_STYLE);
}

inline void LwpBulletOverride::RevertSkip()
{
    LwpOverride::Override(BO_SKIP, STATE_STYLE);
}

inline void LwpBulletOverride::RevertRightAligned()
{
    LwpOverride::Override(BO_RIGHTALIGN, STATE_STYLE);
}

/////////////////////////////////////////////////////////////////
class LwpAlignmentOverride : public LwpOverride
{
public:
    LwpAlignmentOverride() : m_nAlignType(ALIGN_LEFT), m_nPosition(0), m_nAlignChar(0){};

    void Read(LwpObjectStream* pStrm);

    enum AlignType
    {
        ALIGN_LEFT			= 0,
        ALIGN_RIGHT			= 1,
        ALIGN_CENTER		= 2,
        ALIGN_JUSTIFY		= 3,
        ALIGN_JUSTIFYALL	= 4,
        ALIGN_NUMERICLEFT	= 5,
        ALIGN_NUMERICRIGHT	= 6,
        ALIGN_SQUEEZE		= 7
    };

    AlignType GetAlignType(){ return m_nAlignType; }
    void Override(LwpAlignmentOverride* other);//add by  1-24
    void OverrideAlignment(AlignType val);//add by  1-24
private:
    enum
    {
        AO_TYPE		= 0x01,
        AO_POSITION	= 0x02,
        AO_CHAR		= 0x04
    };

    AlignType	m_nAlignType;
    sal_uInt32	m_nPosition;
    sal_uInt16	m_nAlignChar;
};

/////////////////////////////////////////////////////////////////
class LwpSpacingCommonOverride : public LwpOverride
{
public:
    LwpSpacingCommonOverride() : m_nSpacingType(SPACING_NONE), m_nAmount(0), m_nMultiple(65536){};

    void Read(LwpObjectStream* pStrm);

    enum SpacingType
    {
        SPACING_DYNAMIC	= 0,
        SPACING_LEADING	= 1,
        SPACING_CUSTOM	= 2,
        SPACING_NONE	= 3
    };

    SpacingType GetType() const {return m_nSpacingType;};
    sal_Int32 GetAmount() const {return m_nAmount;};
    sal_Int32 GetMultiple() const {return m_nMultiple;};

    void Override(LwpSpacingCommonOverride* other);
    void OverrideType(SpacingType val);
    void OverrideAmount(sal_Int32 val);
    void OverrideMultiple(sal_Int32 val);

protected:
    enum
    {
        SPO_TYPE	= 0x01,
        SPO_AMOUNT	= 0x02,
        SPO_MULTIPLE= 0x04
    };
    SpacingType	m_nSpacingType;//sal_uInt16
    sal_Int32	m_nAmount;
    sal_Int32	m_nMultiple;

};

/////////////////////////////////////////////////////////////////
class LwpSpacingOverride : public LwpOverride
{
public:
    LwpSpacingOverride();
    LwpSpacingOverride& operator=(LwpSpacingOverride& other);
    virtual ~LwpSpacingOverride();

    void Read(LwpObjectStream* pStrm);

    void Override(LwpSpacingOverride* other);

    LwpSpacingCommonOverride* GetSpacing(){return m_pSpacing;};
    LwpSpacingCommonOverride* GetAboveLineSpacing(){return m_pAboveLineSpacing;};
    LwpSpacingCommonOverride* GetAboveSpacing(){return m_pParaSpacingAbove;};
    LwpSpacingCommonOverride* GetBelowSpacing(){return m_pParaSpacingBelow;};
private:
    LwpSpacingCommonOverride*	m_pSpacing;
    LwpSpacingCommonOverride*	m_pAboveLineSpacing;
    LwpSpacingCommonOverride*	m_pParaSpacingAbove;
    LwpSpacingCommonOverride*	m_pParaSpacingBelow;
};

/////////////////////////////////////////////////////////////////
class LwpIndentOverride : public LwpOverride
{
public:
    LwpIndentOverride() : m_nAll(0), m_nFirst(0), m_nRest(0), m_nRight(0) {};
    LwpIndentOverride& operator=(LwpIndentOverride& other);
    void Read(LwpObjectStream* pStrm);

    enum
    {
        RELATIVE_FIRST, RELATIVE_REST, RELATIVE_ALL
    };

    inline double GetFirst() const;
    inline double GetLeft() const;
    inline double GetRight() const;

    sal_uInt16 GetRelative();
    sal_Bool IsUseRelative();
    void Override(LwpIndentOverride* other);
    void OverrideIndentAll(sal_Int32 val);
    void OverrideIndentFirst(sal_Int32 val);
    void OverrideIndentRight(sal_Int32 val);
    void OverrideIndentRest(sal_Int32 val);
    void OverrideUseRelative(sal_Bool use);
    void OverrideRelative(sal_uInt16 relative);
    sal_Int32 GetMAll() const {return m_nAll;}
    sal_Int32 GetMFirst() const {return m_nFirst;}
    sal_Int32 GetMRest() const {return m_nRest;}
    sal_Int32 GetMRight() const {return m_nRight;}
    void SetMAll(sal_Int32 val){m_nAll=val;}
    void SetMFirst(sal_Int32 val){m_nFirst=val;}
    void SetMRest(sal_Int32 val){m_nRest=val;}
    void SetMRight(sal_Int32 val){m_nRight=val;}
private:
    enum
    {
        IO_ALL			= 0x0001,
        IO_FIRST		= 0x0002,
        IO_REST			= 0x0004,
        IO_RIGHT		= 0x0008,
        IO_HANGING		= 0x0010,
        IO_EQUAL		= 0x0020,
        IO_BODY			= 0x0040,
        IO_REL_ALL		= 0x0080,
        IO_REL_FIRST	= 0x0100,
        IO_REL_REST		= 0x0200,
        IO_REL_FLAGS	= (IO_REL_ALL | IO_REL_FIRST | IO_REL_REST),
#ifdef JAPANESE_ENABLED // 96/4/8 ueda for indentation by char width
        IO_USE_RELATIVE	= 0x0400,
        IO_CHARUNIT		= 0x0800
#else
        IO_USE_RELATIVE	= 0x0400
#endif
    };

    sal_Int32	m_nAll;
    sal_Int32	m_nFirst;
    sal_Int32	m_nRest;
    sal_Int32	m_nRight;
};
inline double LwpIndentOverride::GetFirst() const
{
        return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nFirst-m_nRest));
}
inline double LwpIndentOverride::GetLeft() const
{
        return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nAll+m_nRest));
}
inline double LwpIndentOverride::GetRight() const
{
    return LwpTools::ConvertToMetric(LwpTools::ConvertFromUnits(m_nRight));
}

/////////////////////////////////////////////////////////////////
class LwpBackgroundStuff;
class LwpAmikakeOverride : public LwpOverride
{
public:
    LwpAmikakeOverride();

    virtual ~LwpAmikakeOverride();

    void Read(LwpObjectStream* pStrm);
    enum
    {
        AMIKAKE_NONE		= 0,
        AMIKAKE_BACKGROUND	= 1,
        AMIKAKE_CHARACTER	= 2
    };

private:
    LwpBackgroundStuff*	m_pBackgroundStuff;
    sal_uInt16		m_nType;

};

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
