/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#include <StyleSheetTable.hxx>
#include <dmapper/DomainMapper.hxx>
#include <NumberingManager.hxx>
#include <ConversionHelper.hxx>
#include <TblStylePrHandler.hxx>
#include <BorderHandler.hxx>
#include <doctok/resourceids.hxx>
#include <ooxml/resourceids.hxx>
#include <vector>
#include <com/sun/star/beans/XMultiPropertySet.hpp>
#include <com/sun/star/beans/XPropertyState.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/text/XChapterNumberingSupplier.hpp>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
#include <com/sun/star/style/XStyle.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <map>
#include <stdio.h>
#include <rtl/ustrbuf.hxx>

#include <dmapperLoggers.hxx>

using namespace ::com::sun::star;
namespace writerfilter {
namespace dmapper
{

typedef ::std::map< ::rtl::OUString, ::rtl::OUString> StringPairMap_t;

/*-- 21.06.2006 07:34:44---------------------------------------------------

  -----------------------------------------------------------------------*/
StyleSheetEntry::StyleSheetEntry() :
        sStyleIdentifierI()
        ,sStyleIdentifierD()
        ,bIsDefaultStyle(false)
        ,bInvalidHeight(false)
        ,bHasUPE(false)
        ,nStyleTypeCode(STYLE_TYPE_UNKNOWN)
        ,sBaseStyleIdentifier()
        ,sNextStyleIdentifier()
        ,pProperties(new StyleSheetPropertyMap)
{
#if OSL_DEBUG_LEVEL > 1
            nStyleTypeCode = STYLE_TYPE_PARA;
#endif
}

StyleSheetEntry::~StyleSheetEntry()
{
}

TableStyleSheetEntry::TableStyleSheetEntry( StyleSheetEntry& rEntry, StyleSheetTable* pStyles ):
    StyleSheetEntry( ),
    m_pStyleSheet( pStyles )
{

    bIsDefaultStyle = rEntry.bIsDefaultStyle;
    bInvalidHeight = rEntry.bInvalidHeight;
    bHasUPE = rEntry.bHasUPE;
    nStyleTypeCode = STYLE_TYPE_TABLE;
    sBaseStyleIdentifier = rEntry.sBaseStyleIdentifier;
    sNextStyleIdentifier = rEntry.sNextStyleIdentifier;
    sStyleName = rEntry.sStyleName;
    sStyleName1 = rEntry.sStyleName1;
	sStyleIdentifierI = rEntry.sStyleIdentifierI;
	sStyleIdentifierD = rEntry.sStyleIdentifierD;

    m_nColBandSize = 1;
    m_nRowBandSize = 1;
}

TableStyleSheetEntry::~TableStyleSheetEntry( )
{
    m_pStyleSheet = NULL;
}

void TableStyleSheetEntry::AddTblStylePr( TblStyleType nType, PropertyMapPtr pProps )
{
    static TblStyleType pTypesToFix[] =
    {
        TBL_STYLE_FIRSTROW,
        TBL_STYLE_LASTROW,
        TBL_STYLE_FIRSTCOL,
        TBL_STYLE_LASTCOL
    };

    static PropertyIds pPropsToCheck[] =
    {
        PROP_BOTTOM_BORDER,
        PROP_TOP_BORDER,
        PROP_RIGHT_BORDER,
        PROP_LEFT_BORDER
    };

    int i = 0;
    while ( i < 4 )
    {
        if ( nType == pTypesToFix[i] )
        {
            PropertyIds nChecked = pPropsToCheck[i];
            PropertyMap::iterator pCheckedIt = pProps->find( PropertyDefinition( nChecked, false )  );

            PropertyIds nInsideProp = ( i < 2 ) ? META_PROP_HORIZONTAL_BORDER : META_PROP_VERTICAL_BORDER;
            PropertyMap::iterator pInsideIt = pProps->find( PropertyDefinition( nInsideProp, false )  );

            bool bHasChecked = pCheckedIt != pProps->end( );
            bool bHasInside = pInsideIt != pProps->end( );

            if ( bHasChecked && bHasInside )
            {
                // In this case, remove the inside border
                pProps->erase( pInsideIt );
            }

            i = 4; // Stop looping stupidly
        }
        i++;
    }

    // Append the tblStylePr
    m_aStyles[nType] = pProps;
}

PropertyMapPtr TableStyleSheetEntry::GetProperties( sal_Int32 nMask, StyleSheetEntryDequePtr pStack )
{
    PropertyMapPtr pProps( new PropertyMap );

    // First get the parent properties
    StyleSheetEntryPtr pEntry = m_pStyleSheet->FindParentStyleSheet( sBaseStyleIdentifier );

    if ( pEntry.get( ) )
    {
        if (pStack.get() == NULL)
            pStack.reset(new StyleSheetEntryDeque());

        StyleSheetEntryDeque::const_iterator aIt = find(pStack->begin(), pStack->end(), pEntry);

        if (aIt != pStack->end())
        {
            pStack->push_back(pEntry);
            
        TableStyleSheetEntry* pParent = static_cast<TableStyleSheetEntry *>( pEntry.get( ) );
            pProps->insert( pParent->GetProperties( nMask ), (pStack.get() != NULL) );
            
            pStack->pop_back();
    }
    }
    
    // And finally get the mask ones
    pProps->insert( GetLocalPropertiesFromMask( nMask ) );

    return pProps;
}

void lcl_mergeProps( PropertyMapPtr pToFill,  PropertyMapPtr pToAdd, TblStyleType nStyleId )
{
    static PropertyIds pPropsToCheck[] =
    {
        PROP_BOTTOM_BORDER,
        PROP_TOP_BORDER,
        PROP_RIGHT_BORDER,
        PROP_LEFT_BORDER,
    };

    bool pRemoveInside[] =
    {
        ( nStyleId == TBL_STYLE_FIRSTROW ),
        ( nStyleId == TBL_STYLE_LASTROW ),
        ( nStyleId == TBL_STYLE_LASTCOL ),
        ( nStyleId == TBL_STYLE_FIRSTCOL )
    };

    for ( unsigned i = 0 ; i != sizeof(pPropsToCheck) / sizeof(PropertyIds); i++ )
    {
        PropertyIds nId = pPropsToCheck[i];
        PropertyDefinition aProp( nId, false );
        PropertyMap::iterator pIt = pToAdd->find( aProp );
   
        if ( pIt != pToAdd->end( ) )
        {
            PropertyMap::iterator pDestIt = pToFill->find( aProp );
            
            if ( pRemoveInside[i] )
            {
                // Remove the insideH and insideV depending on the cell pos
                PropertyIds nInsideProp = ( i < 2 ) ? META_PROP_HORIZONTAL_BORDER : META_PROP_VERTICAL_BORDER;
                pDestIt = pToFill->find( PropertyDefinition( nInsideProp, false ) );
                if ( pDestIt != pToFill->end( ) )
                    pToFill->erase( pDestIt );
            }
        }    
    }

    pToFill->insert( pToAdd );
}

void TableStyleSheetEntry::MergePropertiesFromMask(const short nBit, const sal_Int32 nMask, 
                                                   const TblStyleType nStyleId,
                                                   PropertyMapPtr pToFill)
{
    TblStylePrs::iterator pIt = m_aStyles.find( nStyleId );

    short nTestBit = 1 << nBit;
    sal_Int32 nBitMask = sal_Int32( nTestBit );
    if ( ( nMask & nBitMask ) && ( pIt != m_aStyles.end( ) ) )
        lcl_mergeProps( pToFill, pIt->second, nStyleId );
}

PropertyMapPtr TableStyleSheetEntry::GetLocalPropertiesFromMask( const sal_Int32 nMask )
{
    // Order from right to left
    static TblStyleType aBitsOrder[] = 
    {
        TBL_STYLE_SWCELL,
        TBL_STYLE_SECELL,
        TBL_STYLE_NWCELL,
        TBL_STYLE_NECELL,
        TBL_STYLE_BAND2HORZ,
        TBL_STYLE_BAND1HORZ,
        TBL_STYLE_BAND2VERT,
        TBL_STYLE_BAND1VERT,
        TBL_STYLE_LASTCOL,
        TBL_STYLE_FIRSTCOL,
        TBL_STYLE_LASTROW,
        TBL_STYLE_FIRSTROW,
        TBL_STYLE_UNKNOWN
    };

    // Get the properties applying according to the mask
    PropertyMapPtr pProps( new PropertyMap( ) );
    short nBit = 4;
    do
    {
        MergePropertiesFromMask(nBit, nMask, aBitsOrder[nBit], pProps);
        nBit++;
    }
    while ( nBit < 13 );

    nBit = 0;
    do
    {
        MergePropertiesFromMask(nBit, nMask, aBitsOrder[nBit], pProps);
        nBit++;
    }
    while ( nBit < 4 );         // nw/ne/sw/se overwrite others

    return pProps;
}

/*-- 06.02.2008 11:30:46---------------------------------------------------

  -----------------------------------------------------------------------*/
struct ListCharStylePropertyMap_t
{
    ::rtl::OUString         sCharStyleName;
    PropertyValueVector_t   aPropertyValues;

