AOO410/main/svx/source/table/cell.cxx

/**************************************************************
 * 
 * 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.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"

#include <com/sun/star/drawing/BitmapMode.hpp>
#include <com/sun/star/style/XStyle.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/table/TableBorder.hpp>

#include <cppuhelper/typeprovider.hxx>
#include <svl/style.hxx>
#include <svl/itemset.hxx>

#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>

#include "svx/sdr/properties/textproperties.hxx"
#include "editeng/outlobj.hxx"
#include "editeng/writingmodeitem.hxx"
#include "svx/svdotable.hxx"
#include "svx/svdoutl.hxx"
#include "svx/unoshtxt.hxx"
#include "svx/svdmodel.hxx"

#include "tableundo.hxx"
#include "cell.hxx"
#include "svx/svdotable.hxx"
#include "svx/svdoutl.hxx"
#include "svx/unoshtxt.hxx"
#include "svx/unoshprp.hxx"
#include "svx/unoshape.hxx"
#include "editeng/editobj.hxx"
#include "editeng/boxitem.hxx"
#include "svx/xflbstit.hxx"
#include "svx/xflbmtit.hxx"
#include <svx/svdpool.hxx>

// -----------------------------------------------------------------------------

using ::rtl::OUString;
using ::vos::OGuard;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::table;
using namespace ::com::sun::star::drawing;
using namespace ::com::sun::star::style;
using namespace ::com::sun::star::container;

// -----------------------------------------------------------------------------

static const SvxItemPropertySet* ImplGetSvxCellPropertySet()
{
	// Propertymap fuer einen Outliner Text
    static const SfxItemPropertyMapEntry aSvxCellPropertyMap[] =
	{
		FILL_PROPERTIES
//		{ MAP_CHAR_LEN("HasLevels"),					OWN_ATTR_HASLEVELS,				&::getBooleanCppuType(), ::com::sun::star::beans::PropertyAttribute::READONLY,		0},
		{ MAP_CHAR_LEN("Style"),						OWN_ATTR_STYLE,					&::com::sun::star::style::XStyle::static_type(),									::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_WRITINGMODE),		SDRATTR_TEXTDIRECTION,			&::getCppuType( (::com::sun::star::text::WritingMode*) 0 ),							0,		0},
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_HORZADJUST),		SDRATTR_TEXT_HORZADJUST,		&::getCppuType((const ::com::sun::star::drawing::TextHorizontalAdjust*)0),	0,		0}, \
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_LEFTDIST),			SDRATTR_TEXT_LEFTDIST,			&::getCppuType((const sal_Int32*)0),		0,		SFX_METRIC_ITEM}, \
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_LOWERDIST),		SDRATTR_TEXT_LOWERDIST,			&::getCppuType((const sal_Int32*)0),		0,		SFX_METRIC_ITEM}, \
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_RIGHTDIST),		SDRATTR_TEXT_RIGHTDIST,			&::getCppuType((const sal_Int32*)0),		0,		SFX_METRIC_ITEM}, \
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_UPPERDIST),		SDRATTR_TEXT_UPPERDIST,			&::getCppuType((const sal_Int32*)0),		0,		SFX_METRIC_ITEM}, \
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_VERTADJUST),		SDRATTR_TEXT_VERTADJUST,		&::getCppuType((const ::com::sun::star::drawing::TextVerticalAdjust*)0),	0,		0},\
		{ MAP_CHAR_LEN(UNO_NAME_TEXT_WORDWRAP),			SDRATTR_TEXT_WORDWRAP,			&::getBooleanCppuType(),		0,		0}, \

		{ MAP_CHAR_LEN("TableBorder"),					OWN_ATTR_TABLEBORDER,			&::getCppuType((const TableBorder*)0), 0, 0 }, \
		{ MAP_CHAR_LEN("TopBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \
		{ MAP_CHAR_LEN("BottomBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \
		{ MAP_CHAR_LEN("LeftBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \
		{ MAP_CHAR_LEN("RightBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \

		SVX_UNOEDIT_OUTLINER_PROPERTIES,
		SVX_UNOEDIT_CHAR_PROPERTIES,
		SVX_UNOEDIT_PARA_PROPERTIES,
		{0,0,0,0,0,0}
	};

	static SvxItemPropertySet aSvxCellPropertySet( aSvxCellPropertyMap, SdrObject::GetGlobalDrawObjectItemPool() ); 
	return &aSvxCellPropertySet;
}

namespace sdr
{
	namespace properties
	{
		class CellProperties : public TextProperties
		{
		protected:
			// create a new itemset
			SfxItemSet& CreateObjectSpecificItemSet(SfxItemPool& rPool);

		public:
			// basic constructor
			CellProperties(SdrObject& rObj, sdr::table::Cell* pCell );

			// constructor for copying, but using new object
			CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell);

			// destructor
			~CellProperties();

			// Clone() operator, normally just calls the local copy constructor
			BaseProperties& Clone(SdrObject& rObj) const;

			void ForceDefaultAttributes();

			void ItemSetChanged(const SfxItemSet& rSet);

			void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem);

            void SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr);

			sdr::table::CellRef mxCell;
		};

		// create a new itemset
		SfxItemSet& CellProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
		{
			return *(new SfxItemSet(rPool,

				// range from SdrAttrObj
				SDRATTR_START, SDRATTR_SHADOW_LAST,
				SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
				SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,

				// range for SdrTableObj
				SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,

				// range from SdrTextObj
				EE_ITEMS_START, EE_ITEMS_END,

				// end
				0, 0));
		}

		CellProperties::CellProperties(SdrObject& rObj, sdr::table::Cell* pCell)
		:	TextProperties(rObj)
		,	mxCell(pCell)
		{
		}

		CellProperties::CellProperties(const CellProperties& rProps, SdrObject& rObj, sdr::table::Cell* pCell)
		:	TextProperties(rProps, rObj)
		,	mxCell( pCell )
		{
		}

		CellProperties::~CellProperties()
		{
		}
		
		BaseProperties& CellProperties::Clone(SdrObject& rObj) const
		{
			DBG_ERROR("CellProperties::Clone(), does not work yet!");
			return *(new CellProperties(*this, rObj,0));
		}

		void CellProperties::ForceDefaultAttributes()
		{
		}

		void CellProperties::ItemSetChanged(const SfxItemSet& rSet )
		{
			SdrTextObj& rObj = (SdrTextObj&)GetSdrObject();

			if( mxCell.is() )
			{
				OutlinerParaObject* pParaObj = mxCell->GetEditOutlinerParaObject();
				
                bool bOwnParaObj = pParaObj != 0;

				if( pParaObj == 0 )
					pParaObj = mxCell->GetOutlinerParaObject();
				
				if(pParaObj)
				{
					// handle outliner attributes
					Outliner* pOutliner = 0;

					if(mxCell->IsTextEditActive())
					{
						pOutliner = rObj.GetTextEditOutliner();
					}
					else
					{
						pOutliner = &rObj.ImpGetDrawOutliner();
						pOutliner->SetText(*pParaObj);
					}

					sal_uInt32 nParaCount(pOutliner->GetParagraphCount());

					for(sal_uInt16 nPara = 0; nPara < nParaCount; nPara++)
					{
						SfxItemSet aSet(pOutliner->GetParaAttribs(nPara));
						aSet.Put(rSet);
						pOutliner->SetParaAttribs(nPara, aSet);
					}

					if(!mxCell->IsTextEditActive())
					{
						if(nParaCount)
						{
							// force ItemSet
							GetObjectItemSet();

							SfxItemSet aNewSet(pOutliner->GetParaAttribs(0L));
							mpItemSet->Put(aNewSet);
						}

						OutlinerParaObject* pTemp = pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount);
						pOutliner->Clear();

						mxCell->SetOutlinerParaObject(pTemp);
					}

                    if( bOwnParaObj )
                        delete pParaObj;
				}
			}

			// call parent
			AttributeProperties::ItemSetChanged(rSet);

			if( mxCell.is() )
				mxCell->notifyModified();
		}

		void CellProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
		{
			if(pNewItem && (SDRATTR_TEXTDIRECTION == nWhich))
			{
				sal_Bool bVertical(com::sun::star::text::WritingMode_TB_RL == ((SvxWritingModeItem*)pNewItem)->GetValue());

				sdr::table::SdrTableObj& rObj = (sdr::table::SdrTableObj&)GetSdrObject();
				if( rObj.IsVerticalWriting() != bVertical )
					rObj.SetVerticalWriting(bVertical);

				// Set a cell vertical property
				OutlinerParaObject* pParaObj = mxCell->GetEditOutlinerParaObject();
				if( pParaObj == 0 )
					pParaObj = mxCell->GetOutlinerParaObject();
				if(pParaObj)
				{
					pParaObj->SetVertical(bVertical);
				}

			}

			// call parent
			AttributeProperties::ItemChange( nWhich, pNewItem );
		}
        
        void CellProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
        {
            TextProperties::SetStyleSheet( pNewStyleSheet, bDontRemoveHardAttr );
        }
	} // end of namespace properties
} // end of namespace sdr

namespace sdr { namespace table {

// -----------------------------------------------------------------------------
// Cell
// -----------------------------------------------------------------------------

rtl::Reference< Cell > Cell::create( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject )
{
    rtl::Reference< Cell > xCell( new Cell( rTableObj, pOutlinerParaObject ) );
    if( xCell->mxTable.is() )
    {
        Reference< XEventListener > xListener( xCell.get() );
        xCell->mxTable->addEventListener( xListener );
    }
    return xCell;
}

// -----------------------------------------------------------------------------

Cell::Cell( SdrTableObj& rTableObj, OutlinerParaObject* pOutlinerParaObject ) throw()
: SdrText( rTableObj, pOutlinerParaObject )
, SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
, mpPropSet( ImplGetSvxCellPropertySet() )
, mpProperties( new sdr::properties::CellProperties( rTableObj, this ) )
, mnCellContentType( CellContentType_EMPTY )
, mfValue( 0.0 )
, mnError( 0 )
, mbMerged( sal_False )
, mnRowSpan( 1 )
, mnColSpan( 1 )
, mxTable( rTableObj.getTable() )
{
	if( rTableObj.GetModel() ) 
		SetModel( rTableObj.GetModel() );
}

// -----------------------------------------------------------------------------

Cell::~Cell() throw()
{
	dispose();
}

// -----------------------------------------------------------------------------

void Cell::dispose()
{
    if( mxTable.is() )
    {
        try
        {
            Reference< XEventListener > xThis( this );
            mxTable->removeEventListener( xThis );
        }
        catch( Exception& )
        {
            DBG_ERROR("Cell::dispose(), exception caught!");
        }
	    mxTable.clear();
    }

	if( mpProperties )
	{
		delete mpProperties;
		mpProperties = 0;
	}
	SetOutlinerParaObject( 0 );
}

// -----------------------------------------------------------------------------

void Cell::SetModel(SdrModel* pNewModel)
{
	SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( GetEditSource() );
	if( (GetModel() != pNewModel) || ( pNewModel && !pTextEditSource) )
	{
		if( mpProperties )
		{
			SfxItemPool* pItemPool = mpProperties->GetObjectItemSet().GetPool();

			// test for correct pool in ItemSet; move to new pool if necessary
			if( pNewModel && pItemPool && pItemPool != &pNewModel->GetItemPool())
				mpProperties->MoveToItemPool(pItemPool, &pNewModel->GetItemPool(), pNewModel);
		}

		if( pTextEditSource )
		{
			pTextEditSource->ChangeModel( pNewModel );
		}
		else
		{
			SetEditSource( new SvxTextEditSource( &GetObject(), this, static_cast< XWeak * >( this ) ) );
		}

		SetStyleSheet( 0, sal_True );
		SdrText::SetModel( pNewModel );
		ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
	}
}

// -----------------------------------------------------------------------------

void Cell::merge( sal_Int32 nColumnSpan, sal_Int32 nRowSpan )
{
	if( (mnColSpan != nColumnSpan) || (mnRowSpan != nRowSpan) || (mbMerged != sal_False) )
	{
		mnColSpan = nColumnSpan;
		mnRowSpan = nRowSpan;
		mbMerged = sal_False;
		notifyModified();
	}
}

// -----------------------------------------------------------------------------

void Cell::mergeContent( const CellRef& xSourceCell )
{
	SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );

	if( xSourceCell->hasText() )
	{
		SdrOutliner& rOutliner=rTableObj.ImpGetDrawOutliner();
		rOutliner.SetUpdateMode(sal_True);

		if( hasText() )
		{
			rOutliner.SetText(*GetOutlinerParaObject());
			rOutliner.AddText(*xSourceCell->GetOutlinerParaObject());
		}
		else
		{
			rOutliner.SetText(*xSourceCell->GetOutlinerParaObject());
		}

		SetOutlinerParaObject( rOutliner.CreateParaObject() );
		rOutliner.Clear();
		xSourceCell->SetOutlinerParaObject(rOutliner.CreateParaObject());
		rOutliner.Clear();
		SetStyleSheet( GetStyleSheet(), sal_True );
	}
}

// -----------------------------------------------------------------------------

void Cell::cloneFrom( const CellRef& xCell )
{
	if( xCell.is() )
	{
		replaceContentAndFormating( xCell );

		mnCellContentType = xCell->mnCellContentType;

		msFormula = xCell->msFormula;
		mfValue = xCell->mfValue;
		mnError = xCell->mnError;

        mbMerged = xCell->mbMerged;
        mnRowSpan = xCell->mnRowSpan;
        mnColSpan = xCell->mnColSpan;
    
    }
	notifyModified();
}

void Cell::replaceContentAndFormating( const CellRef& xSourceCell )
{
	if( xSourceCell.is() && mpProperties )
	{
		mpProperties->SetMergedItemSet( xSourceCell->GetObjectItemSet() );
		SetOutlinerParaObject( new OutlinerParaObject(*xSourceCell->GetOutlinerParaObject()) );

		SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
		SdrTableObj& rSourceTableObj = dynamic_cast< SdrTableObj& >( xSourceCell->GetObject() );

		if(rSourceTableObj.GetModel() != rTableObj.GetModel())
		{
			SetStyleSheet( 0, sal_True );
		}
	}
}

// -----------------------------------------------------------------------------

void Cell::setMerged()
{
	if( !mbMerged )
	{
		mbMerged = sal_True;
		notifyModified();
	}
}

// -----------------------------------------------------------------------------

void Cell::notifyModified()
{
	if( mxTable.is() )
		mxTable->setModified( sal_True );
}

// -----------------------------------------------------------------------------
// SdrTextShape proxy
// -----------------------------------------------------------------------------

bool Cell::IsTextEditActive()
{
    bool isActive = false;
	SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
	if(rTableObj.getActiveCell().get() == this )
    {
        OutlinerParaObject* pParaObj = rTableObj.GetEditOutlinerParaObject();
        if( pParaObj != 0 )
        {
            isActive = true;
		    delete pParaObj;
        }
    }
	return isActive;
}

// -----------------------------------------------------------------------------

bool Cell::hasText() const
{
	OutlinerParaObject* pParaObj = GetOutlinerParaObject();
	if( pParaObj )
	{
		const EditTextObject& rTextObj = pParaObj->GetTextObject();
		if( rTextObj.GetParagraphCount() >= 1 )
		{
			if( rTextObj.GetParagraphCount() == 1 )
			{
				if( rTextObj.GetText(0).Len() == 0 )
					return false;
			}
			return true;
		}
	}

	return false;
}

// -----------------------------------------------------------------------------

OutlinerParaObject* Cell::GetEditOutlinerParaObject() const
{
	SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
	if( rTableObj.getActiveCell().get() == this )
		return rTableObj.GetEditOutlinerParaObject();
	return 0;
}

// -----------------------------------------------------------------------------

void Cell::SetStyleSheet( SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr )
{
	// only allow cell styles for cells
	if( pStyleSheet && pStyleSheet->GetFamily() != SFX_STYLE_FAMILY_FRAME )
		return;

	if( mpProperties && (mpProperties->GetStyleSheet() != pStyleSheet) )
	{
		mpProperties->SetStyleSheet( pStyleSheet, bDontRemoveHardAttr );
	}
}

// -----------------------------------------------------------------------------

const SfxItemSet& Cell::GetObjectItemSet()
{
	if( mpProperties )
	{
		return mpProperties->GetObjectItemSet();
	}
	else
	{
		DBG_ERROR("Cell::GetObjectItemSet(), called without properties!");
        return GetObject().GetObjectItemSet();
	}
}

void Cell::SetObjectItem(const SfxPoolItem& rItem)
{
	if( mpProperties )
	{
		mpProperties->SetObjectItem( rItem );
		notifyModified();
	}
}

void Cell::SetMergedItem(const SfxPoolItem& rItem)
{
	SetObjectItem(rItem);
}

SfxStyleSheet* Cell::GetStyleSheet() const
{
	if( mpProperties )
		return mpProperties->GetStyleSheet();
	else
		return 0;
}

// -----------------------------------------------------------------------------

SfxStyleSheetPool* Cell::GetStyleSheetPool() const
{
	if( mpProperties && mpProperties->GetStyleSheet() )
		return dynamic_cast< SfxStyleSheetPool* >( &mpProperties->GetStyleSheet()->GetPool() );
	else
		return 0;
}

// -----------------------------------------------------------------------------

const Rectangle& Cell::GetCurrentBoundRect() const
{
	return maCellRect;
}

// -----------------------------------------------------------------------------

void Cell::TakeTextAnchorRect(Rectangle& rAnchorRect) const
{
	rAnchorRect.nLeft = maCellRect.nLeft + GetTextLeftDistance();
	rAnchorRect.nRight = maCellRect.nRight - GetTextRightDistance();
	rAnchorRect.nTop = maCellRect.nTop + GetTextUpperDistance();
	rAnchorRect.nBottom = maCellRect.nBottom - GetTextLowerDistance();
}

// -----------------------------------------------------------------------------

const SfxItemSet& Cell::GetItemSet() const
{
	return mpProperties->GetObjectItemSet();
}

// -----------------------------------------------------------------------------

void Cell::SetMergedItemSetAndBroadcast(const SfxItemSet& rSet, sal_Bool bClearAllItems)
{
	if( mpProperties )
	{
		mpProperties->SetMergedItemSetAndBroadcast(rSet, bClearAllItems);
		notifyModified();
	}
}

// -----------------------------------------------------------------------------

sal_Int32 Cell::getMinimumWidth()
{
	return GetTextLeftDistance() + GetTextRightDistance() + 100;
}

// -----------------------------------------------------------------------------

sal_Int32 Cell::getMinimumHeight()
{
	if( !mpProperties )
		return 0;

	SdrTableObj& rTableObj = dynamic_cast< SdrTableObj& >( GetObject() );
	sal_Int32 nMinimumHeight = 0;

	Rectangle aTextRect;
	TakeTextAnchorRect( aTextRect );
	Size aSize( aTextRect.GetSize() );
	aSize.Height()=0x0FFFFFFF;

	SdrOutliner* pEditOutliner = rTableObj.GetCellTextEditOutliner( *this );
	if(pEditOutliner)
	{
		pEditOutliner->SetMaxAutoPaperSize(aSize);
		nMinimumHeight = pEditOutliner->GetTextHeight()+1;
	}
	else /*if ( hasText() )*/
	{
		Outliner& rOutliner=rTableObj.ImpGetDrawOutliner();
		rOutliner.SetPaperSize(aSize);
		rOutliner.SetUpdateMode(sal_True);
		ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );

		if( GetOutlinerParaObject() )
		{
			rOutliner.SetText(*GetOutlinerParaObject());
		}
		nMinimumHeight=rOutliner.GetTextHeight()+1;
		rOutliner.Clear();
	}

	nMinimumHeight += GetTextUpperDistance() + GetTextLowerDistance();
	return nMinimumHeight;
}