    ListCharStylePropertyMap_t(const ::rtl::OUString& rCharStyleName, const PropertyValueVector_t& rPropertyValues):
        sCharStyleName( rCharStyleName ),
        aPropertyValues( rPropertyValues )
        {}
};
typedef std::vector< ListCharStylePropertyMap_t > ListCharStylePropertyVector_t;
/*-- 19.06.2006 12:04:32---------------------------------------------------

  -----------------------------------------------------------------------*/
struct StyleSheetTable_Impl
{
    DomainMapper&                           m_rDMapper;
    uno::Reference< text::XTextDocument>    m_xTextDocument;
    uno::Reference< beans::XPropertySet>    m_xTextDefaults; 
    std::vector< StyleSheetEntryPtr >       m_aStyleSheetEntries;
    StyleSheetEntryPtr                      m_pCurrentEntry;
    PropertyMapPtr                          m_pDefaultParaProps, m_pDefaultCharProps;
    PropertyMapPtr                          m_pCurrentProps;
    StringPairMap_t                         m_aStyleNameMap;
    ListCharStylePropertyVector_t           m_aListCharStylePropertyVector;
    
    
    StyleSheetTable_Impl(DomainMapper& rDMapper, uno::Reference< text::XTextDocument> xTextDocument);

    ::rtl::OUString HasListCharStyle( const PropertyValueVector_t& rCharProperties );
};
/*-- 15.11.2007 08:30:02---------------------------------------------------

  -----------------------------------------------------------------------*/
StyleSheetTable_Impl::StyleSheetTable_Impl(DomainMapper& rDMapper, uno::Reference< text::XTextDocument> xTextDocument ) :
            m_rDMapper( rDMapper ),
            m_xTextDocument( xTextDocument ),
            m_pCurrentEntry(),
            m_pDefaultParaProps(new PropertyMap),
            m_pDefaultCharProps(new PropertyMap)
{
    //set font height default to 10pt
    uno::Any aVal = uno::makeAny( double(10.) );
    m_pDefaultCharProps->Insert( PROP_CHAR_HEIGHT, true, aVal );
    m_pDefaultCharProps->Insert( PROP_CHAR_HEIGHT_ASIAN, true, aVal );
    m_pDefaultCharProps->Insert( PROP_CHAR_HEIGHT_COMPLEX, true, aVal );
}
/*-- 06.02.2008 11:45:21---------------------------------------------------

  -----------------------------------------------------------------------*/
::rtl::OUString StyleSheetTable_Impl::HasListCharStyle( const PropertyValueVector_t& rPropValues )
{
    ::rtl::OUString sRet;
    ListCharStylePropertyVector_t::const_iterator aListVectorIter = m_aListCharStylePropertyVector.begin();
    while( aListVectorIter != m_aListCharStylePropertyVector.end() )
    {
        //if size is identical
        if( aListVectorIter->aPropertyValues.size() == rPropValues.size() )
        {
            bool bBreak = false;
            //then search for all contained properties
            PropertyValueVector_t::const_iterator aList1Iter = rPropValues.begin();
            while( aList1Iter != rPropValues.end() && !bBreak)
            {
                //find the property
                bool bElementFound = false;
                PropertyValueVector_t::const_iterator aList2Iter = aListVectorIter->aPropertyValues.begin();
                while( aList2Iter != aListVectorIter->aPropertyValues.end() && !bBreak )
                {
                    if( aList2Iter->Name == aList1Iter->Name )
                    {
                        bElementFound = true;
                        if( aList2Iter->Value != aList1Iter->Value )
                            bBreak = true;
                        break;
                    }
                    ++aList2Iter;
                }
                //set break flag if property hasn't been found
                if(!bElementFound )
                {
                    bBreak = true;
                    break;
                }
                ++aList1Iter;
            }    
            if( !bBreak )
                return aListVectorIter->sCharStyleName;
        }
        ++aListVectorIter;
    }
    return sRet;    
}    
/*-- 19.06.2006 12:04:32---------------------------------------------------

  -----------------------------------------------------------------------*/
StyleSheetTable::StyleSheetTable(DomainMapper& rDMapper, uno::Reference< text::XTextDocument> xTextDocument) 
: LoggedProperties(dmapper_logger, "StyleSheetTable")
, LoggedTable(dmapper_logger, "StyleSheetTable")
, m_pImpl( new StyleSheetTable_Impl(rDMapper, xTextDocument) )
{
}
/*-- 19.06.2006 12:04:33---------------------------------------------------

  -----------------------------------------------------------------------*/
StyleSheetTable::~StyleSheetTable()
{
    delete m_pImpl;
}
/*-- 19.06.2006 12:04:33---------------------------------------------------

  -----------------------------------------------------------------------*/
void StyleSheetTable::lcl_attribute(Id Name, Value & val)
{
    OSL_ENSURE( m_pImpl->m_pCurrentEntry, "current entry has to be set here");
    if(!m_pImpl->m_pCurrentEntry)
        return ;
    int nIntValue = val.getInt();
    (void)nIntValue;
    ::rtl::OUString sValue = val.getString();
//    printf ( "StyleSheetTable::attribute(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)Name, (unsigned int)nIntValue, ::rtl::OUStringToOString(sValue, RTL_TEXTENCODING_DONTKNOW).getStr());
    /* WRITERFILTERSTATUS: table: StyleSheetTable_attributedata */
    switch(Name)
    {
        case NS_rtf::LN_ISTD:
            /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sStyleIdentifierD = ::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16);
        break;
        case NS_rtf::LN_STI:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
        {
            ::rtl::OUString tempStyleIdentifier = GetStyleIdFromIndex(static_cast<sal_uInt32>(nIntValue));
            if (tempStyleIdentifier.getLength())
                m_pImpl->m_pCurrentEntry->sStyleIdentifierI = tempStyleIdentifier;
            if (nIntValue == 0 || nIntValue == 65)
                m_pImpl->m_pCurrentEntry->bIsDefaultStyle = true;
        }
        break;
        case NS_rtf::LN_SGC:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->nStyleTypeCode = (StyleType)nIntValue;
        break;
        case NS_rtf::LN_ISTDBASE:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            if (static_cast<sal_uInt32>(nIntValue) != 0xfff)
                m_pImpl->m_pCurrentEntry->sBaseStyleIdentifier = ::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16);
        break;
        case NS_rtf::LN_ISTDNEXT:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            if (static_cast<sal_uInt32>(nIntValue) != 0xfff)
                m_pImpl->m_pCurrentEntry->sNextStyleIdentifier = ::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16);
        break;
        case NS_rtf::LN_FSCRATCH:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_FINVALHEIGHT:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_FHASUPE:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_FMASSCOPY:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_CUPX:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_BCHUPE:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_FAUTOREDEF:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_FHIDDEN:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        case NS_rtf::LN_UNUSED8_3:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
            //noone seems to care about it
        break;
        case NS_rtf::LN_XSTZNAME:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sStyleName1 = sValue;
            if (m_pImpl->m_pCurrentEntry->sStyleIdentifierI.getLength())
                m_pImpl->m_pCurrentEntry->sStyleIdentifierI = sValue;
        break;
        case NS_rtf::LN_XSTZNAME1:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sStyleName = sValue;
            if (m_pImpl->m_pCurrentEntry->sStyleIdentifierI.getLength())
                m_pImpl->m_pCurrentEntry->sStyleIdentifierI = sValue;
        break;
        case NS_rtf::LN_UPX:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            resolveAttributeProperties(val);
        break;
        case NS_ooxml::LN_CT_Style_type:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
        {
/*          defaults should be set at the service "com.sun.star.text.Defaults"          
             if (nIntValue == 1)
                *(m_pImpl->m_pCurrentEntry->pProperties) = *(m_pImpl->m_pDefaultParaProps);
            else if (nIntValue == 2)
                *(m_pImpl->m_pCurrentEntry->pProperties) = *(m_pImpl->m_pDefaultCharProps);*/
            StyleType nType = ( StyleType ) nIntValue;
            if ( nType == STYLE_TYPE_TABLE )
            {
                StyleSheetEntryPtr pEntry = m_pImpl->m_pCurrentEntry;
                TableStyleSheetEntryPtr pTableEntry( new TableStyleSheetEntry( *pEntry.get( ), this ) );
                m_pImpl->m_pCurrentEntry = pTableEntry;
            }
            else
                m_pImpl->m_pCurrentEntry->nStyleTypeCode = (StyleType)nIntValue;
        }
        break;
        case NS_ooxml::LN_CT_Style_default:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->bIsDefaultStyle = (nIntValue != 0);
        break;
        case NS_ooxml::LN_CT_Style_customStyle:
        /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        break;
        case NS_ooxml::LN_CT_Style_styleId:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sStyleIdentifierI = sValue;
            m_pImpl->m_pCurrentEntry->sStyleIdentifierD = sValue;
        break;
        case NS_ooxml::LN_CT_TblWidth_w:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            dynamic_cast< StyleSheetPropertyMap* >( m_pImpl->m_pCurrentEntry->pProperties.get() )->SetCT_TblWidth_w( nIntValue );
        break;
        case NS_ooxml::LN_CT_TblWidth_type:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            dynamic_cast< StyleSheetPropertyMap* >( m_pImpl->m_pCurrentEntry->pProperties.get() )->SetCT_TblWidth_type( nIntValue );
        break;
        default:
        {
#ifdef DEBUG_DOMAINMAPPER
            dmapper_logger->element("unhandled");
#endif
        }
        break;
    }
}
/*-- 19.06.2006 12:04:33---------------------------------------------------

  -----------------------------------------------------------------------*/
void StyleSheetTable::lcl_sprm(Sprm & rSprm)
{
    sal_uInt32 nSprmId = rSprm.getId();
    Value::Pointer_t pValue = rSprm.getValue();
    sal_Int32 nIntValue = pValue.get() ? pValue->getInt() : 0;
    (void)nIntValue;
    rtl::OUString sStringValue = pValue.get() ? pValue->getString() : rtl::OUString();
    //printf ( "StyleSheetTable::sprm(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nSprmId, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
   
    /* WRITERFILTERSTATUS: table: StyleSheetTable_sprm */
    switch(nSprmId)
    {
        case NS_ooxml::LN_CT_Style_name:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            //this is only a UI name!
            m_pImpl->m_pCurrentEntry->sStyleName = sStringValue;
            m_pImpl->m_pCurrentEntry->sStyleName1 = sStringValue;
            break;      
        case NS_ooxml::LN_CT_Style_basedOn:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sBaseStyleIdentifier = sStringValue;
            break;
        case NS_ooxml::LN_CT_Style_next:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_pCurrentEntry->sNextStyleIdentifier = sStringValue;
            break;
        case NS_ooxml::LN_CT_Style_aliases:
        case NS_ooxml::LN_CT_Style_link:
        case NS_ooxml::LN_CT_Style_autoRedefine:
        case NS_ooxml::LN_CT_Style_hidden:
        case NS_ooxml::LN_CT_Style_uiPriority:
        case NS_ooxml::LN_CT_Style_semiHidden:
        case NS_ooxml::LN_CT_Style_unhideWhenUsed:
        case NS_ooxml::LN_CT_Style_qFormat:
        case NS_ooxml::LN_CT_Style_locked:
        case NS_ooxml::LN_CT_Style_personal:
        case NS_ooxml::LN_CT_Style_personalCompose:
        case NS_ooxml::LN_CT_Style_personalReply:
        case NS_ooxml::LN_CT_Style_rsid:
        case NS_ooxml::LN_CT_Style_trPr:
            /* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
        break;
        case NS_ooxml::LN_CT_Style_tcPr:
        {
            resolveSprmProps(rSprm);
        }
        break;
        case NS_ooxml::LN_CT_Style_tblPr: //contains table properties
        case NS_ooxml::LN_CT_Style_tblStylePr: //contains  to table properties

        case NS_ooxml::LN_CT_TblPrBase_tblInd: //table properties - at least width value and type
        case NS_ooxml::LN_EG_RPrBase_rFonts: //table fonts
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
        {
            writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
            if( pProperties.get())
            {
                TblStylePrHandlerPtr pTblStylePrHandler( new TblStylePrHandler( m_pImpl->m_rDMapper ) );
                pProperties->resolve( *pTblStylePrHandler );

                // Add the properties to the table style
                TblStyleType nType = pTblStylePrHandler->getType( );
                PropertyMapPtr pProps = pTblStylePrHandler->getProperties( );
                StyleSheetEntry *  pEntry = m_pImpl->m_pCurrentEntry.get();
                
                if (nType == TBL_STYLE_UNKNOWN)
                {
                    pEntry->pProperties->insert(pProps);
                }
                else
                {
                    TableStyleSheetEntry * pTableEntry = dynamic_cast<TableStyleSheetEntry*>( pEntry );
                    if (pTableEntry != NULL)
                        pTableEntry->AddTblStylePr( nType, pProps );
                }
            }
            break;
        }
        case NS_ooxml::LN_CT_PPrDefault_pPr:
        case NS_ooxml::LN_CT_DocDefaults_pPrDefault:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_rDMapper.PushStyleSheetProperties( m_pImpl->m_pDefaultParaProps );
            m_pImpl->m_rDMapper.sprm( rSprm );
            m_pImpl->m_rDMapper.PopStyleSheetProperties();
            applyDefaults( true );
        break;
        case NS_ooxml::LN_CT_RPrDefault_rPr:
        case NS_ooxml::LN_CT_DocDefaults_rPrDefault:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            m_pImpl->m_rDMapper.PushStyleSheetProperties( m_pImpl->m_pDefaultCharProps );
            m_pImpl->m_rDMapper.sprm( rSprm );
            m_pImpl->m_rDMapper.PopStyleSheetProperties();
            applyDefaults( false );
        break;
        case NS_ooxml::LN_CT_TblPrBase_jc:     //table alignment - row properties!
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
             m_pImpl->m_pCurrentEntry->pProperties->Insert( PROP_HORI_ORIENT, false, 
                uno::makeAny( ConversionHelper::convertTableJustification( nIntValue )));
        break;
        case NS_ooxml::LN_CT_TrPrBase_jc:     //table alignment - row properties!
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
                dynamic_cast< StyleSheetPropertyMap* >( m_pImpl->m_pCurrentEntry->pProperties.get() )->SetCT_TrPrBase_jc(nIntValue);
        break;
        case NS_ooxml::LN_CT_TblPrBase_tblBorders: //table borders, might be defined in table style
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
        {    
            writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
            if( pProperties.get())
            {
                BorderHandlerPtr pBorderHandler( new BorderHandler(m_pImpl->m_rDMapper.IsOOXMLImport()) );
                pProperties->resolve(*pBorderHandler);
                m_pImpl->m_pCurrentEntry->pProperties->insert( pBorderHandler->getProperties(), true );
            }
        }
        break;
        case NS_ooxml::LN_CT_TblPrBase_tblStyleRowBandSize:
        case NS_ooxml::LN_CT_TblPrBase_tblStyleColBandSize:
        {
            StyleSheetEntry* pEntry = m_pImpl->m_pCurrentEntry.get( );
            TableStyleSheetEntry *pTEntry = static_cast<TableStyleSheetEntry*>( pEntry );
            if ( pTEntry )
            {
                if ( nSprmId == NS_ooxml::LN_CT_TblPrBase_tblStyleRowBandSize )
                    pTEntry->m_nRowBandSize = nIntValue;
                else
                    pTEntry->m_nColBandSize = nIntValue;
            }
        }
        break;
        case NS_ooxml::LN_CT_TblPrBase_tblCellMar:
            //no cell margins in styles
        break;
        case NS_ooxml::LN_CT_Style_pPr:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            // no break
        case NS_ooxml::LN_CT_Style_rPr:
        /* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
            // no break
        default:
            {
                if (!m_pImpl->m_pCurrentEntry)
                    break;
                
                TablePropertiesHandlerPtr pTblHandler( new TablePropertiesHandler( true ) );
                pTblHandler->SetProperties( m_pImpl->m_pCurrentEntry->pProperties );
                if ( !pTblHandler->sprm( rSprm ) )
                {
                    m_pImpl->m_rDMapper.PushStyleSheetProperties( m_pImpl->m_pCurrentEntry->pProperties );
                    
                    PropertyMapPtr pProps(new PropertyMap());                    
                    m_pImpl->m_rDMapper.sprmWithProps( rSprm, pProps );

                    m_pImpl->m_pCurrentEntry->pProperties->insert(pProps);
                    
                    m_pImpl->m_rDMapper.PopStyleSheetProperties( );
                }
            }
            break;
}
}
/*-- 19.06.2006 12:04:33---------------------------------------------------

  -----------------------------------------------------------------------*/
void StyleSheetTable::lcl_entry(int /*pos*/, writerfilter::Reference<Properties>::Pointer_t ref)
{
    //create a new style entry
    // printf("StyleSheetTable::entry(...)\n");
    OSL_ENSURE( !m_pImpl->m_pCurrentEntry, "current entry has to be NULL here");
    StyleSheetEntryPtr pNewEntry( new StyleSheetEntry );
    m_pImpl->m_pCurrentEntry = pNewEntry;
    m_pImpl->m_rDMapper.PushStyleSheetProperties( m_pImpl->m_pCurrentEntry->pProperties );
    ref->resolve(*this);
    //append it to the table
    m_pImpl->m_rDMapper.PopStyleSheetProperties();
    if( !m_pImpl->m_rDMapper.IsOOXMLImport() || m_pImpl->m_pCurrentEntry->sStyleName.getLength() >0)
    {
        m_pImpl->m_pCurrentEntry->sConvertedStyleName = ConvertStyleName( m_pImpl->m_pCurrentEntry->sStyleName );
        m_pImpl->m_aStyleSheetEntries.push_back( m_pImpl->m_pCurrentEntry );
    }
    else
    {
        //TODO: this entry contains the default settings - they have to be added to the settings
    }    
    
    StyleSheetEntryPtr pEmptyEntry;
    m_pImpl->m_pCurrentEntry = pEmptyEntry;
}
/*-- 21.06.2006 15:34:49---------------------------------------------------
    sorting helper
  -----------------------------------------------------------------------*/
typedef std::vector< beans::PropertyValue > _PropValVector;
class PropValVector : public _PropValVector
{
public:
    PropValVector(){}

    void    Insert( beans::PropertyValue aVal );
    uno::Sequence< uno::Any > getValues();
    uno::Sequence< ::rtl::OUString > getNames();
};
void    PropValVector::Insert( beans::PropertyValue aVal )
{
    _PropValVector::iterator aIt = begin();
    while(aIt != end())
    {
        if(aIt->Name > aVal.Name)
        {
            insert( aIt, aVal );
            return;
        }
        ++aIt;
    }
    push_back( aVal );
}
uno::Sequence< uno::Any > PropValVector::getValues()
{
    uno::Sequence< uno::Any > aRet( size() );
    uno::Any* pValues = aRet.getArray();
    sal_Int32 nVal = 0;
    _PropValVector::iterator aIt = begin();
    while(aIt != end())
    {
        pValues[nVal++] = aIt->Value;
        ++aIt;
    }
    return aRet;
}
uno::Sequence< ::rtl::OUString > PropValVector::getNames()
{
    uno::Sequence< ::rtl::OUString > aRet( size() );
    ::rtl::OUString* pNames = aRet.getArray();
    sal_Int32 nVal = 0;
    _PropValVector::iterator aIt = begin();
    while(aIt != end())
    {
        pNames[nVal++] = aIt->Name;
        ++aIt;
    }
    return aRet;
}
/*-- 21.06.2006 13:35:48---------------------------------------------------

  -----------------------------------------------------------------------*/
void StyleSheetTable::ApplyStyleSheets( FontTablePtr rFontTable )
{
    try
    {
        uno::Reference< style::XStyleFamiliesSupplier > xStylesSupplier( m_pImpl->m_xTextDocument, uno::UNO_QUERY_THROW );
        uno::Reference< lang::XMultiServiceFactory > xDocFactory( m_pImpl->m_xTextDocument, uno::UNO_QUERY_THROW );
        uno::Reference< container::XNameAccess > xStyleFamilies = xStylesSupplier->getStyleFamilies();
        uno::Reference<container::XNameContainer> xCharStyles;
        uno::Reference<container::XNameContainer> xParaStyles;

        PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
        xStyleFamilies->getByName(rPropNameSupplier.GetName( PROP_CHARACTER_STYLES )) >>= xCharStyles;
        xStyleFamilies->getByName(rPropNameSupplier.GetName( PROP_PARAGRAPH_STYLES )) >>= xParaStyles;
        if(xCharStyles.is() && xParaStyles.is())
        {
            std::vector< StyleSheetEntryPtr >::iterator aIt = m_pImpl->m_aStyleSheetEntries.begin();
            while( aIt != m_pImpl->m_aStyleSheetEntries.end() )
            {
                StyleSheetEntryPtr pEntry = *aIt;
                if( pEntry->nStyleTypeCode == STYLE_TYPE_CHAR || pEntry->nStyleTypeCode == STYLE_TYPE_PARA )
                {
                    bool bParaStyle = pEntry->nStyleTypeCode == STYLE_TYPE_PARA;
                    bool bInsert = false;
                    uno::Reference< container::XNameContainer > xStyles = bParaStyle ? xParaStyles : xCharStyles;
                    uno::Reference< style::XStyle > xStyle;
                    ::rtl::OUString sConvertedStyleName = ConvertStyleName( pEntry->sStyleName );
                    if(xStyles->hasByName( sConvertedStyleName ))
                        xStyles->getByName( sConvertedStyleName ) >>= xStyle;
                    else
                    {
                        bInsert = true;
                        xStyle = uno::Reference< style::XStyle >(xDocFactory->createInstance(
                                    bParaStyle ?
                                        rPropNameSupplier.GetName( PROP_SERVICE_PARA_STYLE ) :
                                        rPropNameSupplier.GetName( PROP_SERVICE_CHAR_STYLE )),
                                        uno::UNO_QUERY_THROW);
                    }
                    if( pEntry->sBaseStyleIdentifier.getLength() )
                    {
                        try
                        {
                            //TODO: Handle cases where a paragraph <> character style relation is needed
                            StyleSheetEntryPtr pParent = FindStyleSheetByISTD( pEntry->sBaseStyleIdentifier );
                            if (pParent.get() != NULL)
                                xStyle->setParentStyle(ConvertStyleName( pParent->sStyleName ));
                        }
                        catch( const uno::RuntimeException& )
                        {
                            OSL_ENSURE( false, "Styles parent could not be set");
                        }
                    }
                    else if( bParaStyle )
                    {
                        //now it's time to set the default parameters - for paragraph styles
                        //Fonts: Western first entry in font table
                        //CJK: second entry
                        //CTL: third entry, if it exists

                        sal_uInt32 nFontCount = rFontTable->size();
                        if( !m_pImpl->m_rDMapper.IsOOXMLImport() && nFontCount > 2 )
                        {
                            uno::Any aTwoHundredFortyTwip = uno::makeAny(12.);
    //                      font size to 240 twip (12 pts) for all if not set
                            pEntry->pProperties->Insert(PROP_CHAR_HEIGHT, true, aTwoHundredFortyTwip, false);
    //                      western font not already set -> apply first font
                            const FontEntry::Pointer_t pWesternFontEntry(rFontTable->getFontEntry( 0 ));
                            rtl::OUString sWesternFontName = pWesternFontEntry->sFontName;
                            pEntry->pProperties->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sWesternFontName ), false);

    //                      CJK  ... apply second font
                            const FontEntry::Pointer_t pCJKFontEntry(rFontTable->getFontEntry( 2 ));
                            pEntry->pProperties->Insert(PROP_CHAR_FONT_NAME_ASIAN, true, uno::makeAny( pCJKFontEntry->sFontName ), false);
                            pEntry->pProperties->Insert(PROP_CHAR_HEIGHT_ASIAN, true, aTwoHundredFortyTwip, false);
    //                      CTL  ... apply third font, if available
                            if( nFontCount > 3 )
                            {
                                const FontEntry::Pointer_t pCTLFontEntry(rFontTable->getFontEntry( 3 ));
                                pEntry->pProperties->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( pCTLFontEntry->sFontName ), false);
                                pEntry->pProperties->Insert(PROP_CHAR_HEIGHT_COMPLEX, true, aTwoHundredFortyTwip, false);
                            }
                        }
    //                  Widow/Orphan -> set both to two if not already set
                        uno::Any aTwo = uno::makeAny(sal_Int8(2));
                        pEntry->pProperties->Insert(PROP_PARA_WIDOWS, true, aTwo, false);
                        pEntry->pProperties->Insert(PROP_PARA_ORPHANS, true, aTwo, false);
    //                  Left-to-right direction if not already set
                        pEntry->pProperties->Insert(PROP_WRITING_MODE, true, uno::makeAny( sal_Int16(text::WritingMode_LR_TB) ), false);
    //                  font color COL_AUTO if not already set
                        pEntry->pProperties->Insert(PROP_CHAR_COLOR, true, uno::makeAny( sal_Int32(0xffffffff) ), false);
                    }

                    uno::Sequence< beans::PropertyValue > aPropValues = pEntry->pProperties->GetPropertyValues();
                    bool bAddFollowStyle = false;
                    if(bParaStyle && !pEntry->sNextStyleIdentifier.getLength() )
                    {
                            bAddFollowStyle = true;
                    }
                    //remove Left/RightMargin values from TOX heading styles
                    if( bParaStyle )
                    {
                        // Set the outline levels
                        const StyleSheetPropertyMap* pStyleSheetProperties = dynamic_cast<const StyleSheetPropertyMap*>(pEntry ? pEntry->pProperties.get() : 0);
                        if ( pStyleSheetProperties )
                        {
                            aPropValues.realloc( aPropValues.getLength( ) + 1 );

                            beans::PropertyValue aLvlVal( rPropNameSupplier.GetName( PROP_OUTLINE_LEVEL ), 0,
                                    uno::makeAny( sal_Int16( pStyleSheetProperties->GetOutlineLevel( ) ) ),
                                    beans::PropertyState_DIRECT_VALUE );
                            aPropValues[ aPropValues.getLength( ) - 1 ] = aLvlVal;

                            if ( pStyleSheetProperties->GetOutlineLevel( ) == 0 )
                            {
                                aPropValues.realloc( aPropValues.getLength( ) + 1 );
                                beans::PropertyValue aStyleVal( rPropNameSupplier.GetName( PROP_NUMBERING_STYLE_NAME ), 0,
                                        uno::makeAny( rtl::OUString::createFromAscii( "" ) ),
                                        beans::PropertyState_DIRECT_VALUE );
                                aPropValues[ aPropValues.getLength( ) - 1 ] = aStyleVal;
                            }
                        }

                        uno::Reference< beans::XPropertyState >xState( xStyle, uno::UNO_QUERY_THROW );
                        if( sConvertedStyleName.equalsAscii( "Contents Heading" ) ||
                            sConvertedStyleName.equalsAscii( "User Index Heading" ) ||
                            sConvertedStyleName.equalsAscii( "Index Heading" ))
                        {
                            //left margin is set to NULL by default
                            uno::Reference< beans::XPropertyState >xState1( xStyle, uno::UNO_QUERY_THROW );
                            xState1->setPropertyToDefault(rPropNameSupplier.GetName( PROP_PARA_LEFT_MARGIN ));
                        }
                        else if( sConvertedStyleName.equalsAscii( "Text body" ) )
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_PARA_BOTTOM_MARGIN ));
                        else if( sConvertedStyleName.equalsAscii( "Heading 1" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 2" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 3" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 4" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 5" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 6" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 7" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 8" ) ||
                                sConvertedStyleName.equalsAscii( "Heading 9" ) )
                        {
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_WEIGHT ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_WEIGHT_ASIAN ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_WEIGHT_COMPLEX ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_POSTURE ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_POSTURE_ASIAN ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_POSTURE_COMPLEX ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_PROP_HEIGHT        ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_PROP_HEIGHT_ASIAN  ));
                            xState->setPropertyToDefault(rPropNameSupplier.GetName( PROP_CHAR_PROP_HEIGHT_COMPLEX));

                        } else if(sConvertedStyleName.equalsAscii( "Title" ) ||
								sConvertedStyleName.equalsAscii( "Subtitle" ))	{
							//set the default adjust for ParaStyle Title and Subtitle to left
							try
							{
								uno::Reference< beans::XPropertySet > xProp( xStyle, uno::UNO_QUERY );
								if( xProp.is() )
								{
									uno::Any aMSDefaultVal = uno::makeAny( (sal_Int16)style::ParagraphAdjust_LEFT );
									xProp->setPropertyValue( rPropNameSupplier.GetName( PROP_PARA_ADJUST), aMSDefaultVal );
								}
							}
							catch(...)
							{
								OSL_ENSURE( false, "Default ParaAdjust style property could not be set");
							}
						}
                    }

                    if(bAddFollowStyle || aPropValues.getLength())
                    {
                        PropValVector aSortedPropVals;
                        for( sal_Int32 nProp = 0; nProp < aPropValues.getLength(); ++nProp)
                        {
                                // Don't add the style name properties
                            bool bIsParaStyleName = aPropValues[nProp].Name.equalsAscii( "ParaStyleName" );
                            bool bIsCharStyleName = aPropValues[nProp].Name.equalsAscii( "CharStyleName" );
                            if ( !bIsParaStyleName && !bIsCharStyleName )
                            {
                                aSortedPropVals.Insert( aPropValues[nProp] );
                            }
                        }
                        if(bAddFollowStyle)
                        {
                            //find the name of the Next style
                            std::vector< StyleSheetEntryPtr >::iterator aNextStyleIt = m_pImpl->m_aStyleSheetEntries.begin();
                            for( ; aNextStyleIt !=  m_pImpl->m_aStyleSheetEntries.end(); ++aNextStyleIt )
                            {
                                if( ( *aNextStyleIt )->sStyleName.getLength() &&
                                        ( *aNextStyleIt )->sStyleName == pEntry->sNextStyleIdentifier)
                                {
                                    beans::PropertyValue aNew;
                                    aNew.Name = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FollowStyle"));
                                    aNew.Value = uno::makeAny(ConvertStyleName( ( *aNextStyleIt )->sStyleIdentifierD ));
                                    aSortedPropVals.Insert( aNew );
                                    break;
                                }
                            }
                        }

                        try
                        {
                            uno::Reference< beans::XMultiPropertySet > xMultiPropertySet( xStyle, uno::UNO_QUERY_THROW);
                            xMultiPropertySet->setPropertyValues( aSortedPropVals.getNames(), aSortedPropVals.getValues() );
                        }
                        catch( const lang::WrappedTargetException& rWrapped)
                        {
                            (void) rWrapped;
                            rtl::OString aMessage("Some style properties could not be set");
#if OSL_DEBUG_LEVEL > 0                            
                            beans::UnknownPropertyException aUnknownPropertyException;
                            
                            if( rWrapped.TargetException >>= aUnknownPropertyException )
                            {
                                aMessage += rtl::OString(": " );
                                ::rtl::OString sTemp;
                                aUnknownPropertyException.Message.convertToString(&sTemp, RTL_TEXTENCODING_ASCII_US, 0 );
                                aMessage += sTemp;
                            }
#endif
                            OSL_ENSURE( false, aMessage.getStr());
                        }
                        catch( const uno::Exception& rEx)
                        {
                            (void) rEx;
                            OSL_ENSURE( false, "Some style properties could not be set");
                        }
                    }
                    if(bInsert)
                    {
                        xStyles->insertByName( sConvertedStyleName, uno::makeAny( xStyle) );
                    }
                }
                ++aIt;
            }
        }
    }
    catch( uno::Exception& rEx)
    {
        (void)rEx;
        OSL_ENSURE( false, "Styles could not be imported completely");
    }
}
/*-- 22.06.2006 15:56:56---------------------------------------------------

  -----------------------------------------------------------------------*/