// -----------------------------------------------------------------------------

long Cell::GetTextLeftDistance() const
{
	return ((SdrTextLeftDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LEFTDIST))).GetValue();
}

// -----------------------------------------------------------------------------

long Cell::GetTextRightDistance() const
{
	return ((SdrTextRightDistItem&)(GetItemSet().Get(SDRATTR_TEXT_RIGHTDIST))).GetValue();
}

// -----------------------------------------------------------------------------

long Cell::GetTextUpperDistance() const
{
	return ((SdrTextUpperDistItem&)(GetItemSet().Get(SDRATTR_TEXT_UPPERDIST))).GetValue();
}

// -----------------------------------------------------------------------------

long Cell::GetTextLowerDistance() const
{
	return ((SdrTextLowerDistItem&)(GetItemSet().Get(SDRATTR_TEXT_LOWERDIST))).GetValue();
}

// -----------------------------------------------------------------------------

SdrTextVertAdjust Cell::GetTextVerticalAdjust() const
{
	return ((SdrTextVertAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_VERTADJUST))).GetValue();
}

// -----------------------------------------------------------------------------

SdrTextHorzAdjust Cell::GetTextHorizontalAdjust() const
{
	return ((SdrTextHorzAdjustItem&)(GetItemSet().Get(SDRATTR_TEXT_HORZADJUST))).GetValue();
}