const StyleSheetEntryPtr StyleSheetTable::FindStyleSheetByISTD(const ::rtl::OUString& sIndex)
{
    StyleSheetEntryPtr pRet;
    for( sal_uInt32 nPos = 0; nPos < m_pImpl->m_aStyleSheetEntries.size(); ++nPos )
    {
        if( m_pImpl->m_aStyleSheetEntries[nPos]->sStyleIdentifierD == sIndex)
        {
            pRet = m_pImpl->m_aStyleSheetEntries[nPos];
            break;
        }
    }
    return pRet;
}
/*-- 28.12.2007 14:45:45---------------------------------------------------

  -----------------------------------------------------------------------*/
const StyleSheetEntryPtr StyleSheetTable::FindStyleSheetByStyleName(const ::rtl::OUString& sIndex)
{
    StyleSheetEntryPtr pRet;
    for( sal_uInt32 nPos = 0; nPos < m_pImpl->m_aStyleSheetEntries.size(); ++nPos )
    {
        if( m_pImpl->m_aStyleSheetEntries[nPos]->sStyleName == sIndex)
        {
            pRet = m_pImpl->m_aStyleSheetEntries[nPos];
            break;
        }
    }
    return pRet;
}
/*-- 28.12.2007 14:45:45---------------------------------------------------

  -----------------------------------------------------------------------*/
const StyleSheetEntryPtr StyleSheetTable::FindStyleSheetByConvertedStyleName(const ::rtl::OUString& sIndex)
{
    StyleSheetEntryPtr pRet;
    for( sal_uInt32 nPos = 0; nPos < m_pImpl->m_aStyleSheetEntries.size(); ++nPos )
    {
        if( m_pImpl->m_aStyleSheetEntries[nPos]->sConvertedStyleName == sIndex)
        {
            pRet = m_pImpl->m_aStyleSheetEntries[nPos];
            break;
        }
    }
    return pRet;
}

/*-- 17.07.2006 11:47:00---------------------------------------------------

  -----------------------------------------------------------------------*/
const StyleSheetEntryPtr StyleSheetTable::FindParentStyleSheet(::rtl::OUString sBaseStyle)
{
    if( !sBaseStyle.getLength() )
    {
        StyleSheetEntryPtr pEmptyPtr;
        return pEmptyPtr;
    }
    if( m_pImpl->m_pCurrentEntry)
        sBaseStyle = m_pImpl->m_pCurrentEntry->sBaseStyleIdentifier;

    return FindStyleSheetByISTD( sBaseStyle );
}
/*-- 21.12.2006 15:58:23---------------------------------------------------

  -----------------------------------------------------------------------*/