// -----------------------------------------------------------------------------

void Cell::SetOutlinerParaObject( OutlinerParaObject* pTextObject )
{
	SdrText::SetOutlinerParaObject( pTextObject );
    maSelection.nStartPara = 0xffff;

    if( pTextObject == 0 )
        ForceOutlinerParaObject( OUTLINERMODE_TEXTOBJECT );
}

// -----------------------------------------------------------------------------

void Cell::AddUndo()
{
	SdrObject& rObj = GetObject();
	if( rObj.IsInserted() && GetModel() && GetModel()->IsUndoEnabled() )
	{
		CellRef xCell( this );
		GetModel()->AddUndo( new CellUndo( &rObj, xCell ) );
	}
}

// -----------------------------------------------------------------------------

sdr::properties::TextProperties* Cell::CloneProperties( sdr::properties::TextProperties* pProperties, SdrObject& rNewObj, Cell& rNewCell )
{
	if( pProperties )
		return new sdr::properties::CellProperties( *static_cast<sdr::properties::CellProperties*>(pProperties), rNewObj, &rNewCell );
	else
		return 0;
}

// -----------------------------------------------------------------------------

sdr::properties::TextProperties* Cell::CloneProperties( SdrObject& rNewObj, Cell& rNewCell )
{
    return CloneProperties(mpProperties,rNewObj,rNewCell);
}