static const sal_Char *aStyleNamePairs[] =
{
    "Normal",                     "Standard",               
    "heading 1",                  "Heading 1",              
    "heading 2",                  "Heading 2",              
    "heading 3",                  "Heading 3",              
    "heading 4",                  "Heading 4",              
    "heading 5",                  "Heading 5",              
    "heading 6",                  "Heading 6",              
    "heading 7",                  "Heading 7",              
    "heading 8",                  "Heading 8",              
    "heading 9",                  "Heading 9",              
    "Heading1",                   "Heading 1",              
    "Heading2",                   "Heading 2",              
    "Heading3",                   "Heading 3",              
    "Heading4",                   "Heading 4",              
    "Heading5",                   "Heading 5",              
    "Heading6",                   "Heading 6",              
    "Heading7",                   "Heading 7",              
    "Heading8",                   "Heading 8",              
    "Heading9",                   "Heading 9",              
    "Heading 1",                  "Heading 1",              
    "Heading 2",                  "Heading 2",              
    "Heading 3",                  "Heading 3",              
    "Heading 4",                  "Heading 4",              
    "Heading 5",                  "Heading 5",              
    "Heading 6",                  "Heading 6",              
    "Heading 7",                  "Heading 7",              
    "Heading 8",                  "Heading 8",              
    "Heading 9",                  "Heading 9",              
    "Index 1",                   "Index 1",                 
    "Index 2",                   "Index 2",                 
    "Index 3",                   "Index 3",                 
    "Index 4",                   "",                         
    "Index 5",                   "",                         
    "Index 6",                   "",                         
    "Index 7",                   "",                         
    "Index 8",                   "",                         
    "Index 9",                   "",                         
    "TOC 1",                     "Contents 1",              
    "TOC 2",                     "Contents 2",              
    "TOC 3",                     "Contents 3",              
    "TOC 4",                     "Contents 4",              
    "TOC 5",                     "Contents 5",              
    "TOC 6",                     "Contents 6",              
    "TOC 7",                     "Contents 7",              
    "TOC 8",                     "Contents 8",              
    "TOC 9",                     "Contents 9",              
    "TOC Heading",               "Contents Heading",
    "TOCHeading",                "Contents Heading",
    "toc 1",                     "Contents 1",              
    "toc 2",                     "Contents 2",              
    "toc 3",                     "Contents 3",              
    "toc 4",                     "Contents 4",              
    "toc 5",                     "Contents 5",              
    "toc 6",                     "Contents 6",              
    "toc 7",                     "Contents 7",              
    "toc 8",                     "Contents 8",              
    "toc 9",                     "Contents 9",              
    "TOC1",                     "Contents 1",
    "TOC2",                     "Contents 2",
    "TOC3",                     "Contents 3",
    "TOC4",                     "Contents 4",
    "TOC5",                     "Contents 5",
    "TOC6",                     "Contents 6",
    "TOC7",                     "Contents 7",
    "TOC8",                     "Contents 8",
    "TOC9",                     "Contents 9",
    "Normal Indent",             "",                         
    "Footnote Text",             "Footnote",                
    "Annotation Text",           "",                         
    "Header",                    "Header",                  
    "header",                    "Header",                  
    "Footer",                    "Footer",                  
    "footer",                    "Footer",                  
    "Index Heading",             "Index Heading",           
    "Caption",                   "",                         
    "Table of Figures",          "",                         
    "Envelope Address",          "Addressee",               
    "Envelope Return",           "Sender",                  
    "Footnote Reference",        "Footnote anchor",         
    "Annotation Reference",      "",                         
    "Line Number",               "Line numbering",          
    "Page Number",               "Page Number",             
    "Endnote Reference",         "Endnote anchor",          
    "Endnote Text",              "Endnote Symbol",          
    "Table of Authorities",      "",                         
    "Macro Text",                "",                         
    "TOA Heading",               "",                         
    "List",                      "List",                    
    "List 2",                    "",                         
    "List 3",                    "",                         
    "List 4",                    "",                         
    "List 5",                    "",                         
    "List Bullet",               "",                         
    "List Bullet 2",             "",                         
    "List Bullet 3",             "",                         
    "List Bullet 4",             "",                         
    "List Bullet 5",             "",                         
    "List Number",               "",                         
    "List Number 2",             "",                         
    "List Number 3",             "",                         
    "List Number 4",             "",                         
    "List Number 5",             "",                         
    "Title",                     "Title",                   
    "Closing",                   "",                         
    "Signature",                 "Signature",               
    "Default Paragraph Font",    "",                         
    "DefaultParagraphFont",      "Default Paragraph Font",
    "Body Text",                 "Text body",               
    "BodyText",                  "Text body",
    "BodyTextIndentItalic",     "Text body indent italic",
    "Body Text Indent",          "Text body indent",        
    "BodyTextIndent",           "Text body indent",
    "BodyTextIndent2",          "Text body indent2",
    "List Continue",             "",                         
    "List Continue 2",           "",                         
    "List Continue 3",           "",                         
    "List Continue 4",           "",                         
    "List Continue 5",           "",                         
    "Message Header",            "",                         
    "Subtitle",                  "Subtitle",                
    "Salutation",                "",                         
    "Date",                      "",                         
    "Body Text First Indent",    "Body Text Indent",        
    "Body Text First Indent 2",  "",                         
    "Note Heading",              "",                         
    "Body Text 2",               "",                         
    "Body Text 3",               "",                         
    "Body Text Indent 2",        "",                         
    "Body Text Indent 3",        "",                         
    "Block Text",                "",                         
    "Hyperlink",                 "Internet link",           
    "Followed Hyperlink",        "Visited Internet Link",   
    "Strong",                    "Strong Emphasis",         
    "Emphasis",                  "Emphasis",                
    "Document Map",              "",                         
    "Plain Text",                "",
    "NoList",                   "No List",
    "AbstractHeading",          "Abstract Heading",
    "AbstractBody",             "Abstract Body",
    "PageNumber",               "page number"
    "TableNormal",              "Normal Table",
    "DocumentMap",              "Document Map"
};


::rtl::OUString StyleSheetTable::ConvertStyleName( const ::rtl::OUString& rWWName, bool bExtendedSearch)
{
    ::rtl::OUString sRet( rWWName );
    if( bExtendedSearch )
    {
        //search for the rWWName in the IdentifierD of the existing styles and convert the sStyleName member
        std::vector< StyleSheetEntryPtr >::iterator aIt = m_pImpl->m_aStyleSheetEntries.begin();
        //TODO: performance issue - put styles list into a map sorted by it's sStyleIdentifierD members
        while( aIt != m_pImpl->m_aStyleSheetEntries.end() )
        {
            if( rWWName == ( *aIt )->sStyleIdentifierD ) 
                sRet = ( *aIt )->sStyleName;
            ++aIt;
        }    
    }    
    if(!m_pImpl->m_aStyleNameMap.size())
    {
        for( sal_uInt32 nPair = 0; nPair < sizeof(aStyleNamePairs) / sizeof( sal_Char*) / 2; ++nPair)
        {
                m_pImpl->m_aStyleNameMap.insert( StringPairMap_t::value_type(
                    ::rtl::OUString::createFromAscii(aStyleNamePairs[2 * nPair]),
                    ::rtl::OUString::createFromAscii(aStyleNamePairs[2 * nPair + 1]) ));
        }
    }
    StringPairMap_t::iterator aIt = m_pImpl->m_aStyleNameMap.find( sRet );
    if(aIt != m_pImpl->m_aStyleNameMap.end() && aIt->second.getLength())
        sRet = aIt->second;
    return sRet;
}