// -----------------------------------------------------------------------------
// XInterface
// -----------------------------------------------------------------------------

Any SAL_CALL Cell::queryInterface( const Type & rType ) throw(RuntimeException)
{
	if( rType == XMergeableCell::static_type() )
		return Any( Reference< XMergeableCell >( this ) );

	if( rType == XCell::static_type() )
		return Any( Reference< XCell >( this ) );

	if( rType == XLayoutConstrains::static_type() )
		return Any( Reference< XLayoutConstrains >( this ) );

    if( rType == XEventListener::static_type() )
        return Any( Reference< XEventListener >( this ) );

	Any aRet( SvxUnoTextBase::queryAggregation( rType ) );
	if( aRet.hasValue() )
		return aRet;

	return ::cppu::OWeakObject::queryInterface( rType );
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::acquire() throw ()
{
	::cppu::OWeakObject::acquire();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::release() throw ()
{
	::cppu::OWeakObject::release();
}

// -----------------------------------------------------------------------------
// XTypeProvider
// -----------------------------------------------------------------------------

Sequence< Type > SAL_CALL Cell::getTypes(  ) throw (RuntimeException)
{
    Sequence< Type > aTypes( SvxUnoTextBase::getTypes() );

    sal_Int32 nLen = aTypes.getLength();
    aTypes.realloc(nLen + 2);
	aTypes[nLen++] = XMergeableCell::static_type();
	aTypes[nLen++] = XLayoutConstrains::static_type();

	return aTypes;
}

// -----------------------------------------------------------------------------

Sequence< sal_Int8 > SAL_CALL Cell::getImplementationId(  ) throw (RuntimeException)
{
    static ::cppu::OImplementationId* pId = 0;
	if (! pId)
	{
        ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
		if (! pId)
		{
			static ::cppu::OImplementationId aId;
			pId = &aId;
		}
	}
	return pId->getImplementationId();
}

// -----------------------------------------------------------------------------
// XServiceInfo
// -----------------------------------------------------------------------------

OUString SAL_CALL Cell::getImplementationName(  ) throw (RuntimeException)
{
	return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.svx.table.Cell" ) );
}

// -----------------------------------------------------------------------------

sal_Bool SAL_CALL Cell::supportsService( const OUString& ServiceName ) throw (RuntimeException)
{
	if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.table.cell" ) ) == 0 )
		return sal_True;

	if( ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.cell" ) ) == 0 )
		return sal_True;

	return SvxUnoTextBase::supportsService( ServiceName );
}

// -----------------------------------------------------------------------------

Sequence< OUString > SAL_CALL Cell::getSupportedServiceNames(  ) throw (RuntimeException)
{
	Sequence< OUString > aSeq( SvxUnoTextBase::getSupportedServiceNames() );
	sal_Int32 nIndex = aSeq.getLength();
	aSeq.realloc( nIndex + 2 );
	aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.table.cell" ) );
	aSeq[nIndex++] = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.cell" ) );
	return aSeq;
}

// -----------------------------------------------------------------------------
// XLayoutConstrains
// -----------------------------------------------------------------------------

::com::sun::star::awt::Size SAL_CALL Cell::getMinimumSize(  ) throw (RuntimeException)
{
	return ::com::sun::star::awt::Size( getMinimumWidth(),  getMinimumHeight() );
}

// -----------------------------------------------------------------------------

::com::sun::star::awt::Size SAL_CALL Cell::getPreferredSize(  ) throw (RuntimeException)
{
	return getMinimumSize();
}

// -----------------------------------------------------------------------------

::com::sun::star::awt::Size SAL_CALL Cell::calcAdjustedSize( const ::com::sun::star::awt::Size& aNewSize ) throw (RuntimeException)
{
	return aNewSize;
}

// -----------------------------------------------------------------------------
// XMergeableCell
// -----------------------------------------------------------------------------

sal_Int32 SAL_CALL Cell::getRowSpan() throw (RuntimeException)
{
	return mnRowSpan;
}

// -----------------------------------------------------------------------------

sal_Int32 SAL_CALL Cell::getColumnSpan() throw (RuntimeException)
{
	return mnColSpan;
}

// -----------------------------------------------------------------------------

sal_Bool SAL_CALL Cell::isMerged() throw (RuntimeException)
{
	return mbMerged;
}

// -----------------------------------------------------------------------------
// XCell
// -----------------------------------------------------------------------------

OUString SAL_CALL Cell::getFormula(  ) throw (RuntimeException)
{
	return msFormula;
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setFormula( const OUString& aFormula ) throw (RuntimeException)
{
	if( msFormula != aFormula )
	{
		msFormula = aFormula;
	}
}

// -----------------------------------------------------------------------------

double SAL_CALL Cell::getValue(  ) throw (RuntimeException)
{
	return mfValue;
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setValue( double nValue ) throw (RuntimeException)
{
	if( mfValue == nValue )
	{
		mfValue = nValue;
		mnCellContentType = CellContentType_VALUE;
	}
}

// -----------------------------------------------------------------------------

CellContentType SAL_CALL Cell::getType() throw (RuntimeException)
{
	return mnCellContentType;
}

// -----------------------------------------------------------------------------

sal_Int32 SAL_CALL Cell::getError(  ) throw (RuntimeException)
{
	return mnError;
}

// -----------------------------------------------------------------------------
// XPropertySet
// -----------------------------------------------------------------------------

Any Cell::GetAnyForItem( SfxItemSet& aSet, const SfxItemPropertySimpleEntry* pMap )
{
	Any aAny( SvxItemPropertySet_getPropertyValue( *mpPropSet, pMap, aSet ) );

	if( *pMap->pType != aAny.getValueType() )
	{
		// since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
		if( ( *pMap->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
		{
			sal_Int32 nValue = 0;
			aAny >>= nValue;
			aAny <<= (sal_Int16)nValue;
		}
		else
		{
			DBG_ERROR("GetAnyForItem() Returnvalue has wrong Type!" );
		}
	}

	return aAny;
}

Reference< XPropertySetInfo > SAL_CALL Cell::getPropertySetInfo() throw(RuntimeException)
{
	return mpPropSet->getPropertySetInfo();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setPropertyValue( const OUString& rPropertyName, const Any& rValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
	if( pMap )
	{
		if( (pMap->nFlags & PropertyAttribute::READONLY ) != 0 )
			throw PropertyVetoException();

		switch( pMap->nWID )
		{
		case OWN_ATTR_STYLE:
		{
			Reference< XStyle > xStyle;
			if( !( rValue >>= xStyle ) )
				throw IllegalArgumentException();

			SfxUnoStyleSheet* pStyle = SfxUnoStyleSheet::getUnoStyleSheet(xStyle);
			SetStyleSheet( pStyle, sal_True );
			return;
		}
		case OWN_ATTR_TABLEBORDER:
		{
			if(rValue.getValueType() != ::getCppuType((const TableBorder*)0) )
				break;

			const TableBorder* pBorder = (const TableBorder* )rValue.getValue();
			if( pBorder == NULL )
				break;
			
            SvxBoxItem aBox( SDRATTR_TABLE_BORDER );
            SvxBoxInfoItem aBoxInfo( SDRATTR_TABLE_BORDER_INNER );
			SvxBorderLine aLine;

			sal_Bool bSet = SvxBoxItem::LineToSvxLine(pBorder->TopLine, aLine, false);
			aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_TOP);
			aBoxInfo.SetValid(VALID_TOP, pBorder->IsTopLineValid);

			bSet = SvxBoxItem::LineToSvxLine(pBorder->BottomLine, aLine, false);
			aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_BOTTOM);
			aBoxInfo.SetValid(VALID_BOTTOM, pBorder->IsBottomLineValid);

			bSet = SvxBoxItem::LineToSvxLine(pBorder->LeftLine, aLine, false);
			aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_LEFT);
			aBoxInfo.SetValid(VALID_LEFT, pBorder->IsLeftLineValid);

			bSet = SvxBoxItem::LineToSvxLine(pBorder->RightLine, aLine, false);
			aBox.SetLine(bSet ? &aLine : 0, BOX_LINE_RIGHT);
			aBoxInfo.SetValid(VALID_RIGHT, pBorder->IsRightLineValid);

			bSet = SvxBoxItem::LineToSvxLine(pBorder->HorizontalLine, aLine, false);
			aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_HORI);
			aBoxInfo.SetValid(VALID_HORI, pBorder->IsHorizontalLineValid);

			bSet = SvxBoxItem::LineToSvxLine(pBorder->VerticalLine, aLine, false);
			aBoxInfo.SetLine(bSet ? &aLine : 0, BOXINFO_LINE_VERT);
			aBoxInfo.SetValid(VALID_VERT, pBorder->IsVerticalLineValid);

			aBox.SetDistance(pBorder->Distance, false);
			aBoxInfo.SetValid(VALID_DISTANCE, pBorder->IsDistanceValid);

			mpProperties->SetObjectItem(aBox);
			mpProperties->SetObjectItem(aBoxInfo);
			return;
		}
		case OWN_ATTR_FILLBMP_MODE:
		{
			BitmapMode eMode;
			if(!(rValue >>= eMode) )
			{
				sal_Int32 nMode = 0;
				if(!(rValue >>= nMode))
					throw IllegalArgumentException();

					eMode = (BitmapMode)nMode;
			}

			mpProperties->SetObjectItem( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
			mpProperties->SetObjectItem( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
			return;
		}	
		default:
		{
			SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
			aSet.Put(mpProperties->GetItem(pMap->nWID));

			bool bSpecial = false;

			switch( pMap->nWID )
			{
				case XATTR_FILLBITMAP:
				case XATTR_FILLGRADIENT:
				case XATTR_FILLHATCH:
				case XATTR_FILLFLOATTRANSPARENCE:
				case XATTR_LINEEND:
				case XATTR_LINESTART:
				case XATTR_LINEDASH:
				{
					if( pMap->nMemberId == MID_NAME )
					{
						OUString aApiName;
						if( rValue >>= aApiName )
						{
							if( SvxShape::SetFillAttribute( pMap->nWID, aApiName, aSet, GetModel() ) )
								bSpecial = true;
						}
					}
				}
				break;
			}

			if( !bSpecial )
			{

				if( !SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pMap, rValue, aSet ))
				{
					if( aSet.GetItemState( pMap->nWID ) != SFX_ITEM_SET )
					{
						// Default aus ItemPool holen
						if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
							aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
					}

					if( aSet.GetItemState( pMap->nWID ) == SFX_ITEM_SET )
					{
						SvxItemPropertySet_setPropertyValue( *mpPropSet, pMap, rValue, aSet );
					}
				}
			}

			GetModel()->SetChanged();
			mpProperties->SetMergedItemSetAndBroadcast( aSet );
			return;
		}
		}
	}
	throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------

Any SAL_CALL Cell::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
	if( pMap )
	{
		switch( pMap->nWID )
		{
/*
        case OWN_ATTR_HASLEVELS:
		{
			return Any( hasLevels() );
		}
*/
		case OWN_ATTR_STYLE:
		{
			return Any( Reference< XStyle >( dynamic_cast< SfxUnoStyleSheet* >( GetStyleSheet() ) ) );
		}
		case OWN_ATTR_TABLEBORDER:
		{
			const SvxBoxInfoItem& rBoxInfoItem = static_cast<const SvxBoxInfoItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER_INNER));
			const SvxBoxItem& rBox = static_cast<const SvxBoxItem&>(mpProperties->GetItem(SDRATTR_TABLE_BORDER));

		 	TableBorder aTableBorder;
			aTableBorder.TopLine 				= SvxBoxItem::SvxLineToLine(rBox.GetTop(), false);
			aTableBorder.IsTopLineValid 		= rBoxInfoItem.IsValid(VALID_TOP);
			aTableBorder.BottomLine				= SvxBoxItem::SvxLineToLine(rBox.GetBottom(), false);
			aTableBorder.IsBottomLineValid		= rBoxInfoItem.IsValid(VALID_BOTTOM);
			aTableBorder.LeftLine				= SvxBoxItem::SvxLineToLine(rBox.GetLeft(), false);
			aTableBorder.IsLeftLineValid		= rBoxInfoItem.IsValid(VALID_LEFT);
			aTableBorder.RightLine				= SvxBoxItem::SvxLineToLine(rBox.GetRight(), false);
			aTableBorder.IsRightLineValid		= rBoxInfoItem.IsValid(VALID_RIGHT );
			aTableBorder.HorizontalLine			= SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetHori(), false);
			aTableBorder.IsHorizontalLineValid 	= rBoxInfoItem.IsValid(VALID_HORI);
			aTableBorder.VerticalLine			= SvxBoxItem::SvxLineToLine(rBoxInfoItem.GetVert(), false);
			aTableBorder.IsVerticalLineValid	= rBoxInfoItem.IsValid(VALID_VERT);
			aTableBorder.Distance 				= rBox.GetDistance();
			aTableBorder.IsDistanceValid 		= rBoxInfoItem.IsValid(VALID_DISTANCE);
			
			return Any( aTableBorder );
		}
		case OWN_ATTR_FILLBMP_MODE:
		{
			const XFillBmpStretchItem& rStretchItem = static_cast<const XFillBmpStretchItem&>(mpProperties->GetItem(XATTR_FILLBMP_STRETCH));
			const XFillBmpTileItem& rTileItem = static_cast<const XFillBmpTileItem&>(mpProperties->GetItem(XATTR_FILLBMP_TILE));
			if( rTileItem.GetValue() )
			{
				return Any( BitmapMode_REPEAT );
			}
			else if( rStretchItem.GetValue() )
			{
				return Any(  BitmapMode_STRETCH );
			}
			else
			{
				return Any(  BitmapMode_NO_REPEAT );
			}
		}
		default:
		{
			SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
			aSet.Put(mpProperties->GetItem(pMap->nWID));

			Any aAny;
			if(!SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pMap, aAny ))
			{
				if(!aSet.Count())
				{
					// Default aus ItemPool holen
					if(GetModel()->GetItemPool().IsWhich(pMap->nWID))
						aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
				}

				if( aSet.Count() )
					aAny = GetAnyForItem( aSet, pMap );
			}

			return aAny;
		}
		}
	}
	throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
}

// -----------------------------------------------------------------------------
// XMultiPropertySet
// -----------------------------------------------------------------------------

void SAL_CALL Cell::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues ) throw (PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
{
	OGuard aSolarGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

	const sal_Int32 nCount = aPropertyNames.getLength();
	
	const OUString* pNames = aPropertyNames.getConstArray();
	const Any* pValues = aValues.getConstArray();

	for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
	{
		try
		{
			setPropertyValue( *pNames, *pValues );
		}
		catch( UnknownPropertyException& )
		{
			DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
		}
        catch( Exception& )
        {
			DBG_ERROR("svx::Cell::setPropertyValues(), Exception caught!" );
        }
	}
}

// -----------------------------------------------------------------------------

Sequence< Any > SAL_CALL Cell::getPropertyValues( const Sequence< OUString >& aPropertyNames ) throw (RuntimeException)
{
	OGuard aSolarGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

	const sal_Int32 nCount = aPropertyNames.getLength();
	const OUString* pNames = aPropertyNames.getConstArray();

	Sequence< Any > aRet( nCount );
	Any* pValue = aRet.getArray();

	for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
	{
		try
		{
			*pValue = getPropertyValue( *pNames );
		}
		catch( UnknownPropertyException& )
		{
			DBG_ERROR("svx::Cell::setPropertyValues(), unknown property!" );
		}
		catch( Exception& )
		{
			DBG_ERROR( "svx::Cell::getPropertyValues(), Exception caught!" );
		}
	}

	return aRet;
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::addPropertiesChangeListener( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
{
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
{
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::firePropertiesChangeEvent( const Sequence< OUString >& /*aPropertyNames*/, const Reference< XPropertiesChangeListener >& /*xListener*/ ) throw (RuntimeException)
{
}

// -----------------------------------------------------------------------------
// XPropertyState
// -----------------------------------------------------------------------------

PropertyState SAL_CALL Cell::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);

	if( pMap )
	{
		PropertyState eState;
		switch( pMap->nWID )
		{
		case OWN_ATTR_FILLBMP_MODE:
		{
			const SfxItemSet& rSet = mpProperties->GetMergedItemSet();

			const bool bStretch = rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET;
			const bool bTile = rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET;
			if( bStretch || bTile )
			{
				eState = PropertyState_DIRECT_VALUE;
			}
			else
			{
				eState = PropertyState_DEFAULT_VALUE;
			}
		}
/*
		case OWN_ATTR_HASLEVELS:
		{
			return PropertyState_DIRECT_VALUE;
		}
*/
		case OWN_ATTR_STYLE:
		{
			return PropertyState_DIRECT_VALUE;
		}
		case OWN_ATTR_TABLEBORDER:
		{
			const SfxItemSet& rSet = mpProperties->GetMergedItemSet();
			if( (rSet.GetItemState( SDRATTR_TABLE_BORDER_INNER, sal_False ) == SFX_ITEM_DEFAULT) && (rSet.GetItemState( SDRATTR_TABLE_BORDER, sal_False ) == SFX_ITEM_DEFAULT) )
				return PropertyState_DEFAULT_VALUE;

			return PropertyState_DIRECT_VALUE;
		}
		default:
		{
			const SfxItemSet& rSet = mpProperties->GetMergedItemSet();

			switch( rSet.GetItemState( pMap->nWID, sal_False ) )
			{
			case SFX_ITEM_READONLY:
			case SFX_ITEM_SET:
				eState = PropertyState_DIRECT_VALUE;
				break;
			case SFX_ITEM_DEFAULT:
				eState = PropertyState_DEFAULT_VALUE;
				break;
	//		case SFX_ITEM_UNKNOWN:
	//		case SFX_ITEM_DONTCARE:
	//		case SFX_ITEM_DISABLED:
			default:
				eState = PropertyState_AMBIGUOUS_VALUE;
				break;
			}

			// if a item is set, this doesn't mean we want it :)
			if( ( PropertyState_DIRECT_VALUE == eState ) )
			{
				switch( pMap->nWID )
				{
				// the following items are disabled by changing the
				// fill style or the line style. so there is no need
				// to export items without names which should be empty
				case XATTR_FILLBITMAP:
				case XATTR_FILLGRADIENT:
				case XATTR_FILLHATCH:
				case XATTR_LINEDASH:
					{
						NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
						if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
							eState = PropertyState_DEFAULT_VALUE;
					}
					break;

				// #i36115#
				// If e.g. the LineStart is on NONE and thus the string has length 0, it still
				// may be a hard attribute covering the set LineStart of the parent (Style).
				// #i37644#
				// same is for fill float transparency
				case XATTR_LINEEND:
				case XATTR_LINESTART:
				case XATTR_FILLFLOATTRANSPARENCE:
					{
						NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
						if( pItem == NULL )
							eState = PropertyState_DEFAULT_VALUE;
					}
					break;
				}
			}
		}
		}
		return eState;
	}
	throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------

Sequence< PropertyState > SAL_CALL Cell::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

	const sal_Int32 nCount = aPropertyName.getLength();

	Sequence< PropertyState > aRet( nCount );

	const OUString* pNames = aPropertyName.getConstArray();
	PropertyState* pState = aRet.getArray();

	for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pState++ )
	{
		try
		{
			*pState = getPropertyState( *pNames );
		}
		catch( Exception& )
		{
			*pState = PropertyState_AMBIGUOUS_VALUE;
		}
	}

	return aRet;
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
	if( pMap )
	{
		switch( pMap->nWID )
		{
		case OWN_ATTR_FILLBMP_MODE:
		{
			mpProperties->ClearObjectItem( XATTR_FILLBMP_STRETCH );
			mpProperties->ClearObjectItem( XATTR_FILLBMP_TILE );
			break;
		}
//		case OWN_ATTR_HASLEVELS:
		case OWN_ATTR_STYLE:
			break;

		case OWN_ATTR_TABLEBORDER:
		{
			mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER_INNER );
			mpProperties->ClearObjectItem( SDRATTR_TABLE_BORDER );
			break;
		}

		default:
		{
			mpProperties->ClearObjectItem( pMap->nWID );
		}
		}

		GetModel()->SetChanged();
		return;
	}
	throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------

Any SAL_CALL Cell::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	if( (mpProperties == 0) || (GetModel() == 0) )
		throw DisposedException();

    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
	if( pMap )
	{
		switch( pMap->nWID )
		{
		case OWN_ATTR_FILLBMP_MODE:
			return Any(  BitmapMode_NO_REPEAT );

/*
        case OWN_ATTR_HASLEVELS:
			return Any( sal_False );
*/
		case OWN_ATTR_STYLE:
		{
			Reference< XStyle > xStyle;
			return Any( xStyle );
		}

		case OWN_ATTR_TABLEBORDER:
		{
			TableBorder aBorder;
			return Any( aBorder );
		}
		
		default:
		{
			if(  GetModel()->GetItemPool().IsWhich(pMap->nWID) )
			{
				SfxItemSet aSet( GetModel()->GetItemPool(), pMap->nWID, pMap->nWID);
				aSet.Put(GetModel()->GetItemPool().GetDefaultItem(pMap->nWID));
				return GetAnyForItem( aSet, pMap );
			}
		}
		}
	}
	throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------
// XMultiPropertyStates
// -----------------------------------------------------------------------------

void SAL_CALL Cell::setAllPropertiesToDefault(  ) throw (RuntimeException)
{
	if( mpProperties )
		delete mpProperties;
	mpProperties = new sdr::properties::CellProperties( static_cast< SdrTableObj& >( GetObject() ), this );

	SdrOutliner& rOutliner = GetObject().ImpGetDrawOutliner();

	OutlinerParaObject* pParaObj = GetOutlinerParaObject();
	if( pParaObj )
	{
		rOutliner.SetText(*pParaObj);
		sal_uInt32 nParaCount(rOutliner.GetParagraphCount());

		if(nParaCount)
		{
			ESelection aSelection( 0, 0, EE_PARA_ALL, EE_PARA_ALL);
			rOutliner.RemoveAttribs(aSelection, sal_True, 0);

			OutlinerParaObject* pTemp = rOutliner.CreateParaObject(0, (sal_uInt16)nParaCount);
			rOutliner.Clear();

			SetOutlinerParaObject(pTemp);
		}
	}
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setPropertiesToDefault( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, RuntimeException)
{
	sal_Int32 nCount = aPropertyNames.getLength();
	const OUString* pName = aPropertyNames.getConstArray();

	while(nCount--)
		setPropertyToDefault( *pName++ );
}

// -----------------------------------------------------------------------------

Sequence< Any > SAL_CALL Cell::getPropertyDefaults( const Sequence< OUString >& aPropertyNames ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
{
	sal_Int32 nCount = aPropertyNames.getLength();
	Sequence< Any > aDefaults( nCount );
	Any* pDefaults = aDefaults.getArray();
	const OUString* pName = aPropertyNames.getConstArray();

	while(nCount--)
		*pDefaults++ = getPropertyDefault( *pName++ );

	return aDefaults;
}

// -----------------------------------------------------------------------------
// XFastPropertySet
// -----------------------------------------------------------------------------

void SAL_CALL Cell::setFastPropertyValue( sal_Int32 nHandle, const Any& aValue ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
{
	(void)aValue;
	(void)nHandle;
    throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------
// TODO: Refactor this method!
Any SAL_CALL Cell::getFastPropertyValue( sal_Int32 nHandle ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
{
    (void)nHandle;
    throw UnknownPropertyException();
}

// -----------------------------------------------------------------------------
// XText
// -----------------------------------------------------------------------------

void SAL_CALL Cell::insertTextContent( const Reference< XTextRange >& xRange, const Reference< XTextContent >& xContent, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
{
	SvxUnoTextBase::insertTextContent( xRange, xContent, bAbsorb );
	notifyModified();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::removeTextContent( const Reference< XTextContent >& xContent ) throw (NoSuchElementException, RuntimeException)
{
	SvxUnoTextBase::removeTextContent( xContent );
	notifyModified();
}

// -----------------------------------------------------------------------------
// XSimpleText
// -----------------------------------------------------------------------------

Reference< XTextCursor > SAL_CALL Cell::createTextCursor(  ) throw (RuntimeException)
{
	return SvxUnoTextBase::createTextCursor();
}

// -----------------------------------------------------------------------------

Reference< XTextCursor > SAL_CALL Cell::createTextCursorByRange( const Reference< XTextRange >& aTextPosition ) throw (RuntimeException)
{
	return SvxUnoTextBase::createTextCursorByRange( aTextPosition );
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::insertString( const Reference< XTextRange >& xRange, const OUString& aString, sal_Bool bAbsorb ) throw (RuntimeException)
{
	SvxUnoTextBase::insertString( xRange, aString, bAbsorb );
	notifyModified();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::insertControlCharacter( const Reference< XTextRange >& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb ) throw (IllegalArgumentException, RuntimeException)
{
	SvxUnoTextBase::insertControlCharacter( xRange, nControlCharacter, bAbsorb );
	notifyModified();
}

// -----------------------------------------------------------------------------
// XTextRange
// -----------------------------------------------------------------------------

Reference< XText > SAL_CALL Cell::getText(  ) throw (RuntimeException)
{
	return SvxUnoTextBase::getText();
}

// -----------------------------------------------------------------------------

Reference< XTextRange > SAL_CALL Cell::getStart(  ) throw (RuntimeException)
{
	return SvxUnoTextBase::getStart();
}

// -----------------------------------------------------------------------------

Reference< XTextRange > SAL_CALL Cell::getEnd(  ) throw (RuntimeException)
{
	return SvxUnoTextBase::getEnd();
}

// -----------------------------------------------------------------------------

OUString SAL_CALL Cell::getString(  ) throw (RuntimeException)
{
    maSelection.nStartPara = 0xffff;
	return SvxUnoTextBase::getString();
}

// -----------------------------------------------------------------------------

void SAL_CALL Cell::setString( const OUString& aString ) throw (RuntimeException)
{
	SvxUnoTextBase::setString( aString );
	notifyModified();
}

// XEventListener
void SAL_CALL Cell::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
{
	mxTable.clear();
    dispose();
}

static OUString getCellName( sal_Int32 nCol, sal_Int32 nRow )
{
    rtl::OUStringBuffer aBuf;

    if (nCol < 26*26)
    {
        if (nCol < 26)
            aBuf.append( static_cast<sal_Unicode>( 'A' +
                        static_cast<sal_uInt16>(nCol)));
        else
        {
            aBuf.append( static_cast<sal_Unicode>( 'A' +
                        (static_cast<sal_uInt16>(nCol) / 26) - 1));
            aBuf.append( static_cast<sal_Unicode>( 'A' +
                        (static_cast<sal_uInt16>(nCol) % 26)));
        }
    }
    else
    {
        String aStr;
        while (nCol >= 26)
        {
            sal_Int32 nC = nCol % 26;
            aStr += static_cast<sal_Unicode>( 'A' +
                    static_cast<sal_uInt16>(nC));
            nCol = nCol - nC;
            nCol = nCol / 26 - 1;
        }
        aStr += static_cast<sal_Unicode>( 'A' +
                static_cast<sal_uInt16>(nCol));
        aStr.Reverse();
        aBuf.append( aStr);
    }
    aBuf.append( OUString::valueOf(nRow+1) );
    return aBuf.makeStringAndClear();
}

OUString Cell::getName()
{
    // todo: optimize!
    OUString sName;
    if( mxTable.is() ) try
    {
        Reference< XCell > xThis( static_cast< XCell* >( this ) );

        sal_Int32 nRowCount = mxTable->getRowCount();
        sal_Int32 nColCount = mxTable->getColumnCount();
        for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
        {
            for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
            {
                Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
                if( xCell == xThis )
                {
                    return getCellName( nCol, nRow );
                }
            }
        }
    }
    catch( Exception& )
    {
    }

    return sName;
}

} }