::rtl::OUString StyleSheetTable::GetStyleIdFromIndex(const sal_uInt32 sti)
{
    ::rtl::OUString sRet;
    if (sti >= (sizeof(aStyleNamePairs) / sizeof( sal_Char*) / 2))
        sRet = ::rtl::OUString();
    else
        sRet = ::rtl::OUString::createFromAscii(aStyleNamePairs[2 * sti]);
    return sRet;
}

void StyleSheetTable::resolveSprmProps(Sprm & rSprm)
{
    writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
    if( pProperties.get())
        pProperties->resolve(*this);
}

void StyleSheetTable::resolveAttributeProperties(Value & val)
{
    writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
    if( pProperties.get())
        pProperties->resolve(*this);
}
/*-- 18.07.2007 15:59:34---------------------------------------------------

  -----------------------------------------------------------------------*/
void StyleSheetTable::applyDefaults(bool bParaProperties)
{
    try{
        if(!m_pImpl->m_xTextDefaults.is())
        {
            m_pImpl->m_xTextDefaults = uno::Reference< beans::XPropertySet>( 
                m_pImpl->m_rDMapper.GetTextFactory()->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Defaults"))), 
                uno::UNO_QUERY_THROW );
        }
        PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
        if( bParaProperties && m_pImpl->m_pDefaultParaProps.get() && m_pImpl->m_pDefaultParaProps->size())
        {
            PropertyMap::iterator aMapIter = m_pImpl->m_pDefaultParaProps->begin();
            for( ; aMapIter != m_pImpl->m_pDefaultParaProps->end(); ++aMapIter )
            {
                try
                {
                    m_pImpl->m_xTextDefaults->setPropertyValue(rPropNameSupplier.GetName( aMapIter->first.eId ), aMapIter->second);
                }
                catch( const uno::Exception& )
                {
                    OSL_ENSURE( false, "setPropertyValue exception");
                }    
            }
        }    
        if( !bParaProperties && m_pImpl->m_pDefaultCharProps.get() && m_pImpl->m_pDefaultCharProps->size())
        {
            PropertyMap::iterator aMapIter = m_pImpl->m_pDefaultCharProps->begin();
            for( ; aMapIter != m_pImpl->m_pDefaultCharProps->end(); ++aMapIter )
            {
                try
                {
                    m_pImpl->m_xTextDefaults->setPropertyValue(rPropNameSupplier.GetName( aMapIter->first.eId ), aMapIter->second);
                }
                catch( const uno::Exception& )
                {
                    OSL_ENSURE( false, "setPropertyValue exception");
                }    
            }
        }
    }
    catch( const uno::Exception& )
    {
    }    
}
/*-- 05.02.2008 10:27:36---------------------------------------------------

  -----------------------------------------------------------------------*/
::rtl::OUString StyleSheetTable::getOrCreateCharStyle( PropertyValueVector_t& rCharProperties )
{
    //find out if any of the styles already has the required properties then return it's name
    ::rtl::OUString sListLabel = m_pImpl->HasListCharStyle(rCharProperties);
    if( sListLabel.getLength() )
        return sListLabel;
    const char cListLabel[] = "ListLabel ";
    uno::Reference< style::XStyleFamiliesSupplier > xStylesSupplier( m_pImpl->m_xTextDocument, uno::UNO_QUERY_THROW );
    uno::Reference< container::XNameAccess > xStyleFamilies = xStylesSupplier->getStyleFamilies();
    uno::Reference<container::XNameContainer> xCharStyles;
    xStyleFamilies->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CharacterStyles"))) >>= xCharStyles;
    //search for all character styles with the name sListLabel + <index>
    sal_Int32 nStyleFound = 0;
    uno::Sequence< ::rtl::OUString > aStyleNames = xCharStyles->getElementNames();
    const ::rtl::OUString* pStyleNames = aStyleNames.getConstArray();
    for( sal_Int32 nStyle = 0; nStyle < aStyleNames.getLength(); ++nStyle )
    {
        if( pStyleNames[nStyle].matchAsciiL( cListLabel, sizeof( cListLabel ) - 1  ))
        {
            ::rtl::OUString sSuffix = pStyleNames[nStyle].copy( sizeof( cListLabel ) - 1 );
            sal_Int32 nSuffix = sSuffix.toInt32();
            if( nSuffix > 0 )
            {
                if( nSuffix > nStyleFound )
                    nStyleFound = nSuffix;
            }
        }    
    }
    sListLabel = ::rtl::OUString::createFromAscii( cListLabel );
    sListLabel += ::rtl::OUString::valueOf( ++nStyleFound );
    //create a new one otherwise
    uno::Reference< lang::XMultiServiceFactory > xDocFactory( m_pImpl->m_xTextDocument, uno::UNO_QUERY_THROW );
    PropertyNameSupplier& rPropNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
    try
    {
        uno::Reference< style::XStyle > xStyle( xDocFactory->createInstance(
            rPropNameSupplier.GetName( PROP_SERVICE_CHAR_STYLE )), uno::UNO_QUERY_THROW);
        //uno::Reference< container::XNamed >xNamed( xStyle, uno::UNO_QUERY_THROW );
        //xNamed->setName( sListLabel );
        uno::Reference< beans::XPropertySet > xStyleProps(xStyle, uno::UNO_QUERY_THROW );
        PropertyValueVector_t::const_iterator aCharPropIter = rCharProperties.begin();
        while( aCharPropIter != rCharProperties.end())
        {
            try
            {
                xStyleProps->setPropertyValue( aCharPropIter->Name, aCharPropIter->Value );
            }
            catch( const uno::Exception& rEx )
            {
                (void)rEx;
                OSL_ENSURE( false, "Exception in StyleSheetTable::getOrCreateCharStyle - Style::setPropertyValue");
            }    
            ++aCharPropIter;
        }
        xCharStyles->insertByName( sListLabel, uno::makeAny( xStyle) );
        m_pImpl->m_aListCharStylePropertyVector.push_back( ListCharStylePropertyMap_t( sListLabel, rCharProperties ));
    }
    catch( const uno::Exception& rEx )
    {
        (void)rEx;
        OSL_ENSURE( false, "Exception in StyleSheetTable::getOrCreateCharStyle");
    }    
    
    return sListLabel;
}

}//namespace dmapper
}//namespace writerfilter